How do I test NestJS without createTestingModule?

Record the running app with Keploy. Because capture happens at the socket, the real DI container boots and guards, interceptors, and pipes all execute — so there is no module graph to assemble in the test.

Is Keploy an alternative to overrideProvider?

Yes, for integration tests. Every override removes a real call and the check that came with it. Keploy records the real provider chain, so the integration a test is named for actually happens.

Do NestJS guards and interceptors run under Keploy?

Yes. The request arrives over a real socket, so the guard authorises it, the validation pipe checks the body, and the response interceptor shapes the output — all of it captured and replayed.

Can Keploy mock TypeORM and Prisma calls?

Yes. Keploy records the database wire protocol beneath both, so a repository or Prisma query replays with the exact rows it received. No test database, no synchronize step, and no migration run in CI.

Does Keploy work with the Fastify adapter?

Yes, and identically. Capture happens at the socket rather than inside the HTTP adapter, so Express and Fastify adapters record and replay the same way with no configuration difference.

Is Keploy free for NestJS projects?

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

Keploy as a NestJS testing framework

Keploy tests NestJS applications by recording real requests through the running HTTP server and every database or outbound call they trigger, then replaying both as assertions. There is no Test.createTestingModule graph to assemble and no provider to override.

Generate NestJS tests free

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

18.4K+

1.2M+300M+mocks createdSlack

What Keploy gives a NestJS team

Any NestJS app, unchanged

Keploy runs the compiled entrypoint. Express and Fastify adapters, microservice transports, and GraphQL resolvers all record the same way because capture happens at the socket rather than inside the DI container.

NestJS 9 and above
Express or Fastify adapter
REST, GraphQL, and gRPC
Modules initialise for real

Try Keploy for free Explore the docs

The problem

Why NestJS 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 NestJS: by hand, with Jest + createTestingModule, or with Keploy

createTestingModule rebuilds the container with providers swapped out. Keploy records the running app, so guards, interceptors, pipes, and the real provider chain all execute.

By hand

Jest + createTestingModule

With Keploy

Select any row for the full comparison, with code.

Get started Book a call

Same coverage, three costs

What you write for NestJS 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.ts

hand-written

// Hand-written: the controller is called past guards and pipes.

import { OrdersController } from './orders.controller';

const fakeRepo = {

findOne: async () => ({ id: 'ord_1', amountMinor: 4200, state: 'NEW' }),

save: async (order) => order,

};

const fakePayments = {

authorize: async () => ({ status: 'AUTHORIZED' }),

};

describe('OrdersController', () => {

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

const controller = new OrdersController(fakeRepo as any, fakePayments as any);

const result = await controller.confirm('ord_1', { paymentToken: 'tok_123' });

expect(result.state).toBe('CONFIRMED');

});

Two casts to any and two hand-written doubles. The auth guard, validation pipe, and response interceptor never run.

Jest + createTestingModule1–2 hours

orders.e2e-spec.ts

tool-assisted

// Jest + createTestingModule + supertest.

import { Test } from '@nestjs/testing';

import request from 'supertest';

import nock from 'nock';

let app;

beforeAll(async () => {

const moduleRef = await Test.createTestingModule({

imports: [AppModule],

})

.overrideProvider(PaymentsService)

.useValue({ authorize: async () => ({ status: 'AUTHORIZED' }) })

.compile();

app = moduleRef.createNestApplication();

await app.init();

});

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

const res = await request(app.getHttpServer())

.post('/orders/ord_1/confirm')

.send({ paymentToken: 'tok_123' });

expect(res.status).toBe(200);

});

Drives the real pipeline — but PaymentsService is overridden, so the one integration this test is named for never actually happens.

With Keploy~5 minutes

test-1.yaml

auto-generated

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

# Real container. Real guards. No overrides.

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

body:

id: "ord_1"

state: "CONFIRMED"

amountMinor: 4200

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

noise:

- body.confirmedAt

mocks:

- kind: Postgres

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

- kind: Http

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

status: 200

The guard authorised this request, the pipe validated the body, and the real PaymentsService made the call — all captured, none overridden.

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

Explore the docs Request a trial

Keploy vs the alternatives

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

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

RecordingKeploy proxyeBPF · userspace

PostgreSQLPostgres protocol under TypeORM and Prisma

MySQLMySQL protocol under TypeORM and Prisma

MongoDBWire protocol under Mongoose and the Nest Mongo module

RedisRESP under ioredis and BullMQ

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

7 of the 7 dependencies a typical NestJS 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 TypeORM and Prisma
Auto-mocked
MySQLView page
MySQL protocol under TypeORM and Prisma
Auto-mocked
MongoDBView page
Wire protocol under Mongoose and the Nest Mongo module
Auto-mocked
RedisView page
RESP under ioredis and BullMQ
Auto-mocked
Apache KafkaView page
Kafka protocol under the Nest Kafka transport
Auto-mocked
gRPCView page
HTTP/2 framed calls from the Nest gRPC transport
Outbound HTTP
Auto-mocked
Outbound HTTP
Any HttpService, axios, or fetch call

Explore the docs Book a call

Quick start

Your first NestJS test suite in under five minutes

Every command below runs against your existing NestJS 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/main.js"
3
3Exercise the paths you care about
Build as normal, then drive the running app. 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/main.js" --delay 10