Tests auto-réparateurs (self-healing) : quand un test qui se répare tout seul cache un vrai bug
Les tests auto-réparateurs (self-healing) gardent la suite au vert. Mais une fausse réparation cache un vrai bug : gardez chaque changement visible.
Les tests auto-réparateurs (self-healing) se réparent eux-mêmes quand l'application change : un test qui ne trouve pas un élément en choisit un similaire et continue. Cela économise de l'entretien, mais un mauvais choix fait réussir un parcours cassé, et personne n'est prévenu.
Vous connaissez ce matin-là. Un nouveau build est arrivé, quarante tests sont rouges, et aucun n'a trouvé de bug : chacun a perdu un bouton qu'il trouvait avant. L'auto-réparation promet d'en finir avec ces matins. La question, c'est ce qu'elle fait le jour où le bouton a vraiment disparu.
Qu'est-ce qu'un test auto-réparateur (self-healing) ?
Définition
Un test auto-réparateur est un test automatisé qui se modifie lui-même quand il ne trouve plus un élément.
- L'outil cherche ce qui lui ressemble le plus à l'écran et l'utilise à sa place.
- L'exécution continue comme si de rien n'était.
L'automatisation des tests auto-réparatrice existe à cause d'un seul type d'entretien. Dans un test codé, chaque bouton, champ et lien est trouvé par un localisateur : une ligne qui décrit où se trouve l'élément dans la page ou la fenêtre. Quand un développeur renomme ou déplace l'élément, le localisateur ne correspond plus, et le test échoue alors que l'application fonctionne.
Pourquoi les localisateurs cassent si souvent, c'est le sujet de « Element not found » : quand les sélecteurs et les localisateurs échouent.
Pourquoi les équipes veulent une automatisation des tests auto-réparatrice
Trois difficultés rendent l'auto-réparation séduisante.
Des builds rouges qui n'ont rien trouvé
Un petit changement de l'application fait passer des dizaines de tests au rouge, et aucun ne désigne un bug.
Des heures de réparation
Les testeurs passent leur semaine à réparer des localisateurs au lieu de tester le produit.
Une suite à laquelle personne ne se fie
Après assez de fausses alertes, l'équipe ne regarde plus du tout les tests rouges.
Le souhait qui la motive est légitime. Un test devrait survivre à un changement qu'aucun utilisateur ne remarquerait : un identifiant renommé, un bouton légèrement déplacé, un nouveau conteneur autour d'un formulaire. Aucun de ces changements n'est un bug, et aucun ne devrait coûter une matinée.
Les tests qui échouent sans raison ont leur propre coût, chiffré dans Tests instables et faux positifs.
Qu'est-ce qu'une fausse réparation ?
Définition
Une fausse réparation est une réparation qui choisit le mauvais élément.
- Le test continue et clique sur quelque chose, ou vérifie quelque chose, qui ressemble seulement à ce pour quoi il a été fait.
- Puis il réussit.
L'exécution est verte sur un parcours cassé.
La semaine dernière
Votre commande
Le test clique sur Payer maintenant.
Cette semaine
Votre commande
Payer maintenant a disparu. Le test se répare tout seul et clique sur Payer plus tard.
Ce que dit le build
Test réussi
Ce que reçoit le client
Une commande jamais payée
Par erreur, une version remplace le bouton Payer maintenant par Payer plus tard. Le test ne trouve pas Payer maintenant. Sa réparation trouve un bouton de la même taille au même endroit, au nom proche, et clique dessus. La commande est sauvegardée comme impayée, la dernière étape voit toujours une page de commande, et l'exécution réussit. La première personne à s'en apercevoir est un client.
Un test en échec coûte quelques minutes. Une fausse réparation supprime le seul signal que le test était là pour donner.
Une fausse alerte échoue pour rien. Une fausse réparation réussit pour rien, et c'est pire : personne n'ouvre un test vert pour le vérifier.
Comment un test trouve un élément, et ce qu'il attend : deux changements différents
Toutes les réparations ne présentent pas le même risque. Un test retient deux choses sur chaque élément, et elles ne doivent pas être traitées de la même façon.
Comment l'élément est trouvé
L'utilisateur voit le même écran.
Le test peut suivre tout seul, et dire où il a trouvé l'élément.
Ce que l'assertion attend
L'utilisateur voit un autre écran.
Le test échoue, et une personne décide.
| Ce qui a changé | Exemple | Si le test suit en silence |
|---|---|---|
| Comment l'élément est trouvé | Le bouton a gardé son apparence et son rôle, mais il a bougé ou changé d'identifiant. | Risque faible : l'utilisateur voit le même écran. |
| Ce que le test attend | Le texte, la couleur ou l'état du bouton a changé, ou un autre élément a pris sa place. | Risque élevé : c'est une décision sur votre produit. |
La règle compte encore plus quand l'IA écrit le code testé, comme l'explique Comment tester du code généré par l'IA.
Deux questions à poser à tout test auto-réparateur
Avant de vous fier à un test qui se répare lui-même, posez deux questions.
Qui est prévenu ?
Quand un test s'est modifié lui-même, qui est prévenu, et peut-on voir ce qu'il était avant et ce qu'il est devenu ?
Qui a décidé ?
Qui a décidé que la nouvelle version était la bonne : une personne qui a regardé l'écran, ou l'outil seul ?
Si les réponses honnêtes sont « personne » et « l'outil », chaque exécution verte mérite un second regard, et le temps gagné est dépensé à nouveau.La même habitude de poser des questions avant de faire confiance est derrière Outils de test IA : 7 questions à poser avant d'en choisir un.
Moins de casses à réparer : aucun localisateur à entretenir
GUI Test Studio, qui automatise les tests de bout en bout de toute application sans code, part de l'autre bout. Personne n'écrit de localisateur, donc vous n'en avez aucun à entretenir. Vous enregistrez le parcours une fois, ou vous le décrivez dans une consigne, et chaque assertion porte sur ce que voit l'utilisateur.
Le GTS Engine + AI trouve chaque élément de deux façons.
- Il interroge d'abord l'application, par ses informations d'accessibilité.
- Quand l'application ne dit rien, il trouve l'élément à vue, à l'écran.
- Un bouton déplacé, une fenêtre plus large ou une liste qui a défilé est trouvé là où il se trouve maintenant, et le rapport de confiance dit où.
Sur une page web, un test enregistré garde plusieurs façons d'atteindre chaque élément.Quand la première ne marche plus, la suivante trouve le même élément, et l'exécution le note.Comment GUI Test Studio trouve les éléments explique les deux façons.
Cette seconde moitié explique pourquoi un sosie ne passe pas en douce. Si Payer plus tard se trouve là où était Payer maintenant, l'assertion le compare au Payer maintenant qu'elle attend, et échoue.
Quand l'écran a vraiment changé : un échec que tout le monde voit
Certains changements sont réels : de nouveaux mots sur un bouton, une nouvelle couleur, un champ qui a disparu. GUI Test Studio ne décide pas à votre place de ce qu'ils signifient. L'assertion échoue, l'exécution est rouge, et le rapport de confiance s'ouvre sur ce qui s'est passé.
Le rapport vous donne ce dont une décision a besoin.
- L'image attendue se trouve à côté de l'image obtenue, et la différence est marquée.
- Avec l'analyse intelligente par IA activée, une phrase dit ce qui a changé en mots simples, par exemple un bouton passé d'actif à désactivé.
- La vidéo de l'exécution montre les étapes qui y ont mené.
- Le rapport est sauvegardé avec l'exécution, donc l'échec reste consigné.
Le guide Le rapport de confiance explique tout ce que montre une exécution, et Comment lire un rapport de test suit un échec de la première ligne jusqu'à la décision.
Accepter la nouvelle apparence ou signaler le bug : une personne décide
Assertion échouée : bouton Payer
Attendu
Payer maintenantObtenu
Payer plus tardLe texte du bouton est passé de « Payer maintenant » à « Payer plus tard ».
Personne ne l'a voulu : signalez le bug
Un rapport d'anomalie avec les étapes et les deux images, en fichier ou en ticket Jira.
C'était voulu : acceptez la nouvelle apparence
Un clic, annulable, puis sauvegardé dans le test.
Regarder
L'attendu à côté de l'obtenu
Un bug ?
Le signaler depuis le rapport
Voulu ?
Accepter la nouvelle apparence
Sauvegarder
Dans le test
- 1
Ouvrir l'assertion échouée
Dans le rapport de confiance, sélectionnez l'assertion échouée. Son image attendue se trouve à côté de l'image obtenue, et la différence est marquée.
- 2
Décider : un bug, ou un changement voulu
Demandez-vous si l'équipe voulait que l'écran ait cet aspect. Si personne ne l'a voulu, c'est un bug.
- 3
Un bug : le signaler depuis le rapport
Créez un rapport d'anomalie en PDF ou en fichier Excel, ou en ticket Jira. Les étapes, les images et la raison sont remplies à partir de l'exécution.
- 4
Un changement voulu : accepter la nouvelle apparence
Cliquez sur Accepter le résultat obtenu comme attendu.La nouvelle apparence reste en attente jusqu'à ce que vous sauvegardiez, et Ctrl+Z l'annule.
- 5
Sauvegarder
Cliquez sur Sauvegarder.Le fichier de test est mis à jour, et la prochaine exécution attend la nouvelle apparence.
Après une refonte, de nombreuses assertions échouent pour la même raison.Une feuille liste chaque assertion échouée avec ses deux images : décochez les vrais bugs, et acceptez le reste en une fois.Mettre à jour un test après un changement montre chaque fenêtre.
Une réparation silencieuse ou une décision visible
| Question | Une réparation silencieuse | Une décision visible |
|---|---|---|
| Que se passe-t-il quand un élément a changé ? | L'outil choisit un élément similaire, et l'exécution continue. | L'assertion échoue, et l'exécution le dit. |
| Qui est prévenu ? | Celui qui lit le journal des réparations, si quelqu'un le lit. | Tous ceux qui voient le build. Le rapport s'ouvre sur l'échec. |
| Qui décide que la nouvelle version est la bonne ? | L'outil. | Une personne qui a vu l'attendu à côté de l'obtenu. |
| À quoi ressemble un vrai bug ? | À un test vert. | À un test rouge, avec les deux images. |
| Que reste-t-il ensuite ? | Une exécution verte, et un test qui ne vérifie plus ce pour quoi il a été fait. | Le rapport sauvegardé de l'exécution en échec, et l'apparence acceptée dans le test. |
| Combien cela coûte-t-il ? | Rien aujourd'hui, et un bug manqué plus tard. | Un clic par changement, ou un seul examen pour plusieurs. |
Un test qui se modifie lui-même entre deux exécutions n'est plus le même test.Pourquoi le même test doit donner deux fois la même réponse, c'est le sujet de Tests IA reproductibles.
Ce qu'il faut savoir avant de commencer
| Limite | Ce que cela signifie |
|---|---|
| Accepter, c'est un clic par changement | Une personne examine chaque nouvelle apparence. Après une refonte, la feuille des assertions échouées vous permet d'en accepter plusieurs ensemble. |
| Un test vérifie ce qu'on lui a demandé de vérifier | Un changement sur une partie de l'écran qu'aucune assertion ne regarde n'est pas vu. Ajoutez une assertion là où c'est important. |
| L'IA peut laisser passer une différence mineure | Avec l'analyse intelligente par IA activée, une assertion échouée qui ne diffère que par des détails qu'un utilisateur ne remarquerait pas peut être déclarée réussie. Le rapport le dit, et le fichier de test n'est pas modifié. |
Points clés
- 1Les tests auto-réparateurs se réparent eux-mêmes en choisissant un élément similaire quand le leur est introuvable.
- 2Une fausse réparation choisit le mauvais élément : un test vert sur un parcours cassé, et personne n'est prévenu.
- 3Deux changements, deux règles : la façon de trouver un élément peut s'adapter, ce qu'une assertion attend ne change que si une personne est d'accord.
- 4Dans GUI Test Studio, aucun localisateur à entretenir : chaque élément est trouvé d'abord par les informations d'accessibilité de l'application, et à vue quand l'application ne dit rien.
- 5Un vrai changement échoue au grand jour, et une personne accepte la nouvelle apparence en un clic ou signale le bug.
Questions
Qu'est-ce qu'un test auto-réparateur (self-healing) ?
Les tests auto-réparateurs (self-healing) sont des tests automatisés qui se modifient eux-mêmes quand ils ne trouvent plus un élément. L'outil cherche ce qui lui ressemble le plus à l'écran, l'utilise à sa place et poursuit l'exécution. Le but est d'épargner à l'équipe la réparation des tests après de petits changements de l'application.
Qu'est-ce qu'une fausse réparation dans l'automatisation des tests ?
Une fausse réparation est une réparation qui choisit le mauvais élément. Le test clique sur quelque chose, ou vérifie quelque chose, qui ressemble seulement à l'élément pour lequel il a été fait, et réussit. Le résultat est un test vert sur un parcours cassé.
L'automatisation des tests auto-réparatrice est-elle sûre ?
Elle est sûre quand elle ne change que la façon dont un test trouve un élément et vous le dit à chaque fois. Elle est risquée quand elle change ce que le test attend, ou choisit un autre élément, sans qu'une personne regarde. Demandez qui est prévenu quand un test s'est modifié lui-même, et qui a décidé que le changement était le bon.
Pourquoi les tests automatisés cassent-ils quand l'application change ?
La plupart des tests codés trouvent chaque bouton et chaque champ par un localisateur, une ligne qui décrit où se trouve l'élément dans la page ou la fenêtre. Quand un développeur renomme ou déplace l'élément, le localisateur ne correspond plus et le test échoue, alors que l'application fonctionne.
GUI Test Studio a-t-il des tests auto-réparateurs ?
Il a bien moins besoin de réparation, et il laisse la décision à une personne. Vous n'avez aucun localisateur à écrire ni à réparer : chaque élément est trouvé d'abord par les informations d'accessibilité de l'application, et à vue quand l'application ne dit rien. Quand l'écran a vraiment changé, l'assertion échoue dans le rapport de confiance, et vous acceptez la nouvelle apparence en un clic ou signalez le bug.
Comment mettre à jour un test après un changement voulu ?
Ouvrez l'assertion échouée dans le rapport de confiance, regardez l'image attendue et l'image obtenue, et cliquez sur Accepter le résultat obtenu comme attendu. Ctrl+Z l'annule jusqu'à ce que vous cliquiez sur Sauvegarder. Après la sauvegarde, le test attend la nouvelle apparence.
Puis-je accepter de nombreux changements à la fois après une refonte ?
Oui. Le rapport de confiance liste chaque assertion échouée avec ses deux images sur une seule feuille. Vous décochez celles qui sont de vrais bugs et vous acceptez le reste ensemble.
Qui doit décider quand un test change ?
Une personne qui a vu ce qui a changé. Un test énonce ce que votre équipe attend du produit, donc changer ce qu'il attend est une décision sur le produit. Un outil peut préparer cette décision en montrant l'attendu à côté de l'obtenu, mais il ne devrait pas la prendre seul.
Windows et Jira sont des marques de leurs propriétaires respectifs.
À lire aussi
Tous les articles
Fiabilité des tests
Preuves de test pour les audits : ce qu'un auditeur attend d'un test automatisé
11 min de lecture

Fiabilité des tests
Pauses fixes dans les tests : arrêtez de deviner un délai, attendez plutôt l'écran
10 min de lecture

Fiabilité des tests
Encore un « element not found » ? Comment tester quand les sélecteurs et les localisateurs échouent
14 min de lecture