Hogyan tesztelünk NestJS alkalmazásokat?

Question

Accepted Answer

A NestJS egy beépített **tesztelési segédeszközt biztosít (`@nestjs/testing`)**, amely integrálva van a Jest-tel, és az **függőség-injektálási architektúrája különösen tiszta tesztelést tesz lehetővé** — létrehozol egy tesztelési modult és injektálsz mock-okat a függőségekhez. A tesztek unit tesztekre (izoláltak) és e2e tesztekre (teljes alkalmazás) oszlanak.

## Unit tesztelés egy service-nél (mock-olt függőségekkel)

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

A fő előny: a NestJS DI-ja lehetővé teszi a **valódi függőségek lecserélését mock-okra** a tesztelési modul provider-jein keresztül — így izoláltan tesztelheted a service-t, anélkül, hogy valódi adatbázisra vagy külső szolgáltatásokra lenne szükség.

## Függőségek egyszerű mock-olása

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

Mivel az osztályok nem maguk konstruálják meg a függőségeiket (ezt a DI végzi), a mock-ok helyettesítése triviális — ez a tiszta unit tesztek alapja.

## Végpont-végpont (e2e) tesztelés — a teljes alkalmazás HTTP-n keresztül

```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 tesztek** bootstrappelnek a teljes alkalmazást és valódi HTTP kéréseket intéznek (a `supertest`-en keresztül), ellenőrizve, hogy az egész flow (routing → guard-ok → pipe-ok → handler → válasz) megfelelően működik.

## Tesztelési stratégia

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

## Miért fontos

A tesztelés elengedhetetlen a megbízható alkalmazások számára, és a NestJS architektúrája ezt Notable tisztán teszi lehetővé — a tesztelés módjának megértése fontos mind a kódminőség, mind azért, mert a keretrendszer *tesztelbetőségre van tervezve*.

A központi felismerés az, hogy a **függőség-injektálás trivialissá teszi a mock-olást**: mivel az osztályok deklarálják a függőségeiket és a DI biztosítja azokat, a `@nestjs/testing` modul lehetővé teszi bármely függőség (adatbázis repository-k, külső szolgáltatások, konfigurációk) lecserélését egy mock-ra az azonosítója alapján, lehetővé téve gyors, izolált **unit teszteket** a service-ekről, guard-okról és pipe-okról valódi infrastruktúra nélkül.

Ez a testelbetőség a fő oka annak, hogy a DI-alapú keretrendszereket, mint a NestJS-t, értékelik.

Az unit teszteket kiegészítve a **e2e tesztek** (a teljes alkalmazás bootstrappelése és valódi HTTP kérések intézése a `supertest`-en keresztül) ellenőrzik, hogy az egész kérés pipeline — routing, guard-ok, validáció, handler-ek — helyesen működik együtt.

A tesztelési segédeszközök (`Test.createTestingModule`, provider-ek mock-okkal való felülírása), az unit és e2e tesztek írásának módja, valamint egy értelmes tesztelési stratégia (sok gyors izolált unit teszt, kevesebb teljes e2e teszt, egy teszt adatbázis) ismerete a professzionális NestJS fejlesztés jellegzetessége.

Ez a fejlett mérnöki gyakorlatot tükrözi, és pontosan azt használja ki, ami a NestJS strukturált, DI-vezérelt tervét értékessé teszi, ezért fontos senior szintű téma.