La maggior parte dei modelli di caso di test è un foglio di calcolo con quindici colonne: un ID, un modulo, una priorità, le precondizioni, i passaggi, il risultato atteso, poi uno stato, chi l’ha eseguito, quando, su quale build, e una colonna dei commenti che si riempie di “superato” e “vedi Slack”.

Guarda di nuovo quelle colonne e vedrai che descrivono due cose diverse. La prima metà descrive un controllo. La seconda metà descrive una volta in cui qualcuno l’ha eseguito. Mettere entrambe sulla stessa riga è il motivo per cui i fogli dei casi di test finiscono per marcire, ed è l’unica cosa che questo modello fa in modo diverso.

Il caso e l’esecuzione sono documenti diversi

Un caso di test si scrive una volta sola e cambia solo quando cambia il comportamento che verifica. Un’esecuzione avviene a ogni rilascio. Uno è una definizione e l’altra una registrazione, e hanno cicli di vita diversi.

Se alla riga del caso dai una sola colonna Stato, ogni esecuzione sovrascrive la precedente. Il foglio conosce solo il risultato più recente. “È stato superato nell’ultima release su questa build” sparisce nel momento in cui qualcuno scrive “fallito” sopra, e con esso sparisce la prova che permetterebbe di capire se il fallimento è nuovo.

Debole
Una riga per caso, con colonne Stato, Testato da e Data che vengono sovrascritte ogni volta che il caso viene eseguito.
Meglio
Il caso scritto una volta, con sotto un registro delle esecuzioni al quale si aggiunge soltanto una nuova riga.

La seconda forma risponde alle domande che le persone si fanno davvero: quando è stato superato l’ultima volta, su quale build ha cominciato a fallire, e se è mai stato eseguito su Safari. La prima forma non può rispondere a nessuna, perché ogni risposta è stata scritta nella stessa cella.

Il modello

Quattro sezioni. Le prime tre definiscono il controllo e cambiano di rado. La quarta è il registro delle esecuzioni, e cresce soltanto.

# Caso di test: [cosa viene verificato, in una frase]

**ID:** [numero TC]
**Area:** [funzionalità o schermata]
**Ultima modifica:** [data, e cosa è cambiato nel comportamento]

## Precondizioni

Lo stato in cui il sistema deve trovarsi prima che il passaggio 1 abbia senso. Il caso lo predispone da solo;
non dipende mai dal fatto che un altro test sia stato eseguito prima.

- [account, ruolo o dati che devono esistere]
- [ambiente, flag o browser, se conta]

## Passaggi

Un'azione per passaggio.

1. [azione]
2. [azione]
3. [azione]

## Risultato atteso

Abbastanza specifico da poter risultare sbagliato. Dichiara anche cosa NON deve accadere.

- [cosa dovrebbe vedere chi esegue il caso]
- [cosa non deve accadere: nessuna navigazione, nessuna seconda email, nessun addebito]

## Registro delle esecuzioni

Una riga per esecuzione. Non modificare mai una riga vecchia; aggiungine una nuova.

| Data | Build | Chi | Browser e ambiente | Risultato | Cosa si è visto davvero | Prova |
| --- | --- | --- | --- | --- | --- | --- |
| [data] | [versione] | [nome] | [browser, SO, ambiente] | superato / fallito / bloccato | [osservato, a parole] | [collegamento] |
Modello di caso di testtest-case-template.it.txt1,14 KBScarica

Bloccato non significa fallito

La colonna Risultato ha tre valori, e il terzo è quello che la maggior parte dei modelli omette.

Un caso è bloccato quando non è stato possibile eseguirlo affatto: mancava l’account di test, lo staging era giù, il flag della funzionalità era disattivato. Non si è appreso nulla sul comportamento. Registrarlo come fallito fa salire il conteggio dei difetti per un motivo che non ha nulla a che vedere con il software, qualcuno apre un bug che nessuno riesce a riprodurre, e la vera domanda, perché la precondizione non è stata soddisfatta, non viene mai posta.

Registrarlo come superato, cosa che accade più spesso di quanto qualcuno ammetta, fa contare come copertura un controllo che non è mai stato eseguito. Delle due bugie, questa è la peggiore, perché è quella che nessuno torna mai a correggere.

La colonna che fa il lavoro

Cosa si è visto davvero è la cella più preziosa del registro delle esecuzioni, e nella maggior parte dei fogli di calcolo non esiste. Al suo posto c’è una colonna Stato, e “fallito” in una colonna Stato dice alla persona successiva quasi niente.

Confronta “fallito” con “è apparso il messaggio di errore, ma la pagina è anche passata alla dashboard e l’utente risultava connesso”. La seconda formulazione è già mezzo rapporto di bug. Dice cosa è successo, dice in cosa si differenzia dal risultato atteso scritto tre sezioni sopra, ed è stata scritta dall’unica persona che l’ha visto, nell’unico momento in cui poteva ancora descriverlo con precisione.

Scrivila anche per i superamenti, in poche parole. Un superamento che registra cosa è stato visto può essere verificato in seguito. Un superamento che registra solo “superato” va creduto sulla parola.

Cosa eliminare

La maggior parte delle colonne della versione a quindici colonne, perché qualcos’altro le contiene già.

Progettato da e Data di creazione sono nella cronologia delle versioni del posto in cui vive il caso. La Priorità appartiene all’area testata e non al singolo caso, e su un caso singolo viene impostata una volta e non viene mai riesaminata. I Dati di test appartengono alle precondizioni, dove vengono letti come parte della preparazione invece che in una colonna accanto. Le Post-condizioni sono di solito il risultato atteso riscritto, e quando non lo sono, diventano le precondizioni del caso successivo.

Quello che non devi eliminare è la riga Ultima modifica. Un caso il cui risultato atteso è stato modificato in silenzio il giorno in cui ha cominciato a fallire è il documento più fuorviante del testing, e una sola riga con una data e un motivo rende visibile questo problema.

Per sapere cosa va in ogni sezione e come scrivere passaggi che qualcun altro possa seguire, la guida su come scrivere un caso di test li copre nel dettaglio. Quando i casi si sommano in una release, il modello di piano di test è la pagina che dice quali sono nell’ambito.

Quando un’esecuzione fallisce

Un’esecuzione fallita è l’inizio di un rapporto di bug, e una buona riga del registro ha già fatto gran parte del lavoro: i passaggi sono scritti, il risultato atteso è scritto, e accanto a essi è scritto cosa si è visto davvero. Ciò che la riga non può contenere è lo stato della macchina su cui è fallita. La versione del browser, la console e le richieste dietro la pagina sono esattamente ciò che chi risolverà il problema chiederà, e quando lo chiederà, la scheda sarà già stata chiusa.

Session Replay

Estensione Chrome gratuita. Un clic sulla pagina che non funziona cattura lo screenshot, la console e il log di rete, e ti dà un link da incollare nel ticket.

Ottieni l'estensione

Quel link è proprio ciò a cui serve la colonna Prova. Mettilo nella riga, metti l’ID del caso nel rapporto di bug, e i due restano uniti: chi lo risolve può rieseguire lo stesso controllo, e chi lo eseguirà nella prossima release può vedere che in passato è fallito, e perché.

La versione breve

Scrivi il caso una volta e registra ogni esecuzione sotto di esso, invece di sovrascrivere un solo stato. Dai al risultato tre valori, perché un controllo che non ha potuto essere eseguito non è né un superamento né un fallimento. Registra cosa si è visto davvero, sia sui superamenti sia sui fallimenti. Elimina le colonne che qualcos’altro già registra, e tieni la riga che dice quando il risultato atteso è cambiato l’ultima volta.