AI CodeOps

Barrières de couverture de tests : seuils, nouveau code et limites

Mis à jour le

Fonctionnement des barrières de couverture, lignes ou branches, contrôle du nouveau code plutôt que du projet entier, et pourquoi la couverture ne prouve rien sur ce que vérifient vos tests.

Une barrière de couverture de tests fait échouer un changement lorsque la couverture de tests mesurée passe sous un seuil fixé. C'est l'une des barrières qualité les plus courantes, car elle est peu coûteuse à calculer et facile à comprendre. C'est aussi l'une des plus mal interprétées : la couverture montre quelle part du code s'est exécutée pendant les tests, pas si les tests ont vérifié quoi que ce soit. Bien utilisée, une barrière de couverture empêche la couverture de tests de glisser et pousse chaque changement à s'accompagner de tests. Utilisée comme une fin en soi, elle produit des tests écrits pour faire monter un chiffre.

Cette page approfondit un type de preuve présenté dans Qu'est-ce qu'une barrière qualité ?.

Ce que mesure la couverture

Les outils de couverture instrumentent le code, exécutent les tests et enregistrent les parties qui se sont exécutées. Les mesures courantes sont :

  • Couverture des lignes ou des instructions. La part des lignes ou des instructions exécutées au moins une fois. La plus largement disponible.
  • Couverture des branches. La part des issues de décision qui ont été exécutées : pour chaque if, le chemin vrai et le chemin faux. Plus stricte que la couverture des lignes, puisqu'une ligne contenant une condition peut s'exécuter sans que les deux issues soient testées.
  • Couverture des fonctions. La part des fonctions appelées au moins une fois.
  • Couverture des conditions et des décisions. Des formes plus strictes, utilisées dans les logiciels critiques pour la sécurité. La couverture des conditions/décisions modifiée (MC/DC), par exemple, est exigée pour le niveau le plus critique des logiciels embarqués à bord des aéronefs selon les recommandations DO-178C.

La plupart des équipes appliquent la barrière à la couverture des lignes, car tous les outils courants la signalent, et ajoutent la couverture des branches là où leurs outils la signalent de manière fiable.

Les types de barrière de couverture

Il existe trois conceptions courantes, au comportement très différent.

BarrièreRèglePoint fortPoint faible
Seuil de projetLa couverture totale doit rester supérieure ou égale à N%Simple ; arrête le déclin à long termeUn petit changement fait à peine bouger le total, testé ou non
Couverture du nouveau code (diff)Les lignes ajoutées ou modifiées doivent être couvertes à N%Tient chaque changement au niveau exigéNécessite un outillage qui rapporte la couverture au diff
Pas de baisse (cliquet)La couverture ne doit pas descendre sous la dernière valeur enregistréeAmélioration régulière sans grand saut initialPeut bloquer un changement valable qui supprime du code testé

Un seuil de projet est le plus simple à mettre en place et le plus faible pour chaque changement : dans une grande base de code, un changement non testé de quelques centaines de lignes peut ne faire bouger le total que d'une fraction de pour cent. La couverture du nouveau code est la plus utile pour relire des changements individuels, car elle pose une question directe : les lignes ajoutées par ce changement sont-elles exercées par des tests ?

Ce que la couverture ne peut pas vous dire

La couverture mesure l'exécution, et elle a donc des angles morts qui comptent pour une barrière.

  • Assertions. Un test qui appelle une fonction et ne vérifie rien couvre quand même chaque ligne qu'il exécute.
  • Justesse des attentes. Un test qui attend la mauvaise valeur couvre le code et réussit.
  • Comportement manquant. La couverture mesure le code qui existe. Une vérification manquante, comme un test de permission absent, n'a aucune ligne qui puisse rester non couverte.
  • Effets d'intégration. Une couverture élevée par les tests unitaires dit peu de chose de la façon dont les composants se comportent ensemble.

Il existe aussi un effet comportemental, souvent résumé par la loi de Goodhart : lorsqu'une mesure devient un objectif, elle cesse d'être une bonne mesure. Une barrière qui ne récompense que le chiffre invite à écrire des tests pour le faire monter.

La couverture et le code écrit par l'IA

Les barrières de couverture sont un moyen peu coûteux de vérifier qu'un agent IA a écrit des tests en plus de son code, et non à sa place. Elles sont aussi faciles à satisfaire pour un agent sans véritables tests, en général sans aucune intention de tromper : on a demandé à l'agent des tests qui réussissent et de la couverture, et il les a produits.

Les schémas à surveiller dans les tests écrits par l'IA :

  • des tests qui appellent du code et vérifient seulement qu'aucune exception n'a été levée ;
  • des tests de snapshot qui enregistrent comme valeur attendue tout ce que le code renvoie ;
  • des mocks qui remplacent la logique testée, si bien que le test vérifie le mock ;
  • des tests générés à partir de l'implémentation, qui reprennent ses bugs comme attentes.

Traitez la couverture comme un seuil que chaque changement doit franchir, et le diff des tests comme quelque chose qu'un relecteur lit. Consultez Comment relire du code écrit par un agent IA pour savoir quoi examiner.

De meilleurs signaux à associer à la couverture

  • Test de mutation. Un outil apporte de petites modifications au code, comme inverser une comparaison, et vérifie si un test échoue. Les mutations qui survivent révèlent du code qui s'exécute sous test sans être vraiment vérifié. Des outils existent pour la plupart des langages, comme Stryker pour JavaScript et TypeScript, PIT pour Java et mutmut pour Python. Ils sont plus lents que la couverture, si bien que les équipes les exécutent souvent selon une planification ou uniquement sur les fichiers modifiés.
  • Tests de régression pour les correctifs. Un correctif de bug doit inclure un test qui échoue sans le correctif. Ce test prouve quelque chose que la couverture ne peut pas prouver.
  • Revue du diff des tests. Les tests supprimés, les assertions assouplies et les attentes modifiées sont visibles dans le diff et invisibles dans un chiffre de couverture.

Fixer un seuil de couverture

  1. Mesurez d'abord. Exécutez la couverture sur la branche principale et notez le chiffre actuel de chaque projet.
  2. Choisissez le type de barrière. La couverture du nouveau code si vos outils la prennent en charge ; sinon, un seuil de projet complété par un cliquet.
  3. Fixez le seuil près du chiffre actuel. Un seuil que la base de code respecte déjà est applicable dès le premier jour.
  4. Excluez délibérément. Le code généré, le code vendorisé et les utilitaires de test peuvent être exclus, dans une configuration relue comme du code. Les exclusions silencieuses sont un moyen de contourner la barrière.
  5. Décidez de ce qui se passe sans chiffre de couverture. Si une exécution de tests ne signale pas de couverture, la barrière bloque, ou ignore le seuil et le dit. Ne l'affichez pas comme réussie.
  6. Relevez-le avec le temps. Revoyez le seuil régulièrement et relevez-le lorsque la couverture a augmenté.

Comment AI CodeOps s'y prend

Lorsqu'une session AI CodeOps exécute les tests de votre projet dans son bac à sable, elle lit le chiffre de couverture global dans la sortie des tests lorsque celle-ci contient un résumé : une ligne TOTAL de pytest-cov, une ligne All files d'Istanbul (telle qu'affichée par Jest et Vitest ; sa première colonne, celle des instructions) ou une ligne étiquetée comme coverage: 85.3%. Le chiffre est enregistré avec l'exécution de tests sous forme de nombre entier, arrondi à l'inférieur.

Le seuil de couverture est l'option minCoveragePct de la vérification de livraison qu'appelle votre CI :

{ "pullRequestURL": "https://github.com/acme/checkout/pull/42", "minCoveragePct": 80 }

Lorsqu'elle est définie, la dernière exécution de tests ayant signalé une couverture doit atteindre le seuil, sinon la livraison est refusée avec une raison telle que « Coverage 71% is below the required 80% ». Si aucune exécution de tests du changement n'a signalé de couverture, la livraison est refusée elle aussi : « Coverage wasn't reported, so the 80% floor can't be checked ». Un seuil sans chiffre à contrôler ne passe pas. Faites donc afficher un résumé par votre commande de test, par exemple pytest --cov ou vitest run --coverage, avant de fixer un seuil. La barrière de chaque session dans la console bloque les tests en échec mais ne vérifie pas la couverture. Les tests en échec refusent la livraison, quelle que soit la couverture.

Consultez l'entrée seuil de couverture pour plus de détails, la référence de l'API pour chaque option de la vérification de livraison, et Tests par IA pour le fonctionnement des tests.

Questions fréquentes

Qu'est-ce qu'un bon pourcentage de couverture de tests ?

Il n'existe pas de chiffre universel. Mesurez où en est la base de code aujourd'hui, fixez le seuil près de ce niveau et relevez-le à mesure que la couverture progresse. Un seuil très au-dessus du chiffre actuel est soit ignoré, soit atteint avec des tests de faible valeur.

Faut-il utiliser la couverture des lignes ou la couverture des branches ?

La couverture des branches est plus stricte, car elle vérifie que les deux côtés de chaque décision ont été exécutés. Utilisez-la là où vos outils la signalent de manière fiable. La couverture des lignes est la plus largement disponible et constitue un point de départ raisonnable.

Une couverture de 100% signifie-t-elle que le code n'a pas de bugs ?

Non. La couverture montre quel code s'est exécuté pendant les tests, pas si les tests ont vérifié les résultats. Du code peut être entièrement couvert par des tests aux assertions faibles ou absentes.

Une barrière de couverture doit-elle s'appliquer aux changements écrits par l'IA ?

C'est un signal peu coûteux qu'un agent a écrit des tests avec son code. Associez-la à une revue du diff des tests, car un agent peut augmenter la couverture avec des tests qui exécutent le code sans le vérifier.