Hur testar du NestJS-applikationer?

Question

Accepted Answer

NestJS tillhandahåller ett inbyggt **testverktyg (`@nestjs/testing`)** integrerat med Jest, och dess **arkitektur för beroendeinjektion gör testning särskilt ren** — du skapar en testmodul och injicerar mocks för beroenden. Tester delas in i enhetstester (isolerade) och e2e-tester (full app).

## Enhetstestning av en service (med mockade beroenden)

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

Den viktigaste fördelen: NestJS:s DI låter dig **ersätta riktiga beroenden med mocks** via testmodulens providers — så du testar servicen i isolation, utan en riktig databas eller externa tjänster.

## Mockade beroenden på ett enkelt sätt

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

Eftersom klasser inte konstruerar sina beroenden (DI gör det), är det enkelt att ersätta med mocks — grunden för rena enhetstester.

## End-to-end (e2e) testning — full app över 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** startar den fullständiga applikationen och gör riktiga HTTP-förfrågningar (via `supertest`), verifierande att hela flödet (routing → guards → pipes → handler → response) fungerar tillsammans.

## Teststrategi

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

## Varför det spelar roll

Testning är väsentligt för tillförlitliga applikationer, och NestJS:s arkitektur gör det anmärkningsvärt rent — att förstå hur man testar är viktigt både för kodkvalitet och för att ramverket är *utformat* för testbarhet.

Den centrala insikten är att **beroendeinjektion gör mockad testning trivial**: eftersom klasser deklarerar sina beroenden och DI tillhandahåller dem, låter modulen `@nestjs/testing` dig ersätta vilket beroende som helst (databaskällor, externa tjänster, konfiguration) med en mock enligt dess token, möjliggörande snabba, isolerade **enhetstester** av services, guards och pipes utan riktlig infrastruktur.

Den här testbarheten är en stor anledning till att DI-baserade ramverk som NestJS är värdefulla.

En komplement till enhetstester, **e2e-tester** (startar full app och gör riktiga HTTP-förfrågningar via `supertest`) verifierar att hela request-pipelinen — routing, guards, validering, handlers — fungerar tillsammans korrekt.

Att känna till testverktygen (`Test.createTestingModule`, provider-överskrivning för mockad testning), hur man skriver både enhet- och e2e-tester, och en förnuftig teststrategi (många snabba isolerade enhetstester, färre fullständiga e2e-tester, en testdatabas) är ett kännetecken för professionell NestJS-utveckling.

Det återspeglar mogen ingenjörspraxis och utnyttjar exakt vad som gör NestJS:s strukturerade, DI-drivna design värdefull, vilket gör det till ett viktigt ämne på senior-nivå.