Smoke test, sanity test e test di regressione: quale eseguire, e quando
Smoke test, sanity test e test di regressione: che cosa controlla ciascuno, quando eseguirlo e come eseguirli tutti e tre dagli stessi test registrati.
Lo smoke test controlla che una nuova build si avvii e che le sue funzionalità principali rispondano. Il sanity test controlla in profondità una correzione o una modifica. Il test di regressione controlla che niente di ciò che funzionava prima si sia rotto. Si distinguono per ampiezza, profondità e momento.
La maggior parte dei team conosce i tre nomi e continua a eseguirli tutti e tre a mano, quando c'è tempo. Quando un rilascio è in ritardo, il lungo giro di regressione è la prima cosa tagliata, e un vecchio bug ricompare davanti a un cliente.
Smoke test, sanity test e test di regressione: la risposta breve
Immaginate la vostra app come una griglia: le sue funzionalità da sinistra a destra, e la profondità con cui ciascuna è testata dall'alto in basso. I tre tipi di test accendono parti diverse di quella griglia.
Smoke test
Ampio e superficiale
Questa build merita di essere testata?
Sanity test
Stretto e profondo
Questa correzione funziona?
Test di regressione
Ampio e profondo
Si è rotto qualcos'altro?
Che cos'è lo smoke test?
Definizione
Lo smoke test è un breve insieme di test che controlla se una nuova build è abbastanza stabile da essere testata.
- Avvia l'app e tocca una volta ogni funzionalità principale: l'app si apre, un utente riesce ad accedere, le schermate principali si caricano, l'azione chiave risponde.
- Non guarda i dettagli.
Una build che non supera lo smoke test torna subito agli sviluppatori, e nessuno perde una giornata a testarla.
Lo smoke test è chiamato anche build verification test, perché viene eseguito subito dopo la creazione di una build. Il suo valore è la velocità: pochi minuti, a ogni build, con un sì o un no chiaro alla fine.
Che cos'è il sanity test?
Definizione
Il sanity test è un controllo rapido e mirato che una correzione o una piccola modifica funzioni, e che la parte dell'app intorno si comporti ancora in modo sensato.
- Si esegue su una build che porta la correzione di un bug o una piccola modifica.
- Va in profondità su quella sola area e lascia stare il resto.
Quando passa, la build merita la più lunga esecuzione di regressione.
Fatto a mano, un sanity check è spesso improvvisato: il tester fa qualche clic a memoria intorno all'area corretta. È veloce, ma non lascia traccia di ciò che è stato guardato, e due tester raramente guardano le stesse cose.
Che cos'è il test di regressione?
Definizione
Il test di regressione esegue di nuovo i test esistenti dopo una modifica, per controllare che niente di ciò che già funzionava si sia rotto.
- È ampio e profondo: ogni flusso importante, con i suoi risultati controllati.
- È il più lungo dei tre, ed è per questo che si esegue di notte o prima di un rilascio.
Questo articolo lo tratta in breve di proposito.La guida completa, con i tipi di test di regressione e ciò che va messo in una suite, è che cos'è il test di regressione.
Smoke test, sanity test e test di regressione a confronto
| Che cosa confrontare | Smoke test | Sanity test | Test di regressione |
|---|---|---|---|
| La domanda che pone | Questa build merita di essere testata? | Questa correzione funziona? | Si è rotto qualcos'altro? |
| Quanto è ampio | Tutta l'app | Una funzionalità o una correzione | Tutta l'app |
| Quanto è profondo | Superficiale: un solo tocco per funzionalità | Profondo, in un solo punto | Profondo, ovunque conti |
| Quando si esegue | A ogni build | Dopo una correzione o una piccola modifica | Ogni notte e prima di un rilascio |
| Quanto dura | Pochi minuti | Pochi minuti | Un'ora o più, senza nessuno davanti allo schermo |
| Che cosa significa un fallimento | La build viene respinta | La correzione torna indietro | Una regressione viene colta prima che gli utenti la vedano |
Smoke test e sanity test sono la coppia che si confonde più spesso. Per distinguerli basta guardare che cosa osservano: uno smoke test guarda l'intera build, un sanity test guarda una sola modifica.
Quale eseguire, e in quale momento di un rilascio
I tre non sono rivali. Ciascuno ha il suo momento in un rilascio, e ciascuno decide se vale la pena eseguire il successivo.
A ogni build
Suite di smoke test
Pochi test brevi, pochi minuti. Un fallimento respinge la build.
Dopo una correzione o una piccola modifica
Sanity check
Il test che copre la correzione, eseguito di nuovo, con il suo risultato controllato.
Ogni notte, e prima di un rilascio
Suite di regressione
Tutti i test, senza nessuno davanti allo schermo. Il report si legge al mattino.
L'ordine è sempre lo stesso.
- Prima lo smoke test: se la build non riesce ad avviarsi o a far accedere un utente, non vale la pena eseguire altro.
- Poi il sanity test: se la correzione non funziona, la build torna indietro prima della lunga esecuzione.
- Per ultimo il test di regressione: una volta che la build è stabile e la correzione è giusta, si controlla tutto il resto.
Una settimana, un'app: i tre in pratica
I numeri qui sotto sono un'illustrazione, con cifre tonde.
| Quando | Che cosa è stato eseguito | Che cosa ha trovato |
|---|---|---|
| Lunedì, arriva una nuova build | La suite di smoke test: accedere, aprire un cliente, creare una fattura, esportarla. Cinque test, quattro minuti. | Passano tutti. La build merita di essere testata. |
| Martedì, viene corretto un bug di arrotondamento dell'imposta | Un sanity check: il test della fattura eseguito di nuovo, con il suo totale controllato. | Passa. La correzione funziona. |
| Martedì notte | La suite di regressione: tutti e quaranta i test. | Uno fallisce: il totale di una nota di credito è sbagliato. La correzione è arrivata fin lì. |
Il bug della nota di credito viene trovato mercoledì mattina da un report, non tre settimane dopo da un cliente. Senza l'esecuzione notturna, la correzione sarebbe stata rilasciata insieme a quel bug.
Perché il test di regressione è la prima cosa che salta
Fatti a mano, i tre si contendono le stesse ore.
- Uno smoke test a ogni build sottrae un tester al vero lavoro di test più volte al giorno.
- Un sanity check fatto a memoria non lascia traccia di ciò che è stato guardato.
- Un giro completo di regressione richiede giorni, così si riduce alle schermate che qualcuno ricorda quando il rilascio è in ritardo.
- I bug che ritornano stanno nelle schermate per cui nessuno ha avuto tempo.
Nessuno decide di saltare il test di regressione. Finisce messo da parte, un rilascio in ritardo dopo l'altro.
Automatizzare i tre con un framework scritto in codice come Selenium o Playwright sposta il lavoro sui programmatori: qualcuno scrive gli script, li contrassegna nel codice come smoke o regressione, e li ripara ogni volta che una schermata cambia.I tester che conoscono meglio il prodotto non possono toccarli.Test manuali e test automatizzati esamina questo compromesso in dettaglio.
Con i test registrati, i tre sono gli stessi test, raggruppati in modo diverso
GUI Test Studio automatizza i test end-to-end di qualsiasi applicazione senza codice. Fate un flusso una volta nella vostra app mentre GUI Test Runner-Recorder lo registra, e il test poi si riproduce da solo: gli stessi passaggi, nello stesso ordine, a ogni esecuzione.
Una volta che i vostri flussi sono test registrati, smoke, sanity e regressione smettono di essere tre lavori distinti. Sono tre modi di raggruppare ed eseguire gli stessi file di test.
Suite di smoke test
3 test su 6
A ogni build
Sanity check
1 test su 6
Dopo una correzione al checkout
Suite di regressione
6 test su 6
Ogni notte
| Tipo di esecuzione | Che cos'è, con i test registrati | Come si esegue |
|---|---|---|
| Suite di smoke test | Pochi test brevi, uno per funzionalità principale. | Da gtr-cli, a ogni build. |
| Sanity check | L'unico test che copre la correzione, eseguito di nuovo. | Con Esegui test, oppure da metà del test. |
| Suite di regressione | Tutti i test che avete. | Da gtr-cli, ogni notte e prima di un rilascio. |
Tre cose mantengono gli stessi test utilizzabili in tutti e tre i ruoli.
- Ogni controllo attende ciò che si aspetta e prosegue nel momento in cui c'è, così un test breve resta breve.
- Un gruppo di passaggi come Accesso è uno scenario che altri test riutilizzano, quindi si registra una volta sola.
- Il GTS Engine trova ogni elemento prima tramite le informazioni di accessibilità dell'app e a vista quando l'app non dice nulla, così un test sopravvive ai piccoli cambiamenti dello schermo.
Perché un controllo che attende batte una pausa di durata fissa è spiegato in le pause fisse nei test, e Scenari mostra come i passaggi di un test vengono riutilizzati in un altro.
Un sanity check non deve per forza riprodurre un test lungo dall'inizio.In GUI Test Studio, mettete l'indicatore di riproduzione dove inizia la parte corretta e scegliete Salva ed esegui dall'indicatore di riproduzione: con l'app riportata nello stato che aveva in quel momento, vengono eseguiti solo i passaggi da lì in poi.Eseguire un test lo spiega.
Come costruire una suite di smoke test e una suite di regressione dagli stessi test
L'intera configurazione consiste in sei piccoli passaggi, e il primo è l'unico che richiede davvero tempo.
- 1
Registrare ogni flusso una volta
Fate clic su Registra in GUI Test Runner-Recorder e fate il flusso nella vostra app, come farebbe un utente. Ogni flusso che conta diventa un file di test, con i controlli di ciò che lo schermo ha mostrato.
- 2
Condividere i passaggi comuni come scenario
Raggruppate i passaggi con cui inizia ogni test, come l'accesso, in uno scenario chiamato Accesso. Aggiungete quel test agli altri come scenario, così l'accesso si registra una volta e si riutilizza.
- 3
Scegliere gli smoke test
Scegliete un test breve per funzionalità principale: l'app si apre, un utente accede, la schermata principale si carica, l'azione chiave risponde. Tenete i loro file di test insieme in una cartella, come tests\smoke.
- 4
Tenere i test più approfonditi in una seconda cartella
Mettete tutti gli altri test in una cartella come tests\regression. La suite di regressione è l'insieme delle due cartelle: tutti i test che avete.
- 5
Eseguire gli smoke test a ogni build e tutto di notte
Sulla macchina di build, gtr-cli esegue la cartella smoke dopo ogni build ed entrambe le cartelle ogni notte. Un test fallito fa fallire la build, e ogni esecuzione conserva il suo report, il suo video e le sue immagini.
- 6
Dopo una correzione, eseguire di nuovo un solo test
Aprite il test che copre la correzione e fate clic su Esegui test: è il vostro sanity check. In un test lungo, avviate l'esecuzione dall'indicatore di riproduzione in GUI Test Studio, con l'app riportata nello stato che aveva in quel momento.
Eseguire gli smoke test a ogni build e i test di regressione ogni notte
Su una macchina di build, gtr-cli esegue i test dalla riga di comando in qualsiasi strumento di CI/CD. Accetta file di test, cartelle e pattern, quanti ne elencate. Una cartella esegue i file di test che contiene.
gtr-cli run tests\smoke --countdown 0 --junit results\smoke.xml
gtr-cli run tests\smoke tests\regression --countdown 0 --junit results\regression.xml- La prima riga appartiene al job di build, e un test fallito fa fallire la build tramite il codice di uscita.
- La seconda riga appartiene a un job notturno.
- Ogni esecuzione scrive un file dei risultati che il vostro strumento di CI legge, e conserva il suo report di affidabilità, il suo video e le sue immagini.
Al mattino, un test di regressione fallito si legge, non si indovina: il report di affidabilità mostra il passaggio fallito, ciò che era atteso accanto a ciò che è stato trovato, e la cronologia delle esecuzioni precedenti.Come leggere un report di test mostra che cosa guardare per primo, e Eseguire i test nella pipeline elenca ogni opzione di gtr-cli.
Cosa sapere prima di iniziare
| Limite | Cosa significa |
|---|---|
| Un'esecuzione usa lo schermo reale | I test vengono eseguiti uno dopo l'altro su una macchina, a meno che un test web non giri senza finestra del browser. Date all'esecuzione notturna di regressione una macchina di build che nessuno sta usando. |
| Lo stesso punto di partenza | Un test si riproduce a partire dallo stato in cui è stato registrato. Ogni suite deve riportare l'app in quello stato, e un test web apre la propria finestra del browser pulita. |
| Un test controlla ciò che gli è stato detto di controllare | Una suite di smoke test verde dice che le funzionalità principali rispondono. Non dice che ogni dettaglio è giusto: quello è compito della suite di regressione. |
Punti chiave
- 1Lo smoke test è ampio e superficiale. Decide in pochi minuti se una build merita di essere testata.
- 2Il sanity test è stretto e profondo. Conferma una correzione prima che parta la lunga esecuzione.
- 3Il test di regressione è ampio e profondo. Dimostra che la modifica non ha rotto niente di ciò che funzionava.
- 4Ciascuno ha il suo momento: lo smoke test a ogni build, il sanity test dopo una correzione, il test di regressione ogni notte e prima di un rilascio.
- 5Con i test registrati, sono un unico insieme di file di test. GUI Test Studio li raggruppa e li esegue in tre modi, senza codice.
Domande
Qual è la differenza tra smoke test e sanity test?
Lo smoke test controlla l'intera build in modo superficiale, per decidere se è abbastanza stabile da essere testata. Il sanity test controlla in profondità una correzione o una piccola modifica. Lo smoke test viene per primo, a ogni build, e il sanity test segue una build che porta una correzione.
Qual è la differenza tra smoke test e test di regressione?
Lo smoke test tocca una volta ogni funzionalità principale e richiede pochi minuti. Il test di regressione esegue ogni flusso importante con i suoi risultati controllati, e può richiedere ore. Uno smoke test dice che la build è viva, e un test di regressione dice che niente di ciò che funzionava si è rotto.
Il sanity test fa parte del test di regressione?
In pratica, sì. Un sanity check è una piccola fetta della suite di regressione: i test che coprono l'area che è cambiata. Si esegue subito dopo la correzione, e la suite di regressione completa gira più tardi, di notte o prima di un rilascio.
Che cosa viene prima: smoke test, sanity test o test di regressione?
Lo smoke test viene per primo, a ogni nuova build. Il sanity test viene dopo, quando la build porta una correzione o una piccola modifica. Il test di regressione viene per ultimo, di notte o prima di un rilascio, perché è il più lungo dei tre.
Che cos'è un build verification test?
Build verification test, cioè test di verifica della build, è un altro nome dello smoke test. Si esegue subito dopo la creazione di una build e risponde a una sola domanda: questa build è abbastanza stabile da essere testata ulteriormente.
Quanti test vanno in una suite di smoke test?
Pochi: un test breve per funzionalità principale, di solito da cinque a dieci in tutto, così l'intera suite gira in pochi minuti. Una suite di smoke test che diventa lenta smette di essere eseguita a ogni build, e allora non protegge più nulla.
Uno smoke test fallito deve far fallire la build?
Sì. Una build che non supera lo smoke test non merita di essere testata oltre, quindi la pipeline deve fermarsi e il team deve essere avvisato. Con GUI Test Studio, gtr-cli termina con un codice di uscita che la pipeline legge, così un test fallito fa fallire la build.
Gli smoke test e i test di regressione si possono automatizzare senza codice?
Sì. Con GUI Test Studio registrate ogni flusso una volta facendolo nella vostra app, e il test si riproduce da solo. La suite di smoke test e la suite di regressione sono allora due gruppi degli stessi file di test, eseguiti da gtr-cli a ogni build e ogni notte.
Selenium, Playwright e Windows sono marchi dei rispettivi proprietari.
Continua a leggere
Tutti gli articoli
Automazione dei test
Cos'è il test end-to-end? Una guida semplice con un esempio reale
10 min di lettura

Automazione dei test
Cos'è il test funzionale? Esempi, tipi e differenze rispetto al test end-to-end
9 min di lettura

Automazione dei test
Test manuali e test automatizzati: perché i test manuali non bastano per i test end-to-end
15 min di lettura