Preuves de test pour les audits : ce qu'un auditeur attend d'un test automatisé

Preuves de test pour les audits : ce qu'un auditeur demande à un test automatisé, et comment chaque exécution garde rapport, vidéo, images et historique.

Par Ait Nohaila, Chargée de développement commercial 11 min de lecture

Les preuves de test démontrent qu'un test s'est réellement exécuté : ce qui a été testé, quand, sur quelle version, avec quel résultat, et ce que montrait l'écran. Un auditeur les veut pour chaque exécution, lisibles des mois plus tard.

Dans une banque, chez un fournisseur de logiciels de santé, dans un service public ou dans toute entreprise auditée, « les tests ont réussi » n'est pas une réponse. L'auditeur demande à le voir. Alors un testeur passe les jours qui précèdent l'audit à coller des captures d'écran dans un document, pour des tests exécutés il y a des semaines.

Que sont les preuves de test ?

Définition

Les preuves de test, c'est tout ce qui permet à quelqu'un qui n'était pas là de vérifier qu'un test s'est exécuté et ce qu'il a trouvé.

  • Elles nomment le test et ce qu'il vérifie.
  • Elles donnent la date, la version et le résultat.
  • Elles montrent à quoi ressemblait l'écran, pour les étapes qui ont réussi comme pour celle qui a échoué.

De bonnes preuves peuvent être ouvertes un an plus tard par une personne qui n'a jamais vu l'application.

Une piste d'audit pour les tests, c'est la même idée dans la durée : les preuves de chaque exécution, dans l'ordre, pour que chacun puisse suivre ce qui a été testé d'une version à la suivante.

Pourquoi une coche verte dans un journal de build n'est pas une preuve

Un pipeline qui finit au vert prouve une seule chose : une commande s'est exécutée et s'est terminée sans erreur. Il ne dit pas quelles étapes se sont exécutées, ce qu'a comparé chaque assertion, ni ce que montrait l'écran à ce moment-là.

Un journal de build

tests : réussis
Quelles étapes se sont exécutées ?
Qu'a comparé chaque assertion ?
Que montrait l'écran ?

Une affirmation, sans rien à ouvrir.

Les preuves de la même exécution

Chaque étape et chaque assertion, avec son verdict
Les images attendues à côté des images obtenues
La vidéo de toute l'exécution

Une preuve que chacun peut ouvrir plus tard.

La même exécution, racontée de deux façons. Un auditeur accepte la seconde.
Un résultat est une affirmation. La preuve, c'est ce qui permet à quelqu'un d'autre de vérifier l'affirmation.

Cet écart compte le plus le jour où quelque chose tourne mal. Quand un défaut arrive chez les clients, la question n'est plus de savoir si les tests ont réussi. C'est de savoir ce qu'ils ont regardé exactement, et personne ne peut y répondre à partir d'une coche.

Ce que demande un auditeur, et les preuves qui y répondent

Que l'audit porte sur les contrôles financiers, sur le système qualité d'un logiciel médical ou sur la sécurité de l'information, les questions sur les tests ont la même forme. Chacune a une réponse qui devrait déjà exister quand la question arrive.

Ce que demande l'auditeurLes preuves qui répondent
Qu'est-ce qui a été testé ?Le test lui-même : un fichier qui contient chaque étape et chaque assertion, lisible en mots simples.
Quand s'est-il exécuté ?La date et l'heure de l'exécution, affichées sur son rapport et conservées avec ses résultats.
Sur quelle version ?Le build de votre pipeline qui a exécuté le test, avec les preuves conservées comme artefact de ce build.
Quel a été le résultat ?Le verdict de l'exécution et de chaque assertion : réussie, ou échouée et pourquoi.
Que montrait l'écran ?La vidéo de l'exécution, et l'image attendue à côté de ce que l'exécution a trouvé.
Réussissait-il avant ?L'historique des exécutions précédentes du même test.
Qu'est devenu l'échec ?Un rapport d'anomalie avec les étapes pour reproduire, ou le ticket qu'il est devenu dans votre outil de suivi.
Qui a décidé qu'il avait réussi ?La propre comparaison de l'assertion, la même à chaque exécution, ou un verdict de l'IA sauvegardé avec son explication.
Qui a changé ce que le test attend ?L'historique du fichier de test dans votre gestion de versions : un auteur et une date pour chaque changement.

Pourquoi rassembler les preuves de test à la main ne tient pas dans la durée

Beaucoup d'équipes répondent à ces questions par un document : un testeur déroule le scénario, fait une capture de chaque écran, la colle sous l'étape et signe la page.

Cela marche pour une version, puis les coûts apparaissent.

  • Cela prend des jours qui reviennent avant chaque audit et chaque version.
  • Cela ne montre que les écrans que quelqu'un a pensé à capturer, jamais ceux d'entre les deux.
  • Cela peut être fait après coup, et c'est précisément ce qu'un auditeur est payé pour mettre en doute.
  • Cela dépend d'une seule personne consciencieuse, et cela s'arrête quand elle est absente.

Ce que GUI Test Studio conserve pour chaque exécution, tout seul

GUI Test Studio automatise les tests de bout en bout de toute application sans code : vous enregistrez un parcours une fois, ou vous le décrivez dans une consigne, et le test le rejoue. Chaque exécution, sur votre poste ou dans un pipeline, laisse les mêmes preuves derrière elle sans que personne ne les demande.

Une exécution

Le testLa date et l'heureLe verdict

Rapport de confiance

Chaque étape, ce qui a réussi, ce qui a échoué et pourquoi

Vidéo de l'exécution

Chaque étape, y compris celles qui ont réussi

Images

Ce qui était attendu, à côté de ce que l'exécution a trouvé

Fichiers de résultats

JUnit et JSON, pour votre pipeline

Historique

Les exécutions précédentes du même test

Rapport d'anomalie

PDF ou Excel, avec les étapes pour reproduire

Le dossier de preuves d'une exécution. L'exécution l'écrit tout entier d'elle-même, sous forme de fichiers dans un dossier que vous choisissez.
PreuveCe qu'elle contient
Le rapport de confianceLe verdict, puis chaque étape dans l'ordre : ce qui a réussi, ce qui a échoué et pourquoi. Il est sauvegardé avec l'exécution et se rouvre exactement tel qu'il était.
La vidéo de l'exécutionToute l'exécution de la première étape à la dernière, pour que les étapes qui ont réussi se voient aussi.
L'attendu à côté de l'obtenuPour une assertion visuelle, l'image que le test attend à côté de ce que l'exécution a trouvé, avec ce qui a changé mis en évidence.
Les fichiers de résultatsUn fichier JUnit pour votre outil de CI et un fichier JSON pour vos propres scripts, écrits par gtr-cli.
L'historiqueChaque exécution précédente du même test, assertion par assertion.
Le rapport d'anomaliePour un échec : un PDF ou un classeur Excel avec les étapes pour reproduire et les images.
Une exécution réussie est aussi une preuve : chaque étape et chaque assertion, avec son verdict, sauvegardées avec le test.

Le guide Le rapport de confiance explique tout ce que montre le rapport, et Comment lire un rapport de test suit un échec du verdict jusqu'à l'étape suivante.

Une piste d'audit pour les tests : l'historique de chaque exécution

Une exécution dit ce qui s'est passé aujourd'hui.Un audit demande ce qui s'est passé sur un an.Historique, dans la barre d'outils du rapport, suit chaque assertion à travers toutes les exécutions d'un test : quelle exécution a échoué la première, comment chaque assertion s'est comportée dans le temps, et ce qui a changé entre deux exécutions.Le rapport de n'importe quelle exécution passée s'ouvre depuis là.

Chaque exécution du test, dans l'ordre. Le premier échec de chaque assertion est daté.

Le test lui-même a aussi sa piste.

  • Un test est un seul fichier, il trouve donc sa place dans la gestion de versions ou le stockage sauvegardé que votre équipe utilise déjà.
  • Chaque changement de ce qu'un test attend a alors un auteur et une date.
  • Une exécution en ligne de commande ne modifie jamais le fichier de test, donc ce qui s'est exécuté est ce qui a été relu.

Qui a décidé ? Des assertions et des verdicts de l'IA qu'un auditeur peut examiner

Dès que l'IA entre dans les tests, un auditeur pose une nouvelle question : qui a décidé que ceci avait réussi ? La réponse doit être quelque chose qu'une personne peut ouvrir et lire.

Pendant l'exécution : les étapes enregistrées se rejouent toutes seules, et aucune IA ne pilote l'application.

IA désactivée

Chaque assertion décide sur sa propre comparaison

Le même écran reçoit le même verdict à chaque exécution.

Analyse intelligente par IA activée

Une assertion échouée reçoit un second regard

Le verdict de l'IA et son explication sont sauvegardés avec l'exécution.

Dans les deux cas, le rapport dit qui a décidé de chaque assertion. L'IA est un choix de votre équipe, et elle peut rester désactivée.
Votre réglageQui décide d'une assertionCe qui est conservé
IA désactivée, comme à l'installationLa propre comparaison de l'assertion. Elle réussit ou échoue de la même façon à chaque exécution.Le verdict et les images.
Analyse intelligente par IA activéePour une assertion échouée, l'IA porte un second regard et rend le verdict final de cette assertion.Le verdict, l'explication en mots simples, chaque différence trouvée et les instructions données à l'IA.

L'IA est optionnelle, et le choix vous appartient : une IA dans le cloud avec votre propre clé, un modèle d'IA local, l'un des nôtres ou le vôtre, ou aucune.Les réponses sont conservées avec l'exécution, donc rouvrir un rapport ne redemande rien, et l'historique montre ce que l'IA a dit à chaque exécution passée.Voir Analyse intelligente par IA.

Des preuves qui restent sur vos propres ordinateurs

La question suivante d'un auditeur porte sur l'endroit où vivent les preuves et sur qui peut y accéder. Avec GUI Test Studio, les tests, les enregistrements, les exécutions et les rapports sont des fichiers sur vos propres ordinateurs. Chaque exécution est conservée dans le dossier de résultats, à l'intérieur du dossier propre au test.

Trois décisions vous reviennent donc.

  • La durée de conservation des preuves suit vos propres règles de conservation, pas celles d'un fournisseur.
  • Qui peut les ouvrir suit les droits de vos propres dossiers et de votre serveur de build.
  • Leur archivage se fait là où vous gardez déjà vos autres documents.

Une vidéo montre tout ce que montrait l'écran, donc exécutez vos tests avec des comptes de test et des données inventées.Confidentialité des données dans l'automatisation des tests explique comment garder les vraies données hors de chaque capture d'écran, et Souveraineté IA dans les tests logiciels traite de qui décide quelle IA voit vos écrans.

Comment conserver les preuves de chaque exécution dans votre pipeline

gtr-cli, l'exécuteur en ligne de commande, exécute les mêmes tests dans n'importe quel outil de CI/CD et écrit les preuves là où vous le lui indiquez.Exécuter des tests dans votre pipeline liste chaque option.

  1. 1

    Placer les tests là où votre pipeline peut les lire

    Un test est un fichier. Gardez-le avec votre projet, dans la gestion de versions ou sur un partage que lit la machine de build, pour que chaque changement de ce qu'un test attend ait un auteur et une date.

  2. 2

    Exécuter les tests avec gtr-cli et demander les fichiers de résultats

    Ajoutez la commande à votre pipeline. Le fichier JUnit alimente la page de résultats de tests de votre outil de CI, et le fichier JSON contient les mêmes résultats pour vos propres scripts et tableaux de bord.

    Exécuter chaque test d'un dossier et conserver ses preuves
    gtr-cli run tests --junit results\tests.xml --json results\tests.json --artifacts evidence --bug-report pdf
  3. 3

    Rassembler les preuves dans un seul dossier

    L'option des artefacts rassemble la vidéo, le rapport de confiance et les images d'échec de chaque test dans le dossier que vous nommez.

  4. 4

    Demander un rapport d'anomalie pour chaque test en échec

    L'option du rapport d'anomalie écrit un rapport rempli, en PDF, pour chaque test qui a échoué, avec les étapes pour reproduire.

  5. 5

    Conserver le dossier comme artefact du build

    Indiquez à votre outil de CI de conserver les dossiers de résultats et de preuves comme artefacts. Le numéro de build relie alors les preuves à la version testée, et la durée de conservation de votre outil de CI s'applique.

  6. 6

    Rouvrir une exécution quand quelqu'un la demande

    Les exécutions du pipeline arrivent aussi dans le dossier de résultats de chaque test. Ouvrez le test dans GUI Test Runner-Recorder, et l'historique les liste à côté des vôtres. Le rapport de n'importe quelle exécution passée se rouvre exactement tel qu'il était.

OptionCe qu'elle conserve
--junitLe fichier de résultats que lit votre outil de CI pour sa page de résultats de tests.
--jsonLes mêmes résultats pour vos propres tableaux de bord et scripts.
--artifactsLa vidéo, le rapport de confiance et les images d'échec de chaque test, dans un seul dossier.
--bug-report pdfUn rapport d'anomalie rempli pour chaque test en échec.

Quand une exécution échoue : le rapport d'anomalie est aussi une preuve

Un audit n'attend pas que chaque test réussisse. Il attend que chaque échec soit suivi. Une exécution en échec contient déjà ce qu'il faut pour cela : les étapes qui y ont mené, ce qui était attendu, ce qui est apparu à la place, et combien de fois elle a échoué auparavant.

Le rapport d'anomalie est rempli à partir de l'exécution. Vous le lisez, l'ajustez et le sauvegardez.

Rapport d'anomalie, dans le bandeau du rapport, l'écrit en PDF ou en classeur Excel, avec un zip des images à côté, ou crée un ticket sur votre propre site Jira.Voir Créer un rapport d'anomalie, et Connecter Jira au rapport de confiance pour le ticket que devient une exécution en échec.

ExempleUn échec, suivi du début à la fin

Le build 418 échoue sur le récapitulatif de commande. Le dossier de preuves de ce build contient le rapport, la vidéo et un rapport d'anomalie en PDF. Le développeur corrige le total, le build 419 réussit, et son rapport est conservé de la même façon. Un an plus tard, toute l'histoire peut être ouverte : l'échec, le bug, la correction et la preuve de la correction.

Ce qu'il faut savoir avant de commencer

LimiteCe que cela signifie
Il ne vous rend pas conformeGUI Test Studio vous donne les preuves à montrer. Que ce soient les bonnes preuves, conservées le bon temps, c'est vos propres règles qui le décident.
Il ne connaît pas la version de votre applicationVotre pipeline la connaît. Conservez les preuves comme artefact du build testé, et le numéro de build relie les deux.
Un test vérifie ce qu'on lui a demandé de vérifierLes preuves démontrent que ces assertions se sont exécutées et ce qu'elles ont trouvé, pas que rien d'autre ne va mal.
Conserver les fichiers, c'est votre travailLes preuves vous appartiennent : sauvegardez-les, et décidez qui peut supprimer une exécution ou effacer l'historique d'un test.

Points clés

  • 1Les preuves de test, c'est une preuve que quelqu'un d'autre peut ouvrir : ce qui a été testé, quand, sur quelle version, avec quel résultat, et ce que montrait l'écran.
  • 2Une coche verte est une affirmation, et des preuves rassemblées à la main coûtent des jours et peuvent toujours être mises en doute.
  • 3GUI Test Studio conserve tout seul les preuves de chaque exécution : un rapport sauvegardé, une vidéo, des images, des fichiers de résultats et un historique.
  • 4Un auditeur peut voir qui a décidé : la propre comparaison de chaque assertion, ou un verdict de l'IA sauvegardé avec son explication, et l'IA peut rester désactivée.
  • 5Les preuves sont des fichiers sur vos propres ordinateurs, donc la conservation et l'accès suivent vos règles.Cela ne vous rend pas conforme : cela vous donne de quoi montrer.

Questions

Que sont les preuves de test ?

Les preuves de test démontrent qu'un test s'est réellement exécuté et ce qu'il a trouvé. Elles disent ce qui a été testé, quand, sur quelle version, avec quel résultat, et elles montrent à quoi ressemblait l'écran. Une ligne qui dit « réussi » est une affirmation, et les preuves sont ce qui l'étaye.

Que veut voir un auditeur des tests automatisés ?

Un auditeur veut voir ce que vérifie chaque test, quand il s'est exécuté, sur quelle version du logiciel, quel a été le résultat, et une preuve qui puisse être ouverte plus tard. Pour un échec, l'auditeur veut aussi voir ce qui a été fait à son sujet.

Un build réussi suffit-il comme preuve de test ?

Non. Un build réussi prouve que quelque chose s'est exécuté et s'est terminé sans erreur. Il ne montre pas quelles étapes se sont exécutées, ce qu'a comparé chaque assertion, ni ce que montrait l'écran. Conservez le rapport, la vidéo et les fichiers de résultats de l'exécution avec le build.

Comment créer une piste d'audit pour des tests automatisés ?

Conservez trois choses pour chaque exécution : le test tel qu'il était, les résultats de l'exécution, et le build auquel ils appartiennent. Avec GUI Test Studio, gtr-cli écrit les fichiers de résultats et rassemble le rapport, la vidéo et les images dans un seul dossier, et votre pipeline conserve ce dossier comme artefact du build.

Combien de temps faut-il conserver les preuves de test ?

Aussi longtemps que vos propres règles le disent. Le référentiel sur lequel vous êtes audité, vos contrats et votre système qualité en décident, pas l'outil de test. GUI Test Studio écrit les preuves sous forme de fichiers sur vos ordinateurs, donc vous appliquez la durée de conservation que vous utilisez déjà pour vos autres documents.

Peut-on utiliser l'IA dans des tests audités ?

Oui, quand son rôle est clair et ses réponses conservées. Dans GUI Test Studio, aucune IA ne pilote une exécution. L'analyse intelligente par IA est optionnelle, ne regarde que les assertions échouées, et son verdict et son explication sont sauvegardés avec l'exécution. Quand elle est désactivée, chaque assertion réussit ou échoue sur sa propre comparaison.

GUI Test Studio rend-il mon équipe conforme ?

Non. La conformité est décidée par votre auditeur au regard de vos propres processus, et aucun outil ne peut l'accorder. GUI Test Studio vous donne les preuves à montrer : un rapport sauvegardé, une vidéo, des images, des fichiers de résultats et un historique pour chaque exécution.

Où sont stockées les preuves de test ?

Sur vos propres ordinateurs, sous forme de fichiers. Chaque exécution est conservée dans le dossier de résultats, à l'intérieur du dossier propre au test, et une exécution de pipeline peut aussi tout rassembler dans un dossier que vous nommez. Qui peut ouvrir ces fichiers et combien de temps ils sont conservés relève de la décision de votre équipe.

Jira et Windows sont des marques de leurs propriétaires respectifs.

Tous les articles