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

Mesurer la couverture de code

Cette leçon mesure la part du code exécutée par les tests avec npm run test:cov. Elle explique les quatre indicateurs : instructions, branches, fonctions et lignes. Elle les lit dans le tableau réel d...

0 chapitres 0 QCM Accès gratuit
Mesurer la couverture de code

À propos de ce cours

Cette leçon mesure la part du code exécutée par les tests avec npm run test:cov. Elle explique les quatre indicateurs : instructions, branches, fonctions et lignes. Elle les lit dans le tableau réel de Jest et dans le rapport HTML, qui surligne le code jamais exécuté. Elle exclut les fichiers sans logique, comme main.ts, les modules, les entités et les DTO. Elle fixe des seuils (coverageThreshold) qui font échouer la commande, et mesure séparément la couverture des tests e2e. Elle conclut sur les limites de l'indicateur : 100 % de couverture ne garantit pas des tests pertinents. Activités corrigées.

Objectifs de la leçon

  • Produire et lire un rapport de couverture.
  • Distinguer instructions, branches, fonctions et lignes.
  • Configurer exclusions et seuils minimaux.
  • Connaître les limites de la couverture.
Qu'est-ce que la couverture ?

La couverture de code (code coverage) mesure la proportion du code exécutée au moins une fois pendant les tests. Jest l'obtient avec l'outil Istanbul, qui instrumente le code pour compter les passages.

IndicateurCe qui est compté
Statements (instructions)chaque instruction exécutée
Brancheschaque chemin d'un if, ? :, ??, ||, switch: le cas vrai ET le cas faux
Functionschaque fonction ou méthode appelée au moins une fois
Lineschaque ligne contenant du code exécuté

Les branches sont l'indicateur le plus exigeant : un if (moy >= 16) testé seulement avec 18 a ses lignes couvertes, mais pas sa branche « faux ».

Le rapport

Lançons la couverture sur le projet des leçons 17.2 à 17.4 (notes, inscriptions, stagiaires) :

Résultat réellement obtenu :

$ npm run test:cov
---------------------------|---------|----------|---------|---------|-------------------
File                       | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s 
---------------------------|---------|----------|---------|---------|-------------------
All files                  |   52.53 |    59.67 |      50 |    51.3 |                   
 src                       |       0 |        0 |       0 |       0 |                   
  app.module.ts            |       0 |      100 |     100 |       0 | 1-5               
  configurer-app.ts        |       0 |      100 |       0 |       0 | 1-7               
  main.ts                  |       0 |        0 |       0 |       0 | 1-9               
 src/inscriptions          |   97.22 |       80 |   66.66 |   96.42 |                   
  inscription.entity.ts    |     100 |       75 |     100 |     100 | 15                
  inscriptions.service.ts  |     100 |    81.25 |     100 |     100 | 13-14             
  mail.service.ts          |      80 |      100 |       0 |   66.66 | 7                 
 src/notes                 |   88.88 |    95.45 |     100 |   88.88 |                   
  calculs.ts               |     100 |      100 |     100 |     100 |                   
  notes.controller.ts      |     100 |       75 |     100 |     100 | 6                 
  notes.module.ts          |       0 |      100 |     100 |       0 | 1-6               
  notes.service.ts         |     100 |      100 |     100 |     100 |                   
 src/stagiaires            |       0 |        0 |       0 |       0 |                   
  mail.service.ts          |       0 |      100 |       0 |       0 | 1-7               
  stagiaire.dto.ts         |       0 |      100 |     100 |       0 | 1-6               
  stagiaires.controller.ts |       0 |        0 |       0 |       0 | 1-19              
  stagiaires.module.ts     |       0 |      100 |     100 |       0 | 1-7               
  stagiaires.service.ts    |       0 |        0 |       0 |       0 | 1-23              
---------------------------|---------|----------|---------|---------|-------------------

Test Suites: 4 passed, 4 total
Tests:       23 passed, 23 total
Snapshots:   0 total
Time:        2.24 s
Ran all test suites.
Lecture
  • calculs.ts et notes.service.ts: 100 % partout, grâce aux tests des leçons 17.1 et 17.2.
  • src/stagiaires: 0 %. Ces fichiers sont pourtant testés… en e2e. npm run test:cov ne lance que les tests unitaires.
  • main.ts, app.module.ts, les modules, l'entité et le DTO font baisser les totaux. Ils ne contiennent pas de logique à tester.
  • Des branches non couvertes sont signalées sur des lignes de décorateurs (ligne 6 de notes.controller.ts, ligne 15 de l'entité, lignes 13-14 du service). Ce ne sont pas des if de votre code, mais du code que TypeScript génère pour les métadonnées des décorateurs (emitDecoratorMetadata). Ne cherchez pas à les couvrir.
  • mail.service.ts: sa méthode n'est jamais appelée, puisqu'il est toujours simulé. C'est normal : on le testerait avec un vrai serveur de test (MailDev, chapitre 15).

Rapport de couverture HTML

Le rapport HTML (coverage/lcov-report/index.html) : un clic sur un dossier ou un fichier affiche le détail.

Fichier non couvert dans le rapport HTML

Le détail d'un fichier : en rouge, le code jamais exécuté par les tests unitaires (le service des stagiaires n'est testé qu'en e2e).

Exclusions et seuils

Dans jest.config.ts, on exclut ce qui n'a pas de logique et on fixe des seuils: en dessous, la commande échoue.

📄 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/**/*.(t|j)s',
    // ce qui n'a pas de logique à tester : démarrage, modules, entités, DTO
    '!src/main.ts',
    '!src/**/*.module.ts',
    '!src/**/*.entity.ts',
    '!src/**/*.dto.ts',
  ],
  // en dessous de ces pourcentages, « npm run test:cov » échoue (utile en intégration continue)
  coverageThreshold: {
    global: { statements: 90, branches: 85, functions: 90, lines: 90 },
  },
  coverageDirectory: './coverage',
  testEnvironment: 'node',
};

export default config;

Résultat réellement obtenu :

$ npm run test:cov   (avec exclusions et seuils)
---------------------------|---------|----------|---------|---------|-------------------
File                       | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s 
---------------------------|---------|----------|---------|---------|-------------------
All files                  |   61.98 |    60.71 |   51.85 |   61.62 |                   
 src                       |       0 |      100 |       0 |       0 |                   
  configurer-app.ts        |       0 |      100 |       0 |       0 | 1-7               
 src/inscriptions          |   96.42 |    81.25 |   66.66 |   95.45 |                   
  inscriptions.service.ts  |     100 |    81.25 |     100 |     100 | 13-14             
  mail.service.ts          |      80 |      100 |       0 |   66.66 | 7                 
 src/notes                 |     100 |    95.45 |     100 |     100 |                   
  calculs.ts               |     100 |      100 |     100 |     100 |                   
  notes.controller.ts      |     100 |       75 |     100 |     100 | 6                 
  notes.service.ts         |     100 |      100 |     100 |     100 |                   
 src/stagiaires            |       0 |        0 |       0 |       0 |                   
  mail.service.ts          |       0 |      100 |       0 |       0 | 1-7               
  stagiaires.controller.ts |       0 |        0 |       0 |       0 | 1-19              
  stagiaires.service.ts    |       0 |        0 |       0 |       0 | 1-23              
---------------------------|---------|----------|---------|---------|-------------------
Jest: Coverage for statements (61.98%) does not meet "global" threshold (90%)
Jest: Coverage for branches (60.71%) does not meet "global" threshold (85%)
Jest: Coverage for lines (61.62%) does not meet "global" threshold (90%)
Jest: Coverage for functions (51.85%) does not meet "global" threshold (90%)

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

Les totaux ne comptent plus les fichiers sans logique, et la commande signale les quatre seuils non atteints (avec un code de sortie en erreur : en intégration continue, la fusion serait bloquée). Il reste à tester StagiairesService unitairement, ou à ajouter la couverture des tests e2e.

La couverture des tests e2e

Le fichier test/jest-e2e.json a pour racine le dossier test/: pour mesurer la couverture de src/, on crée une configuration dont la racine est le projet :

📄 test/jest-e2e-cov.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/**/*.spec.ts", "!src/**/*.module.ts", "!src/**/*.entity.ts", "!src/**/*.dto.ts"],
  "coverageDirectory": "coverage-e2e"
}

Résultat réellement obtenu :

$ npm run test:e2e -- --config ./test/jest-e2e-cov.json --coverage
---------------------------|---------|----------|---------|---------|-------------------
File                       | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s 
---------------------------|---------|----------|---------|---------|-------------------
All files                  |   36.36 |    26.78 |   40.74 |   36.04 |                   
 src                       |     100 |      100 |     100 |     100 |                   
  configurer-app.ts        |     100 |      100 |     100 |     100 |                   
 src/inscriptions          |       0 |        0 |       0 |       0 |                   
  inscriptions.service.ts  |       0 |        0 |       0 |       0 | 1-31              
  mail.service.ts          |       0 |      100 |       0 |       0 | 1-7               
 src/notes                 |       0 |        0 |       0 |       0 |                   
  calculs.ts               |       0 |        0 |       0 |       0 | 2-14              
  notes.controller.ts      |       0 |        0 |       0 |       0 | 1-15              
  notes.service.ts         |       0 |        0 |       0 |       0 | 1-25              
 src/stagiaires            |    97.5 |    83.33 |    90.9 |   96.29 |                   
  mail.service.ts          |      80 |      100 |       0 |   66.66 | 7                 
  stagiaires.controller.ts |     100 |       80 |     100 |     100 | 7-17              
  stagiaires.service.ts    |     100 |     87.5 |     100 |     100 | 8                 
---------------------------|---------|----------|---------|---------|-------------------
Test Suites: 1 passed, 1 total
Tests:       6 passed, 6 total
Snapshots:   0 total
Time:        1.67 s
Ran all test suites.

Les tests e2e couvrent bien src/stagiaires (et configurer-app.ts) ; les fichiers des autres leçons, sans test e2e, restent à 0. Les deux rapports sont complémentaires.

Les limites de l'indicateur: la couverture dit ce qui a été exécuté, pas ce qui a été vérifié. Un test sans aucun expect qui appelle toutes les méthodes donne 100 % de couverture et ne détecte rien. Visez une couverture élevée des services (la logique métier), 80 % est un objectif courant, mais jugez surtout la qualité des tests : valeurs limites, cas d'erreur, effets vérifiés. La couverture sert surtout à trouver ce qui n'est pas testé.

Activités

Activité 1 Atteindre les seuils

Écrivez les tests unitaires de StagiairesService (avec un mock de MailService) pour que npm run test:cov respecte les seuils de la leçon. Quels tests sont indispensables pour couvrir toutes les branches ?

Voir le corrigé

trouver: stagiaire trouvé et 404 ; creer: création (e-mail envoyé) et doublon (409, aucun e-mail) ; lister. Les branches sont les deux issues des if de trouver et creer. Les branches de décorateurs du contrôleur restent non couvertes : si elles empêchent d'atteindre le seuil des branches, ajoutez '!src/**/*.controller.ts' aux exclusions des tests unitaires, puisque les contrôleurs sont couverts par les e2e.

Activité 2 Couverture trompeuse

Ce test donne 100 % de couverture à mention(). Que lui reproche-t-on ? Réécrivez-le.

it('mention', () => {
  [18, 15, 13, 11, 5, null].forEach((m) => mention(m));
});
Voir le corrigé

Il n'y a aucun expect: le test passe même si toutes les mentions sont fausses. Et il ne teste aucune valeur limite (16, 14, 12, 10). Réécriture : le it.each de la leçon 17.1, qui vérifie chaque résultat, y compris aux bornes.

Activité 3 Lire le rapport HTML

Ouvrez coverage/lcov-report/index.html dans votre navigateur après npm run test:cov. Que signifient : une ligne surlignée en rouge ; un « I » ou un « E » jaune devant un if; un nombre comme « 3x » dans la marge ?

Voir le corrigé

Rouge : jamais exécutée. « I » (if path not taken) : la branche « vrai » du if n'a jamais été prise ; « E » (else path not taken) : la branche « faux » ne l'a jamais été. « 3x » : la ligne a été exécutée trois fois. Le raccourci clavier n (ou j) saute au prochain bloc non couvert.

Activité 4 Couverture dans le README

Ajoutez à .gitignore les dossiers coverage/ et coverage-e2e/. Pourquoi ne pas les versionner ? Comment partager quand même le taux de couverture avec l'équipe ?

Voir le corrigé

Ce sont des fichiers générés, différents à chaque exécution : les versionner encombre l'historique et crée des conflits. On partage plutôt le résultat via l'intégration continue (GitHub Actions publie le rapport comme artefact, ou un service comme Codecov affiche un badge dans le README).

À retenir

  • npm run test:cov : instructions, branches, fonctions, lignes ; rapport HTML dans coverage/lcov-report.
  • Les branches (vrai ET faux de chaque condition) sont l'indicateur le plus exigeant.
  • Exclure main.ts, modules, entités, DTO ; coverageThreshold pour faire échouer sous un seuil.
  • npm run test:cov ne compte que les tests unitaires ; configuration dédiée pour la couverture e2e.
  • Couvert ne veut pas dire vérifié : la couverture sert à trouver ce qui n'est pas testé.

Cet article vous a-t-il aidé ?