Kaip testuoti NestJS aplikacijas?

Question

Accepted Answer

NestJS suteikia įmontuotą **testavimo utility (`@nestjs/testing`)** integruotą su Jest, ir jo **priklausomybės injekavimo architektūra daro testavimą ypač švaru** — sukuriate testavimo modulį ir injektuojate mock'us priklausomybėms. Testai skirstosi į vienetų testus (izoliuotus) ir e2e testus (visa aplikacija).

## Vienetų testavimas serviso (su mock'uotomis priklausomybėmis)

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

Pagrindinė pranašumas: NestJS DI leidžia jums **keisti tikras priklausomybes į mock'us** per testavimo modulio tiekėjus — todėl testinate servisą izoliuotai, be tikros duomenų bazės arba išorinių paslaugų.

## Priklausomybių mock'avimas lengvai

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

Bei kurie klasės nekonstruoja savo priklausomybių (DI tai daro), todėl mock'ų pakeitimas yra trivialus — švaių vienetų testų pagrindas.

## End-to-end (e2e) testavimas — visa aplikacija per 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 testai** įkelia visą aplikaciją ir atliekami tikrie HTTP užklausimai (per `supertest`), patikrinant, kad visas srautas (maršrutizavimas → saugos mechanizmai → pipeai → handler'is → atsakymas) veikia kartu.

## Testavimo strategija

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

## Kodėl tai svarbu

Testavimas yra neatsiejama patikimų aplikacijų dalis, ir NestJS architektūra tai daro ypač švaru — suprasti, kaip testuoti, svarbu tiek kodo kokybei, tiek todėl, kad sistema yra *skirta* testavimui.

Centrinė idėja yra, kad **priklausomybės injekavimas daro mock'avimą trivialiu**: kadangi klasės deklaruoja savo priklausomybes ir DI jas teikia, `@nestjs/testing` modulis leidžia jums bet kurią priklausomybę (duomenų bazės saugyklas, išorines paslaugas, konfigūraciją) pakeisti mock'u pagal jo žymę, leidžiant greitai, izoliuotai **testuoti vienetus** serviso, saugos mechanizmų ir pipeų be tikros infrastruktūros.

Šis testavimas yra viena iš pagrindinių priežasčių, kodėl DI pagrindu grindžtos sistemos kaip NestJS yra vertinamos.

Dengdami vienetų testus, **e2e testai** (įkeliant visą aplikaciją ir atliekami tikrie HTTP užklausimai per `supertest`) patikrina, kad visas užklausos srautas — maršrutizavimas, saugos mechanizmai, validacija, handlerio — veikia kartu teisingai.

Žinoti testavimo utilities (`Test.createTestingModule`, tiekėjų nepaisymus mock'avimui), kaip rašyti tiek vienetų, tiek e2e testus, ir protingą testavimo strategiją (daug greitų izoliuotų vienetų testų, mažiau visų e2e testų, testavimo duomenų bazę) yra profesionalaus NestJS programavimo ženklas.

Tai atspindi brandią inžinerijos praktiką ir pasinaudoja būtent tuo, kas daro NestJS struktūrizuotą, DI varytą projektavimą vertingu, todėl tai yra svarbi aukštesnio lygio tema.