Che cos’è lo smoke testing nello sviluppo software? È il primo rapido sguardo a una build appena prodotta: una manciata di controlli che rispondono a una sola domanda, «questa build è abbastanza stabile da meritare di essere testata?». Se l’applicazione non si avvia, la pagina di login restituisce un errore o il checkout non si completa mai, non ha senso eseguire una suite di regressione da due ore. Lo smoke test lo rileva in pochi minuti e rimanda la build direttamente agli sviluppatori.
Gli smoke test sono una parte piccola ma portante di qualsiasi configurazione seria di servizi di testing software. Si collocano tra gli unit test gestiti dagli sviluppatori e le suite funzionali, di regressione ed end-to-end, più lente, e fungono da gate che decide se quelle suite più lente vengono eseguite. I team che saltano questo gate tendono a scoprire le build difettose nel modo più costoso, dopo che tester o clienti ci hanno già perso tempo.
Questa guida tratta la definizione, l’origine del termine, la differenza tra smoke test, build verification test, sanity test e test di regressione, quando eseguirlo, un processo passo dopo passo, una checklist di smoke test di esempio, la configurazione CI/CD con un esempio di pipeline, gli strumenti per il 2026, vantaggi e limiti e le best practice che mantengono una smoke suite veloce e affidabile.
Che cos’è lo smoke testing nello sviluppo software?
Lo smoke testing è un controllo ampio e superficiale di una nuova build software che verifica il funzionamento delle funzioni più importanti, così che il team possa decidere se accettare la build per ulteriori test o respingerla. Non cerca di trovare ogni bug. Cerca di trovare i bug che renderebbero inutile qualsiasi altro test.
Il Glossario ISTQB, il vocabolario di riferimento usato dai tester di software in tutto il mondo, definisce lo smoke test come «a test suite that covers the main functionality of a component or system to determine whether it works properly before planned testing begins», cioè una suite di test che copre le funzionalità principali di un componente o sistema per determinare se funziona correttamente prima dell’inizio dei test pianificati. Tre idee di questa definizione contano nella pratica:
- Solo le funzionalità principali. Uno smoke test copre i percorsi critici, come l’avvio dell’app, l’accesso, il caricamento della schermata principale e il completamento della transazione principale. I casi limite restano per dopo.
- Ampiezza più che profondità. Tocca molte aree del sistema in modo leggero invece di esplorarne a fondo una sola.
- Prima dei test pianificati. Viene eseguito per primo, come criterio di ingresso. Uno smoke test fallito ferma la pipeline; uno superato apre la strada ai test funzionali, di regressione e di performance.
Il risultato di uno smoke test è binario: la build o «supera lo smoke» e prosegue, o «fallisce lo smoke» e torna allo sviluppo. Proprio questo esito semplice rende gli smoke test così facili da automatizzare e così utili come gate.
Che cos’è uno smoke test nello sviluppo software, in parole semplici?
In parole semplici, uno smoke test nello sviluppo software è un rapido controllo dello stato di salute di una nuova build. Pensi a un meccanico che gira la chiave, verifica che il motore parta, che le luci si accendano e che i freni rispondano prima di fissare la revisione completa dell’auto. Nessuno fa una revisione completa a un’auto che non parte, e nessuno dovrebbe eseguire un ciclo di test completo su una build che non si avvia.
Da dove viene il termine «smoke test»?
Il termine viene dall’elettronica e dall’idraulica, molto prima del software. Gli ingegneri elettronici alimentavano per la prima volta una scheda appena assemblata e osservavano se usciva fumo: niente fumo significava che la scheda era almeno abbastanza sicura da essere testata come si deve. Gli idraulici pompavano fumo innocuo in un nuovo impianto di tubature per vedere da dove fuoriusciva.
Il software ha preso in prestito l’idea negli anni Novanta. L’articolo di Steve McConnell «Daily Build and Smoke Test», pubblicato su IEEE Software nel luglio 1996, lo descriveva come «a common practice at Microsoft and some other shrink-wrap software companies», una pratica comune in Microsoft e in alcune altre aziende di software pacchettizzato. In quel processo l’intero prodotto veniva compilato ogni giorno e poi sottoposto a un controllo relativamente semplice per vedere se «fuma» quando viene eseguito. McConnell citava come esempio il progetto Windows NT 3.0: circa 5,6 milioni di righe di codice in 40.000 file sorgente, dove una build completa poteva richiedere fino a 19 ore, eppure un team di build di quattro persone eseguiva comunque la build giornaliera e lo smoke test.
Il principio da allora non è cambiato. Ciò che è cambiato è la velocità: una pipeline del 2026 compila e sottopone a smoke test un’applicazione web in pochi minuti, a ogni merge, invece che una volta per notte.
Smoke testing e build verification testing: sono la stessa cosa?
Sì, nella maggior parte dei team smoke testing e build verification testing (BVT) indicano la stessa cosa: una serie di controlli che decide se una nuova build è abbastanza buona da essere testata. L’unica sfumatura è l’accento. «BVT» sottolinea che il controllo è automatizzato e viene eseguito su ogni build; «smoke test» è il termine più ampio e di uso quotidiano.
Il Glossario ISTQB definisce il build verification test come «an automated test that validates the integrity of each new build and verifies its key/core functionality, stability, and testability», ovvero un test automatizzato che convalida l’integrità di ogni nuova build e ne verifica le funzionalità chiave, la stabilità e la testabilità. Confrontandola con la definizione di smoke test vista sopra, la sovrapposizione è evidente. Altri nomi che potrebbe incontrare per la stessa idea sono intake test, confidence test e build acceptance test.
Perché il sanity testing a volte viene chiamato smoke test
La terminologia varia da una fonte all’altra, e questo confonde molti team. Il Glossario ISTQB elenca sanity test, intake test e confidence test come sinonimi di smoke test. La maggior parte dei professionisti e dei produttori di strumenti, però, usa «sanity test» per qualcosa di più ristretto: un rapido controllo di una correzione o funzionalità specifica dopo una modifica minore. Questa guida segue l’uso dei professionisti e confronta i due nel dettaglio più avanti. Qualunque termine scelga il Suo team, lo concordi nella strategia di test, così che «lo smoke è fallito» significhi la stessa cosa per tutti.
Perché lo smoke testing è importante?
Lo smoke testing è importante perché ferma le build difettose nel momento più economico possibile, prima che tester, ambienti di staging e clienti ci spendano tempo. Un controllo di cinque minuti che respinge una build difettosa può far risparmiare a un team QA un’intera giornata di indagini e a un team di release un rollback d’emergenza.
Il costo dei difetti scoperti tardi è ben documentato. Il Planning Report 02-3 del NIST (2002) stimava che un’infrastruttura di testing software inadeguata costasse all’economia statunitense circa 59,5 miliardi di dollari l’anno, di cui circa 22,2 miliardi evitabili con test anticipati e migliori. Gli smoke test non sostituiscono test approfonditi, ma sono uno dei modi più economici per anticipare il rilevamento dei difetti.
Nel lavoro quotidiano, una smoke suite affidabile dà a un team:
- Un segnale chiaro di go o no-go. Nessuno discute se una build sia testabile; decide il gate.
- Tempo QA protetto. I tester iniziano ogni ciclo su una build che si sa avviarsi e completare il suo flusso principale.
- Feedback più rapido agli sviluppatori. Un merge difettoso viene segnalato in pochi minuti, quando la modifica è ancora fresca.
- Deployment più sicuri. I controlli smoke post-deployment intercettano errori di configurazione e di ambiente che non emergono mai negli unit test.
- Una baseline di qualità visibile. Il tasso di superamento dello smoke nel tempo mostra se il ramo principale sta diventando più o meno stabile.
È anche un’applicazione diretta dell’approccio shift-left: eseguire i controlli più importanti il prima e il più spesso possibile.
Quando eseguire gli smoke test?
Esegua uno smoke test ogni volta che il software cambia in un modo che potrebbe comprometterne il funzionamento di base: su ogni nuova build, prima di qualsiasi ciclo di test pianificato e subito dopo ogni deployment. In una pipeline CI/CD questo di solito significa più volte al giorno. I trigger tipici includono:
- Viene prodotta una nuova build, che derivi da un merge sul ramo principale o da una build notturna.
- Prima dell’inizio dei test funzionali o di regressione, come criterio di ingresso per il ciclo QA.
- Dopo il deployment in un ambiente di test o di staging, per confermare che ambiente, configurazione e dati siano collegati correttamente.
- Subito dopo una release in produzione, come controllo post-deployment dei percorsi critici live.
- Dopo modifiche all’infrastruttura, come l’aggiornamento di un database, una nuova regione cloud, la rotazione di un certificato o l’aggiornamento di una dipendenza.
- Dopo un hotfix, per confermare che la correzione non abbia compromesso l’avvio o il flusso principale.
Il passaggio in staging merita un’attenzione particolare: una build può superare ogni test sulla macchina di uno sviluppatore e fallire comunque in un ambiente con secret, feature flag o dati diversi. La nostra guida allo staging nello sviluppo software spiega come mantenere quell’ambiente abbastanza vicino alla produzione perché i risultati dello smoke abbiano un significato.
Chi esegue lo smoke testing?
Lo smoke testing è di solito in capo agli ingegneri QA o di test automation che progettano la suite, ma nei team moderni viene eseguito automaticamente e l’intero team agisce in base al risultato. Chi lo esegue concretamente dipende dalla maturità del team:
- Gli ingegneri QA scelgono i percorsi critici, scrivono i casi di smoke test e mantengono la suite in buona salute.
- Gli sviluppatori eseguono la suite in locale prima del push e correggono subito uno smoke fallito, perché blocca tutti.
- Gli ingegneri DevOps o di piattaforma integrano la suite nella pipeline CI/CD e nei controlli post-deployment.
- I release manager considerano uno smoke superato una condizione necessaria per promuovere una build.
Nei team piccoli senza tester dedicati, gli sviluppatori gestiscono l’intero processo. Funziona, a patto che qualcuno sia esplicitamente responsabile di mantenere la suite breve e affidabile.
Come eseguire uno smoke test: 6 passaggi
Per eseguire uno smoke test, individui le poche funzioni senza le quali il prodotto non può vivere, le trasformi in casi di test brevi e ripetibili, le esegua su ogni nuova build in un ambiente simile alla produzione e accetti o respinga la build in base a un unico risultato superato o fallito. I passaggi seguenti valgono per prodotti web, mobile e API.
- Individuare i percorsi critici. Elenchi i flussi che renderebbero il prodotto inutilizzabile se non funzionassero: avvio, accesso, schermata principale, transazione principale (checkout, prenotazione, pagamento, caricamento) e qualsiasi integrazione da cui dipende il business.
- Scrivere casi di test brevi e indipendenti. Un test per ogni controllo critico, ciascuno eseguibile da solo con dati di test noti. Mantenga pochi passaggi e risultati attesi inequivocabili.
- Preparare ambiente e dati. Usi un ambiente stabile e simile alla produzione, con account precaricati e metodi di pagamento di test. Gli smoke test che dipendono da dati condivisi e mutevoli diventano rapidamente instabili.
- Eseguire la suite sulla nuova build. La avvii automaticamente dalla pipeline oppure esegua la checklist a mano per i prodotti in fase molto iniziale.
- Prendere una decisione go o no-go. Qualsiasi errore respinge la build. Non «approvi con eccezioni»: se un controllo non è critico, non appartiene alla smoke suite.
- Segnalare e correggere. Invii l’errore, i log e gli screenshot agli sviluppatori che hanno apportato la modifica, corregga la build ed esegua di nuovo lo smoke prima di qualsiasi altro test.
Che cosa contiene una smoke test suite? Una checklist di esempio
Una buona smoke test suite contiene solo i controlli il cui fallimento renderebbe inutili ulteriori test, in genere tra 5 e 30 casi di test eseguiti in pochi minuti. L’elenco esatto dipende dal prodotto, ma la maggior parte delle suite copre avvio, autenticazione, navigazione, transazione principale e integrazioni chiave.
Esempio di smoke test: un’applicazione web di e-commerce
La tabella seguente mostra una checklist di smoke test realistica per un negozio online. Ogni riga è un singolo controllo con una condizione di superamento chiara.
| # | Controllo | Condizione di superamento |
|---|---|---|
| 1 | La home page si carica | HTTP 200, navigazione principale e griglia prodotti visibili |
| 2 | L’utente può accedere | L’account di test effettua il login e vede il nome del proprio account |
| 3 | La ricerca restituisce risultati | Un prodotto noto compare per una query nota |
| 4 | La pagina prodotto si apre | Prezzo, immagini e pulsante «Aggiungi al carrello» vengono visualizzati |
| 5 | Il carrello funziona | L’articolo viene aggiunto e il totale del carrello si aggiorna |
| 6 | Il checkout si completa | Il pagamento con carta di test va a buon fine in sandbox, viene mostrato il numero d’ordine |
| 7 | La conferma d’ordine viene inviata | L’evento o l’email di conferma arriva nella casella di test |
| 8 | L’endpoint di health è verde | API, database e provider di pagamento risultano operativi |
Noti che cosa manca: casi limite degli sconti, regole di validazione degli indirizzi, tutti i metodi di pagamento, compatibilità con i browser. Questi appartengono alle suite funzionali e di regressione. Lo smoke test dimostra solo che il negozio è in grado di ricevere un ordine.
Esempi di smoke test per app mobile e API
Per un’app mobile, una smoke suite verifica in genere che l’app si installi e si avvii senza crash, che compaia la schermata di onboarding o di login, che un utente possa accedere, che la home carichi i dati dal backend e che la registrazione alle notifiche push vada a buon fine. Per un’API, verifica che il servizio si avvii, che l’endpoint di health risponda, che l’autenticazione restituisca un token e che una chiamata di lettura e una di scrittura sulla risorsa principale vadano a buon fine con gli status code e la struttura di risposta attesi.
Tipi di smoke testing: manuale, automatizzato e ibrido
Lo smoke testing può essere manuale, automatizzato o un mix dei due. Gli smoke test automatizzati sono la scelta standard per qualsiasi prodotto con una pipeline CI/CD, mentre i controlli smoke manuali hanno ancora senso per prodotti in fase molto iniziale e per controlli visivi o specifici per dispositivo difficili da automatizzare.
| Tipo | Come funziona | Ideale per | Principale svantaggio |
|---|---|---|---|
| Manuale | Un tester segue una breve checklist scritta su ogni build | Prototipi, MVP, release poco frequenti | Lento, incoerente, non scala a molte build al giorno |
| Automatizzato | Script eseguono i controlli dalla pipeline CI/CD su ogni build | Prodotti con merge e deployment frequenti | Richiede un impegno iniziale e manutenzione continua |
| Ibrido | Controlli principali automatizzati più qualche verifica manuale di aspetti visivi o dispositivi | App mobile, prodotti con molta UI | La parte manuale può essere saltata in silenzio sotto la pressione delle scadenze |
Lo smoke testing ai diversi livelli di test
Gli smoke test non si limitano al sistema completo. I team eseguono spesso un controllo smoke a più livelli: uno smoke di integrazione conferma che i servizi si avviano e comunicano tra loro, uno smoke di sistema conferma che i flussi critici end-to-end funzionano in un ambiente di deployment e uno smoke di accettazione conferma che una release candidate è pronta per gli utenti business. Gli unit test vengono già eseguiti a ogni modifica, quindi raramente vengono chiamati smoke test, anche se una fase unit fallita blocca la pipeline allo stesso modo. Per capire come si inseriscono gli unit test nel quadro, legga la nostra guida allo unit testing nello sviluppo software.
Smoke testing, sanity testing e regression testing a confronto
Lo smoke testing verifica che una nuova build sia abbastanza stabile da essere testata, il sanity testing verifica che una correzione specifica o una piccola modifica funzioni come previsto e il regression testing verifica che le funzionalità esistenti funzionino ancora dopo qualsiasi modifica. Seguono quest’ordine di profondità: lo smoke è il più ampio e superficiale, la regressione il più profondo e lento.
| Aspetto | Smoke testing | Sanity testing | Regression testing |
|---|---|---|---|
| Domanda a cui risponde | Questa build è testabile? | Questa correzione o modifica funziona? | Si è rotto qualcos’altro? |
| Ambito | Ampio e superficiale, tutti i percorsi critici | Ristretto e concentrato sull’area modificata | Ampio e profondo, l’intero prodotto |
| Quando | A ogni nuova build e deployment | Dopo la correzione di un bug o una modifica minore | Prima delle release e dopo modifiche significative |
| Durata tipica | Minuti | Da minuti a un’ora | Ore, a volte giorni se manuale |
| Con script? | Sì, una suite fissa e stabile | Spesso senza script o ad hoc | Sì, una suite ampia e mantenuta |
| Di solito automatizzato? | Quasi sempre | A volte | Per lo più, con alcuni controlli manuali |
| Esito in caso di fallimento | Build respinta, nessun ulteriore test | Correzione rimandata allo sviluppatore | Release bloccata finché i difetti non sono corretti |
Un modo semplice per ricordare la differenza: lo smoke chiede «funziona?», il sanity chiede «quello che abbiamo appena cambiato ha senso?» e la regressione chiede «tutto ciò che funzionava funziona ancora?». Per una mappa più ampia dei tipi di test e di come i team QA li combinano, consulti la nostra guida alla quality assurance nello sviluppo software.
Come funziona lo smoke testing in una pipeline CI/CD?
In una pipeline CI/CD, la smoke suite viene eseguita automaticamente subito dopo le fasi di build e di unit test, e di nuovo subito dopo ogni deployment; se fallisce, la pipeline si ferma e la build non viene promossa. Così lo smoke testing passa da abitudine manuale a gate di qualità obbligatorio.
Una sequenza tipica è questa: build, unit test, deploy in un ambiente di test, smoke test, poi le suite funzionali e di regressione più lunghe, poi deploy in produzione, quindi uno smoke test post-deployment sulla produzione. Le due fasi smoke intercettano problemi diversi. Lo smoke pre-release intercetta il codice difettoso; lo smoke post-deployment intercetta configurazione, secret, migrazioni e infrastruttura difettosi.
Ecco un job GitHub Actions semplificato che esegue una smoke suite Playwright su un ambiente di staging appena distribuito e fa fallire la pipeline se uno smoke test fallisce:
smoke-test:
needs: deploy-staging
runs-on: ubuntu-latest
timeout-minutes: 10
steps:
- uses: actions/checkout@v4
- run: npm ci
- run: npx playwright install --with-deps chromium
- name: Run smoke suite against staging
run: npx playwright test --grep @smoke
env:
BASE_URL: https://staging.example.com
Due dettagli lo fanno funzionare nella pratica. Il tag @smoke permette al team di mantenere gli smoke test all’interno del progetto di test principale eseguendo solo il sottoinsieme contrassegnato, e il limite timeout-minutes evita che un ambiente bloccato tenga ferma la pipeline per un’ora. La stessa idea vale per GitLab CI, Jenkins, Azure DevOps o qualsiasi altro runner. Per la progettazione completa della pipeline, consulti la nostra guida alla CI/CD nello sviluppo software.
Quanto dovrebbe durare una smoke test suite?
Una smoke test suite dovrebbe di solito terminare in meno di 5-10 minuti, e molti team puntano a meno di 5. Se dura di più, non fornisce più un feedback rapido e gli sviluppatori iniziano a ignorarla o ad aggirarla. Quando una suite supera quel limite, sposti i controlli più lenti o meno critici nella suite di regressione invece di accettare un gate più lento.
Strumenti di smoke testing nel 2026
La maggior parte dei team costruisce gli smoke test con gli stessi strumenti di automazione che già usa per i test funzionali, poi contrassegna un piccolo sottoinsieme come smoke suite. Lo strumento giusto dipende da che cosa si testa: una UI web, un’app mobile o un’API.
| Livello | Strumenti comuni | Controlli smoke tipici |
|---|---|---|
| UI web | Playwright, Cypress, Selenium WebDriver | Caricamento pagine, login, flusso utente principale |
| Mobile | Appium, Espresso (Android), XCUITest (iOS), Maestro | Installazione, avvio senza crash, accesso, dati della home |
| API | Postman con Newman, REST Assured, pytest con requests, k6 | Endpoint di health, token di autenticazione, una chiamata di lettura e una di scrittura |
| Test runner | JUnit, TestNG, pytest, Jest, Vitest | Raggruppamento e tagging del sottoinsieme smoke |
| CI/CD | GitHub Actions, GitLab CI, Jenkins, Azure DevOps | Esecuzione della suite come gate dopo build e deploy |
| Controlli in produzione | Synthetic monitoring nella Sua piattaforma di observability | Controlli programmati in stile smoke dei percorsi critici live |
La scelta dello strumento conta meno della disciplina. Una suite Playwright di dieci test eseguita a ogni merge vale più di un framework sofisticato che nessuno mantiene.
Vantaggi e limiti dello smoke testing
Il principale vantaggio dello smoke testing è che intercetta i difetti che compromettono la build in pochi minuti e a un costo molto basso; il principale limite è che non dice quasi nulla sulla qualità di ciò che sta al di fuori dei percorsi critici. Uno smoke test superato significa «vale la pena testarla», non «pronta per il rilascio».
| Vantaggi | Limiti |
|---|---|
| Trova gli errori critici pochi minuti dopo la build | Superficiale per definizione, non rileva la maggior parte dei difetti funzionali |
| Fa risparmiare tempo QA respingendo le build non testabili | Può creare falsa sicurezza se usato come controllo di rilascio |
| Facile da automatizzare ed eseguire a ogni modifica | Richiede manutenzione quando i flussi critici cambiano |
| Intercetta errori di ambiente e di configurazione dopo il deployment | I test instabili erodono rapidamente la fiducia nel gate |
| Fornisce un segnale go o no-go semplice e condiviso | Diventa lento se i team continuano ad aggiungere controlli non critici |
Best practice per lo smoke testing
Le migliori smoke suite sono brevi, stabili, automatizzate e rigorosamente limitate ai percorsi critici; la maggior parte dei fallimenti dello smoke testing deriva da suite diventate troppo grandi o troppo instabili per essere affidabili. Queste sette pratiche mantengono utile una suite:
- La mantenga piccola. Parta da 5-15 controlli e ne aggiunga uno nuovo solo se il suo fallimento renderebbe inutili ulteriori test.
- Fissi un budget di tempo. Concordi un tempo massimo di esecuzione, per esempio 5 minuti, e consideri un difetto il suo superamento.
- Renda ogni test indipendente. Ogni controllo dovrebbe creare o reimpostare i propri dati ed essere eseguibile in qualsiasi ordine.
- Corregga o rimuova subito i test instabili. Un gate che fallisce a caso insegna alle persone a rilanciarlo e a ignorarlo.
- La esegua in un ambiente simile alla produzione. Stesso stile di configurazione, stesse integrazioni in modalità sandbox, dati realistici.
- Esegua lo smoke test in produzione dopo ogni release. Usi account di sola lettura o di test dedicati, così che i controlli live non tocchino mai dati reali dei clienti.
- Riveda la suite ogni trimestre. Rimuova i controlli delle funzionalità dismesse e aggiunga controlli per i nuovi flussi critici.
Metriche da monitorare per la Sua smoke suite
Monitori pochi numeri semplici per sapere se la smoke suite fa il suo lavoro: il tasso di superamento dello smoke sul ramo principale, la durata mediana della suite, il tasso di fallimenti instabili (fallimenti che passano al rilancio) e il numero di difetti trovati nelle fasi successive che uno smoke test avrebbe dovuto intercettare. Questi numeri si affiancano naturalmente alle metriche di delivery come il change failure rate, spiegato nella nostra guida ai KPI dello sviluppo software.
Errori comuni nello smoke testing
L’errore più comune nello smoke testing è lasciare che la suite si trasformi in una mini suite di regressione che dura troppo e fallisce troppo spesso. Altri problemi frequenti sono facili da individuare una volta che li si conosce:
- Testare casi limite nella smoke suite invece dei percorsi critici principali.
- Eseguire lo smoke solo prima delle release anziché su ogni build, il che ritarda il feedback di giorni.
- Saltare lo smoke post-deployment, così gli errori di configurazione arrivano prima agli utenti.
- Condividere dati di test tra i test, il che causa fallimenti casuali quando i test vengono eseguiti in parallelo.
- Consentire forzature manuali di uno smoke fallito «solo per questa volta», il che vanifica il gate.
Se le Sue release si rompono ancora il primo giorno nonostante una smoke suite, una valutazione QA indipendente può verificare quali percorsi critici sono effettivamente coperti, misurare tassi di instabilità e tempi di esecuzione e ricostruire il gate perché il team torni a fidarsene.
Domande frequenti
Che cos’è lo smoke testing nello sviluppo software?
Lo smoke testing nello sviluppo software è una rapida serie di controlli eseguita su ogni nuova build per verificare che le funzioni più critiche funzionino, come l’avvio, l’accesso e il completamento della transazione principale. Decide se la build è abbastanza stabile per test più approfonditi. Uno smoke test fallito respinge subito la build, così i tester non perdono tempo con un software sostanzialmente difettoso.
Che cos’è uno smoke test nello sviluppo software, con un esempio?
Uno smoke test è un breve controllo, automatizzato o manuale, dei percorsi critici di una build. Per un negozio online, uno smoke test potrebbe verificare che la home page si carichi, che un utente di test possa accedere, che un prodotto possa essere aggiunto al carrello e che un pagamento in sandbox si completi con un numero d’ordine. Se uno qualsiasi di questi controlli fallisce, la build torna agli sviluppatori prima che inizi qualsiasi altro test.
Qual è la differenza tra smoke testing e sanity testing?
Lo smoke testing è un controllo ampio e superficiale che verifica che un’intera nuova build sia abbastanza stabile da essere testata. Il sanity testing è un controllo ristretto che verifica che una specifica correzione di bug o una piccola modifica funzioni come previsto. Lo smoke testing viene eseguito su ogni build ed è quasi sempre automatizzato, mentre il sanity testing viene eseguito dopo modifiche mirate ed è spesso svolto a mano. Alcuni glossari, tra cui quello ISTQB, trattano i due termini come sinonimi.
Lo smoke testing è la stessa cosa del regression testing?
No. Lo smoke testing verifica solo i percorsi critici di una nuova build in pochi minuti per decidere se è testabile. Il regression testing riesegue una suite molto più ampia per confermare che le funzionalità esistenti funzionino ancora dopo una modifica, e può richiedere ore. Lo smoke testing viene eseguito per primo, come gate; il regression testing viene eseguito più tardi, prima di una release.
Quanti test dovrebbe avere una smoke test suite?
La maggior parte delle smoke suite contiene tra 5 e 30 test, e il numero giusto è il più piccolo insieme che copre ogni percorso critico del prodotto. Una regola utile è includere un controllo solo se il suo fallimento renderebbe inutili tutti i test successivi. Se la suite dura più di circa 5-10 minuti, probabilmente è diventata troppo grande.
Gli smoke test si possono automatizzare?
Sì, e per qualsiasi prodotto con una pipeline CI/CD dovrebbero esserlo. Gli smoke test automatizzati vengono eseguiti a ogni build e deployment con strumenti come Playwright, Cypress, Appium o Postman con Newman, e bloccano la pipeline quando un controllo critico fallisce. Le checklist smoke manuali hanno ancora senso per i primi prototipi e per i controlli visivi difficili da automatizzare.
Chi è responsabile dello smoke testing?
Di solito gli ingegneri QA o di test automation progettano e mantengono la smoke suite, gli ingegneri DevOps la integrano nella pipeline CI/CD e gli sviluppatori correggono qualsiasi build che non la supera. Nei team piccoli senza tester dedicati, gli sviluppatori gestiscono l’intero processo. Chiunque ne sia titolare, una persona dovrebbe essere chiaramente responsabile di mantenere la suite veloce e affidabile.
Fonti
- ISTQB, Glossary of Terms used in Software Testing, voci «smoke test» e «build verification test» (v4.2, 2023)
- Steve McConnell, Daily Build and Smoke Test, IEEE Software, vol. 13, n. 4, luglio 1996, pp. 143–144
- NIST, Planning Report 02-3: The Economic Impacts of Inadequate Infrastructure for Software Testing (2002)
- Documentazione Playwright, Test annotations and tags