Hoe test je NestJS-toepassingen?

Question

Accepted Answer

NestJS biedt een ingebouwde **test-utility (`@nestjs/testing`)** geïntegreerd met Jest, en zijn **dependency-injection-architectuur maakt testen vooral schoon** — je maakt een test-module en injecteert mocks voor dependencies. Tests vallen uiteen in unit tests (geïsoleerd) en e2e tests (volledige app).

## Unit testen van een service (met gemockte 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();
  });
});
```

Het belangrijkste voordeel: NestJS's DI laat je **echte dependencies vervangen door mocks** via de providers van de test-module — dus je test de service in isolatie, zonder echte database of externe services.

## Dependencies gemakkelijk mocken

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

Omdat classes hun dependencies niet zelf construeren (DI doet dat), is het vervangen door mocks triviaal — de basis van schone unit tests.

## End-to-end (e2e) testen — de volledige app via 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** bootstrappen de volledige toepassing en doen echte HTTP-requests (via `supertest`), waarbij wordt geverifieerd dat de volledige flow (routing → guards → pipes → handler → response) samen werkt.

## Test-strategie

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

## Waarom het belangrijk is

Testen is essentieel voor betrouwbare toepassingen, en NestJS's architectuur maakt het opvallend schoon — begrijpen hoe je test is belangrijk zowel voor codekwaliteit als omdat het framework *ontworpen* is voor testbaarheid.

Het centrale inzicht is dat **dependency injection mocken triviaal maakt**: omdat classes hun dependencies declareren en DI ze voorziet, laat de `@nestjs/testing`-module je elke dependency (database-repositories, externe services, config) naar een mock vervangen via zijn token, wat snelle, geïsoleerde **unit tests** van services, guards en pipes zonder echte infrastructuur mogelijk maakt.

Deze testbaarheid is een belangrijke reden waarom DI-gebaseerde frameworks zoals NestJS worden gewaardeerd.

Als aanvulling op unit tests verifiëren **e2e tests** (het bootstrappen van de volledige app en echte HTTP-requests via `supertest`) dat de volledige request-pipeline — routing, guards, validatie, handlers — correct samen werkt.

Weten hoe je test-utilities (`Test.createTestingModule`, provider-overrides voor mocken) gebruikt, hoe je zowel unit- als e2e tests schrijft, en een verstandige test-strategie (veel snelle geïsoleerde unit tests, minder volledige e2e tests, een test-database) is een kenmerk van professionele NestJS-ontwikkeling.

Het weerspiegelt volwassen engineering-praktijk en maakt optimaal gebruik van wat NestJS's gestructureerde, DI-gestuurde ontwerp waardevol maakt, wat het een belangrijk onderwerp op senior level maakt.