Avez-vous une question? (216) 97 656 803 hajjriadh@gmail.com
NestJS

Les tests unitaires avec Jest (Test.createTestingModule)

Cette leçon écrit les tests unitaires d'un service et d'un contrôleur NestJS. Elle explique Test.createTestingModule, qui construit un petit module avec le conteneur d'injection de NestJS, puis compil...

0 chapitres 0 QCM Accès gratuit
Les tests unitaires avec Jest (Test.createTestingModule)

À propos de ce cours

Cette leçon écrit les tests unitaires d'un service et d'un contrôleur NestJS. Elle explique Test.createTestingModule, qui construit un petit module avec le conteneur d'injection de NestJS, puis compile et get. Elle montre aussi pourquoi recréer le module dans beforeEach garantit des tests indépendants. Les matchers essentiels sont mis en pratique : toBe, toEqual, toMatchObject, toThrow, ainsi que resolves et rejects pour le code asynchrone. L'exécution affiche le rapport détaillé de 19 tests. Elle présente le fichier généré par nest g et le mode watch. Activités corrigées.

Objectifs de la leçon

  • Construire un module de test avec Test.createTestingModule.
  • Tester un service : valeurs, objets, exceptions, code asynchrone.
  • Tester un contrôleur avec son service.
  • Garder des tests indépendants avec beforeEach.
Le service à tester

📄 src/notes/notes.service.ts

import { Injectable, NotFoundException } from '@nestjs/common';
import { mention, moyenne } from './calculs';

export interface Note { stagiaireId: number; matiere: string; valeur: number }

@Injectable()
export class NotesService {
  private notes: Note[] = [];

  ajouter(note: Note) {
    if (note.valeur < 0 || note.valeur > 20) throw new RangeError('Une note est comprise entre 0 et 20');
    this.notes.push(note);
    return note;
  }

  bulletin(stagiaireId: number) {
    const siennes = this.notes.filter((n) => n.stagiaireId === stagiaireId);
    if (siennes.length === 0) throw new NotFoundException(`Aucune note pour le stagiaire ${stagiaireId}`);
    const moy = moyenne(siennes.map((n) => n.valeur));
    return { stagiaireId, notes: siennes.length, moyenne: moy, mention: mention(moy) };
  }

  async bulletinAsync(stagiaireId: number) {
    await new Promise((r) => setTimeout(r, 10));            // comme une requête en base
    return this.bulletin(stagiaireId);
  }
}
Test.createTestingModule

Un service NestJS reçoit ses dépendances par injection. Plutôt que de faire new NotesService(…) à la main, on demande à NestJS de construire un petit module, exactement comme à l'exécution :

Le module de test

On déclare ce dont le test a besoin, NestJS construit et injecte.

📄 src/notes/notes.service.spec.ts

import { NotFoundException } from '@nestjs/common';
import { Test, TestingModule } from '@nestjs/testing';
import { NotesService } from './notes.service';

describe('NotesService', () => {
  let service: NotesService;

  // Avant CHAQUE test : un module neuf, donc un service neuf (aucune note héritée du test précédent)
  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [NotesService],
    }).compile();
    service = module.get(NotesService);
  });

  it('est défini', () => {
    expect(service).toBeDefined();
  });

  describe('bulletin()', () => {
    it('calcule moyenne et mention à partir des notes du stagiaire', () => {
      service.ajouter({ stagiaireId: 1, matiere: 'SQL', valeur: 16 });
      service.ajouter({ stagiaireId: 1, matiere: 'NestJS', valeur: 13 });
      service.ajouter({ stagiaireId: 2, matiere: 'SQL', valeur: 5 });     // un autre stagiaire

      expect(service.bulletin(1)).toEqual({ stagiaireId: 1, notes: 2, moyenne: 14.5, mention: 'Bien' });
    });

    it('lève NotFoundException si le stagiaire n\'a aucune note', () => {
      expect(() => service.bulletin(99)).toThrow(NotFoundException);
      expect(() => service.bulletin(99)).toThrow('Aucune note pour le stagiaire 99');
    });

    it('fonctionne aussi en asynchrone', async () => {
      service.ajouter({ stagiaireId: 3, matiere: 'SQL', valeur: 9 });
      await expect(service.bulletinAsync(3)).resolves.toMatchObject({ mention: 'Insuffisant' });
      await expect(service.bulletinAsync(4)).rejects.toThrow(NotFoundException);
    });
  });

  describe('ajouter()', () => {
    it.each([-1, 20.5, 25])('refuse la note %p', (valeur) => {
      expect(() => service.ajouter({ stagiaireId: 1, matiere: 'SQL', valeur })).toThrow(RangeError);
    });

    it('accepte les bornes 0 et 20', () => {
      expect(service.ajouter({ stagiaireId: 1, matiere: 'A', valeur: 0 })).toMatchObject({ valeur: 0 });
      expect(service.ajouter({ stagiaireId: 1, matiere: 'B', valeur: 20 })).toMatchObject({ valeur: 20 });
    });
  });
});
Ce qu'il faut remarquer
  • beforeEach recrée le module, donc un service neuf, avant chaque test : les notes ajoutées dans un test n'existent pas dans le suivant. Les tests peuvent s'exécuter dans n'importe quel ordre.
  • toEqual compare tout le contenu ; toMatchObject seulement les propriétés indiquées (plus robuste quand l'objet contient des dates ou des identifiants).
  • Une exception synchrone se teste en passant une fonction à expect: expect(() => service.bulletin(99)).toThrow(…). Sans la flèche, l'exception serait levée avant expect et le test planterait.
  • Pour une promesse: await expect(promesse).resolves… ou .rejects.toThrow(…). Oublier await fait passer le test même si la promesse échoue.
  • toThrow accepte une classe d'exception, un message ou une expression régulière.
Tester un contrôleur

📄 src/notes/notes.controller.ts

import { Body, Controller, Get, Param, ParseIntPipe, Post } from '@nestjs/common';
import { NotesService, type Note } from './notes.service';

@Controller('notes')
export class NotesController {
  constructor(private readonly service: NotesService) {}

  @Post()
  ajouter(@Body() note: Note) {
    return this.service.ajouter(note);
  }

  @Get('bulletin/:id')
  bulletin(@Param('id', ParseIntPipe) id: number) {
    return this.service.bulletin(id);
  }
}

📄 src/notes/notes.controller.spec.ts

import { Test } from '@nestjs/testing';
import { NotesController } from './notes.controller';
import { NotesService } from './notes.service';

describe('NotesController', () => {
  let controleur: NotesController;

  beforeEach(async () => {
    const module = await Test.createTestingModule({
      controllers: [NotesController],
      providers: [NotesService],           // le vrai service : test d'intégration contrôleur + service
    }).compile();
    controleur = module.get(NotesController);
  });

  it('renvoie le bulletin après ajout de notes', () => {
    controleur.ajouter({ stagiaireId: 7, matiere: 'SQL', valeur: 18 });
    expect(controleur.bulletin(7).mention).toBe('Très bien');
  });
});

Ici, le contrôleur est testé avec le vrai service : c'est un petit test d'intégration. Les décorateurs (@Get, ParseIntPipe…) ne sont pas exécutés : on appelle directement la méthode. Le routage, les pipes et les guards se testent en e2e (leçon 17.4).

Résultat réellement obtenu :

$ npm test -- notes --verbose
PASS src/notes/notes.service.spec.ts
  NotesService
    ✓ est défini (152 ms)
    bulletin()
      ✓ calcule moyenne et mention à partir des notes du stagiaire (6 ms)
      ✓ lève NotFoundException si le stagiaire n'a aucune note (34 ms)
      ✓ fonctionne aussi en asynchrone (25 ms)
    ajouter()
      ✓ refuse la note -1 (7 ms)
      ✓ refuse la note 20.5 (7 ms)
      ✓ refuse la note 25 (4 ms)
      ✓ accepte les bornes 0 et 20 (4 ms)

PASS src/notes/notes.controller.spec.ts
  NotesController
    ✓ renvoie le bulletin après ajout de notes (105 ms)

PASS src/notes/calculs.spec.ts
  moyenne()
    ✓ calcule la moyenne de plusieurs notes (4 ms)
    ✓ arrondit à deux décimales (1 ms)
    ✓ renvoie null pour une liste vide (1 ms)
  mention()
    ✓ mention(16) vaut « Très bien »
    ✓ mention(15.99) vaut « Bien »
    ✓ mention(14) vaut « Bien » (1 ms)
    ✓ mention(12) vaut « Assez bien » (1 ms)
    ✓ mention(10) vaut « Passable »
    ✓ mention(9.99) vaut « Insuffisant »
    ✓ mention(null) vaut « Non évalué »

Test Suites: 3 passed, 3 total
Tests:       19 passed, 19 total
Snapshots:   0 total
Time:        1.353 s
Ran all test suites matching notes.
Les fichiers générés et le mode watch

nest g service notes crée aussi notes.service.spec.ts, avec un seul test « should be defined ». C'est un point de départ : complétez-le, ou supprimez-le avec l'option --no-spec si vous préférez écrire vos tests vous-même.

npm test                       # tous les tests unitaires
npm test -- notes              # seulement les fichiers dont le chemin contient « notes »
npm test -- -t "bulletin"      # seulement les tests dont le nom contient « bulletin »
npm run test:watch             # relance à chaque modification (touche a : tout, p : filtrer)

it.only(…) exécute uniquement ce test, it.skip(…) l'ignore : pratique pendant la mise au point, mais ne les commitez jamais (un only oublié désactive silencieusement tous les autres tests du fichier).

Activités

Activité 1 Compléter les tests

Ajoutez à NotesService une méthode supprimer(stagiaireId, matiere) qui lève NotFoundException si la note n'existe pas. Écrivez trois tests : suppression réussie (le bulletin ne la contient plus), note inexistante, et vérification que les notes des autres stagiaires sont intactes.

Voir le corrigé
describe('supprimer()', () => {
  beforeEach(() => {
    service.ajouter({ stagiaireId: 1, matiere: 'SQL', valeur: 12 });
    service.ajouter({ stagiaireId: 1, matiere: 'JS', valeur: 16 });
    service.ajouter({ stagiaireId: 2, matiere: 'SQL', valeur: 8 });
  });

  it('retire la note', () => {
    service.supprimer(1, 'SQL');
    expect(service.bulletin(1)).toMatchObject({ notes: 1, moyenne: 16 });
  });

  it('404 si la note n\'existe pas', () => {
    expect(() => service.supprimer(1, 'Réseaux')).toThrow(NotFoundException);
  });

  it('ne touche pas aux autres stagiaires', () => {
    service.supprimer(1, 'SQL');
    expect(service.bulletin(2).moyenne).toBe(8);
  });
});

Un beforeEach placé dans un describe ne s'applique qu'aux tests de ce bloc ; il s'exécute après celui du niveau supérieur.

Activité 2 Le piège du await

Ce test passe alors que bulletinAsync(4) échoue. Pourquoi ? Corrigez-le.

it('rejette pour un stagiaire sans note', () => {
  expect(service.bulletinAsync(4)).rejects.toThrow(NotFoundException);
});
Voir le corrigé

Sans await (ni return), le test se termine avant que la promesse soit résolue : Jest considère qu'il a réussi. Correction : it('…', async () => { await expect(service.bulletinAsync(4)).rejects.toThrow(NotFoundException); });.

Activité 3 toEqual ou toMatchObject ?

Pour chaque vérification, quel matcher choisir ? (a) Le résultat de moyenne(); (b) une entité renvoyée par un service, avec id et creeLe générés ; (c) un tableau de messages d'erreur dont l'ordre peut varier ; (d) le bulletin complet de la leçon.

Voir le corrigé

(a) toBe (nombre). (b) toMatchObject({ email, formation }): on ne connaît pas la date exacte ; ou toEqual({ ..., creeLe: expect.any(Date) }). (c) toEqual(expect.arrayContaining([...])). (d) toEqual: on connaît toutes les valeurs, et une propriété en trop doit faire échouer le test.

Activité 4 Tester un service existant

Écrivez les tests unitaires de FormationsService du chapitre 06 (liste en mémoire : création, recherche, modification, suppression, 404). Visez au moins un test par chemin de chaque méthode.

Voir le corrigé

Structure attendue : un describe par méthode, un beforeEach qui crée le module, au moins un test « cas normal » et un test par exception (NotFoundException, conflit éventuel). Lancez npm test -- formations --verbose: le rapport doit se lire comme la spécification du service.

À retenir

  • Test.createTestingModule({ providers, controllers }).compile() puis module.get(Classe).
  • beforeEach : un module neuf par test, des tests indépendants.
  • toBe, toEqual, toMatchObject, toThrow ; expect(() => …) pour une exception synchrone.
  • await expect(promesse).resolves / .rejects : ne jamais oublier await.
  • Tester un contrôleur = appeler ses méthodes ; routage, pipes et guards se testent en e2e.

Cet article vous a-t-il aidé ?