Verifica manuale strutturata

In parole semplici

Il test automatico verifica quello che pensi. La verifica manuale verifica anche ciò che non hai pensato. Prima di chiudere un bug, fai un giro strutturato di quattro casi: principale, vicino, limite, controllo. È quindici minuti che evitano regressioni evitabili.

Parole nuove

• caso principale: il caso che il bug colpisce direttamente.
• caso vicino: scenari simili dove la stessa logica passa.
• caso limite: input ai confini (vuoto, zero, max).
• caso di controllo: caso che non c’entra con il bug, ma usa lo stesso modulo. Deve restare invariato.

Cosa impari

• Costruire una matrice di verifica prima di dichiarare chiuso il bug.
• Bilanciare verifica automatica e verifica manuale.
• Evitare il fix che “risolve il caso ma rompe i vicini”.

La matrice di verifica

Una griglia con quattro colonne:

#	Caso	Tipo	Atteso	Osservato	Esito
1	input dell’utente che ha segnalato	principale	X
2	input simile (altro utente)	vicino	X
3	input al confine (vuoto, max)	limite	X
4	input non correlato	controllo	invariato

Compila prima del fix (caso 1 fallisce, caso 4 passa). Compila di nuovo dopo il fix: caso 1 deve passare, caso 4 non deve cambiare.

Esempio: bug del carrello

Bug: cliccando “Salva” su carrello con 3 prodotti, dopo refresh il carrello è vuoto.

Matrice:

#	Caso	Tipo	Atteso
1	carrello con 3 prodotti standard	principale	persiste
2	carrello con 1 prodotto	vicino	persiste
3	carrello con 50 prodotti	vicino	persiste
4	carrello vuoto, click Salva	limite	resta vuoto, niente errori
5	carrello con prodotto a quantità 0	limite	persiste o filtrato (decidere)
6	”Salva” non cliccato, refresh	controllo	sessione precedente
7	logout → login → carrello	controllo	recupero ok

Sette casi. Quindici minuti di click. Coperti i casi vicini e quelli di controllo che il fix non deve rompere.

Casi vicini: perché contano

Il fix risolve un sintomo. Spesso il problema è generale. Esempio:

• Bug: calcolaSconto(100, null) ritorna NaN.
• Fix: gestire null.
• Casi vicini da provare: undefined, "", "abc", -10, NaN.

Se il fix gestisce solo null ma non gli altri, il bug è risolto a metà.

Casi di controllo: perché contano

Verifica che il fix non rompa l’esistente. Esempio:

• Bug: nuova funzione di filtro non rispetta il valore “Tutti”.
• Fix: aggiornata logica filtro.
• Controllo: provare i filtri già esistenti che funzionavano. Devono continuare a funzionare.

Se uno dei controlli si rompe, hai introdotto una regressione.

Verifica manuale vs test automatici

Verifica manuale	Test automatici
Esplorativa, trova ciò che non pensavi	Sistematica, copre ciò che hai scritto
Quindici minuti, una volta	Frazioni di secondo, ogni push
Senso umano (estetica, UX)	Asserzioni meccaniche
Non sostituibile per UI	Sostituibile per logica pura

Non sono alternative: sono complementari. Il fix ideale ha test automatico per il caso principale e verifica manuale per vicini, limite e controllo.

Tempi consigliati

Per un fix piccolo:

• 5 min: scrivere matrice.
• 10 min: eseguire matrice.
• Se trovi un caso vicino rotto: estendere il fix, rifare matrice.

Per un fix grande (>50 righe): raddoppia.

Annotazione delle scoperte

Ogni caso che ti sorprende va annotato nel taccuino:

Caso 5 (quantità 0): il sistema persiste l’elemento anche se invisibile. Comportamento atteso non documentato. Decisione: parlare con product owner.

Spesso la verifica manuale rivela ambiguità di specifica che il test automatico non vede.

Esercizio guidato

Riprendi un bug che hai risolto recentemente.

1. Apri la matrice e compila i quattro casi (principale, due vicini, due limite, due controllo).
2. Eseguili a mano nell’app.
3. Annota osservazioni inattese.
4. Se ne trovi una, decidi: estendere il fix, scrivere un altro bug, accettare come limitazione documentata.

Errori frequenti del principiante

• Verificare solo il caso principale. Il fix passa, il bug vicino resta.
• Saltare i controlli. Sembrano superflui finché un controllo non rompe.
• Compilare la matrice “a memoria”. Scrivila. Eseguila. Annota.
• Trasformare la matrice in romanzo. Voci brevi: input, atteso, osservato.