Jak testujete aplikace v NestJS?

Question

Accepted Answer

NestJS poskytuje zabudovaný **testovací nástroj (`@nestjs/testing`)** integrovaný s Jestem, a jeho **architektura dependency injection činí testování obzvláště čistým** — vytvoříte testovací modul a vložíte mock objekty pro závislosti. Testy se dělí na unit testy (izolované) a e2e testy (celá aplikace).

## Unit testování služby (s mock závislostmi)

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

Hlavní výhoda: NestJS DI vám umožní **vyměnit skutečné závislosti za mocks** prostřednictvím poskytovatelů testovacího modulu — takže testujete službu v izolaci, bez skutečné databáze nebo externích služeb.

## Snadné mockování závislostí

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

Protože třídy nekonstruují své závislosti (DI to dělá), je nahrazení mocků triviální — základ čistých unit testů.

## End-to-end (e2e) testování — celá aplikace přes 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 testy** spouštějí celou aplikaci a dělají skutečné HTTP požadavky (přes `supertest`), ověřují, že celý tok (routing → guards → pipes → handler → response) funguje dohromady.

## Testovací 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.
```

## Proč je to důležité

Testování je zásadní pro spolehlivé aplikace, a architektura NestJS jej činí obzvláště čistým — porozumění tomu, jak testovat, je důležité jak pro kvalitu kódu, tak proto, že je framework *navržen* pro testovatelnost.

Centrální myšlenka je, že **dependency injection činí mockování triviálním**: protože třídy deklarují své závislosti a DI je poskytuje, modul `@nestjs/testing` vám umožní vyměnit jakoukoli závislost (repozitáře databází, externí služby, konfiguraci) za mock podle jejího tokenu, což umožňuje rychlé, izolované **unit testy** služeb, guard ů a pipes bez skutečné infrastruktury.

Tato testovatelnost je jedním z hlavních důvodů, proč jsou frameworky založené na DI jako NestJS oceňovány.

Doplňující unit testy, **e2e testy** (spouštění celé aplikace a dělání skutečných HTTP požadavků přes `supertest`) ověřují, že celá pipeline požadavků — routing, guardy, validace, handlery — fungují správně dohromady.

Znalost testovacích nástrojů (`Test.createTestingModule`, přepisování poskytovatelů pro mockování), jak psát jak unit testy tak e2e testy, a rozumná testovací strategie (mnoho rychlých izolovaných unit testů, méně plných e2e testů, testovací databáze) je charakteristikou profesionálního vývoje v NestJS.

Odráží zralou inženýrskou praxi a využívá přesně to, co činí strukturovaný, na DI založený design NestJS cennému, což z toho činí důležité téma na úrovni senior vývojářů.