How do I test Fastify routes without app.inject?

Record the running server with Keploy. Because capture happens at the socket, every plugin your entrypoint registers, every hook, and JSON schema validation all execute — and the recorded case replays that same path.

Is Keploy an alternative to app.inject?

For integration tests, yes. inject dispatches into an instance the test file assembles, so a plugin loaded only in your entrypoint is missing. Keploy records the real process, so nothing is absent.

Does Fastify schema validation run under Keploy?

Yes. The request arrives over a real socket, so compiled JSON schema validation and fast-json-stringify serialisation both run — meaning a schema that strips or rejects a field is genuinely exercised.

Can Keploy mock database calls in Fastify?

Yes. Capture happens at the wire protocol beneath the driver, so @fastify/postgres, Prisma, Drizzle, and mysql2 all replay with the exact rows they received. No test database and no migration step in CI.

Does Keploy work with Fastify plugins and encapsulation?

Yes. Because the real entrypoint runs, plugin registration order and encapsulation contexts are exactly as production has them — which is precisely what a partial test app cannot guarantee.

Is Keploy free for Fastify projects?

Yes. The Keploy CLI is open source under Apache 2.0 and free to run on any Fastify service with no seat limits. It is not an npm package, so it never appears in package.json.

Keploy as a Fastify testing framework

Keploy tests Fastify applications by recording real requests through the running server and every database or outbound call they trigger, then replaying both as assertions. Schema validation, hooks, and plugin decorators all execute because the request arrives over a real socket.

Generate Fastify tests free

keploy record -c "node dist/server.js"

18.4K+

1.2M+300M+mocks createdSlack

What Keploy gives a Fastify team

Any Fastify app, unchanged

Keploy runs your real entrypoint. Plugins, encapsulation contexts, hooks, and JSON schema validation all execute because capture happens at the socket rather than inside the router.

Fastify 4 and above
Plugins and encapsulation preserved
JSON schema validation runs
TypeScript needs no extra setup

Try Keploy for free Explore the docs

The problem

Why Fastify 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 Fastify: by hand, with tap + app.inject, or with Keploy

app.inject dispatches into an instance the test file assembles, so plugins from your entrypoint are missing. Keploy records the running server, so the app under test is the app you deploy.

By hand

tap + app.inject

With Keploy

Select any row for the full comparison, with code.

Get started Book a call

Same coverage, three costs

What you write for Fastify 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.route.test.js

hand-written

// Hand-written: an instance built here, not in server.js.

const Fastify = require('fastify');

const ordersRoutes = require('../src/routes/orders');

test('confirms an authorized order', async (t) => {

const app = Fastify();

// Note what is missing: auth, rate limiting, and the error handler.

app.decorate('repo', { byId: async () => ({ id: 'ord_1', amountMinor: 4200 }) });

app.decorate('payments', { authorize: async () => ({ status: 'AUTHORIZED' }) });

await app.register(ordersRoutes);

const res = await app.inject({

method: 'POST',

url: '/orders/ord_1/confirm',

payload: { paymentToken: 'tok_123' },

});

t.equal(res.statusCode, 200);

});

The instance is assembled here, so @fastify/jwt and @fastify/rate-limit from server.js are absent and an unauthorised route still passes.

tap + app.inject1–2 hours

orders.inject.test.js

tool-assisted

// tap + app.inject + nock.

const nock = require('nock');

const buildApp = require('../src/app');

test('confirms an authorized order', async (t) => {

// A literal that will not change when Stripe does.

nock('https://api.payments.example.com')

.post('/v1/payment_intents/tok_123/confirm')

.reply(200, { status: 'AUTHORIZED' });

const app = await buildApp({ logger: false });

t.teardown(() => app.close());

const res = await app.inject({

method: 'POST',

url: '/orders/ord_1/confirm',

headers: { authorization: `Bearer ${token}` },

payload: { paymentToken: 'tok_123' },

});

t.equal(res.statusCode, 200);

t.equal(res.json().state, 'CONFIRMED');

});

Better — it uses the app factory — and the Stripe body is still a hand-typed literal, and a plugin registered outside buildApp is still missing.

With Keploy~5 minutes

test-1.yaml

auto-generated

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

# The real server. Every plugin and hook ran.

version: api.keploy.io/v1beta1

kind: Http

name: test-1

spec:

req:

method: POST

url: /orders/ord_1/confirm

header:

Authorization: Bearer <captured>

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

resp:

status_code: 200

header:

X-RateLimit-Remaining: "99"

body:

id: "ord_1"

state: "CONFIRMED"

amountMinor: 4200

noise:

- header.X-RateLimit-Remaining

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

The rate-limit header proves the real plugin chain ran, and the response passed through fast-json-stringify serialisation on the way out.

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

Explore the docs Request a trial

Keploy vs the alternatives

Fastify testing tools, compared

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

Keploy

Jest + supertest

nock

Mocha + Sinon

Mock Service Worker

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

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

RecordingKeploy proxyeBPF · userspace

PostgreSQLPostgres protocol under @fastify/postgres and Prisma

MySQLMySQL protocol under mysql2 and Drizzle

MongoDBWire protocol under @fastify/mongodb

RedisRESP under @fastify/redis and ioredis

+2 more Fastify 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 Fastify, with zero config

6 of the 6 dependencies a typical Fastify 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 @fastify/postgres and Prisma
Auto-mocked
MySQLView page
MySQL protocol under mysql2 and Drizzle
Auto-mocked
MongoDBView page
Wire protocol under @fastify/mongodb
Auto-mocked
RedisView page
RESP under @fastify/redis and ioredis
Auto-mocked
Apache KafkaView page
Kafka protocol under kafkajs
Outbound HTTP
Auto-mocked
Outbound HTTP
Any undici, axios, or fetch call

Explore the docs Book a call

Quick start

Your first Fastify test suite in under five minutes

Every command below runs against your existing Fastify 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 "node dist/server.js"
3
3Exercise the paths you care about
Build as normal, then drive the running server. Every request becomes a test case with its database and HTTP calls captured alongside.
npm run build
curl -X POST localhost:3000/orders/ord_1/confirm -H 'Content-Type: application/json' -H 'Authorization: Bearer $TOKEN' -d '{"paymentToken":"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 "node dist/server.js" --delay 8