Comment testez-vous les applications NestJS ?

Question

Accepted Answer

NestJS fournit un **utilitaire de test intégré (`@nestjs/testing`)** intégré à Jest, et son **architecture d'injection de dépendances rend les tests particulièrement propres** — vous créez un module de test et injectez des mocks pour les dépendances. Les tests se divisent en tests unitaires (isolés) et tests e2e (application complète).

## Test unitaire d'un service (avec dépendances mockées)

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

L'avantage clé : l'injection de dépendances de NestJS vous permet de **remplacer les vraies dépendances par des mocks** via les providers du module de test — vous testez ainsi le service en isolation, sans base de données réelle ni services externes.

## Mocker les dépendances facilement

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

Comme les classes ne construisent pas leurs dépendances (l'injection de dépendances le fait), remplacer les mocks est trivial — le fondement des tests unitaires propres.

## Test end-to-end (e2e) — l'application complète sur 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());
});
```

Les **tests E2E** démarrent l'application complète et font de vraies requêtes HTTP (via `supertest`), vérifiant que tout le flux (routage → guards → pipes → handler → réponse) fonctionne correctement ensemble.

## Stratégie de test

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

## Pourquoi c'est important

Les tests sont essentiels pour des applications fiables, et l'architecture de NestJS les rend remarquablement propres — savoir comment tester est important à la fois pour la qualité du code et parce que le framework est *conçu* pour la testabilité.

L'idée centrale est que l'**injection de dépendances rend les mocks triviaux** : comme les classes déclarent leurs dépendances et que l'injection de dépendances les fournit, le module `@nestjs/testing` vous permet de remplacer n'importe quelle dépendance (repositories de base de données, services externes, configuration) par un mock via son token, permettant des **tests unitaires** rapides et isolés de services, guards et pipes sans infrastructure réelle.

Cette testabilité est une raison majeure pour laquelle les frameworks basés sur l'injection de dépendances comme NestJS sont valorisés.

Complétant les tests unitaires, les **tests e2e** (démarrage de l'application complète et requêtes HTTP réelles via `supertest`) vérifient que tout le pipeline de requête — routage, guards, validation, handlers — fonctionne correctement ensemble.

Connaître les utilitaires de test (`Test.createTestingModule`, les overrides de providers pour les mocks), comment écrire à la fois des tests unitaires et e2e, et une stratégie de test pertinente (nombreux tests unitaires isolés rapides, moins de tests e2e complets, une base de données de test) est un signe distinctif du développement professionnel NestJS.

Cela reflète une pratique d'ingénierie mature et exploite exactement ce qui rend la conception structurée et basée sur l'injection de dépendances de NestJS précieuse, ce qui en fait un sujet important au niveau senior.