Tests de bout en bout instables : pourquoi ils échouent et comment en réduire le nombre
Par Mirko Peters · · Mis à jour
Les tests de bout en bout instables réussissent et échouent sans aucune modification du code. Découvrez les cinq causes habituelles, comment corriger les attentes et les données de test, et que faire des tests que vous ne pouvez pas corriger.
Traduit automatiquement par IA à partir de l'article original. Lire l'original en anglais
Les tests de bout en bout instables sont des tests automatisés de navigateur qui réussissent une exécution, puis échouent à la suivante, sans aucune modification du code, du test ou de l’environnement. Ce guide s’adresse aux responsables QA et aux ingénieurs en automatisation qui passent plus de temps à relancer des builds en échec qu’à corriger des bogues. Vous y découvrirez pourquoi ces tests deviennent instables, quelles sont les cinq causes habituelles, comment corriger la pire d’entre elles (l’attente), et comment gérer les tests que vous ne pouvez pas encore corriger. Un exemple détaillé, avec des chiffres fictifs, montre comment identifier la cause racine en trois étapes.
Points clés
- Un test instable réussit parfois et échoue parfois, sans aucune modification du code, du test ou de l’environnement. Un échec ne vous renseigne donc pas tant que vous n’avez pas relancé l’exécution.
- Google indique qu’environ 1,5 % de ses exécutions de tests étaient instables et que près de 16 % de ses tests présentaient une certaine instabilité. À grande échelle, l’instabilité est donc normale et nécessite un plan d’action.
- Les cinq causes habituelles sont l’état partagé, le timing, les services distants, l’horloge système et les ressources non libérées. Le timing est le premier point à vérifier dans les tests de navigateur.
- Remplacez les pauses fixes par des attentes d’une condition visible, et donnez à chaque test ses propres données afin que les tests ne se perturbent pas mutuellement.
- Placez un test instable en quarantaine à titre provisoire, mais limitez le nombre de tests pouvant y figurer ainsi que la durée de leur présence, sans quoi la suite de non-régression perdra peu à peu toute sa valeur.
Pourquoi les tests instables causent autant de dégâts
Un test est instable lorsque son résultat n’est pas reproductible. L’article de Martin Fowler sur le caractère non déterministe des tests définit un test non déterministe comme un test qui « réussit parfois et échoue parfois », « sans aucune modification notable du code, des tests ou de l’environnement ».
Le préjudice vient de la perte de confiance. Si un build en échec peut signaler un vrai bogue ou simplement du bruit, les gens apprennent à ignorer les builds en échec. Un défaut réel finit alors par passer entre les mailles. Les équipes perdent aussi du temps : chaque échec doit être relancé avant que quiconque puisse dire s’il est important. Une suite de tests instable ralentit également le pipeline CI, car chaque exécution échouée attend une nouvelle tentative et bloque la file de fusion qui suit.
Les chiffres de grands systèmes montrent que ce phénomène est courant, et non rare. Un article du Google Testing Blog, intitulé Flaky Tests at Google and How We Mitigate Them, indique qu’environ 1,5 % de l’ensemble des exécutions de tests ont donné un résultat instable, et que près de 16 % des tests présentaient un certain degré d’instabilité. Il précise également qu’environ 84 % des transitions observées de réussite vers échec impliquent un test instable, et que le projet moyen compte environ 1 000 tests individuels. Vos chiffres seront différents, mais la leçon reste valable : à grande échelle, l’instabilité est une certitude, et il faut donc un processus pour la gérer.
Les tests de bout en bout dans un navigateur sont particulièrement exposés. Chaque test dépend d’un navigateur, d’un réseau, d’une application déployée, de comptes de test et, souvent, de services tiers. Plus il y a d’éléments mobiles, plus les occasions de variation se multiplient. C’est pourquoi les tests de bout en bout tendent à être moins stables que les tests unitaires, qui comportent beaucoup moins d’éléments mobiles.
Les cinq causes habituelles des tests de bout en bout instables
L’article de Fowler identifie cinq causes courantes. Chacune s’applique aux tests de navigateur.
- Absence d’isolation. Les tests partagent un état, comme des enregistrements de base de données ou une session ouverte, si bien qu’un test modifie ce que voit un autre. Correction : reconstruire l’état initial pour chaque test, ou nettoyer après son exécution.
- Comportement asynchrone. La page a besoin de temps pour répondre, et le test agit trop tôt ou trop tard. Fowler recommande de ne jamais utiliser de simples pauses (sleep) pour attendre une réponse asynchrone, et d’employer plutôt un callback ou une interrogation répétée (polling).
- Services distants. Un bac à sable de paiement en ligne, un service de messagerie ou un fournisseur d’identité est lent ou indisponible. Correction : remplacer le système distant par un substitut de test (test double) lorsque le test n’a pas besoin du système réel.
- Temps. Les tests qui lisent l’horloge système ne se comportent pas de la même façon à minuit, en fin de mois ou selon les fuseaux horaires. Correction : contrôler l’horloge dans le test.
- Fuites de ressources. Un test laisse une connexion ou une session ouverte, et un test ultérieur, sans rapport, échoue lorsque la ressource vient à manquer.
L’article de Google ajoute la concurrence, la dépendance à un comportement non déterministe ou indéfini, le code tiers instable et les problèmes d’infrastructure. Considérez ces deux listes comme une liste de contrôle lorsque vous recherchez la cause profonde d’un test en échec.
Corriger d’abord les attentes
Dans les tests de navigateur, le timing est généralement le premier suspect. Un test qui clique sur un bouton avant qu’il soit prêt, ou qui vérifie un message avant son affichage, réussira sur une machine rapide et échouera sur une machine chargée.
Une pause fixe, du type « attendre 5 secondes », est la pire des solutions. Elle fait perdre du temps lorsque la page est rapide, et échoue quand même lorsque la page est lente. Fowler décrit l’interrogation répétée comme une vérification régulière, et non unique, et précise que les délais d’attente ne doivent jamais être des valeurs codées en dur dans le test.
Les outils modernes intègrent ce mécanisme. La documentation de Playwright sur l’actionnabilité énumère les contrôles effectués avant chaque action : l’élément doit être visible, stable (sa position ne change pas entre deux images d’animation), activé, capable de recevoir les événements au point de clic et, pour la saisie, modifiable. Playwright attend que ces contrôles soient satisfaits, ou échoue avec une erreur de dépassement de délai. Sa page de bonnes pratiques ajoute que les assertions « web-first » sont réessayées jusqu’à ce que la condition soit remplie.
Règles pratiques :
- Attendez une condition qu’un utilisateur pourrait voir, comme un titre ou une ligne de tableau, et non un nombre de secondes.
- Privilégiez un sélecteur basé sur le rôle, le texte ou un identifiant de test plutôt qu’un long chemin CSS ou XPath, qui se casse dès que la mise en page change.
- Définissez un délai d’attente global, mais suffisamment généreux, pour toute l’étape plutôt que de multiples petites pauses.
- Vérifiez le résultat avec une assertion qui se réessaie.
Isoler les données de test et l’environnement de test
Le second levier majeur concerne les données. Donnez à chaque test son propre compte, sa propre commande ou son propre dossier. Ne laissez pas deux tests modifier le même enregistrement. Si les tests doivent s’exécuter en parallèle, des données partagées garantissent des échecs aléatoires.
Examinez aussi l’environnement. Un système de préproduction partagé, sur lequel d’autres équipes déploient en pleine exécution de vos tests, provoquera des échecs qu’aucune correction de test ne pourra résoudre. Convenez de fenêtres de déploiement, ou exécutez votre suite sur un environnement dédié.
Si une étape dépend d’un service externe, demandez-vous si le test porte sur ce service. Sinon, remplacez-le par un bouchon (stub). Conservez un petit nombre de tests utilisant le service réel, et traitez-les comme un groupe distinct.
Enfin, rendez chaque échec facile à diagnostiquer. Conservez dans votre pipeline CI le journal, une capture d’écran et une trace de chaque test en échec. La page de bonnes pratiques de Playwright recommande de collecter une trace lors de la première relance d’un test en échec, afin de rejouer ce qui s’est passé au lieu de deviner. Avec un journal et une trace, un test instable devient un problème de flux de travail clair que vous pouvez corriger, par exemple un dépassement de délai sur une étape d’interface lente.
Que faire des tests que vous ne pouvez pas encore corriger
Certains tests instables demandent plus de temps que vous n’en avez, et certains dépendent d’un code que vous ne possédez pas. Gérez-les alors ouvertement, et maintenez la fiabilité des résultats des tests stables.
- Quarantaine. Fowler décrit le déplacement des tests non déterministes vers une suite distincte, afin que les tests sains continuent de fournir un retour fiable. Il ajoute que les tests mis en quarantaine doivent tout de même être corrigés rapidement, et qu’il faut limiter leur nombre ou la durée pendant laquelle ils peuvent y rester.
- Relance avec traçabilité. Google décrit la relance des tests en échec et le marquage d’un test comme instable, de sorte qu’il ne signale un échec qu’après trois échecs consécutifs. L’article précise qu’il s’agit difficilement d’une solution parfaite et met en garde : cela pourrait facilement masquer une véritable condition de concurrence (race condition) ou un autre bogue dans le code testé.
- Suivez l’instabilité des tests dans le temps. Google décrit aussi des outils qui détectent les évolutions du niveau d’instabilité d’un test. Même une simple liste de tests avec leur taux de réussite indique où regarder en premier.
Quel que soit votre choix, rendez la liste des tests instables visible, attribuez un responsable à chaque test et fixez une échéance.
Exemple : identifier la cause en trois étapes
Les chiffres sont fictifs.
Une suite compte 200 tests de navigateur. Sur deux semaines, 14 d’entre eux échouent au moins une fois sans modification du code. Cela représente 7 % des tests.
- Regrouper par cause. L’équipe analyse les journaux d’échec et trie les 14 tests. Huit échouent sur un délai d’attente dépassé lié à un bouton, quatre échouent parce que deux tests modifient le même enregistrement client, et deux échouent uniquement après un déploiement sur l’environnement de préproduction.
- Corriger le groupe le plus important. L’équipe remplace les temporisations fixes des huit tests liés au timing par des attentes de conditions visibles. Sept cessent d’échouer.
- Corriger le groupe suivant. Chaque test qui modifiait le client partagé crée désormais son propre client. Les quatre tests cessent d’échouer.
Après la troisième étape, trois tests instables subsistent. L’équipe met en quarantaine les deux tests liés au déploiement et attribue à chacun un responsable et une échéance de deux semaines. La part de tests instables de la suite passe de 7 % à 1,5 %, et l’équipe la vérifie chaque semaine.
Erreurs courantes
- Ajouter des temporisations fixes. Elles masquent le problème un temps et ralentissent chaque exécution.
- Relancer tous les tests et passer à autre chose. Les relances sans trace masquent de vrais défauts, et la cause profonde reste en place.
- Partager des données de test entre tests. Les exécutions en parallèle en font des échecs aléatoires.
- Tester des services tiers dans chaque test. Remplacez-les par des simulations lorsque le service n’est pas l’objet du test.
- Laisser la quarantaine grandir sans limite. Une quarantaine sans responsable devient un cimetière.
- Accuser d’abord l’outil. Vérifiez le timing, les données et l’environnement avant de changer de framework.
Comment les logiciels peuvent aider
Commencez par ce que votre framework propose : attente automatique, traces et relances en CI. Ajoutez un tableau de bord des échecs par test et par cause, afin que les tendances soient visibles. Un tableur suffit au départ. Les outils qui utilisent un agent IA pour exécuter des tests à partir d’étapes en langage courant peuvent réduire certains problèmes de timing, car l’agent décide de la durée d’attente, mais ils apportent leurs propres risques, comme une mauvaise interprétation des instructions. Testez-les sur quelques tests et comparez le taux d’instabilité avant de décider.
Prochaine étape
Listez cette semaine vos dix tests les moins fiables, attribuez à chacun une cause probable parmi les cinq ci-dessus, et corrigez d’abord les problèmes d’attente. Suivez ensuite chaque semaine le taux de tests de bout en bout instables, et protégez la valeur de votre suite de tests de régression en limitant la quarantaine.