How do you test NestJS applications?

Question

IT Interview Practice · Accepted Answer

NestJS provides a built-in **testing utility (`@nestjs/testing`)** integrated with Jest, and its **dependency-injection architecture makes testing especially clean** — you create a testing module and inject mocks for dependencies. Tests fall into unit tests (isolated) and e2e tests (full app).

## Unit testing a service (with mocked dependencies)

```ts
import { Test } from "@nestjs/testing";

describe("UsersService", () => {
  let service: UsersService;
  let mockRepo = { find: jest.fn(), save: jest.fn() };

beforeEach(async () => {
    const module = await Test.createTestingModule({
      providers: [
        UsersService,
        // inject a MOCK for the repository — no real database needed
        { provide: getRepositoryToken(User), useValue: mockRepo },
      ],
    }).compile();

service = module.get<UsersService>(UsersService);
  });

it("returns all users", async () => {
    mockRepo.find.mockResolvedValue([{ id: 1, name: "Ann" }]);
    const result = await service.findAll();
    expect(result).toHaveLength(1);
    expect(mockRepo.find).toHaveBeenCalled();
  });
});
```

The key advantage: NestJS's DI lets you **swap real dependencies for mocks** via the testing module's providers — so you test the service in isolation, without a real database or external services.

## Mocking dependencies easily

```ts
// provide a fake for ANY dependency by its token
{ provide: EmailService, useValue: { send: jest.fn() } }
{ provide: ConfigService, useValue: { get: () => "test-value" } }
```

Because classes don't construct their dependencies (DI does), substituting mocks is trivial — the foundation of clean unit tests.

## End-to-end (e2e) testing — the full app over HTTP

```ts
import * as request from "supertest";

describe("Users (e2e)", () => {
  let app: INestApplication;

beforeAll(async () => {
    const module = await Test.createTestingModule({
      imports: [AppModule],        // the whole app
    }).compile();
    app = module.createNestApplication();
    await app.init();
  });

it("GET /users", () => {
    return request(app.getHttpServer())   // make a real HTTP request
      .get("/users")
      .expect(200)
      .expect(res => expect(res.body).toBeInstanceOf(Array));
  });

afterAll(async () => await app.close());
});
```

**E2E tests** bootstrap the full application and make real HTTP requests (via `supertest`), verifying the entire flow (routing → guards → pipes → handler → response) works together.

## Testing strategy

```text
Unit tests  → services, guards, pipes in isolation (mock dependencies) — fast, numerous
Integration → a controller + its real service together via the testing module
E2E tests   → full app over HTTP (supertest) — verify real request flows, fewer
Use a TEST database (or mocks) for e2e; override providers for external services.
```

## Why it matters

Testing is essential for reliable applications, and NestJS's architecture makes it notably clean — understanding how to test is important both for code quality and because the framework is *designed* for testability.

The central insight is that **dependency injection makes mocking trivial**: because classes declare their dependencies and DI provides them, the `@nestjs/testing` module lets you swap any dependency (database repositories, external services, config) for a mock by its token, enabling fast, isolated **unit tests** of services, guards, and pipes without real infrastructure.

This testability is a major reason DI-based frameworks like NestJS are valued.

Complementing unit tests, **e2e tests** (bootstrapping the full app and making real HTTP requests via `supertest`) verify that the entire request pipeline — routing, guards, validation, handlers — works together correctly.

Knowing the testing utilities (`Test.createTestingModule`, provider overrides for mocking), how to write both unit and e2e tests, and a sensible testing strategy (many fast isolated unit tests, fewer full e2e tests, a test database) is a hallmark of professional NestJS development.

It reflects mature engineering practice and leverages exactly what makes NestJS's structured, DI-driven design valuable, making it an important senior-level topic.

Unit testing a service (with mocked dependencies)

Mocking dependencies easily

End-to-end (e2e) testing — the full app over HTTP

Testing strategy

Why it matters

Related questions