L’IA peut-elle rédiger des cas de test à partir de user stories ? Les points à vérifier en premier
Par Mirko Peters · · Mis à jour
L’IA peut-elle générer des cas de test à partir de user stories ? Des études montrent des ébauches rapides mais incomplètes. Voici ce qu’il faut vérifier en premier : la couverture, les ambiguïtés, les cas limites et les tests inventés.
Traduit automatiquement par IA à partir de l'article original. Lire l'original en anglais
L’IA peut-elle générer des cas de test à partir de user stories ? Oui, et elle le fait en quelques secondes, mais l’ébauche doit faire l’objet d’un examen attentif avant d’entrer dans votre suite de tests. Ce guide s’adresse aux responsables QA qui souhaitent l’essayer sans faire baisser la qualité. Vous y découvrirez ce que deux études publiées ont constaté, les problèmes qui reviennent systématiquement, ainsi qu’une liste de contrôle pour vérifier une ébauche. Un exemple détaillé, avec des chiffres fictifs, montre comment une relecture modifie un lot de cas de test générés.
Points clés
- L’IA peut rédiger des ébauches de cas de test à partir de user stories en quelques secondes à quelques minutes. Une expérimentation de Thoughtworks a montré une couverture élevée des critères d’acceptation énoncés, mais la qualité dépendait de la clarté de la story.
- La même expérimentation a mesuré une ambiguïté dans environ 27 % des cas générés et environ 6 % de cas incorrects. Une relecture n’est donc pas facultative.
- Les études décrivent quatre problèmes récurrents : des cas non pertinents ou inventés, des cas redondants, des cas limites manquants et des données d’entrée non entièrement spécifiées.
- Relisez chaque ébauche au regard des critères d’acceptation, supprimez les doublons, ajoutez les cas limites et les parcours négatifs, et réécrivez toute étape imprécise.
- Considérez le modèle comme un assistant qui rédige, et gardez une personne responsable de ce qui entre dans la suite de non-régression.
L’IA peut-elle générer des cas de test à partir de user stories ? Ce qu’ont montré les études
Un article de Thoughtworks, AI generated test cases from user stories: an experimental research study, décrit une petite expérimentation. Trois ingénieurs QA ayant entre trois et cinq ans d’expérience ont rédigé manuellement des cas de test pour neuf user stories. Ensuite, des outils d’IA générative, principalement GitHub Copilot, ChatGPT servant de comparaison, ont produit des cas de test pour les mêmes stories à partir de prompts affinés.
En moyenne, les cas générés couvraient 98,67 % des critères d’acceptation et présentaient une structure cohérente. L’article signale environ 4 % de doublons, environ 6 % de cas de test incorrects et un score d’ambiguïté d’environ 27 %. Il décrit la génération comme prenant de quelques secondes à quelques minutes, au lieu de plusieurs heures.
Les faiblesses étaient tout aussi nettes. La qualité dépendait fortement de la précision des données d’entrée. Les outils peinaient avec la logique métier complexe, identifiaient peu de cas limites sans consigne explicite et réalisaient peu de tests non fonctionnels, sauf demande explicite. Les auteurs qualifient leur hypothèse de partiellement validée, estiment que la supervision humaine reste indispensable, et soulignent que l’échantillon de neuf user stories est restreint.
Un deuxième article, une étude arXiv intitulée Automatic High-Level Test Case Generation using Large Language Models, porte sur des cas d’utilisation plutôt que sur des user stories ; il constitue donc un résultat connexe. Les auteurs ont constitué un jeu de données de 1 067 cas d’utilisation et de 3 606 cas de test issus de 168 projets. Lors d’une évaluation humaine, GPT-4o a obtenu une note de 3,91 pour l’exhaustivité et de 3,98 pour la pertinence, contre 4,04 et 4,30 pour les cas rédigés par des humains. Les auteurs jugent le résultat satisfaisant, mais ils indiquent qu’une évaluation humaine complète des cas de test automatisés est nécessaire.
Ce que les chiffres disent, et ce qu’ils ne disent pas
Soyez prudent avec les pourcentages. Les deux études énoncent leurs limites. L’expérience Thoughtworks s’appuyait sur neuf user stories, des outils et versions précis, et une évaluation en partie subjective ; elle n’a pas mesuré la productivité sur le long terme. Elle indique également que ChatGPT a mieux réussi que GitHub Copilot lorsqu’une interprétation fine de la consigne était nécessaire : les résultats dépendent donc de l’outil et de la consigne.
Dans l’article arXiv, les 26 évaluateurs humains ne se sont accordés que modérément entre eux, avec un Kappa de Cohen de 0,42, et les participants constituaient un échantillon de commodité. Les auteurs soulignent aussi qu’un score de similarité automatique ne permet pas de détecter de façon fiable les cas limites ou négatifs manquants. C’est pourquoi ils réclament une évaluation humaine.
Le taux de couverture élevé mérite lui aussi un second regard. Il mesure les critères qui ont été écrits. Il ne peut pas révéler les règles que personne n’a consignées dans la story, et ce sont souvent ces règles implicites qui abritent les défauts.
Quatre problèmes récurrents
L’article arXiv identifie quatre problèmes récurrents, et les résultats de Thoughtworks vont dans le même sens :
- Cas non pertinents. Les auteurs les rattachent à l’hallucination de l’IA : le modèle produit une information plausible mais incorrecte. Un exemple concernait un test portant sur une fonctionnalité que l’application ne prenait pas en charge.
- Cas redondants. Certains cas reprennent un autre cas avec une modification mineure.
- Cas limites manquants. Les modèles ont omis des cas que les testeurs humains avaient inclus, comme le rejet d’un type de fichier non pris en charge.
- Spécification insuffisante des entrées. Certains cas générés omettaient des champs de saisie nécessaires au test.
Aucun de ces problèmes ne rend un brouillon inutilisable. Ils vous indiquent ce qu’il faut vérifier.
Ce qu’il faut vérifier en premier : une liste de contrôle
Thoughtworks recommande de réviser les résultats avant toute utilisation en production, en les confrontant aux critères d’acceptation, en signalant les logiques peu claires et en vérifiant la couverture des cas limites. Transformez cela en liste de contrôle pour chaque lot :
- Couverture. Chaque critère d’acceptation est-il couvert par au moins un cas de test ? Listez les critères et cochez-les un à un.
- Tests inventés. Chaque cas correspond-il à un élément de la story ? Supprimez les cas portant sur des fonctionnalités inexistantes.
- Doublons. Fusionnez les cas qui vérifient le même comportement avec les mêmes données.
- Étapes précises. Chaque étape nomme-t-elle l’élément et la donnée ? Réécrivez les formulations vagues, comme « saisir des données valides ».
- Résultats attendus. Chaque résultat attendu est-il observable à l’écran ou dans un enregistrement ?
- Cas limites et chemins négatifs. Ajoutez les saisies vides, les formats incorrects, les limites et les échecs d’autorisation.
- Exigences non fonctionnelles. Ajoutez les contrôles de performance, d’accessibilité et de sécurité que la story suppose, car le modèle peut les omettre.
Pour un lot volumineux, examinez d’abord un échantillon. Lisez intégralement les dix premiers cas. Si beaucoup d’entre eux échouent à la liste de contrôle, corrigez la story ou la consigne avant de poursuivre, car le même défaut se reproduira dans le reste du lot. Il s’agit d’une règle de travail, et non d’un résultat tiré des études.
La génération de cas de test par IA s’inscrit dans les tests logiciels comme une étape de rédaction qui précède l’automatisation des tests. Une équipe QA peut utiliser l’IA pour créer des cas de test pour chaque scénario de test d’une story, vérifier la couverture des tests par rapport aux critères d’acceptation, puis décider quels cas transformer en tests automatisés. L’outil d’IA assure la rédaction, et l’équipe QA conserve la conception des tests. Utilisée de cette manière, cette approche permet de générer des tests plus rapidement sans altérer la qualité de la suite.
Cette vérification relève du human-in-the-loop. Le testeur ne réécrit pas le brouillon. Il le juge, et ce jugement est la part que le modèle ne peut pas fournir.
Rendre les entrées plus faciles à exploiter pour l’IA
Thoughtworks indique que le prompt est passé d'une demande simple à une demande qui attribuait un rôle au modèle et lui demandait d'utiliser Given, When, Then lorsque c'était pertinent. Le même rapport précise que la couverture des scénarios complexes a nécessité un travail important sur le prompt. Trois bonnes pratiques aident :
- Rédigez des critères d'acceptation explicites. Si la user story est floue, les cas de test le seront aussi. Commencez par corriger la user story.
- Ajoutez du contexte. Indiquez le rôle de l'utilisateur, le domaine produit concerné et les règles que le modèle ne peut pas deviner.
- Demandez une structure. Utilisez l'IA avec un format clair : demandez pour chaque cas un titre, les préconditions, les étapes, les données et le résultat attendu, et demandez à l'IA de lister ses hypothèses.
Veillez à ce que le prompt ne contienne aucun secret ni aucune donnée client. Utilisez des valeurs d'exemple inventées.
Exemple : revue d'un lot
Les chiffres sont fictifs.
Une équipe soumet dix user stories à un assistant IA. Celui-ci renvoie 60 cas de test en quelques minutes. Le responsable QA les vérifie avec le product owner.
- 6 cas sont des doublons : l'équipe les supprime.
- 5 cas testent un comportement que le produit ne possède pas : l'équipe les supprime également. Il reste 49 cas.
- 7 des 49 cas restants ont des étapes ou des résultats imprécis : l'équipe les réécrit.
- 9 cas limites et chemins négatifs manquent : l'équipe les ajoute à la main.
La suite finale compte 58 cas de test. La revue a pris environ trois heures, alors que rédiger les 58 cas à partir de zéro aurait pu prendre une journée entière. L'équipe conserve ses notes de revue, consigne les types de cas rejetés et s'en sert pour améliorer le prompt du sprint suivant. Le gain est réel, mais il provient de la revue et non du seul modèle.
Erreurs courantes
- Accepter le lot sans le lire. Les doublons et les cas inventés entrent dans la suite et sapent la confiance qu'on lui accorde.
- Mesurer le succès au nombre de cas. Davantage de cas ne signifie pas davantage de couverture.
- Fournir au modèle des user stories floues. Une entrée médiocre produit une sortie médiocre.
- Oublier les cas limites et les contrôles non fonctionnels. Les études montrent que les modèles ont tendance à les omettre.
- Mettre des données privées dans les prompts. Utilisez des valeurs fictives et respectez votre politique de données.
- Négliger le lien avec les critères d'acceptation. Sans ce lien, vous ne pouvez pas démontrer ce qui est couvert.
Comment les logiciels peuvent aider
Un tableur ou votre outil de gestion des tests peut regrouper côte à côte les critères, les cas générés et le statut de revue. Marquez chaque cas comme accepté, réécrit ou rejeté, et conservez les totaux afin de connaître, au bout de quelques sprints, votre propre taux de rejet. Un outil de revue de code ou un document partagé facilite la revue conjointe par les testeurs et les product owners. Si vous utilisez un assistant IA, choisissez-en un qui vous laisse contrôler le prompt et voir l'intégralité de sa sortie. Pour les cas au niveau du navigateur, un outil de tests de bout en bout pouvant exécuter les étapes approuvées en langage courant peut ensuite prendre le relais. Testez d'abord sur une seule équipe avant de généraliser.
Prochaine étape
Prenez une user story terminée, demandez à un outil d'IA de générer des cas de test, puis vérifiez le brouillon à l'aide de la liste de contrôle ci-dessus. Comptez ce que vous supprimez, réécrivez et ajoutez, et utilisez ces chiffres pour décider dans quelle mesure votre équipe peut laisser l'IA générer des cas de test à partir des user stories.