Come si testano le applicazioni NestJS?

Question

Accepted Answer

NestJS fornisce un **utility di testing integrato (`@nestjs/testing`)** integrato con Jest, e la sua **architettura di dependency injection rende il testing particolarmente pulito** — crei un modulo di testing e inietti mock per le dipendenze. I test si dividono in unit test (isolati) e test e2e (app completa).

## Unit test di un service (con dipendenze mockate)

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

Il vantaggio principale: la DI di NestJS ti consente di **sostituire le dipendenze reali con mock** tramite i provider del modulo di testing — così testi il service in isolamento, senza un database reale o servizi esterni.

## Mockare le dipendenze facilmente

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

Poiché le classi non costruiscono le loro dipendenze (lo fa la DI), sostituire i mock è banale — il fondamento dei unit test puliti.

## Test end-to-end (e2e) — l'app completa su 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());
});
```

I **test e2e** bootstrap l'applicazione completa e fanno richieste HTTP reali (tramite `supertest`), verificando che l'intero flusso (routing → guard → pipe → handler → response) funzioni insieme.

## Strategia di testing

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

## Perché è importante

Il testing è essenziale per applicazioni affidabili, e l'architettura di NestJS lo rende notevolmente pulito — capire come testare è importante sia per la qualità del codice sia perché il framework è *progettato* per la testabilità.

L'insight centrale è che **la dependency injection rende il mocking banale**: poiché le classi dichiarano le loro dipendenze e la DI le fornisce, il modulo `@nestjs/testing` ti consente di sostituire qualsiasi dipendenza (repository di database, servizi esterni, config) con un mock tramite il suo token, abilitando **unit test** veloci e isolati di service, guard e pipe senza infrastruttura reale.

Questa testabilità è una ragione principale per cui i framework basati su DI come NestJS sono apprezzati.

Complementando i unit test, i **test e2e** (bootstrap dell'app completa e richieste HTTP reali tramite `supertest`) verificano che l'intera pipeline di richiesta — routing, guard, validazione, handler — funzionino insieme correttamente.

Conoscere gli utility di testing (`Test.createTestingModule`, override dei provider per il mocking), come scrivere sia unit che test e2e, e una strategia di testing sensata (molti unit test veloci e isolati, meno test e2e completi, un database di test) è un marchio dello sviluppo NestJS professionale.

Riflette una pratica di ingegneria matura e sfrutta esattamente ciò che rende prezioso il design strutturato e guidato dalla DI di NestJS, rendendolo un argomento importante a livello senior.