Tests unitaires, d’intégration et de bout en bout : là où l’IA apporte le plus
Par Mirko Peters · · Mis à jour
Tests unitaires, d’intégration et de bout en bout : ce que vérifie chaque niveau, combien en écrire et où l’IA apporte le plus, de la rédaction de tests unitaires à la revue des parcours dans le navigateur.
Traduit automatiquement par IA à partir de l'article original. Lire l'original en anglais
Tests unitaires, d’intégration et de bout en bout : cette question est au cœur de toute stratégie de tests logiciels. Chaque niveau vérifie une chose différente, coûte un effort différent et apporte un type de confiance différent. Ce guide s’adresse aux responsables QA à qui l’on demande où l’IA doit trouver sa place dans les tests logiciels. Vous verrez ce que vérifie chaque niveau, combien de tests de chaque type une suite saine doit comporter, où l’IA apporte le plus et où elle ajoute des risques. Un exemple concret, avec des chiffres fictifs, montre comment une équipe a décidé où concentrer ses efforts.
Points clés
- Un test unitaire vérifie une partie de code, un test d’intégration vérifie le lien avec un élément extérieur à l’application, et un test de bout en bout exécute le système déployé via son interface.
- La pyramide des tests recommande d’écrire beaucoup de tests unitaires petits et rapides, quelques tests à plus gros grain et très peu de tests de haut niveau, car les niveaux supérieurs sont plus lents et demandent davantage de maintenance.
- L’IA est particulièrement utile lorsque le résultat est de petite taille et facile à vérifier, comme la rédaction de tests unitaires et d’API, à condition qu’une personne puisse relire chaque test généré.
- Les tests générés par l’IA peuvent gonfler la couverture sans valider le comportement, par exemple lorsqu’ils exécutent du code sans assertions, ou avec des assertions faibles.
- Considérez le résultat de l’IA comme un brouillon à tous les niveaux, et réservez le jugement humain aux parcours ambigus, aux contrôles visuels et aux revues d’accessibilité.
Tests unitaires, d’intégration et de bout en bout : ce que vérifie chacun
L’article de Martin Fowler The Practical Test Pyramid propose des définitions claires.
- Les tests unitaires garantissent qu’une unité précise de votre base de code, le sujet du test, fonctionne comme prévu. Leur périmètre est le plus restreint de tous les types de tests. C’est le niveau de tests unitaires que les développeurs écrivent le plus souvent.
- Les tests d’intégration vérifient l’intégration de votre application avec les éléments qui lui sont extérieurs, comme une base de données, un système de fichiers ou un service distinct. Fowler privilégie les tests étroits, qui ne vérifient qu’un seul point d’intégration externe à la fois. C’est le rôle de l’intégration testing.
- Les tests de bout en bout testent l’application déployée via son interface utilisateur et couvrent l’ensemble du système intégré. Fowler les appelle tests de pile large. C’est le domaine du test de bout en bout.
La principale différence entre les tests unitaires et les tests d’intégration tient au périmètre : une partie du code face au lien entre les parties. Les tests fonctionnels et les tests système vérifient également le logiciel de l’extérieur, et le test de bout en bout en est la forme pilotée par le navigateur. Il est donc important de bien définir le vocabulaire employé au sein de l’équipe.
Les développeurs écrivent en général les tests unitaires et les exécutent à chaque commit. Pour retenir la différence, pensez à la question auquel chaque niveau répond : un test unitaire demande si cette fonction est correcte. Un test d’intégration demande si nous dialoguons correctement avec cet autre système. Un test de bout en bout demande si un utilisateur peut mener ce parcours à son terme.
Combien de tests de chaque type : la pyramide des tests
La pyramide des tests est la représentation habituelle de cet équilibre. Fowler's recommande d’écrire beaucoup de tests unitaires petits et rapides, quelques tests à plus gros grain et très peu de tests de haut niveau. Il l’énonce comme une règle : plus le niveau est élevé, moins vous devriez avoir de tests.
La raison en est le coût. Selon l’article, les tests unitaires s’exécutent très rapidement, les tests d’intégration sont nettement plus lents parce qu’ils impliquent de véritables composants externes, et les tests de bout en bout s’exécutent assez lentement. Ces derniers demandent aussi une maintenance importante et sont réputés pour leur instabilité.
Cette instabilité est mesurable à grande échelle. Un billet du Google Testing Blog, Flaky Tests at Google and How We Mitigate Them, indique qu’environ 1,5 % de ses exécutions de tests ont donné un résultat instable et que près de 16 % de ses tests ont présenté une certaine instabilité.
Les trois niveaux alimentent la non-régression, car ils sont rejoués après chaque modification.
Fowler met aussi en garde contre la forme inverse, qu’il appelle le « cornet de glace » : de nombreux tests manuels et au niveau du navigateur au sommet, et peu de tests unitaires à la base. Il la décrit comme un cauchemar à maintenir, dont l’exécution prend beaucoup trop de temps. Si votre suite ressemble à cela, ajouter de l’IA ne corrigera pas cette forme. Elle risque seulement de produire plus vite davantage de tests lents.
Tests unitaires et tests d’intégration : quand utiliser chaque niveau
La comparaison publiée par TestRail sur les tests unitaires et tests d’intégration recense des différences concrètes. Les tests unitaires sont rapides à mettre en œuvre et à exécuter, et sont généralement pris en charge par les développeurs. Les tests d’intégration impliquent souvent des ingénieurs QA et des testeurs. Les tests unitaires utilisent des mocks et des stubs pour éviter les systèmes externes, tandis que les tests d’intégration portent sur les interactions réelles, tout en pouvant encore recourir à des mocks lorsqu’un service externe est indisponible, peu fiable ou coûteux.
Les avantages des tests unitaires sont un retour rapide, une détection précoce des anomalies et un code plus modulaire. Leur faiblesse est qu’une suite de tests unitaires ne montre pas si les composants fonctionnent ensemble, ce que les tests d’intégration apportent. TestRail recommande les tests unitaires pour la logique isolée, dès le début du développement, et les tests d’intégration pour les flux qui traversent plusieurs modules, bases de données ou services tiers. Il décrit deux façons de les exécuter : Big Bang, qui teste l’ensemble après le développement et est plus difficile à déboguer, et incrémentale, qui teste de petits groupes pas à pas et facilite la localisation des problèmes.
Fowler propose une règle pour choisir le niveau : si un test de haut niveau détecte une erreur alors qu’aucun test de niveau inférieur n’échoue, rédigez un test de niveau inférieur. Descendez les tests aussi bas que possible dans la pyramide, et supprimez les tests de haut niveau qui font double emploi avec ce que les niveaux inférieurs couvrent déjà. Une stratégie de test complète utilise les trois niveaux, chaque niveau supérieur se concentrant sur ce que les niveaux inférieurs ne peuvent pas couvrir.
Deux questions connexes reviennent souvent. Fowler constate que certains appellent la couche intermédiaire « tests d’intégration », d’autres « tests de composants », et que s’accorder sur les termes compte davantage que le nom retenu. Il indique aussi que les tests d’acceptation, qui vérifient le logiciel du point de vue de l’utilisateur, peuvent se situer à n’importe quel niveau : ils sont donc orthogonaux à la pyramide. Les tests unitaires et les tests de bout en bout sont par conséquent les deux extrémités d’une même échelle, et non des écoles rivales.
Ces tests se prêtent facilement à l’automatisation dans un pipeline. TestRail indique que les tests unitaires s’exécutent généralement tôt, souvent juste après un push ou une pull request, et que les tests d’intégration s’exécutent plus tard, une fois l’application déployée dans un environnement de préproduction ou de test. Ensemble, ils forment une porte de qualité.
Là où l’IA apporte le plus
Les outils fondés sur l’IA générative diffèrent, mais une tendance apparaît dans les recommandations des éditeurs. L’article de Parasoft sur l’utilisation de l’IA dans les tests logiciels conseille aux équipes de générer des tests unitaires et d’API pendant que les modifications sont fraîches, et mentionne l’aide de l’IA pour créer des tests d’API, suggérer des assertions et construire des scénarios de données. Il note aussi que la virtualisation de services, qui simule des dépendances lentes, coûteuses ou indisponibles, facilite les tests d’intégration.
Cela correspond à la pyramide. Les raisons sont notre propre déduction, et non une mesure :
- Une sortie courte est facile à relire. Un test unitaire généré tient en quelques lignes. Un relecteur peut le lire, l’exécuter et décider en une minute s’il vérifie la bonne chose.
- Un retour rapide révèle les mauvais tests. Un test unitaire erroné échoue ou réussit rapidement : le problème est donc détecté le jour même.
- Entrées et sorties clairement définies. Les fonctions et les appels d’API ont des entrées et des sorties définies, ce qui donne à l’outil une cible précise.
- Nombreux cas répétitifs. Les valeurs limites et les chemins d’erreur sont répétitifs dans les tests unitaires, et un brouillon fait gagner beaucoup de saisie.
Laissez l’IA rédiger le brouillon, mais une personne doit en assumer la responsabilité : celui qui accepte un test généré répond de ce qu’il vérifie, exactement comme pour un test écrit à la main.
Pour les tests d’intégration, l’IA peut rédiger un cas de test ou des données de test et simuler des dépendances, mais une personne doit définir le contrat avec l’autre système, et ce sont les tests d’intégration qui vérifient ce contrat.
Au niveau des tests de bout en bout, l’IA apporte une aide d’une autre nature. Les outils qui exécutent, dans un navigateur, des étapes décrites en langage courant peuvent réduire le coût de rédaction d’un test de parcours. Ils ne modifient pas le coût d’exécution et ne suppriment pas le besoin d’une règle claire de réussite ou d’échec.
Les domaines où l’IA est la moins utile, et points de vigilance
L’article de Parasoft est direct sur ses limites. Il recommande de maintenir une relecture humaine sur chaque modification générée par l’IA et de traiter sa sortie comme un brouillon. Il précise que, mal utilisée, l’IA peut gonfler la couverture sans valider le comportement, et il met en garde contre les tests vides qui exécutent du code sans véritable assertion, ou avec des assertions faibles ou absentes. Il signale comme symptôme préoccupant les sorties qui varient d’une exécution à l’autre avec les mêmes entrées. Il ajoute que l’IA ne peut pas valider seule les modifications critiques pour la sécurité, ni remplacer le jugement humain sur les parcours ambigus, les contrôles visuels et les revues d’accessibilité. Pour les données, il met en garde contre les requêtes contenant des secrets ou des données réglementées.
Les stratégies de test qui recourent à l’IA demandent quatre vérifications :
- Une couverture qui augmente sans rien détecter. Vérifiez les assertions, et pas seulement les chiffres de couverture.
- Des tests qui reproduisent le code. Un test qui répète l’implémentation réussira même lorsque la logique est fausse.
- Une sortie instable. Si un test généré change d’une exécution à l’autre, figez la version que vous avez relue.
- Des données qui sortent de l’entreprise. Ne collez pas de secrets, de données clients ou de données réglementées dans une requête.
Exemple : là où une équipe concentre ses efforts
Les chiffres sont fictifs.
Une équipe dispose de 600 tests automatisés : 450 tests unitaires, 110 tests d’intégration et 40 tests de bout en bout. Les tests de navigateur occupent 50 minutes sur un pipeline de 60 minutes, et six d’entre eux échouent de façon aléatoire chaque semaine.
Le responsable QA prend trois mesures. Premièrement, un assistant IA rédige des tests unitaires pour le nouveau code, et un développeur relit chaque brouillon. Au cours du premier mois, l’assistant produit 120 tests. Les relecteurs en rejettent 30 parce que leurs assertions sont faibles, de sorte que 90 rejoignent la suite.
Deuxièmement, l’IA rédige les données de test des tests d’intégration, tandis que les contrats restent écrits à la main.
Troisièmement, les 40 tests de bout en bout ne bénéficient d’aucune aide de l’IA. Le responsable supprime six doublons déjà couverts par un test de niveau inférieur, plus rapide, et le pipeline passe de 60 à 48 minutes. L’effort de l’IA a été concentré là où la relecture coûte le moins, et la couche lente a diminué.
Erreurs courantes
- Utiliser l’IA pour ajouter davantage de tests de navigateur. La couche lente et instable grossit, et le pipeline ralentit.
- Accepter des tests générés sans les lire. Des assertions faibles donnent une couverture sans sécurité.
- Mesurer le succès au nombre de tests. Comptez plutôt les défauts détectés et les minutes gagnées.
- Négliger les tests d’intégration. Des tests unitaires complétés de quelques parcours peuvent laisser passer des contrats rompus entre systèmes.
- Coller des données sensibles dans les requêtes. Définissez une stratégie avant la première requête.
Comment les logiciels peuvent aider
Votre infrastructure de test existante et votre système d’intégration continue fournissent déjà les durées d’exécution et les taux d’échec. Commencez par là, et regroupez les chiffres par niveau. Les outils de revue de code facilitent la relecture des brouillons de l’IA, car le relecteur peut voir le test généré à côté du code. Examinez les outils de couverture en parallèle d’une vérification des assertions, afin de ne pas confondre couverture et qualité. Ajoutez d’abord un assistant IA à un seul niveau de test logiciel, et comparez le temps de relecture, le nombre de brouillons rejetés et les défauts échappés avant d’élargir le pilote.
Prochaine étape
Comptez vos tests à chaque niveau, et notez la durée d’exécution et le taux d’instabilité de chaque niveau. Choisissez ensuite un niveau pour un pilote IA et consignez ce que vous allez mesurer, afin que votre prochain débat sur les tests unitaires, d’intégration et de bout en bout repose sur des données.