plan-de-test-manuel

Rédige un plan de test manuel pour vérifier la branche courante dans l'application en cours d'exécution : cas avec préconditions, étapes et résultat attendu exact, répartis entre ce qu'un agent peut exécuter avec un navigateur ou un simulateur iOS et ce qu'un humain doit faire manuellement (ex : test de lecteur d'écran), avec une répétition par agent de chaque cas humain via l'arbre d'accessibilité et, lorsque le lecteur d'écran peut être piloté, une transcription réelle.

Qu'est-ce que plan-de-test-manuel ?

Cette compétence génère un plan de test manuel pour une branche de code, en se concentrant sur les aspects non couverts par les tests automatisés. Elle identifie les modifications, analyse la PR, le ticket et la conversation en cours, et produit des cas de test adaptés, chacun assigné à un agent (navigateur, simulateur iOS) ou à un humain. Les cas humains sont d'abord « répétés » par l'agent (via l'arbre d'accessibilité ou un lecteur d'écran pilotable) pour trouver les problèmes évidents avant l'intervention humaine. Le plan est concis, ciblé sur les bugs importants, et exécuté tard dans le processus de développement (après les relectures de code et les tests automatisés). Il s'appuie sur un build local, jamais sur la production, et indique comment vérifier l'environnement de test (staging) avant toute exécution. Il prend en charge les agents disposant d'un navigateur intégré, d'un simulateur iOS/Android, d'un lecteur d'écran (VoiceOver) et d'un navigateur scripté (Playwright).

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/MagnusBrogie/agent-skills/tree/HEAD/manual-test-plan

Installed? Explore more Développement et programmation skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Plan de test manuel

Rédigez le plan pour vérifier cette branche dans l'application en cours d'exécution. Le plan couvre ce que les tests automatisés ne peuvent pas montrer : l'apparence et le comportement de la modification avec des données réelles, dans des flux réels, à travers les états qu'un utilisateur peut atteindre.

Chaque cas est attribué à la personne qui peut le résoudre : un agent pilotant un navigateur, un agent pilotant un simulateur iOS, ou un humain. Donnez à un agent tout ce qu'un agent peut résoudre. Pour les cas que seul un humain peut résoudre, faites d'abord tenter par un agent une répétition, afin que les problèmes évidents soient trouvés avant qu'une personne n'y consacre du temps et que la personne sache où chercher.

Exécuter un cas dans l'application est coûteux. Un agent pilotant un navigateur dépense plusieurs fois le nombre de jetons d'un test de code pour la même vérification, et une personne dépense des minutes. Le plan est donc petit et ciblé : il contient les cas les plus susceptibles de révéler un bogue important, et rien qu'un test dans le code pourrait couvrir aussi bien. Un bon plan est suffisamment court pour être exécuté en entier.

Pour la même raison, rédigez et exécutez le plan tard : après les relectures qui lisent le code, après les correctifs et les remaniements qu'elles entraînent, et après la mise en place des tests de code. Ensuite, le plan est exécuté une fois, sur le code qui sera fusionné, et les passes précédentes ont déjà effectué les vérifications peu coûteuses. Si le code est encore en cours de modification, dites-le en haut du plan. S'il change après l'exécution du plan, nommez les cas qui doivent être réexécutés : ceux dont la ligne « Attrape » pointe vers le code modifié.

Notes locales. Si un fichier nommé LOCAL.md se trouve à côté de ce fichier, lisez-le avant de commencer. Il contient les propres valeurs par défaut de l'utilisateur pour les projets sur lesquels il travaille (commandes, hôtes, comptes, chemins) et ne fait pas partie de la compétence publiée. Là où il couvre le projet en question, il compte comme faisant partie des instructions du projet ; là où ce n'est pas le cas, ignorez-le.

Rassembler les modifications

La demande peut nommer une branche de base. Si aucune n'est donnée, choisissez-la dans cet ordre :

  1. La branche de base de la pull request de la branche, si elle en a une : gh pr view --json baseRefName --jq .baseRefName.
  2. La branche par défaut du dépôt : git symbolic-ref --short refs/remotes/origin/HEAD.
  3. origin/main, puis main.

Utilisez la référence distante (origin/<branche>) de préférence à une branche locale du même nom. Incluez le travail qui n'est pas encore validé :

base=$(git merge-base <base> HEAD)
git diff --stat "$base"          # validé + indexé + non indexé
git diff "$base"
git status --short               # les fichiers non suivis ne sont pas dans le diff ; lisez-les
git log --oneline "$base"..HEAD

Lire les trois sources que le diff ne contient pas

Le diff montre ce qui a changé. Il ne montre pas à quoi sert le changement, ce que les gens ont déjà vu mal tourner, ou ce qui a été décidé dans cette conversation. Lisez les trois avant de choisir un cas. Ce sont des entrées obligatoires, pas un contexte ; le plan rapporte ce qui a été lu et montre comment chaque source l'a façonné.

1. La pull request et ses commentaires

pr=$(gh pr view --json number --jq .number)
gh pr view --json title,body,baseRefName
for kind in "issues/$pr/comments" "pulls/$pr/reviews" "pulls/$pr/comments"; do
  gh api "repos/{owner}/{repo}/$kind" --paginate --jq '.[]
    | select(.user.type != "Bot" and (.body // "") != "")
    | {id, reply_to: .in_reply_to_id, user: .user.login, path, line: (.line // .original_line), body}'
done

Les trois listes sont les commentaires de conversation, les résumés de relecture et les commentaires en ligne sur les lignes du diff, en excluant les sorties des bots. Les bots sont toujours là où se trouve généralement un lien de déploiement, donc cherchez cela séparément. L'environnement déployé n'est pas l'endroit où le plan est exécuté (voir "Tester un build local" ci-dessous) ; le lien sert de comparaison et de solution de repli :

gh api "repos/{owner}/{repo}/issues/$pr/comments" --paginate \
  --jq '.[] | select(.user.type == "Bot") | .body' | grep -oE 'https?://[^ )|>"]+' | sort -u

Lisez la description, chaque commentaire humain et les réponses de l'auteur. Un rapport dans la description compte autant qu'un dans un commentaire. Tirez-en :

  • Toute chose qu'une personne a vue dans l'application : une valeur erronée, un état qui ne se termine jamais, un flux cassé, une capture d'écran. Chacune devient un cas qui reteste ce rapport exact, que le code ait changé ou non depuis. Demandez ensuite où ailleurs la même panne pourrait se manifester (les écrans apparentés, le même état atteint d'une autre manière) et envisagez un cas là-bas.
  • Des doutes sur le comportement soulevés lors de la relecture ("l'ordre peut être en désaccord avec ce qui est affiché") : chacun est un cas candidat, noté haut pour la probabilité, car un lecteur du code l'a déjà suspecté.
  • Les notes de test dans la description : ce que l'auteur dit avoir testé, et ce qu'il dit ne pas avoir testé. Datez les notes par rapport au journal des validations (git log --format='%h %ad %s' --date=short "$base"..HEAD) : ce qui a été testé avant que des validations ultérieures ne touchent le même code n'a pas été testé dans sa forme actuelle. Les validations qui sont arrivées après le dernier test manuel sont l'endroit où le plan devrait viser en premier.
  • Des liens vers des environnements déployés : le déploiement de la branche elle-même, et celui de la base, pour des comparaisons côte à côte.
  • Des décisions prises dans le fil sur la façon dont quelque chose devrait se comporter. Celles-ci fixent les résultats attendus.

2. Le ticket

Trouvez l'identifiant du ticket dans le nom de la branche, les sujets des validations, le titre ou le corps de la pull request, ou un commentaire d'un robot de suivi sur la pull request. Cherchez-le avec le tracker que les instructions du projet nomment, en utilisant l'outil disponible pour cela. Lisez la description, les critères d'acceptation, la discussion, et toute capture d'écran ou étapes de reproduction jointes. Tirez-en :

  • Le rapport original. Si le ticket décrit un bogue, ses étapes de reproduction deviennent le premier cas du plan : les étapes telles que rapportées, avec le comportement corrigé comme résultat attendu. Si le ticket n'est qu'un titre, ou pointe vers un fil ou une pièce jointe qui ne peut pas être lu, dites-le, reconstruisez le cas à partir du titre et de la description de la pull request, et marquez-le comme reconstruit.
  • Chaque critère d'acceptation. Chacun doit aboutir dans l'un des trois endroits : un cas dans le plan, un test nommé dans le code qui le couvre, ou la liste de ce qui a été omis, avec la raison.
  • Les utilisateurs, données et plateformes concernés que le ticket nomme, qui indiquent avec quelle forme de données et quel appareil tester.
  • Les tickets connexes vers lesquels il renvoie, où ils décrivent le même domaine défaillant d'une autre manière.

3. La conversation jusqu'à présent

Revenez dans cette conversation avant d'écrire. Tirez-en :

  • Les résultats de la relecture : vérifiez d'abord chacun par rapport à l'arbre actuel, car il a peut-être été corrigé depuis. Un résultat qui nécessite l'application en cours d'exécution pour confirmer reçoit un cas : un qui confirme le correctif, ou un qui montre la panne si elle a été laissée. Un résultat qu'un test dans le code peut cibler va sur la liste des tests à écrire, pas dans les cas.
  • Les listes "Non vérifié" et les étapes de validation manuelle des passes de relecture précédentes. Celles-ci ont été écrites pour être vérifiées dans l'application ; ce sont les entrées les plus directes qui existent.
  • Ce que l'utilisateur a dit à propos du changement : les parties qui l'inquiètent, les états qu'il a mentionnés, ce qu'il a déjà testé manuellement, et ce qu'il a dit de ne pas perdre de temps dessus. Une inquiétude exprimée augmente la note d'un cas ; « J'ai vérifié cela » le supprime.
  • Les décisions sur le comportement prises dans la conversation, qui fixent les résultats attendus que le code seul laisse ouverts.
  • Ce qui a changé dans le code pendant la conversation. Le code écrit ou réécrit dans cette session a été le moins testé.

Si la conversation ne contient rien de pertinent, dites-le dans le plan ; ne faites pas comme si c'était le cas.

Lorsqu'une source ne peut pas être lue

Si gh est manquant ou non connecté, la branche n'a pas de pull request, aucun ticket n'est lié, ou le tracker est inaccessible, continuez avec ce que vous avez. Nommez chaque source qui n'a pas été lue en haut du plan, et dites que le plan pourrait manquer ce qu'elle contenait. Ne présentez pas un plan construit à partir du seul diff comme un plan complet.

Lire ce qui d'autre a une incidence sur le plan

  • Comment exécuter l'application localement : la commande documentée du projet pour un build local, le backend auquel elle parle et les ports qu'elle utilise. Lisez les instructions du projet pour les environnements de test, les comptes de test et les indicateurs de fonctionnalité, et pour les plateformes sur lesquelles l'application est livrée (web, iOS, Android).

  • Ce que couvrent les tests automatisés : lisez les tests dans le diff, afin que le plan ne fasse perdre de temps à personne sur ce qu'un test valide déjà.

  • Quels outils un agent a ici : un navigateur qu'il peut piloter, et un simulateur de périphérique. Dans Orca, ce sont le navigateur intégré (la compétence orca-cli) et le simulateur iOS (la compétence orca-emulator ; orca-emulator-android pour Android). Cherchez aussi :

    • Un lecteur d'écran que l'agent peut piloter, comme la compétence voiceover, qui exécute le vrai VoiceOver de macOS sur une page et renvoie ce qu'il dit.
    • Un navigateur scripté (Playwright avec un navigateur installé) pour ce que le navigateur intégré ne peut pas faire. Par exemple, le navigateur intégré peut ne pas mettre une copie dans le presse-papiers du système, donc vérifier ce qui est copié nécessite un navigateur dont l'agent peut lire le presse-papiers.

    Notez lesquels sont disponibles dans cette session ; le plan l'indique dans sa configuration.

Tester un build local, pas la branche déployée

Planifiez chaque cas par rapport à un build local de l'arbre de travail. Un environnement de fonctionnalité ou d'aperçu déployé ne contient que ce qui a été validé et poussé : il est en retard sur le code en cours de travail, il ne peut pas montrer les modifications non validées, et un correctif effectué pendant les tests nécessiterait une validation et un push avant de pouvoir être retesté là-bas. Un build local montre le code tel qu'il est maintenant, et un correctif peut être retesté immédiatement.

La configuration du plan indique donc :

  • Comment construire et démarrer l'application localement, avec la commande exacte issue de la documentation du projet, le répertoire dans lequel l'exécuter et l'URL qu'elle sert. Si d'autres sessions ou arbres de travail peuvent exécuter l'application, dites comment choisir des ports libres.
  • À quel backend le build local parle. Il doit s'agir du backend de préproduction (staging) ou de test, jamais de la production. Un build local pointant vers la production exécute chaque cas, y compris les cas simulés et les commandes, sur les systèmes réels des clients. Les projets ont souvent une commande par environnement (par exemple un script stage et un prod) : nommez celui de préproduction dans le plan, et dites clairement que celui de production ne doit pas être utilisé. Si la documentation du projet ne précise pas quelle commande cible quel backend, trouvez-le à partir de la configuration de build, et si ce n'est toujours pas clair, arrêtez-vous et demandez à l'utilisateur ; ne devinez pas.
  • Comment vérifier le backend avant le premier cas : regardez où l'application en cours d'envoi de requêtes (l'hôte d'un appel API dans le journal réseau, ou l'URL API configurée) et confirmez qu'il s'agit de l'hôte de préproduction. Le plan nomme l'hôte à attendre. S'il s'agit de l'hôte de production, arrêtez-vous : ne vous connectez pas et n'exécutez aucun cas.
  • Comment savoir que le build est le code actuel : démarrez-le à partir de l'arbre de travail après la dernière modification, et reconstruisez ou rechargez après toute modification ultérieure. Si l'application affiche une version ou une validation, vérifiez-la.
  • Comment l'arrêter lorsque l'exécution est terminée.

Utilisez un environnement déployé uniquement pour :

  • Comparer avec la base : le déploiement de la branche de base, à côté du build local de la branche, pour les cas côte à côte.
  • Ce qu'un build local ne peut pas montrer : un cas concernant le déploiement lui-même, comme les ressources construites, la mise en cache, ou une application native qui encapsule le site déployé. Avant un tel cas, vérifiez que l'arbre de travail est propre et poussé et que le déploiement sert cette validation, et dites-le dans le cas.
  • Une solution de repli lorsque l'application ne peut pas être construite localement. Dites pourquoi en haut du plan, et indiquez quelle validation le déploiement sert et ce qui se trouve dans l'arbre de travail qui lui manque.

La même règle s'applique à tout environnement déployé utilisé par le plan : le déploiement de préproduction, jamais celui de production. Lorsqu'une branche a à la fois un déploiement de préproduction et un déploiement de production, donnez uniquement l'URL de préproduction dans le plan.

Déterminer quoi tester

  1. Listez ce qu'un utilisateur peut voir ou faire différemment. Tracez chaque modification du diff vers l'extérieur, jusqu'aux écrans et flux qui l'affichent. Une modification dans un code partagé atteint tous les écrans qui l'utilisent ; recherchez les appelants et listez-les tous, y compris ceux que la branche ne concernait pas.

  2. Pour chacun, décidez s'il nécessite l'application en cours d'exécution. Demandez si un test dans le code pourrait le résoudre. Si c'est déjà le cas, laissez-le de côté. Si cela pourrait facilement être le cas (une fonction pure, un décodeur, un ordre de tri, une fonction de vue étant donné un état, une transition d'état), laissez-le de côté des cas et mettez-le sur la liste des tests à écrire à la place ; cette vérification s'exécute alors à chaque modification pour rien, alors qu'un cas dans l'application est payé à chaque fois. Ne conservez que ce qu'un test de code ne peut pas atteindre ou qui ne serait pas fiable : comment les données réelles du vrai backend transitent, ce qui est rendu et disposé dans un vrai navigateur, comment les parties testées séparément se comportent une fois réunies, le timing et l'ordre des requêtes réelles, l'état dans lequel l'application se trouve après une navigation réelle, et ce qui est fourni à la technologie d'assistance.

  3. Trouvez les états. Pour chaque écran, lisez le code pour les branches qu'il peut prendre : chargé, en chargement, vide, erreur, données manquantes ou partielles, valeurs nulles et négatives, valeurs très longues, un élément et plusieurs, chaque paramètre ou mode qui modifie l'affichage, chaque type de compte ou d'utilisateur. Conservez les états que le diff touche.

  4. Déterminez comment atteindre chaque état. Nommez le chemin de navigation et décrivez les données dont il a besoin par leur forme ("un instrument détenu dans deux comptes, dont l'un sans coût d'achat"), pas par un compte dont vous n'avez pas confirmé l'existence. Lorsqu'un état est difficile à atteindre avec des données réelles, dites comment il peut être produit (un indicateur de fonctionnalité, une réponse réécrite, un réseau limité, un paramètre) ou marquez-le comme nécessitant un compte de test spécifique.

    Lorsqu'un cas dépend d'une réponse réécrite, le plan doit rendre la réécriture reproductible ; reference/mocks.md explique comment.

    Donnez à chaque cas un moyen d'y parvenir qui ne dépend pas de la chance avec les données du compte. Si les données réelles peuvent manquer de l'état, nommez le contrôle dans l'application qui l'active (un paramètre, un bouton à bascule, un autre compte) ou...

Individual skills in this repo

This repo contains 1 individual skill — each has its own dedicated page.

Skills associés