Comment écrire un cas de test en anglais courant qu'un agent IA peut exécuter
Par Mirko Peters · · Mis à jour
Rédigez des cas de test en langage courant qu'un agent IA peut exécuter : un seul comportement par test, une seule action par étape, des éléments nommés et un résultat attendu clair et vérifiable.
Traduit automatiquement par IA à partir de l'article original. Lire l'original en anglais
Pour rédiger des cas de test en langage courant qu'un agent IA peut exécuter, limitez chaque test à un seul comportement, chaque étape à une seule action et chaque vérification à un seul résultat visible à l'écran. Ce guide s'adresse aux responsables QA et aux testeurs qui souhaitent passer de scripts à des instructions écrites tout en obtenant des résultats fiables. Vous découvrirez les cinq éléments d'un cas de test, les règles qui rendent une étape exécutable, une méthode pour transformer des critères d'acceptation en tests, ainsi qu'un exemple complet que vous pourrez reprendre.
Points clés
- Un cas de test en langage courant comporte cinq éléments : un titre, des préconditions, des étapes, un résultat attendu et les données de test. Un agent IA a besoin que les cinq soient explicitement décrits.
- Rédigez un seul comportement par test et une seule action par étape, car les éditeurs d'outils indiquent que les instructions en une seule étape sont les plus fiables.
- Nommez chaque élément tel qu'un utilisateur le voit, par exemple le bouton Se connecter, plutôt que d'écrire « le bouton » ou « le champ ».
- Donnez à chaque test un résultat attendu vérifiable à l'écran, comme un titre ou un montant, et jamais une formule du type « vérifier que cela fonctionne ».
- Relisez ce que l'agent a généré avant de considérer un succès comme acquis, et réécrivez toute étape qu'il a interprétée d'une façon non voulue.
Les cinq éléments d'un cas de test en langage courant
Un bon cas de test se lit comme une courte histoire que tout membre de l'équipe peut suivre. En test logiciel, la rédaction de cas de test efficaces est une compétence QA essentielle, et les testeurs manuels les ont toujours écrits en langage courant. La nouveauté, c'est qu'un agent IA peut désormais exécuter les étapes du test. Cela compte surtout pour les tests de bout en bout, où un test suit un utilisateur à travers un flux de travail complet dans un navigateur. Pour un agent IA, chaque élément doit être explicite, car l'agent ne peut pas vous demander ce que vous vouliez dire.
- Titre. Une ligne qui énonce le comportement, par exemple « Un client peut réinitialiser un mot de passe oublié ». Le titre est la première information qu'un lecteur voit dans un rapport.
- Préconditions. L'état dans lequel le produit doit se trouver avant le début du test, par exemple « Un compte client existe et le client est déconnecté ».
- Étapes. Ce que fait l'utilisateur, une action par ligne.
- Résultat attendu. Ce que l'utilisateur doit voir ensuite, formulé en termes que vous pouvez vérifier à l'écran.
- Données de test. Les valeurs exactes utilisées, comme une adresse e-mail ou un numéro de commande.
Un modèle commun garde la même structure pour les cas de test de chaque testeur, et une suite de tests fondée sur un seul modèle est beaucoup plus simple à relire. Un cas de test doit aussi permettre de vérifier le résultat, ce qui explique l'importance du résultat attendu.
C'est la même structure que celle du développement piloté par le comportement (BDD). Dans le langage Gherkin, tel qu'expliqué sur Automation Panda, Given décrit l'état initial, When correspond à l'action testée et Then énonce le résultat attendu. Vous n'êtes pas obligé d'utiliser ces mots-clés. Les trois rôles restent néanmoins utiles.
Règles qui rendent une étape exécutable par un agent IA
Les éditeurs d’outils publient des conseils pour rédiger des instructions qu’un agent IA peut suivre. La documentation de BrowserStack pour son agent de test en langage naturel donne des règles qui s’appliquent à la plupart des outils :
- Commencez par un verbe d’action. « Cliquer sur le bouton Envoyer » est clair. « Le bouton d’envoi » n’est pas une instruction.
- Utilisez une seule intention par commande. Découpez les tâches en plusieurs étapes distinctes.
- Nommez précisément l’élément. Écrivez « le bouton Se connecter », et non « le bouton ».
- Faites défiler la page en premier lorsqu’une cible est hors écran. Ajoutez une étape avant l’action.
La même page indique que la fiabilité diminue à mesure que les commandes se complexifient, et que les instructions à une seule étape sont les plus précises. Voici trois règles tirées de l’expérience :
- Utilisez les mots affichés à l’écran. Si le bouton indique « Se connecter », n’écrivez pas « Ouvrir une session ».
- Indiquez les valeurs dans l’étape. Écrivez « Saisir ana@example.com dans le champ Adresse e-mail », et non « saisir une adresse e-mail valide ».
- Évitez les pronoms et les termes vagues. « Il », « là », « correctement » et « bien » masquent tous une décision que l’agent devra deviner.
Comment rédiger des cas de test en langage courant, étape par étape
Suivez cette méthode pour transformer une exigence en cas de test.
- Partez d’un seul critère d’acceptation. Prenez une phrase unique de la user story, par exemple « Un client qui oublie son mot de passe peut en définir un nouveau par e-mail ».
- Choisissez un seul comportement. Chaque cas de test vérifie un comportement. Le guide d’Automation Panda sur la rédaction de bons scénarios Gherkin le formule ainsi : « Un scénario, un comportement » et indique qu’un scénario comportant plusieurs paires When-Then doit être scindé.
- Décrivez l’état initial. Formulez-le comme un état, et non comme des actions de préparation. « Un compte client existe » vaut mieux que dix étapes qui le créent.
- Décrivez les actions de l’utilisateur. Chaque action tient sur une ligne courte, avec un verbe et un élément nommé.
- Décrivez le résultat attendu. Indiquez ce qui s’affiche : un titre, un message, une valeur. Reprenez le texte exact.
- Ajoutez les données. Placez les valeurs dans les étapes ou dans un petit tableau sous le test.
- Relisez-le à voix haute. Si un nouveau collègue ne pouvait pas l’exécuter manuellement, l’agent aura lui aussi du mal.
Le même guide recommande de garder des scénarios courts, avec moins de dix étapes. Un cas de test trop long correspond souvent à plusieurs cas de test réunis. Les variantes d’un même comportement, comme trois mots de passe non valides, doivent figurer dans un tableau de données, et non dans trois copies des mêmes étapes.
Exemple : un test de réinitialisation de mot de passe, avant et après
Les détails sont fictifs.
Avant (trop vague). « Vérifier que la réinitialisation du mot de passe fonctionne. » L’agent ne dispose ni d’état initial, ni d’actions, ni de résultat à contrôler. Il pourrait réussir pour de mauvaises raisons.
Après (exécutable).
- Titre : Un client peut demander un lien de réinitialisation de mot de passe.
- Préconditions : Un compte client existe pour ana@example.com, et le client est déconnecté.
- Étape 1 : Ouvrir la page Se connecter.
- Étape 2 : Cliquer sur le lien « Mot de passe oublié ».
- Étape 3 : Saisir ana@example.com dans le champ Adresse e-mail.
- Étape 4 : Cliquer sur le bouton « Envoyer le lien de réinitialisation ».
- Résultat attendu : La page affiche le message « Vérifiez votre messagerie ».
La version « après » porte sur un seul comportement, cinq actions courtes et un seul résultat visible. Si votre produit exige également que le lien figurant dans l’e-mail fonctionne, rédigez un second cas de test pour ce comportement. Ne prolongez pas le premier.
Exécutez maintenant le test et lisez le journal. Supposons que l’agent ait bien cliqué sur « Mot de passe oublié », mais qu’il ait saisi l’adresse dans une zone de recherche. Le journal fait apparaître l’erreur : vous réécrivez alors l’étape 3 ainsi : « Saisir ana@example.com dans le champ Adresse e-mail du formulaire de réinitialisation ». L’équipe Cypress recommande la même démarche pour son propre outil en langage courant : inspectez chaque étape générée, et passez à du code figé lorsque vous avez besoin d’un test stable.
Variantes : utilisez un tableau de données, et non des copies
De nombreux cas de test vérifient le même comportement avec des valeurs différentes. Un formulaire d’inscription doit refuser une adresse e-mail sans arobase, une adresse sans domaine et une adresse contenant des espaces. N’écrivez pas trois cas de test aux étapes identiques.
Le guide d’Automation Panda indique que Gherkin ne propose pas d’étape « Or ». Pour les variantes d’un même comportement, il recommande un Scenario Outline avec un tableau Examples, et conseille de n’inclure que les variantes nécessaires, car chaque ligne supplémentaire allonge le temps d’exécution. Vous pouvez appliquer la même idée en anglais courant : rédigez les étapes une seule fois avec un paramètre, par exemple « Type {email} into the Email field », puis ajoutez un petit tableau en dessous.
Exemple de tableau, fictif : {email} vaut « ana.example.com » et le message attendu est « Enter a valid email address » ; {email} vaut « ana@ » et le message est le même ; {email} est vide et le message attendu est « Email is required ». Trois lignes, un seul jeu d’étapes, trois résultats clairs. Si une ligne échoue, le rapport indique quelle valeur a enfreint la règle.
Liste de contrôle avant exécution
Utilisez cette liste pour chaque nouveau cas de test :
- Le titre énonce un seul comportement.
- L’état de départ décrit un état, et non une liste de manipulations de configuration.
- Chaque étape commence par un verbe et désigne un élément tel qu’il apparaît à l’écran.
- Toutes les valeurs sont écrites en toutes lettres.
- Le résultat attendu est observable et comporte un texte ou un nombre exact.
- Il y a moins de dix étapes.
- Une autre personne a relu le test.
Erreurs courantes
- Combiner plusieurs comportements dans un même cas de test. En cas d’échec, on ne sait pas quelle partie a cassé.
- Décrire le comment au lieu du quoi. Dix étapes de frappes au clavier masquent l’intention. Formulez l’action au niveau où la décrirait un utilisateur.
- Omettre le résultat attendu. Un cas de test sans vérification peut réussir sans rien prouver.
- Utiliser des noms internes. Les identifiants de test et les classes CSS changent. Utilisez les libellés que voient les utilisateurs.
- Laisser l’IA générative rédiger les tests et les accepter sans les relire. Un modèle peut inventer des étapes que votre produit ne possède pas.
- Laisser les données au hasard. Si une valeur n’est pas précisée, l’agent en choisira une, et le test risque de ne pas être reproductible.
Comment les logiciels peuvent aider
Une feuille de calcul partagée ou une page de wiki suffit pour démarrer. Rédigez chaque test selon la forme en cinq parties et relisez-le comme du code. Si vous utilisez un outil de gestion de tests, conservez un test par fiche et reliez-le à l’exigence correspondante. Un outil de test en langage naturel pourra alors lire le même texte. De nombreuses équipes conservent également un bref guide de style reprenant les règles ci-dessus, afin que chaque nouveau testeur rédige ses étapes de la même manière.
Prochaine étape
Prenez trois critères d’acceptation de votre sprint en cours et rédigez un cas de test pour chacun, en suivant les cinq parties. Exécutez-les dans l’outil de votre choix pour obtenir des cas de test en langage courant qu’un agent peut exécuter, puis corrigez chaque étape que le journal signale comme mal interprétée.