Kako preizkušate NestJS aplikacije?

Question

Accepted Answer

NestJS ponuja vgrajeno **testno sredstvo (`@nestjs/testing`)** integrirano s Jestom, njegova **arhitektura vbrizgavanja odvisnosti pa omogoča izjemno čisto testiranje** — ustvarite testni modul in vbrizgate napake (mocks) za odvisnosti. Testi se delijo na teste enot (izolirane) in e2e teste (celotna aplikacija).

## Testiranje storitve z naključnimi odvisnostmi

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

Glavna prednost: NestJS-ova DI vam omogoči **zameno resničnih odvisnosti z naključkami** preko ponudnikov testnega modula — tako testirате storitev v izolaciji, brez prave baze podatkov ali zunanjih storitev.

## Enostavno nadomestilo odvisnosti

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

Ker razredi ne sestavljajo svojih odvisnosti (to naredi DI), je nadomestilo naključkov banalno — temelj čistih testov enot.

## Testiranje od konca do konca (e2e) — celotna aplikacija preko 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 testi** zagonijo celotno aplikacijo in naredijo prave HTTP zahteve (preko `supertest`), kar preveri, da celoten tok (usmerjanje → varovila → cevi → obdelovalec → odgovor) deluje skupaj.

## Strategija testiranja

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

## Zakaj je to pomembno

Testiranje je bistvenega pomena za zanesljive aplikacije, in NestJS-ova arhitektura to naredi izjemno čisto — razumevanje, kako testirati, je pomembno tako za kakovost kode kot tudi zato, ker je ogrodje *zasnovano* za testnost.

Osrednja ideja je, da **vbrizgavanje odvisnosti naredi nadomestilo naključkov banalno**: ker razredi navedejo svoje odvisnosti, DI pa jih zagotovi, vam modul `@nestjs/testing` omogoči zameno katere koli odvisnosti (shramba podatkov, zunanje storitve, konfiguracija) s naključkom po njenem žetonu, kar omogoči hitro, izolirano **testiranje enot** storitev, varovil in cevi brez prave infrastrukture.

Ta testnost je glavni razlog, da so ogrodja na osnovi DI, kot je NestJS, cenjena.

Dopolnjujoči testi enot, **e2e testi** (zagon celotne aplikacije in izdelava pravih HTTP zahtev preko `supertest`) preverijo, da celoten kanal zahteve — usmerjanje, varovila, preverjanje, obdelovalci — deluje skupaj pravilno.

Znanje testnih pripomočkov (`Test.createTestingModule`, pregledi ponudnikov za nadomestilo), kako pisati tako teste enot kot e2e teste, in smiselna strategija testiranja (številni hitri izolirani testi enot, manj polnih e2e testov, testna baza podatkov) je značilnost profesionalnega razvoja NestJS.

Odseva zmaturano inženirsko prakso in izkoristi natanko tisto, kar naredi strukturirano, na DI napravljeno oblikovanje NestJS vrednega, kar je pomembna tema na višji ravni.