Does Keploy replace testify for Go testing?

No. Keploy replaces the integration layer, where mocks and httptest servers are costly to maintain. Keep testify for unit tests of individual functions — Keploy generates the API-level regression suite from real traffic and runs alongside go test.

Do I need to extract interfaces to use Keploy?

No. Keploy captures traffic outside your process at the socket layer, so it never substitutes a collaborator inside the binary. Concrete types stay concrete, and you do not add an abstraction layer whose only consumer is the test suite.

Is Keploy an alternative to go-sqlmock?

Yes, for integration tests. go-sqlmock asserts on the SQL string your code emits, so every query is written twice. Keploy records the database protocol beneath database/sql and pgx, capturing the real rows without restating a single query.

Can Keploy test Go gRPC services?

Yes. Keploy captures gRPC calls as HTTP/2 frames, which covers both inbound handlers and outbound client calls made through google.golang.org/grpc. Unary and server-streaming calls replay from the recording with no stub server to run.

Does Keploy work with Gin, Echo, and Fiber?

Yes, and identically. Because capture happens at the network layer rather than inside the router, the HTTP framework, middleware chain, and handler signature make no difference to what Keploy records or replays.

Is Keploy free for Go projects?

Yes. The Keploy CLI is open source under Apache 2.0 and free to run on any Go service with no seat limits. It is not a Go module, so it never appears in go.mod or affects your dependency graph.

Keploy as a Go testing framework

Keploy tests Go services by recording real HTTP and database traffic from a running binary, then replaying it as assertions. There are no interfaces to extract for mocking, no httptest.Server to stand up, and no sqlmock expectations to keep in sync with your queries.

Generate Go tests free

keploy record -c "./orders-service"

18.4K+

1.2M+300M+mocks createdSlack

What Keploy gives a Go team

Any Go binary, unchanged

Keploy runs the binary you build and ship. net/http, Gin, Echo, Fiber, chi, and gRPC servers all record the same way, because interception happens at the socket rather than inside the router.

Go 1.19 and above
No build tag or test-only entrypoint
Router and middleware choice is invisible
HTTP and gRPC servers both supported

Try Keploy for free Explore the docs

The problem

Why Go 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 Go: by hand, with testify + sqlmock, or with Keploy

testify and sqlmock need an interface to substitute and a query string to restate. Keploy captures outside the process, so concrete types stay concrete and no contract is written down twice.

By hand

testify + sqlmock

With Keploy

Select any row for the full comparison, with code.

Get started Book a call

Same coverage, three costs

What you write for Go 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_manual_test.go

hand-written

// Hand-written: fakes, request building, and assertions by hand.

package orders

import (

"net/http/httptest"

"strings"

"testing"

)

type fakeRepo struct{}

func (fakeRepo) Get(id string) (*Order, error) {

return &Order{ID: id, AmountMinor: 4200, State: "NEW"}, nil

}

type fakePayments struct{}

func (fakePayments) Charge(tok string) (string, error) {

return "AUTHORIZED", nil

}

func TestConfirmOrder(t *testing.T) {

h := NewHandler(fakeRepo{}, fakePayments{})

body := strings.NewReader(`{"paymentToken":"tok_123"}`)

req := httptest.NewRequest("POST", "/orders/ord_1/confirm", body)

rec := httptest.NewRecorder()

h.ServeHTTP(rec, req)

if rec.Code != 200 {

t.Fatalf("got %d, want 200", rec.Code)

}

Two fake types and two interfaces exist only for this test. Both encode a payload shape nothing checks against the real Postgres rows or Stripe response.

testify + sqlmock1–2 hours

orders_testify_test.go

tool-assisted

// testify + go-sqlmock + httptest.

package orders

import (

"testing"

"github.com/DATA-DOG/go-sqlmock"

"github.com/stretchr/testify/assert"

)

func TestConfirmOrder(t *testing.T) {

db, mock, _ := sqlmock.New()

defer db.Close()

// The query is now written twice: here, and in the repository.

rows := sqlmock.NewRows([]string{"id", "amount_minor", "state"}).

AddRow("ord_1", 4200, "NEW")

mock.ExpectQuery("SELECT id, amount_minor, state FROM orders").

WithArgs("ord_1").

WillReturnRows(rows)

upstream := httptest.NewServer(stripeStub())

defer upstream.Close()

h := NewHandler(NewRepo(db), NewPayments(upstream.URL))

rec := post(h, "/orders/ord_1/confirm", `{"paymentToken":"tok_123"}`)

assert.Equal(t, 200, rec.Code)

assert.NoError(t, mock.ExpectationsWereMet())

}

Idiomatic Go, and still two copies of every contract — the SQL string is duplicated and stripeStub() is a handler someone has to keep current by hand.

With Keploy~5 minutes

test-1.yaml

auto-generated

# Recorded with: keploy record -c './server'

# Nobody wrote this file. Keploy captured it from a real request.

version: api.keploy.io/v1beta1

kind: Http

name: test-1

spec:

req:

method: POST

url: /orders/ord_1/confirm

body: '{"paymentToken":"tok_123"}'

resp:

status_code: 200

body:

id: "ord_1"

state: "CONFIRMED"

amountMinor: 4200

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

noise:

- body.confirmedAt

# No interface, no sqlmock expectation, no httptest server.

mocks:

- kind: Postgres

operation: "SELECT id, amount_minor, state FROM orders WHERE id = $1"

- kind: Http

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

status: 200

The SQL and the upstream response are recorded, not restated. Concrete types stay concrete because nothing in the binary had to become an interface.

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

Explore the docs Request a trial

Keploy vs the alternatives

Go testing tools, compared

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

Keploy

testify + httptest

go-sqlmock

GoMock

Testcontainers

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

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

RecordingKeploy proxyeBPF · userspace

PostgreSQLPostgres protocol under pgx and lib/pq

MySQLMySQL protocol under go-sql-driver/mysql

MongoDBMongoDB wire protocol under mongo-driver

RedisRESP under go-redis and redigo

+4 more Go 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 Go, with zero config

7 of the 8 dependencies a typical Go 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 pgx and lib/pq
Auto-mocked
MySQLView page
MySQL protocol under go-sql-driver/mysql
Auto-mocked
MongoDBView page
MongoDB wire protocol under mongo-driver
Auto-mocked
RedisView page
RESP under go-redis and redigo
Auto-mocked
Apache KafkaView page
Kafka protocol under sarama and kafka-go
Auto-mocked
gRPCView page
HTTP/2 framed calls from google.golang.org/grpc
Outbound HTTP
Auto-mocked
Outbound HTTP
Any net/http client or resty call
Partial
Amazon S3
S3 REST API via aws-sdk-go-v2

Explore the docs Book a call

Quick start

Your first Go test suite in under five minutes

Every command below runs against your existing Go service. Nothing in your source tree changes.

1
1Install the Keploy CLI
A single binary. Nothing is added to go.mod, so your module graph is untouched.
curl -sSL https://keploy.io/install.sh | bash
2
2Build and record
Build as normal, then hand the binary to Keploy instead of running it directly.
go build -o server ./cmd/server
keploy record -c "./server"
3
3Exercise your endpoints
Every request served while recording becomes a test case, with its database and HTTP calls captured alongside.
curl -X POST localhost:8080/orders/ord_1/confirm -H 'Content-Type: application/json' -d '{"paymentToken":"tok_123"}'
4
4Replay in CI
Replay boots the binary against recorded mocks, so the job needs no service containers.
keploy test -c "./server" --delay 5