How do I test Rails without loading a test schema?

Record the running server with Keploy. It captures the SQL ActiveRecord generated together with the rows returned, then replays both — so db:schema:load never runs and replay opens no database connection.

Is Keploy an alternative to VCR for Rails?

Yes, and it addresses VCR's main weakness. A cassette is frozen the day it is recorded and nothing flags it as stale. Keploy re-records every mock in one pass, so refreshing the whole suite is a single command.

Can Keploy mock ActiveRecord queries?

Yes. Keploy records the Postgres or MySQL wire protocol beneath the adapter, so a query replays with the exact rows it received. Because the mock is the generated SQL, a scope change shows up as a real diff.

Do Rails callbacks and strong parameters run under Keploy?

Yes. The request arrives over a real socket, so routing, strong parameters, before_action filters, model callbacks, and serializers all execute and are exercised again on replay.

Does Keploy work with API-only Rails apps?

Yes, and identically. Capture happens at the socket rather than inside Rack, so API-only and full-stack applications record and replay the same way with no configuration difference.

Is Keploy free for Rails projects?

Yes. The Keploy CLI is open source under Apache 2.0 and free to run on any Rails application with no seat limits. It is not a gem, so it never appears in your Gemfile.

Keploy as a Ruby on Rails testing framework

Keploy tests Rails applications by recording real requests through the running server and every ActiveRecord query or outbound call they trigger, then replaying both as assertions. No test schema is loaded, because replay never opens a database connection.

Generate Ruby on Rails tests free

keploy record -c "bundle exec rails server -p 3000"

18.4K+

1.2M+300M+mocks createdSlack

What Keploy gives a Ruby on Rails team

Any Rails app, unchanged

Keploy runs the app through rails server or Puma. Rack middleware, strong parameters, ActiveRecord callbacks, and serializers all execute because capture happens at the socket.

Rails 6.1 and above
rails server, Puma, or Passenger
API-only and full-stack apps
Initializers run for real

Try Keploy for free Explore the docs

The problem

Why Ruby on Rails integration tests slow teams down

The friction is rarely the assertions. It is everything around them — spinning up dependencies, keeping mocks honest, and repairing tests after every refactor.

Book a call Explore the docs

Three ways to do it

Testing Ruby on Rails: by hand, with RSpec request specs + VCR, or with Keploy

Request specs need a migrated test database and cassettes that freeze on the day they are cut. Keploy records both the SQL and the HTTP together, and refreshes them in one pass.

By hand

RSpec request specs + VCR

With Keploy

Select any row for the full comparison, with code.

Get started Book a call

Same coverage, three costs

What you write for Ruby on Rails vs what Keploy records

All three produce the same assertion. Only the third still passes after the next refactor without anyone editing it.

By hand2–4 hours

orders_controller_spec.rb

hand-written

# Hand-written: the controller is exercised past the middleware.

require 'rails_helper'

RSpec.describe OrdersController do

it 'confirms an authorized order' do

allow(Order).to receive(:find).and_return(

Order.new(id: 'ord_1', amount_minor: 4200, state: 'NEW'),

)

allow(Payments).to receive(:authorize).and_return('AUTHORIZED')

controller = described_class.new

result = controller.send(:confirm_order, 'ord_1', 'tok_123')

expect(result[:state]).to eq('CONFIRMED')

end

Two stubbed class methods and a private method called directly. Routing, strong parameters, and the before_action that authorises this never run.

RSpec request specs + VCR1–2 hours

orders_request_spec.rb

tool-assisted

# RSpec request spec + VCR + FactoryBot.

require 'rails_helper'

RSpec.describe 'POST /orders/:id/confirm', type: :request do

before { create(:order, id: 'ord_1', amount_minor: 4200, state: 'NEW') }

# Frozen the day it was cut. Nothing flags it as stale.

it 'confirms an authorized order', vcr: { cassette_name: 'stripe/confirm' } do

post "/orders/ord_1/confirm",

params: { payment_token: 'tok_123' },

headers: { 'Authorization' => "Bearer #{token}" }

expect(response).to have_http_status(:ok)

expect(response.parsed_body['state']).to eq('CONFIRMED')

end

Drives the whole stack, which is the right idea — and it needs a migrated database, a factory, and a cassette that ages out of date on its own.

With Keploy~5 minutes

test-1.yaml

auto-generated

# Recorded with: keploy record -c 'bundle exec rails server -p 3000'

# No schema load. No factory. No cassette.

version: api.keploy.io/v1beta1

kind: Http

name: test-1

spec:

req:

method: POST

url: /orders/ord_1/confirm

header:

Authorization: Bearer <captured>

body: '{"payment_token":"tok_123"}'

resp:

status_code: 200

body:

id: "ord_1"

state: "CONFIRMED"

amount_minor: 4200

confirmed_at: "2026-09-02T11:04:18Z"

noise:

- body.confirmed_at

mocks:

- kind: Postgres

operation: 'SELECT "orders".* FROM "orders" WHERE "orders"."id" = $1 LIMIT $2'

- kind: Http

url: https://api.payments.example.com/v1/payment_intents/tok_123/confirm

status: 200

The SQL and the Stripe response are recorded together, so one re-record refreshes both — rather than a cassette per exchange going stale independently.

Times are estimates for authoring one endpoint’s coverage from scratch, not measurements.

Explore the docs Request a trial

Keploy vs the alternatives

Ruby on Rails testing tools, compared

The options a team on Ruby actually reaches for, and where each one genuinely wins. Select a row for the full comparison.

Keploy

RSpec + WebMock

VCR

FactoryBot

Minitest

Postman

SmartBear ReadyAPI

Best in classStrongPartialNot covered

Assessments reflect each tool’s documented behaviour, not benchmark measurements.

Request a trial Book a call

How it works

Record your Ruby on Rails app once, replay it forever

Keploy sits below your Ruby on Rails process at the network layer. It watches the calls your app already makes, then serves them back on replay so tests run with no dependencies attached.

Your Ruby on Rails appGET/api/v1/orders/{id}200

RecordingKeploy proxyeBPF · userspace

PostgreSQLPostgres protocol under the pg adapter

MySQLMySQL protocol under mysql2

RedisRESP under redis-rb and Rails cache

SidekiqJob pushes as the Redis commands they really are

+2 more Ruby on Rails dependencies

An example shape of a captured call. Your own endpoints and dependencies come from your real traffic, so nothing here has to be written by hand.

Try Keploy for free Request a trial

Mock coverage

What Keploy mocks for Ruby on Rails, with zero config

6 of the 6 dependencies a typical Ruby on Rails service talks to are stubbed from the recording itself — no mock classes, no fixture files, no containers in CI.

Auto-mocked
PostgreSQLView page
Postgres protocol under the pg adapter
Auto-mocked
MySQLView page
MySQL protocol under mysql2
Auto-mocked
RedisView page
RESP under redis-rb and Rails cache
Auto-mocked
SidekiqView page
Job pushes as the Redis commands they really are
Auto-mocked
MongoDBView page
Wire protocol under Mongoid
Outbound HTTP
Auto-mocked
Outbound HTTP
Any Net::HTTP, Faraday, or HTTParty call

Explore the docs Book a call

Quick start

Your first Ruby on Rails test suite in under five minutes

Every command below runs against your existing Ruby on Rails service. Nothing in your source tree changes.

1
1Install the Keploy CLI
A single binary. It needs a Linux kernel with eBPF support, or Docker on macOS and Windows — and it adds nothing to your project's dependencies.
curl -sSL https://keploy.io/install.sh | bash
2
2Record your service
Pass the command you already use to start the app. Keploy runs it and watches every socket it opens.
keploy record -c "bundle exec rails server -p 3000"
3
3Exercise the paths you care about
Drive the running server. Every request becomes a test case with its ActiveRecord queries and outbound HTTP captured alongside.
curl -X POST localhost:3000/orders/ord_1/confirm -H 'Content-Type: application/json' -H 'Authorization: Bearer $TOKEN' -d '{"payment_token":"tok_123"}'
4
4Replay in CI
Replay serves the recorded dependency responses, so the job needs no service containers and no Docker daemon.
keploy test -c "bundle exec rails server -p 3000" --delay 14