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

TP 11 : Écrire les tests unitaires et e2e de l'API bibliothèque

Ce TP ajoute une suite de tests complète au dépôt api-bibliotheque du TP 7, publiée sur GitHub. Les tests unitaires couvrent les dates avec une horloge simulée, le filtre d'erreurs TypeORM et LivresSe...

0 chapitres 0 QCM Accès gratuit
TP 11 : Écrire les tests unitaires et e2e de l'API bibliothèque

À propos de ce cours

Ce TP ajoute une suite de tests complète au dépôt api-bibliotheque du TP 7, publiée sur GitHub. Les tests unitaires couvrent les dates avec une horloge simulée, le filtre d'erreurs TypeORM et LivresService avec ses quatre dépôts simulés. Ils couvrent aussi EmpruntsService avec une transaction simulée : limites, doublons, stock et retards. Les tests e2e utilisent une base MySQL dédiée, configurée par .env.test : validation, erreurs de contraintes, parcours d'emprunt, et deux emprunts simultanés du dernier exemplaire. La couverture est mesurée et analysée. Correction exécutée et grille sur 20.

Objectifs du TP

  • Écrire les tests unitaires des règles métier d'une vraie API, en simulant dépôts et transactions.
  • Écrire des tests e2e sur une base de données de test isolée.
  • Vérifier ce que seuls les tests avec une vraie base peuvent vérifier : contraintes et verrous.
  • Mesurer la couverture et l'analyser.

Durée: 6 h  |  Prérequis: TP 7 (dépôt api-bibliotheque), leçons 17.1 à 17.5, Node.js 24  |  Livrable: le dépôt api-bibliotheque avec l'étiquette v1.1.0.

Stratégie de test du TP 11

Les règles métier en tests unitaires rapides, l'intégration réelle en e2e.

Cahier des charges
  • Unitaires (aucune base, aucun réseau) : date.ts; TypeOrmErreursFilter (chaque code d'erreur) ; LivresService (création, auteur inexistant, catégories inconnues, modification du stock, suppression refusée) ; EmpruntsService (emprunt nominal avec verrou, 404, adhérent inactif, limite de 3, doublon, plus d'exemplaire, retour, retard, double retour).
  • E2e sur la base bibliotheque_test, vidée et recréée à chaque exécution : recherche paginée, validation, ISBN en double (409), suppression d'un auteur qui a des livres (409), parcours d'emprunt et de retour, deux emprunts simultanés du dernier exemplaire (un seul doit réussir), statistiques.
  • Un garde-fou empêche les tests e2e de s'exécuter sur une autre base que la base de test.
  • Couverture mesurée pour les deux suites, fichiers sans logique exclus.
Partie 1 Préparer le dépôt
  1. Vérifiez node -v (24.9 minimum, leçon 17.1). Dans api-bibliotheque, créez la branche tp11-tests.
  2. Créez src/configurer-app.ts (leçon 17.4) et utilisez-le dans main.ts.
  3. Dans AppModule: ConfigModule.forRoot({ isGlobal: true, envFilePath: process.env.NODE_ENV === 'test' ? '.env.test' : '.env' }). Créez .env.test et la base bibliotheque_test (CREATE DATABASE bibliotheque_test;, droits pour apc_dev).
  4. Supprimez les fichiers d'exemple générés (app.controller.spec.ts, test/app.e2e-spec.ts) s'ils ne correspondent plus à votre code. Commit : test: configuration des tests.
Partie 2 Tests unitaires des utilitaires
  1. date.spec.ts avec jest.useFakeTimers().setSystemTime(…): choisissez une date qui fait changer de mois et d'année.
  2. typeorm-erreurs.filter.spec.ts: un ArgumentsHost simulé, une réponse simulée (status qui renvoie this), un it.each par code d'erreur.
  3. Commit : test: utilitaires.
Partie 3 LivresService
  1. Quatre dépôts simulés avec getRepositoryToken.
  2. Pour chaque règle : un test du cas accepté et un test du cas refusé, en vérifiant aussi l'absence d'effet (save non appelé).
  3. Commit : test: LivresService.
Partie 4 EmpruntsService
  1. Un faux EntityManager et une fausse DataSource dont transaction(rappel) appelle directement le rappel ; le jeton est getDataSourceToken().
  2. Une fonction casNominal() qui programme les réponses par défaut ; chaque test n'en modifie qu'une.
  3. Vérifiez que le livre est lu avec le verrou pessimistic_write, et la date de retour prévue avec l'horloge simulée.
  4. Commit : test: EmpruntsService.
Partie 5 Tests e2e
  1. Dans beforeAll: application avec configurerApp, garde-fou sur le nom de la base, synchronize(true) (supprime et recrée les tables d'après les entités), données minimales.
  2. Les scénarios du cahier des charges, dont les deux emprunts lancés en même temps avec Promise.all.
  3. afterAll(() => app.close()). Commit : test: e2e de l'API.
Partie 6 Couverture et livraison
  1. Exclusions dans jest.config.ts et dans test/jest-e2e.json (racine du projet, comme à la leçon 17.5). Ajoutez coverage/ et coverage-e2e/ à .gitignore.
  2. Dans le README : comment lancer les tests, la base de test à créer, et un tableau des taux de couverture obtenus avec votre analyse (ce qui n'est pas couvert, et pourquoi).
  3. Fusion, push, étiquette v1.1.0.
Résultat attendu

Les trois commandes exécutées avec la correction (Node.js 24, base MariaDB de test) :

$ npm test -- --verbose
PASS src/emprunts/emprunts.service.spec.ts
  EmpruntsService
    emprunter()
      ✓ enregistre l'emprunt pour 14 jours et décrémente les disponibles (132 ms)
      ✓ 404 si le livre est introuvable (16 ms)
      ✓ 422 si l'adhérent est inactif (5 ms)
      ✓ 422 au-delà de 3 emprunts en cours (4 ms)
      ✓ 409 si le même livre est déjà emprunté par l'adhérent (5 ms)
      ✓ 409 s'il ne reste aucun exemplaire, sans rien modifier (5 ms)
    rendre()
      ✓ enregistre le retour, incrémente les disponibles et signale le retard (4 ms)
      ✓ 409 si l'emprunt est déjà rendu (4 ms)

PASS src/livres/livres.service.spec.ts
  LivresService
    create()
      ✓ crée le livre avec autant d'exemplaires disponibles que d'exemplaires (82 ms)
      ✓ refuse un auteur inexistant (404) sans rien enregistrer (8 ms)
      ✓ refuse des catégories inconnues (400) (3 ms)
    update()
      ✓ recalcule les disponibles quand le nombre d'exemplaires change (3 ms)
      ✓ refuse de descendre sous le nombre d'exemplaires empruntés (409) (2 ms)
      ✓ 404 si le livre n'existe pas (1 ms)
    remove()
      ✓ refuse la suppression si des emprunts sont en cours (409) (2 ms)
      ✓ supprime sinon (2 ms)

PASS src/common/typeorm-erreurs.filter.spec.ts
  TypeOrmErreursFilter
    ✓ ER_DUP_ENTRY → 409 (4 ms)
    ✓ ER_ROW_IS_REFERENCED_2 → 409 (1 ms)
    ✓ ER_NO_REFERENCED_ROW_2 → 400
    ✓ ER_INCONNUE → 500
    ✓ undefined → 500 (1 ms)

PASS src/common/date.spec.ts
  dates
    ✓ aujourdHui() renvoie la date du jour au format AAAA-MM-JJ (3 ms)
    ✓ dansNJours() passe correctement au mois et à l'année suivants (2 ms)

Test Suites: 4 passed, 4 total
Tests:       23 passed, 23 total
Snapshots:   0 total
Time:        1.74 s
Ran all test suites.

$ npm run test:cov
----------------------------|---------|----------|---------|---------|-------------------
File                        | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s 
----------------------------|---------|----------|---------|---------|-------------------
All files                   |   47.66 |    38.88 |   32.55 |   49.43 |                   
 src                        |       0 |      100 |       0 |       0 |                   
  configurer-app.ts         |       0 |      100 |       0 |       0 | 1-7               
 src/adherents              |       0 |        0 |       0 |       0 |                   
  adherents.controller.ts   |       0 |        0 |       0 |       0 | 1-24              
 src/auteurs                |       0 |        0 |       0 |       0 |                   
  auteurs.controller.ts     |       0 |        0 |       0 |       0 | 1-27              
  auteurs.service.ts        |       0 |        0 |       0 |       0 | 1-27              
 src/common                 |     100 |      100 |     100 |     100 |                   
  date.ts                   |     100 |      100 |     100 |     100 |                   
  typeorm-erreurs.filter.ts |     100 |      100 |     100 |     100 |                   
 src/emprunts               |   65.62 |    60.71 |   38.46 |   67.92 |                   
  emprunts.controller.ts    |       0 |        0 |       0 |       0 | 1-26              
  emprunts.service.ts       |   85.71 |       85 |    62.5 |      90 | 58-78             
 src/livres                 |   54.32 |    41.17 |   46.15 |    58.2 |                   
  livres.controller.ts      |       0 |        0 |       0 |       0 | 1-32              
  livres.service.ts         |   68.75 |    53.84 |   85.71 |      75 | 20-37,50,76-78    
----------------------------|---------|----------|---------|---------|-------------------

Test Suites: 4 passed, 4 total
Tests:       23 passed, 23 total
Snapshots:   0 total
Time:        2.355 s
Ran all test suites.

$ npm run test:e2e -- --verbose --coverage
PASS test/bibliotheque.e2e-spec.ts
  API bibliothèque (e2e, base MySQL de test)
    Livres
      ✓ GET /api/livres?q=mis → recherche par titre, avec méta de pagination (18 ms)
      ✓ POST /api/livres invalide → 400 avec les messages (5 ms)
      ✓ POST /api/livres avec un ISBN déjà utilisé → 409 (filtre TypeORM) (23 ms)
      ✓ DELETE /api/auteurs/:id d'un auteur qui a des livres → 409 (15 ms)
    Emprunts
      ✓ POST /api/emprunts → 201 et un exemplaire de moins (31 ms)
      ✓ le même livre une deuxième fois → 409 (14 ms)
      ✓ PATCH /api/emprunts/:id/retour → 200, puis 409 au second retour (28 ms)
      ✓ deux emprunts SIMULTANÉS du dernier exemplaire : un seul réussit (37 ms)
      ✓ GET /api/emprunts/statistiques (5 ms)

----------------------------|---------|----------|---------|---------|-------------------
File                        | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s 
----------------------------|---------|----------|---------|---------|-------------------
All files                   |    75.7 |    56.34 |   74.41 |   78.97 |                   
 src                        |     100 |      100 |     100 |     100 |                   
  configurer-app.ts         |     100 |      100 |     100 |     100 |                   
 src/adherents              |      75 |       60 |   66.66 |   76.92 |                   
  adherents.controller.ts   |      75 |       60 |   66.66 |   76.92 | 18-24             
 src/auteurs                |   71.87 |    56.25 |      60 |   73.07 |                   
  auteurs.controller.ts     |   86.66 |       75 |      60 |   84.61 | 11,16             
  auteurs.service.ts        |   58.82 |     37.5 |      60 |   61.53 | 12-18,27          
 src/common                 |     100 |       50 |     100 |     100 |                   
  date.ts                   |     100 |      100 |     100 |     100 |                   
  typeorm-erreurs.filter.ts |     100 |       50 |     100 |     100 | 15                
 src/emprunts               |   89.06 |    71.42 |   84.61 |   94.33 |                   
  emprunts.controller.ts    |   93.33 |       75 |      80 |    92.3 | 21                
  emprunts.service.ts       |   87.75 |       70 |    87.5 |      95 | 28,58             
 src/livres                 |   60.49 |       50 |   69.23 |   64.17 |                   
  livres.controller.ts      |   88.23 |       75 |   66.66 |   86.66 | 26,32             
  livres.service.ts         |   53.12 |     42.3 |   71.42 |   57.69 | 28,55,66-92       
----------------------------|---------|----------|---------|---------|-------------------
Test Suites: 1 passed, 1 total
Tests:       9 passed, 9 total
Snapshots:   0 total
Time:        2.093 s
Ran all test suites.
Analyse du résultat
  • Les 23 tests unitaires s'exécutent en 2 secondes, sans base de données ; les 9 tests e2e en 3 à 4 secondes, avec la base.
  • Le test des emprunts simultanés passe : un 201, un 409, et 0 exemplaire disponible. C'est le verrou pessimistic_write du TP 7 qui le garantit. Sans lui, les deux emprunts réussiraient (leçon 11.9). Ce comportement ne peut être prouvé qu'avec une vraie base.
  • Couverture unitaire : 100 % pour les utilitaires, environ 86 % des instructions d'EmpruntsService. Les méthodes enRetard et statistiques (lignes 58-78), simples requêtes, sont laissées aux e2e. Les contrôleurs sont à 0 en unitaire, mais couverts par les e2e.
  • Couverture e2e : livres.service.ts à 53 % seulement, car la modification et la suppression de livres ne sont pas testées en e2e, ni la recherche par catégorie ou disponibilité. C'est la piste d'amélioration principale (activités ci-dessous).
Pour aller plus loin
  • Compléter les e2e : PATCH et DELETE des livres, filtres categorie, disponible, tri, emprunts en retard (en insérant un emprunt daté dans le passé).
  • Exécuter les migrations au lieu de synchronize(true) dans les e2e (source.dropDatabase() puis source.runMigrations()), pour tester aussi les migrations.
  • Intégration continue : un workflow GitHub Actions qui démarre un service MySQL, crée .env.test et lance les deux suites à chaque push.
  • Tests unitaires de AuteursService et des contrôleurs.
Correction
src/configurer-app.ts
import { INestApplication, ValidationPipe } from '@nestjs/common';

// Réglages communs à main.ts ET aux tests e2e : une seule source de vérité
export function configurerApp(app: INestApplication) {
  app.setGlobalPrefix('api');
  app.useGlobalPipes(new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true, transform: true }));
  return app;
}
src/main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { configurerApp } from './configurer-app';

async function bootstrap() {
  const app = configurerApp(await NestFactory.create(AppModule));
  await app.listen(process.env.PORT ?? 3000);
}
bootstrap();
.env.test
# Base dédiée aux tests e2e : elle est VIDÉE à chaque exécution
DB_HOTE=localhost
DB_PORT=3306
DB_UTILISATEUR=apc_dev
DB_MOT_DE_PASSE=secret_dev
DB_NOM=bibliotheque_test
src/common/date.spec.ts
import { aujourdHui, dansNJours } from './date';

describe('dates', () => {
  beforeEach(() => jest.useFakeTimers().setSystemTime(new Date('2026-12-25T10:00:00Z')));
  afterEach(() => jest.useRealTimers());

  it('aujourdHui() renvoie la date du jour au format AAAA-MM-JJ', () => {
    expect(aujourdHui()).toBe('2026-12-25');
  });

  it('dansNJours() passe correctement au mois et à l\'année suivants', () => {
    expect(dansNJours(14)).toBe('2027-01-08');
    expect(dansNJours(0)).toBe('2026-12-25');
  });
});
src/common/typeorm-erreurs.filter.spec.ts
import { ArgumentsHost } from '@nestjs/common';
import { QueryFailedError } from 'typeorm';
import { TypeOrmErreursFilter } from './typeorm-erreurs.filter';

describe('TypeOrmErreursFilter', () => {
  const filtre = new TypeOrmErreursFilter();
  const res = { status: jest.fn().mockReturnThis(), json: jest.fn() };
  const host = { switchToHttp: () => ({ getResponse: () => res }) } as unknown as ArgumentsHost;
  const erreur = (code?: string) => Object.assign(new QueryFailedError('INSERT …', [], new Error('mysql')), { code });

  beforeEach(() => jest.clearAllMocks());

  it.each([
    ['ER_DUP_ENTRY', 409, 'Cette valeur existe déjà (champ unique)'],
    ['ER_ROW_IS_REFERENCED_2', 409, 'Suppression impossible : cet élément est utilisé ailleurs'],
    ['ER_NO_REFERENCED_ROW_2', 400, 'Référence vers un élément inexistant'],
    ['ER_INCONNUE', 500, 'Erreur de base de données'],
    [undefined, 500, 'Erreur de base de données'],
  ])('%s → %i', (code, statut, message) => {
    filtre.catch(erreur(code), host);
    expect(res.status).toHaveBeenCalledWith(statut);
    expect(res.json).toHaveBeenCalledWith({ statusCode: statut, message });
  });
});
src/livres/livres.service.spec.ts
import { BadRequestException, ConflictException, NotFoundException } from '@nestjs/common';
import { Test } from '@nestjs/testing';
import { getRepositoryToken } from '@nestjs/typeorm';
import { Auteur } from '../auteurs/auteur.entity';
import { Emprunt } from '../emprunts/emprunt.entity';
import { Categorie } from './categorie.entity';
import { Livre } from './livre.entity';
import { LivresService } from './livres.service';

describe('LivresService', () => {
  let service: LivresService;
  const livres = { create: jest.fn((d) => d), save: jest.fn(async (l) => ({ id: 10, ...l })), findOne: jest.fn(), remove: jest.fn() };
  const auteurs = { existsBy: jest.fn() };
  const categories = { findBy: jest.fn() };
  const emprunts = { existsBy: jest.fn() };
  const dto = { isbn: '9782070360024', titre: "L'Étranger", anneePublication: 1942, exemplaires: 3, auteurId: 5 };
  const livreExistant = () => ({ id: 1, titre: 'Les Misérables', exemplaires: 5, disponibles: 2, auteurId: 1, categories: [] });

  beforeEach(async () => {
    jest.clearAllMocks();
    const module = await Test.createTestingModule({
      providers: [
        LivresService,
        { provide: getRepositoryToken(Livre), useValue: livres },
        { provide: getRepositoryToken(Auteur), useValue: auteurs },
        { provide: getRepositoryToken(Categorie), useValue: categories },
        { provide: getRepositoryToken(Emprunt), useValue: emprunts },
      ],
    }).compile();
    service = module.get(LivresService);
  });

  describe('create()', () => {
    it('crée le livre avec autant d\'exemplaires disponibles que d\'exemplaires', async () => {
      auteurs.existsBy.mockResolvedValue(true);
      const r = await service.create(dto);
      expect(r).toMatchObject({ id: 10, exemplaires: 3, disponibles: 3, categories: [] });
      expect(categories.findBy).not.toHaveBeenCalled();          // pas de catégories demandées
    });

    it('refuse un auteur inexistant (404) sans rien enregistrer', async () => {
      auteurs.existsBy.mockResolvedValue(false);
      await expect(service.create(dto)).rejects.toThrow(new NotFoundException('Auteur 5 introuvable'));
      expect(livres.save).not.toHaveBeenCalled();
    });

    it('refuse des catégories inconnues (400)', async () => {
      auteurs.existsBy.mockResolvedValue(true);
      categories.findBy.mockResolvedValue([{ id: 1 }]);           // 2 demandées, 1 trouvée
      await expect(service.create({ ...dto, categorieIds: [1, 99] })).rejects.toThrow(BadRequestException);
    });
  });

  describe('update()', () => {
    it('recalcule les disponibles quand le nombre d\'exemplaires change', async () => {
      livres.findOne.mockResolvedValue(livreExistant());          // 5 exemplaires, 2 disponibles → 3 empruntés
      await service.update(1, { exemplaires: 4 });
      expect(livres.save).toHaveBeenCalledWith(expect.objectContaining({ exemplaires: 4, disponibles: 1 }));
    });

    it('refuse de descendre sous le nombre d\'exemplaires empruntés (409)', async () => {
      livres.findOne.mockResolvedValue(livreExistant());
      await expect(service.update(1, { exemplaires: 2 })).rejects.toThrow(
        '3 exemplaire(s) sont empruntés : impossible de descendre à 2',
      );
      expect(livres.save).not.toHaveBeenCalled();
    });

    it('404 si le livre n\'existe pas', async () => {
      livres.findOne.mockResolvedValue(null);
      await expect(service.update(99, { titre: 'X' })).rejects.toThrow(NotFoundException);
    });
  });

  describe('remove()', () => {
    it('refuse la suppression si des emprunts sont en cours (409)', async () => {
      livres.findOne.mockResolvedValue(livreExistant());
      emprunts.existsBy.mockResolvedValue(true);
      await expect(service.remove(1)).rejects.toThrow(ConflictException);
      expect(livres.remove).not.toHaveBeenCalled();
    });

    it('supprime sinon', async () => {
      livres.findOne.mockResolvedValue(livreExistant());
      emprunts.existsBy.mockResolvedValue(false);
      await service.remove(1);
      expect(livres.remove).toHaveBeenCalledWith(expect.objectContaining({ id: 1 }));
    });
  });
});
src/emprunts/emprunts.service.spec.ts
import { ConflictException, NotFoundException, UnprocessableEntityException } from '@nestjs/common';
import { Test } from '@nestjs/testing';
import { getDataSourceToken } from '@nestjs/typeorm';
import { Livre } from '../livres/livre.entity';
import { DUREE_JOURS, EmpruntsService, MAX_EMPRUNTS } from './emprunts.service';

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

  // Faux EntityManager : seules les méthodes utilisées dans les transactions
  const m = {
    findOne: jest.fn(), findOneBy: jest.fn(), countBy: jest.fn(), existsBy: jest.fn(),
    decrement: jest.fn(), increment: jest.fn(),
    create: jest.fn((_entite, donnees) => donnees),
    save: jest.fn(async (e) => ({ id: 7, ...e })),
  };
  // Fausse DataSource : transaction() exécute directement le rappel avec le faux EntityManager
  const source = { transaction: jest.fn((rappel: (em: typeof m) => unknown) => rappel(m)) };

  const livre = (disponibles = 2) => ({ id: 1, titre: 'Les Misérables', disponibles });
  const adherent = (actif = true) => ({ id: 3, prenom: 'Sami', nom: 'Ben Ali', actif });

  beforeEach(async () => {
    jest.clearAllMocks();
    jest.useFakeTimers().setSystemTime(new Date('2026-11-15T09:00:00Z'));
    const module = await Test.createTestingModule({
      providers: [EmpruntsService, { provide: getDataSourceToken(), useValue: source }],
    }).compile();
    service = module.get(EmpruntsService);
  });
  afterEach(() => jest.useRealTimers());

  const casNominal = () => {
    m.findOne.mockResolvedValue(livre());
    m.findOneBy.mockResolvedValue(adherent());
    m.countBy.mockResolvedValue(0);
    m.existsBy.mockResolvedValue(false);
  };

  describe('emprunter()', () => {
    it(`enregistre l'emprunt pour ${DUREE_JOURS} jours et décrémente les disponibles`, async () => {
      casNominal();
      const r = await service.emprunter({ livreId: 1, adherentId: 3 });
      expect(r).toEqual({ id: 7, livre: 'Les Misérables', adherent: 'Sami Ben Ali', dateRetourPrevue: '2026-11-29' });
      expect(m.decrement).toHaveBeenCalledWith(Livre, { id: 1 }, 'disponibles', 1);
      expect(m.findOne).toHaveBeenCalledWith(Livre, expect.objectContaining({ lock: { mode: 'pessimistic_write' } }));
    });

    it('404 si le livre est introuvable', async () => {
      casNominal(); m.findOne.mockResolvedValue(null);
      await expect(service.emprunter({ livreId: 9, adherentId: 3 })).rejects.toThrow(NotFoundException);
    });

    it('422 si l\'adhérent est inactif', async () => {
      casNominal(); m.findOneBy.mockResolvedValue(adherent(false));
      await expect(service.emprunter({ livreId: 1, adherentId: 3 })).rejects.toThrow(UnprocessableEntityException);
    });

    it(`422 au-delà de ${MAX_EMPRUNTS} emprunts en cours`, async () => {
      casNominal(); m.countBy.mockResolvedValue(MAX_EMPRUNTS);
      await expect(service.emprunter({ livreId: 1, adherentId: 3 })).rejects.toThrow(`Limite atteinte : ${MAX_EMPRUNTS} emprunts en cours`);
    });

    it('409 si le même livre est déjà emprunté par l\'adhérent', async () => {
      casNominal(); m.existsBy.mockResolvedValue(true);
      await expect(service.emprunter({ livreId: 1, adherentId: 3 })).rejects.toThrow('Cet adhérent a déjà emprunté ce livre');
    });

    it('409 s\'il ne reste aucun exemplaire, sans rien modifier', async () => {
      casNominal(); m.findOne.mockResolvedValue(livre(0));
      await expect(service.emprunter({ livreId: 1, adherentId: 3 })).rejects.toThrow(ConflictException);
      expect(m.decrement).not.toHaveBeenCalled();
      expect(m.save).not.toHaveBeenCalled();
    });
  });

  describe('rendre()', () => {
    it('enregistre le retour, incrémente les disponibles et signale le retard', async () => {
      m.findOne.mockResolvedValue({ id: 4, livre: livre(), dateRetourPrevue: '2026-11-10', dateRetour: null });
      const r = await service.rendre(4);
      expect(r).toEqual({ id: 4, livre: 'Les Misérables', rendu: '2026-11-15', enRetard: true });
      expect(m.increment).toHaveBeenCalledWith(Livre, { id: 1 }, 'disponibles', 1);
    });

    it('409 si l\'emprunt est déjà rendu', async () => {
      m.findOne.mockResolvedValue({ id: 4, livre: livre(), dateRetour: '2026-11-12' });
      await expect(service.rendre(4)).rejects.toThrow('Emprunt 4 déjà rendu le 2026-11-12');
      expect(m.increment).not.toHaveBeenCalled();
    });
  });
});
test/bibliotheque.e2e-spec.ts
import { INestApplication } from '@nestjs/common';
import { Test } from '@nestjs/testing';
import request from 'supertest';
import { App } from 'supertest/types';
import { DataSource } from 'typeorm';
import { AppModule } from '../src/app.module';
import { configurerApp } from '../src/configurer-app';
import { Categorie } from '../src/livres/categorie.entity';

describe('API bibliothèque (e2e, base MySQL de test)', () => {
  let app: INestApplication<App>;
  let http: ReturnType<typeof request>;
  let ids: { auteur: number; livre: number; livreUnique: number; sami: number; ines: number };

  beforeAll(async () => {
    const module = await Test.createTestingModule({ imports: [AppModule] }).compile();
    app = configurerApp(module.createNestApplication());
    await app.init();
    http = request(app.getHttpServer());

    // Base de test : schéma recréé à partir des entités, puis données minimales
    const source = app.get(DataSource);
    expect(source.options.database).toBe('bibliotheque_test');     // garde-fou : jamais la vraie base !
    await source.synchronize(true);
    await source.getRepository(Categorie).save([{ libelle: 'Roman' }, { libelle: 'Histoire' }]);

    const auteur = await http.post('/api/auteurs').send({ nom: 'Hugo', prenom: 'Victor' }).expect(201);
    const livre = await http.post('/api/livres')
      .send({ isbn: '9782253096344', titre: 'Les Misérables', anneePublication: 1862, exemplaires: 3, auteurId: auteur.body.id, categorieIds: [1] })
      .expect(201);
    const unique = await http.post('/api/livres')
      .send({ isbn: '9782070413119', titre: 'Notre-Dame de Paris', anneePublication: 1831, exemplaires: 1, auteurId: auteur.body.id })
      .expect(201);
    const sami = await http.post('/api/adherents').send({ nom: 'Ben Ali', prenom: 'Sami', email: 'sami@exemple.tn' }).expect(201);
    const ines = await http.post('/api/adherents').send({ nom: 'Trabelsi', prenom: 'Ines', email: 'ines@exemple.tn' }).expect(201);
    ids = { auteur: auteur.body.id, livre: livre.body.id, livreUnique: unique.body.id, sami: sami.body.id, ines: ines.body.id };
  });

  afterAll(() => app.close());

  describe('Livres', () => {
    it('GET /api/livres?q=mis → recherche par titre, avec méta de pagination', async () => {
      const r = await http.get('/api/livres?q=mis').expect(200);
      expect(r.body.donnees).toHaveLength(1);
      expect(r.body.donnees[0]).toMatchObject({ titre: 'Les Misérables', disponibles: 3, auteur: { nom: 'Hugo' } });
      expect(r.body.meta).toEqual({ total: 1, page: 1, limite: 10, pages: 1 });
    });

    it('POST /api/livres invalide → 400 avec les messages', async () => {
      const r = await http.post('/api/livres').send({ isbn: '978', titre: '', anneePublication: 3000, exemplaires: 0, auteurId: 1 }).expect(400);
      expect(r.body.message).toEqual(expect.arrayContaining(["L'ISBN doit contenir 13 chiffres", 'exemplaires must not be less than 1']));
    });

    it('POST /api/livres avec un ISBN déjà utilisé → 409 (filtre TypeORM)', async () => {
      const r = await http.post('/api/livres')
        .send({ isbn: '9782253096344', titre: 'Doublon', anneePublication: 1862, exemplaires: 1, auteurId: ids.auteur })
        .expect(409);
      expect(r.body.message).toBe('Cette valeur existe déjà (champ unique)');
    });

    it('DELETE /api/auteurs/:id d\'un auteur qui a des livres → 409', () =>
      http.delete(`/api/auteurs/${ids.auteur}`).expect(409));
  });

  describe('Emprunts', () => {
    let emprunt: number;

    it('POST /api/emprunts → 201 et un exemplaire de moins', async () => {
      const r = await http.post('/api/emprunts').send({ livreId: ids.livre, adherentId: ids.sami }).expect(201);
      emprunt = r.body.id;
      const livre = await http.get(`/api/livres/${ids.livre}`).expect(200);
      expect(livre.body.disponibles).toBe(2);
    });

    it('le même livre une deuxième fois → 409', () =>
      http.post('/api/emprunts').send({ livreId: ids.livre, adherentId: ids.sami }).expect(409));

    it('PATCH /api/emprunts/:id/retour → 200, puis 409 au second retour', async () => {
      const r = await http.patch(`/api/emprunts/${emprunt}/retour`).expect(200);
      expect(r.body).toMatchObject({ id: emprunt, enRetard: false });
      await http.patch(`/api/emprunts/${emprunt}/retour`).expect(409);
    });

    it('deux emprunts SIMULTANÉS du dernier exemplaire : un seul réussit', async () => {
      const [a, b] = await Promise.all([
        http.post('/api/emprunts').send({ livreId: ids.livreUnique, adherentId: ids.sami }),
        http.post('/api/emprunts').send({ livreId: ids.livreUnique, adherentId: ids.ines }),
      ]);
      expect([a.status, b.status].sort()).toEqual([201, 409]);
      const livre = await http.get(`/api/livres/${ids.livreUnique}`).expect(200);
      expect(livre.body.disponibles).toBe(0);
    });

    it('GET /api/emprunts/statistiques', async () => {
      const r = await http.get('/api/emprunts/statistiques').expect(200);
      expect(r.body.enCours).toBe(1);
    });
  });
});
test/jest-e2e.json
{
  "moduleFileExtensions": ["js", "json", "ts"],
  "rootDir": "..",
  "testEnvironment": "node",
  "testRegex": "test/.*\\.e2e-spec\\.ts$",
  "transform": { "^.+\\.(t|j)s$": "ts-jest" },
  "collectCoverageFrom": ["src/**/*.ts", "!src/main.ts", "!src/data-source.ts", "!src/seeds/**", "!src/**/*.spec.ts", "!src/**/*.module.ts", "!src/**/*.entity.ts", "!src/**/*.dto.ts"],
  "coverageDirectory": "coverage-e2e"
}
jest.config.ts
import type { Config } from 'jest';
import { pathsToModuleNameMapper } from 'ts-jest';
import ts from 'typescript';

// Path aliases (e.g. the ones added by `nest g library`) live in tsconfig.json,
// so they are read from there instead of being duplicated here.
const { config: tsconfig } = ts.readConfigFile(
  './tsconfig.json',
  ts.sys.readFile,
);
const paths = tsconfig?.compilerOptions?.paths ?? {};

const config: Config = {
  moduleFileExtensions: ['js', 'json', 'ts'],
  rootDir: '.',
  testRegex: '.*\\.spec\\.ts$',
  transform: {
    '^.+\\.(t|j)s$': 'ts-jest',
  },
  moduleNameMapper: pathsToModuleNameMapper(paths, { prefix: '<rootDir>/' }),
  collectCoverageFrom: [
    'src/**/*.ts',
    '!src/main.ts',
    '!src/data-source.ts',
    '!src/seeds/**',
    '!src/migrations/**',
    '!src/**/*.module.ts',
    '!src/**/*.entity.ts',
    '!src/**/*.dto.ts',
  ],
  coverageDirectory: './coverage',
  testEnvironment: 'node',
};

export default config;
Grille d'évaluation
CritèrePoints
Branche, commits par étape, .env.test, dossiers de couverture ignorés, étiquette v1.1.0, README2
configurerApp partagé, base de test séparée et garde-fou2
Tests des utilitaires (horloge simulée, filtre avec it.each)2
LivresService: dépôts simulés, cas acceptés et refusés, absence d'effet vérifiée3
EmpruntsService: transaction simulée, toutes les règles, verrou et date vérifiés4
E2e : validation, 409 des contraintes, parcours d'emprunt et de retour3
E2e : emprunts simultanés du dernier exemplaire2
Couverture mesurée (deux suites) et analysée2
Total20

Cet article vous a-t-il aidé ?