Hvordan tester du NestJS-applikasjoner?

Question

Accepted Answer

NestJS tilbyr et innebygd **testingsverktøy (`@nestjs/testing`)** integrert med Jest, og dens **dependency-injection-arkitektur gjør testing særlig ryddig** — du lager en testingsmodul og injiserer mocks for avhengigheter. Tester faller inn i enhetstester (isolerte) og e2e-tester (full app).

## Enhetstesting av en tjeneste (med mockede avhengigheter)

```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();
  });
});
```

Hovedfordelen: NestJS sin DI lar deg **bytte ut echte avhengigheter med mocks** via testingsmodulens leverandører — så du tester tjenesten isolert, uten en ekte database eller eksterne tjenester.

## Mocking av avhengigheter på en enkel måte

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

Fordi klasser ikke konstruerer sine avhengigheter (DI gjør det), er bytte av mocks trivielt — grunnlaget for ryddig enhetstesting.

## End-to-end (e2e) testing — hele appen 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-tester** bootstrap hele applikasjonen og gjør virkelige HTTP-forespørsler (via `supertest`), og verifiserer at hele flyten (ruting → guards → pipes → handler → response) fungerer sammen.

## Testingstrategi

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

## Hvorfor det betyr noe

Testing er essensiell for pålitelige applikasjoner, og NestJS sin arkitektur gjør det bemerkelsesverdig ryddig — å forstå hvordan man tester er viktig både for kodekvalitet og fordi rammeverket er *designet* for testbarhet.

Den sentrale innsikten er at **dependency injection gjør mocking trivielt**: fordi klasser deklarerer sine avhengigheter og DI tilbyr dem, lar `@nestjs/testing`-modulen deg bytte ut hvilken som helst avhengighet (database-repositories, eksterne tjenester, config) med en mock etter dens token, og muliggjør raske, isolerte **enhetstester** av tjenester, guards og pipes uten ekte infrastruktur.

Denne testbarheten er en stor grunn til at DI-baserte rammeverk som NestJS blir verdsatt.

For å utfylle enhetstester, **e2e-tester** (bootstrap hele appen og gjøre virkelige HTTP-forespørsler via `supertest`) verifiserer at hele forespørselsrørledningen — ruting, guards, validering, handlers — fungerer sammen riktig.

Å kjenne testingsverktøyene (`Test.createTestingModule`, provider-overstyringer for mocking), hvordan man skriver både enhets- og e2e-tester, og en fornuftig testingstrategi (mange raske isolerte enhetstester, færre fulle e2e-tester, en testdatabase) er et kjennetegn på profesjonell NestJS-utvikling.

Det reflekterer moden ingeniørpraksis og utnytter nettopp det som gjør NestJS sin strukturerte, DI-drevne design verdifull, noe som gjør det til et viktig tema på seniornivå.