Cum testezi aplicațiile NestJS?

Question

Accepted Answer

NestJS oferă un **utility de testare integrat (`@nestjs/testing`)** care funcționează cu Jest, iar **arhitectura sa de dependency injection face testarea deosebit de curată** — creezi un modul de testare și injectezi mock-uri pentru dependențe. Testele se împart în teste unitare (izolate) și teste e2e (aplicația completă).

## Testarea unui serviciu (cu dependențe mock)

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

Avantajul cheie: DI-ul NestJS te lasă să **înlocuiești dependențele reale cu mock-uri** prin providerii modulului de testare — așa că testezi serviciul în izolare, fără o bază de date reală sau servicii externe.

## Mock-urile dependențelor ușor

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

Pentru că clasele nu construiesc dependențele lor (DI-ul o face), înlocuirea mock-urilor este banală — fundamentul testelor unitare curate.

## Testarea end-to-end (e2e) — aplicația completă peste 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());
});
```

**Testele E2E**Bootstrapează aplicația completă și fac cereri HTTP reale (prin `supertest`), verificând că întregul flux (routing → guards → pipes → handler → response) funcționează împreună.

## Strategie de testare

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

## De ce contează

Testarea este esențială pentru aplicații fiabile, iar arhitectura NestJS o face deosebit de curată — a înțelege cum să testezi este important atât pentru calitatea codului, cât și pentru că framework-ul este *conceput* pentru testabilitate.

Insight-ul central este că **dependency injection face mock-urile banale**: deoarece clasele declară dependențele lor și DI le furnizează, modulul `@nestjs/testing` te lasă să înlocuiești orice dependență (repository-uri de bază de date, servicii externe, config) cu un mock după token, permițând teste unitare rapide, izolate ale serviciilor, guard-urilor și pipe-urilor fără infrastructură reală.

Această testabilitate este un motiv major pentru care framework-urile bazate pe DI, cum ar fi NestJS, sunt apreciate.

Complementând testele unitare, **testele e2e** (bootstrapping-ul aplicației complete și efectuarea de cereri HTTP reale prin `supertest`) verifică că întregul pipeline de cerere — routing, guards, validare, handlers — funcționează corect împreună.

Cunoașterea utility-urilor de testare (`Test.createTestingModule`, provider overrides pentru mock-uri), cum să scrii atât teste unitare, cât și e2e, și o strategie de testare sensibilă (multe teste unitare rapide și izolate, mai puține teste e2e complete, o bază de date de testare) este o caracteristică a dezvoltării profesionale NestJS.

Reflectă practica ingineriei mature și valorifică exact ceea ce face designul structured și DI-driven al NestJS valoros, făcând-o un subiect important la nivel senior.