Does Keploy replace RSpec for Ruby testing?

No. Keploy replaces the integration layer, where WebMock stubs and VCR cassettes are costly to keep honest. Keep RSpec for unit tests of individual classes — Keploy generates the request-level regression suite from real traffic.

Is Keploy a VCR alternative for Ruby?

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 replace WebMock stubs?

Yes, for integration tests. WebMock returns the body registered in your stub, so it cannot notice upstream drift. Keploy captures the real Net::HTTP or Faraday response at the socket layer and replays that instead.

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. There is no test database, no schema load, and no FactoryBot definitions to maintain.

Does Keploy work with Rails and Sinatra?

Yes, and identically. Capture happens at the socket rather than inside Rack, so middleware, routing, strong parameters, and serializers all execute on every recorded request and are exercised again on replay.

Is Keploy free for Ruby projects?

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

Keploy as a Ruby testing framework

Keploy tests Ruby applications by recording real HTTP and ActiveRecord traffic from a running app, then replaying it as assertions. There are no WebMock stubs to register, no VCR cassettes to re-record by hand, and no test database to load a schema into.

Generate Ruby tests free

keploy record -c "bundle exec rails server"

18.4K+

1.2M+300M+mocks createdSlack

What Keploy gives a Ruby team

Any Ruby app, unchanged

Keploy runs the app through rails server, rackup, or Puma. Rails, Sinatra, Hanami, and plain Rack apps all record the same way because capture happens at the socket.

Ruby 3.0 and above
Rails, Sinatra, Hanami, Rack
Puma, Unicorn, or Passenger
No spec_helper changes

Try Keploy for free Explore the docs

The problem

Why Ruby 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: by hand, with RSpec + WebMock, or with Keploy

WebMock stubs and VCR cassettes are both frozen the moment they are written. Keploy records the real exchange, so re-recording refreshes every mock at once instead of one cassette at a time.

By hand

RSpec + WebMock

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 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

order_controller_spec.rb

hand-written

# Hand-written: doubles and payloads all by hand.

require 'rails_helper'

class FakeOrderRepository

def find(id)

{ id: id, amount_minor: 4200, state: 'NEW' }

end

class FakePayments

def authorize(_token)

{ 'status' => 'AUTHORIZED' }

end

RSpec.describe OrderController do

it 'confirms an authorized order' do

controller = described_class.new(FakeOrderRepository.new, FakePayments.new)

response = controller.confirm('ord_1', 'tok_123')

expect(response.status).to eq(200)

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

end

Two double classes exist only for this file, and both hard-code a shape nothing verifies against the real Postgres rows or Stripe response.

RSpec + WebMock1–2 hours

order_controller_webmock_spec.rb

tool-assisted

# RSpec + WebMock + FactoryBot.

require 'rails_helper'

require 'webmock/rspec'

RSpec.describe OrderController do

before do

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

# A literal that will not change when Stripe does.

stub_request(:post, %r{payment_intents/tok_123/confirm})

.to_return(

status: 200,

body: { status: 'AUTHORIZED' }.to_json,

headers: { 'Content-Type' => 'application/json' },

)

end

it 'confirms an authorized order' do

post "/orders/ord_1/confirm", params: { payment_token: 'tok_123' }

expect(response).to have_http_status(:ok)

expect(json_body['state']).to eq('CONFIRMED')

end

Readable and fully offline — and the Stripe body is a hand-typed literal that no longer resembles the real response the day their API changes.

With Keploy~5 minutes

test-1.yaml

auto-generated

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

# No WebMock stub, no cassette, no schema load.

version: api.keploy.io/v1beta1

kind: Http

name: test-1

spec:

req:

method: POST

url: /orders/ord_1/confirm

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 1'

- kind: Http

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

status: 200

The mock is the SQL ActiveRecord actually generated, so a scope change shows up as a real diff instead of passing against a factory-built record.

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

Explore the docs Request a trial

Keploy vs the alternatives

Ruby 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 app once, replay it forever

Keploy sits below your Ruby 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 appGET/api/v1/orders/{id}200

RecordingKeploy proxyeBPF · userspace

PostgreSQLPostgres protocol under the pg adapter

MySQLMySQL protocol under mysql2

RedisRESP under redis-rb

MongoDBWire protocol under Mongoid and the Ruby driver

+3 more Ruby 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, with zero config

6 of the 7 dependencies a typical Ruby 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
Auto-mocked
MongoDBView page
Wire protocol under Mongoid and the Ruby driver
Outbound HTTP
Auto-mocked
Outbound HTTP
Any Net::HTTP, Faraday, or HTTParty call
Auto-mocked
SidekiqView page
Job pushes as the Redis commands they really are
Partial
Apache KafkaView page
Kafka protocol under ruby-kafka

Explore the docs Book a call

Quick start

Your first Ruby test suite in under five minutes

Every command below runs against your existing Ruby 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"
3
3Exercise the paths you care about
Drive the app with curl or your frontend. Every request becomes a test case with its ActiveRecord queries and HTTP calls captured alongside.
curl -X POST localhost:3000/orders/ord_1/confirm -H 'Content-Type: application/json' -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" --delay 12