Prove di test per gli audit: cosa chiede un auditor a un test automatizzato
Prove di test per gli audit: che cosa chiede un auditor a un test automatizzato, e come ogni esecuzione conserva report, video, immagini e cronologia come prova.
Le prove di test dimostrano che un test è stato davvero eseguito: cosa è stato testato, quando, su quale versione, con quale risultato e cosa mostrava lo schermo. Un auditor le vuole per ogni esecuzione, leggibili anche mesi dopo.
In una banca, presso un fornitore di software sanitario, in un servizio pubblico o in qualsiasi azienda sottoposta ad audit, “i test sono passati” non è una risposta. L'auditor chiede di vederlo. Allora un tester passa i giorni prima dell'audit a incollare screenshot in un documento, per test eseguiti settimane prima.
Cosa sono le prove di test?
Definizione
Le prove di test sono tutto ciò che permette a chi non era presente di verificare che un test è stato eseguito e cosa ha trovato.
- Indicano il test e cosa controlla.
- Riportano la data, la versione e il risultato.
- Mostrano com'era lo schermo, per i passaggi superati come per quello fallito.
Una buona prova si può aprire un anno dopo, anche da una persona che non ha mai visto l'app.
Un audit trail per i test è la stessa idea nel tempo: le prove di ogni esecuzione, in ordine, così che chiunque possa seguire cosa è stato testato da una release all'altra.
Perché una spunta verde nel log di una build non è una prova
Una pipeline che finisce in verde dimostra una cosa sola: un comando è stato eseguito ed è terminato senza errori. Non dice quali passaggi sono stati eseguiti, cosa ha confrontato ogni controllo, né cosa mostrava lo schermo in quel momento.
Il log di una build
Un'affermazione, senza nulla da aprire.
Le prove della stessa esecuzione
Una prova che chiunque può aprire in seguito.
Un risultato è un'affermazione. La prova è ciò che permette a qualcun altro di verificare l'affermazione.
Questa differenza conta soprattutto il giorno in cui qualcosa va storto. Quando un difetto arriva ai clienti, la domanda non è più se i test sono passati. È che cosa hanno guardato esattamente, e nessuno può rispondere partendo da una spunta.
Cosa chiede un auditor, e le prove che rispondono
Che l'audit riguardi i controlli finanziari, un sistema qualità per il software medicale o la sicurezza delle informazioni, le domande sui test hanno la stessa forma. Ognuna ha una risposta che dovrebbe già esistere quando arriva la domanda.
| Cosa chiede l'auditor | La prova che risponde |
|---|---|
| Cosa è stato testato? | Il test stesso: un file che contiene ogni passaggio e ogni controllo, leggibile in parole semplici. |
| Quando è stato eseguito? | La data e l'ora dell'esecuzione, mostrate nel suo report e conservate con i suoi risultati. |
| Su quale versione? | La build della vostra pipeline che ha eseguito il test, con le prove conservate come artefatto di quella build. |
| Qual è stato il risultato? | L'esito dell'esecuzione e di ogni controllo: superato, oppure non superato e perché. |
| Cosa mostrava lo schermo? | Il video dell'esecuzione, e l'immagine attesa accanto a ciò che l'esecuzione ha trovato. |
| Era già stato superato prima? | La cronologia delle esecuzioni precedenti dello stesso test. |
| Cosa è successo al fallimento? | Una segnalazione di bug con i passaggi per riprodurre, o il ticket che è diventata nel vostro tracker. |
| Chi ha deciso che è stato superato? | Il confronto proprio del controllo, uguale a ogni esecuzione, oppure un esito dell'IA salvato con la sua spiegazione. |
| Chi ha cambiato ciò che il test si aspetta? | La cronologia del file di test nel vostro sistema di controllo versione: un autore e una data per ogni modifica. |
Perché raccogliere le prove di test a mano non regge
Molti team rispondono a queste domande con un documento: un tester esegue lo scenario, fa uno screenshot di ogni schermata, lo incolla sotto il passaggio e firma la pagina.
Funziona per una release, poi i costi si vedono.
- Richiede giorni che tornano prima di ogni audit e di ogni release.
- Mostra solo le schermate che qualcuno ha pensato di catturare, mai quelle intermedie.
- Si può fare a posteriori, che è proprio ciò di cui un auditor è pagato per dubitare.
- Dipende da una persona scrupolosa, e si ferma quando quella persona è assente.
Cosa conserva GUI Test Studio per ogni esecuzione, da solo
GUI Test Studio automatizza i test end-to-end di qualsiasi applicazione senza codice: registrate un flusso una volta, o lo descrivete in un prompt, e il test lo ripete. Ogni esecuzione, sulla vostra scrivania o in una pipeline, lascia dietro di sé le stesse prove senza che nessuno le chieda.
Un'esecuzione
Report di affidabilità
Ogni passaggio, cosa è stato superato, cosa è fallito e perché
Video dell'esecuzione
Ogni passaggio, compresi quelli superati
Immagini
Ciò che era atteso, accanto a ciò che l'esecuzione ha trovato
File di risultati
JUnit e JSON, per la vostra pipeline
Cronologia
Le esecuzioni precedenti dello stesso test
Segnalazione di bug
PDF o Excel, con i passaggi per riprodurre
| Prova | Cosa contiene |
|---|---|
| Il report di affidabilità | L'esito, poi ogni passaggio in ordine: cosa è stato superato, cosa è fallito e perché. Viene salvato con l'esecuzione e si riapre esattamente com'era. |
| Il video dell'esecuzione | L'intera esecuzione dal primo all'ultimo passaggio, così si vedono anche i passaggi superati. |
| L'atteso accanto all'effettivo | Per un controllo visivo, l'immagine che il test si aspetta accanto a ciò che l'esecuzione ha trovato, con ciò che è cambiato evidenziato. |
| I file di risultati | Un file JUnit per il vostro strumento di CI e un file JSON per i vostri script, scritti da gtr-cli. |
| La cronologia | Ogni esecuzione precedente dello stesso test, controllo per controllo. |
| La segnalazione di bug | Per un fallimento: un PDF o una cartella di lavoro Excel con i passaggi per riprodurre e le immagini. |
La guida Il report di affidabilità spiega tutto ciò che il report mostra, e come leggere un report di test segue un fallimento dall'esito al passo successivo.
Un audit trail per i test: la cronologia di ogni esecuzione
Un'esecuzione risponde a cosa è successo oggi.Un audit chiede cosa è successo nell'arco di un anno.Cronologia, nella barra degli strumenti del report, segue ogni controllo attraverso tutte le esecuzioni di un test: quale esecuzione è fallita per prima, come è andato ogni controllo nel tempo e cosa è cambiato tra due esecuzioni.Da lì si apre il report di qualsiasi esecuzione passata.
Anche il test stesso ha la sua traccia.
- Un test è un solo file, quindi si adatta al controllo versione o all'archivio con backup che il vostro team usa già.
- Ogni modifica di ciò che un test si aspetta ha così un autore e una data.
- Un'esecuzione dalla riga di comando non modifica mai il file di test, quindi ciò che è stato eseguito è ciò che è stato revisionato.
Chi ha deciso? Controlli ed esiti dell'IA che un auditor può esaminare
Appena l'IA entra nei test, un auditor fa una domanda nuova: chi ha deciso che questo è stato superato? La risposta deve essere qualcosa che una persona può aprire e leggere.
Durante l'esecuzione: i passaggi registrati si ripetono da soli, e nessuna IA guida l'app.
IA disattivata
Ogni controllo decide in base al proprio confronto
Lo stesso schermo dà lo stesso esito a ogni esecuzione.
Analisi intelligente con IA attivata
Un controllo non superato riceve un secondo sguardo
L'esito dell'IA e la sua spiegazione vengono salvati con l'esecuzione.
| La vostra impostazione | Chi decide un controllo | Cosa viene conservato |
|---|---|---|
| IA disattivata, come all'installazione | Il confronto proprio del controllo. Viene superato o fallisce allo stesso modo a ogni esecuzione. | L'esito e le immagini. |
| Analisi intelligente con IA attivata | Per un controllo non superato, l'IA dà un secondo sguardo e fornisce l'esito finale di quel controllo. | L'esito, la spiegazione in parole semplici, ogni differenza trovata e le istruzioni date all'IA. |
L'IA è facoltativa, e la scelta è vostra: un'IA cloud con la vostra chiave, un modello di IA locale, nostro o vostro, o nessuna.Le risposte vengono conservate con l'esecuzione, quindi riaprire un report non richiede nulla di nuovo, e la cronologia mostra cosa ha detto l'IA in ogni esecuzione passata.Vedere Analisi intelligente con IA.
Prove che restano sui vostri computer
La domanda successiva di un auditor è dove si trovano le prove e chi può accedervi. Con GUI Test Studio, test, registrazioni, esecuzioni e report sono file sui vostri computer. Ogni esecuzione viene conservata nella cartella dei risultati, all'interno della cartella del test stesso.
Questo rende vostre tre decisioni.
- Per quanto tempo si conservano le prove segue le vostre regole di conservazione, non quelle di un fornitore.
- Chi può aprirle segue i permessi delle vostre cartelle e del vostro server di build.
- Dove vengono archiviate è ovunque conserviate già gli altri documenti.
Un video mostra tutto ciò che mostrava lo schermo, quindi eseguite i test con account di prova e dati inventati.Privacy dei dati nell'automazione dei test spiega come tenere i dati reali fuori da ogni screenshot, e sovranità dell'IA nel test del software tratta chi decide quale IA vede i vostri schermi.
Come conservare le prove di ogni esecuzione nella pipeline
gtr-cli, il runner da riga di comando, esegue gli stessi test in qualsiasi strumento di CI/CD e scrive le prove dove gli indicate.Eseguire i test nella pipeline elenca ogni opzione.
- 1
Tenere i test dove la pipeline può leggerli
Un test è un file. Conservatelo con il vostro progetto, nel controllo versione o su una condivisione che la macchina di build legge, così ogni modifica di ciò che un test si aspetta ha un autore e una data.
- 2
Eseguire i test con gtr-cli e richiedere i file di risultati
Aggiungete il comando alla vostra pipeline. Il file JUnit alimenta la pagina dei risultati dei test del vostro strumento di CI, e il file JSON contiene gli stessi risultati per i vostri script e le vostre dashboard.
Eseguire tutti i test di una cartella e conservarne le provegtr-cli run tests --junit results\tests.xml --json results\tests.json --artifacts evidence --bug-report pdf - 3
Raccogliere le prove in un'unica cartella
L'opzione degli artefatti raccoglie il video, il report di affidabilità e le immagini dei fallimenti di ogni test nella cartella che indicate.
- 4
Richiedere una segnalazione di bug per ogni test fallito
L'opzione della segnalazione di bug scrive un report compilato in PDF per ogni test fallito, con i passaggi per riprodurre.
- 5
Conservare la cartella come artefatto della build
Dite al vostro strumento di CI di conservare come artefatti le cartelle dei risultati e delle prove. Il numero di build collega così le prove alla versione testata, e si applica la conservazione del vostro strumento di CI.
- 6
Riaprire un'esecuzione quando qualcuno lo chiede
Anche le esecuzioni in pipeline finiscono nella cartella dei risultati di ogni test. Aprite il test in GUI Test Runner-Recorder, e la cronologia le elenca accanto alle vostre. Il report di qualsiasi esecuzione passata si riapre esattamente com'era.
| Opzione | Cosa conserva |
|---|---|
| --junit | Il file di risultati che il vostro strumento di CI legge per la pagina dei risultati dei test. |
| --json | Gli stessi risultati per le vostre dashboard e i vostri script. |
| --artifacts | Il video, il report di affidabilità e le immagini dei fallimenti di ogni test, in un'unica cartella. |
| --bug-report pdf | Una segnalazione di bug compilata per ogni test fallito. |
Quando un'esecuzione fallisce: anche la segnalazione di bug è una prova
Un audit non si aspetta che ogni test venga superato. Si aspetta che ogni fallimento abbia un seguito. Un'esecuzione fallita contiene già ciò che serve: i passaggi che hanno portato lì, cosa era atteso, cosa è apparso al suo posto e quante volte era già fallita prima.
Segnalazione di bug, nel banner del report, la scrive come PDF o come cartella di lavoro Excel, con uno zip delle immagini accanto, oppure crea un ticket sul vostro sito Jira.Vedere Creare una segnalazione di bug, e Collegare Jira al report di affidabilità per il ticket in cui si trasforma un'esecuzione fallita.
La build 418 fallisce sul riepilogo dell'ordine. La cartella delle prove di quella build contiene il report, il video e una segnalazione di bug in PDF. Lo sviluppatore corregge il totale, la build 419 viene superata, e il suo report viene conservato allo stesso modo. Un anno dopo, si può aprire l'intera storia: il fallimento, il bug, la correzione e la prova della correzione.
Cosa sapere prima di iniziare
| Limite | Cosa significa |
|---|---|
| Non vi rende conformi | GUI Test Studio vi dà le prove da mostrare. Se sono le prove giuste, conservate per il tempo giusto, lo decidono le vostre regole. |
| Non conosce la versione della vostra app | La conosce la vostra pipeline. Conservate le prove come artefatto della build testata, e il numero di build collega le due cose. |
| Un test controlla ciò che gli è stato detto di controllare | Le prove dimostrano che quei controlli sono stati eseguiti e cosa hanno trovato, non che nient'altro sia sbagliato. |
| Conservare i file spetta a voi | Le prove sono vostre: fatene un backup, e decidete chi può eliminare un'esecuzione o cancellare la cronologia di un test. |
Punti chiave
- 1Le prove di test sono una prova che qualcun altro può aprire: cosa è stato testato, quando, su quale versione, con quale risultato e cosa mostrava lo schermo.
- 2Una spunta verde è un'affermazione, e le prove raccolte a mano costano giorni e si possono sempre mettere in dubbio.
- 3GUI Test Studio conserva da solo le prove di ogni esecuzione: un report salvato, un video, immagini, file di risultati e una cronologia.
- 4Un auditor può vedere chi ha deciso: il confronto proprio di ogni controllo, o un esito dell'IA salvato con la sua spiegazione, e l'IA può restare disattivata.
- 5Le prove sono file sui vostri computer, quindi conservazione e accesso seguono le vostre regole.Non vi rende conformi: vi dà ciò che serve da mostrare.
Domande
Cosa sono le prove di test?
Le prove di test dimostrano che un test è stato davvero eseguito e cosa ha trovato. Dicono cosa è stato testato, quando, su quale versione, con quale risultato, e mostrano com'era lo schermo. Una riga che dice superato è un'affermazione, e le prove sono ciò che la sostiene.
Cosa vuole vedere un auditor dei test automatizzati?
Un auditor vuole vedere cosa controlla ogni test, quando è stato eseguito, su quale versione del software, quale è stato il risultato, e una prova che si possa aprire in seguito. Per un fallimento, l'auditor vuole vedere anche cosa è stato fatto.
Una build superata basta come prova dei test?
No. Una build superata dimostra che qualcosa è stato eseguito ed è terminato senza errori. Non mostra quali passaggi sono stati eseguiti, cosa ha confrontato ogni controllo, né cosa mostrava lo schermo. Conservate con la build il report, il video e i file di risultati dell'esecuzione.
Come creo un audit trail per i test automatizzati?
Conservate tre cose per ogni esecuzione: il test com'era, i risultati dell'esecuzione e la build a cui appartengono. Con GUI Test Studio, gtr-cli scrive i file di risultati e raccoglie il report, il video e le immagini in un'unica cartella, e la vostra pipeline conserva quella cartella come artefatto della build.
Per quanto tempo vanno conservate le prove di test?
Per tutto il tempo che dicono le vostre regole. Lo decidono il framework rispetto al quale siete sottoposti ad audit, i vostri contratti e il vostro sistema qualità, non lo strumento di test. GUI Test Studio scrive le prove come file sui vostri computer, quindi applicate la conservazione che usate già per gli altri documenti.
Si può usare l'IA in test sottoposti ad audit?
Sì, quando il suo ruolo è chiaro e le sue risposte vengono conservate. In GUI Test Studio nessuna IA guida un'esecuzione. L'analisi intelligente con IA è facoltativa, guarda solo i controlli non superati, e il suo esito e la sua spiegazione vengono salvati con l'esecuzione. Se è disattivata, ogni controllo viene superato o fallisce in base al proprio confronto.
GUI Test Studio rende conforme il mio team?
No. La conformità la stabilisce il vostro auditor rispetto ai vostri processi, e nessuno strumento può concederla. GUI Test Studio vi dà le prove da mostrare: un report salvato, un video, immagini, file di risultati e una cronologia per ogni esecuzione.
Dove vengono archiviate le prove di test?
Sui vostri computer, come file. Ogni esecuzione viene conservata nella cartella dei risultati, all'interno della cartella del test stesso, e un'esecuzione in pipeline può anche raccogliere tutto in una cartella che indicate voi. Chi può aprire quei file e per quanto tempo vengono conservati lo decide il vostro team.
Jira e Windows sono marchi dei rispettivi proprietari.
Continua a leggere
Tutti gli articoli
Affidabilità dei test
Test self-healing: quando un test che si ripara da solo nasconde un bug reale
11 min di lettura

Affidabilità dei test
Sleep fissi nei test: smettete di indovinare un tempo, aspettate lo schermo
10 min di lettura

Affidabilità dei test
Ancora «element not found»? Come testare quando selettori e locator falliscono
14 min di lettura