Yury Pukhov, YuSMP Group
Yury Pukhov CEO & Mobile Engineering Lead, YuSMP Group
Aggiungi YuSMP come fonte preferita su Google
TL;DR: Lo smoke testing nello sviluppo software è una breve serie di controlli eseguita su ogni nuova build per verificare che le funzioni più critiche funzionino prima di avviare test più approfonditi. Se l’app si avvia, gli utenti possono accedere e il flusso principale va a buon fine, la build viene accettata; se un controllo fallisce, la build viene respinta subito, risparmiando ore di lavoro QA sprecato.

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.

Nuova scheda elettronica accesa per la prima volta con le sonde di test collegate, l’origine hardware dello smoke test

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:

  1. Viene prodotta una nuova build, che derivi da un merge sul ramo principale o da una build notturna.
  2. Prima dell’inizio dei test funzionali o di regressione, come criterio di ingresso per il ciclo QA.
  3. Dopo il deployment in un ambiente di test o di staging, per confermare che ambiente, configurazione e dati siano collegati correttamente.
  4. Subito dopo una release in produzione, come controllo post-deployment dei percorsi critici live.
  5. 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.
  6. 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.

  1. 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.
  2. 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.
  3. 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.
  4. Eseguire la suite sulla nuova build. La avvii automaticamente dalla pipeline oppure esegua la checklist a mano per i prodotti in fase molto iniziale.
  5. 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.
  6. 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.

#ControlloCondizione di superamento
1La home page si caricaHTTP 200, navigazione principale e griglia prodotti visibili
2L’utente può accedereL’account di test effettua il login e vede il nome del proprio account
3La ricerca restituisce risultatiUn prodotto noto compare per una query nota
4La pagina prodotto si aprePrezzo, immagini e pulsante «Aggiungi al carrello» vengono visualizzati
5Il carrello funzionaL’articolo viene aggiunto e il totale del carrello si aggiorna
6Il checkout si completaIl pagamento con carta di test va a buon fine in sandbox, viene mostrato il numero d’ordine
7La conferma d’ordine viene inviataL’evento o l’email di conferma arriva nella casella di test
8L’endpoint di health è verdeAPI, 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.

TipoCome funzionaIdeale perPrincipale svantaggio
ManualeUn tester segue una breve checklist scritta su ogni buildPrototipi, MVP, release poco frequentiLento, incoerente, non scala a molte build al giorno
AutomatizzatoScript eseguono i controlli dalla pipeline CI/CD su ogni buildProdotti con merge e deployment frequentiRichiede un impegno iniziale e manutenzione continua
IbridoControlli principali automatizzati più qualche verifica manuale di aspetti visivi o dispositiviApp mobile, prodotti con molta UILa 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.

AspettoSmoke testingSanity testingRegression testing
Domanda a cui rispondeQuesta build è testabile?Questa correzione o modifica funziona?Si è rotto qualcos’altro?
AmbitoAmpio e superficiale, tutti i percorsi criticiRistretto e concentrato sull’area modificataAmpio e profondo, l’intero prodotto
QuandoA ogni nuova build e deploymentDopo la correzione di un bug o una modifica minorePrima delle release e dopo modifiche significative
Durata tipicaMinutiDa minuti a un’oraOre, a volte giorni se manuale
Con script?Sì, una suite fissa e stabileSpesso senza script o ad hocSì, una suite ampia e mantenuta
Di solito automatizzato?Quasi sempreA voltePer lo più, con alcuni controlli manuali
Esito in caso di fallimentoBuild respinta, nessun ulteriore testCorrezione rimandata allo sviluppatoreRelease 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.

Ingegnere che controlla lo schermo di una pipeline dove ogni controllo smoke su una nuova build è verde

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.

LivelloStrumenti comuniControlli smoke tipici
UI webPlaywright, Cypress, Selenium WebDriverCaricamento pagine, login, flusso utente principale
MobileAppium, Espresso (Android), XCUITest (iOS), MaestroInstallazione, avvio senza crash, accesso, dati della home
APIPostman con Newman, REST Assured, pytest con requests, k6Endpoint di health, token di autenticazione, una chiamata di lettura e una di scrittura
Test runnerJUnit, TestNG, pytest, Jest, VitestRaggruppamento e tagging del sottoinsieme smoke
CI/CDGitHub Actions, GitLab CI, Jenkins, Azure DevOpsEsecuzione della suite come gate dopo build e deploy
Controlli in produzioneSynthetic monitoring nella Sua piattaforma di observabilityControlli 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».

VantaggiLimiti
Trova gli errori critici pochi minuti dopo la buildSuperficiale per definizione, non rileva la maggior parte dei difetti funzionali
Fa risparmiare tempo QA respingendo le build non testabiliPuò creare falsa sicurezza se usato come controllo di rilascio
Facile da automatizzare ed eseguire a ogni modificaRichiede manutenzione quando i flussi critici cambiano
Intercetta errori di ambiente e di configurazione dopo il deploymentI test instabili erodono rapidamente la fiducia nel gate
Fornisce un segnale go o no-go semplice e condivisoDiventa 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:

  1. La mantenga piccola. Parta da 5-15 controlli e ne aggiunga uno nuovo solo se il suo fallimento renderebbe inutili ulteriori test.
  2. Fissi un budget di tempo. Concordi un tempo massimo di esecuzione, per esempio 5 minuti, e consideri un difetto il suo superamento.
  3. Renda ogni test indipendente. Ogni controllo dovrebbe creare o reimpostare i propri dati ed essere eseguibile in qualsiasi ordine.
  4. Corregga o rimuova subito i test instabili. Un gate che fallisce a caso insegna alle persone a rilanciarlo e a ignorarlo.
  5. La esegua in un ambiente simile alla produzione. Stesso stile di configurazione, stesse integrazioni in modalità sandbox, dati realistici.
  6. 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.
  7. 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