Cos’è lo unit testing nello sviluppo software? È l’abitudine di dimostrare, con piccoli controlli automatici, che ogni mattone di un programma fa esattamente ciò che deve prima che qualcuno combini i mattoni in un prodotto. Ogni codebase seria si basa su questa pratica, dalle piattaforme di pagamento alle app mobile, perché un test unitario che fallisce indica la riga difettosa in pochi secondi, molto prima che un cliente trovi il bug.
I test unitari non sono tutta la storia della qualità. Sono lo strato di base, di responsabilità degli sviluppatori, di una strategia più ampia di servizi di QA e testing del software che copre anche controlli di integrazione, di regressione ed end-to-end. Quando lo strato di base è sottile, ogni altro strato diventa più lento e più costoso, e le date di rilascio iniziano a dipendere dalla fortuna.
Questa guida offre una definizione semplice, l’anatomia di un test unitario, un esempio pratico in Python e JavaScript, il confronto tra i test unitari e gli altri tipi di test, quanta copertura del codice aspettarsi, quali framework usano i team nel 2026, che cosa cambiano gli assistenti di programmazione basati sull’IA e una checklist per valutare i test unitari di qualsiasi team di sviluppo.
Cos’è lo unit testing nello sviluppo software?
Lo unit testing nello sviluppo software è un livello di test in cui la più piccola parte testabile di un’applicazione, chiamata unità sotto test, viene verificata in isolamento da test automatici scritti dagli sviluppatori. È il primo livello di test, prima dei test di integrazione, di sistema e di accettazione, e gira a ogni modifica del codice.
Una «unità» è di solito una funzione, un metodo o una classe. In alcuni linguaggi e team è un piccolo modulo con un’interfaccia pubblica. Ciò che conta è che l’unità abbia un input chiaro e un output atteso chiaro, e che si possa eseguire senza avviare l’intera applicazione. Un test unitario non ha mai bisogno di un database reale, di un server web in esecuzione o di una chiamata di rete per passare.
Esistono due scuole di pensiero su quanto debba essere grande un’unità. La scuola classicista, a volte chiamata scuola di Detroit o di Chicago, considera l’unità come un’unità di comportamento: un piccolo gruppo di oggetti reali testati insieme, con test double solo ai confini lenti o esterni. La scuola mockista, spesso chiamata scuola di Londra, considera ogni classe come l’unità e sostituisce ogni collaboratore con un mock. Funzionano entrambe; molti team tendono verso l’approccio classicista e usa i mock solo ai confini, perché i test con molti mock si rompono ogni volta che cambia il design interno.
Lo unit testing è una pratica white-box. Chi scrive il test sa come è costruito il codice e usa questa conoscenza per scegliere input che raggiungano ogni ramo. Per questo quasi tutti i test unitari li scrivono gli sviluppatori, non tester separati.
Definizione di unit testing: cosa sono i test unitari nello sviluppo software?
Un test unitario è un piccolo programma che chiama un’unità di codice con un input noto e verifica che l’output, il valore restituito o l’effetto collaterale corrisponda a quanto atteso. Se l’asserzione è vera il test passa; altrimenti fallisce e segnala quale aspettativa è stata violata. Un insieme di questi test, eseguito in modo automatico, costituisce la suite di test unitari.
Una buona definizione operativa di unit testing per lo sviluppo software ha quattro parti: l’obiettivo è la più piccola unità testabile, l’unità è isolata dalle sue dipendenze, il controllo è automatico e ripetibile e il risultato è un esito binario, superato o fallito, che non richiede interpretazione umana.
Anatomia di un test unitario: Arrange, Act, Assert
La maggior parte dei test unitari segue lo schema Arrange, Act, Assert, di solito abbreviato in AAA. Arrange prepara i dati di input e gli eventuali test double. Act chiama l’unità una volta. Assert confronta il risultato con il valore atteso. Mantenere visibili questi tre passaggi rende un test facile da leggere e facile da correggere quando fallisce.
I team che seguono il behavior-driven development descrivono la stessa struttura come Given, When, Then: dato un carrello da 200 dollari, quando si applica uno sconto del 25%, allora il totale è 150 dollari. Le parole cambiano, ma la forma del test è identica. Un test dovrebbe avere un solo passaggio Act e verificare un solo comportamento, anche se quel comportamento richiede due o tre asserzioni correlate.
Test case, test suite, test runner: il vocabolario
Lo unit testing ha un piccolo vocabolario che ricorre in ogni framework, in ogni revisione di pull request e in ogni report dei fornitori. La tabella seguente definisce i termini che sentirà più spesso.
| Termine | Significato | Esempio |
|---|---|---|
| Unità sotto test | La funzione, il metodo o la classe che si sta verificando | apply_discount() |
| Test case | Uno scenario con un input specifico e un risultato atteso | «Il 25% di sconto su 200 dollari restituisce 150 dollari» |
| Asserzione | L’istruzione che confronta il valore effettivo con quello atteso | assert total == 150 |
| Fixture | Dati o oggetti di preparazione riutilizzabili, condivisi da più test | Un record cliente di esempio |
| Test suite | Un gruppo di test case correlati eseguiti insieme | Tutti i test del modulo dei prezzi |
| Test runner | Lo strumento che individua, esegue e riporta i test | pytest, Jest, JUnit Platform |
| Test double | Un sostituto di una dipendenza reale durante il test | Un gateway di pagamento finto |
Un semplice esempio di unit testing, passo dopo passo
Il modo più chiaro per capire lo unit testing è leggere un test reale. L’esempio seguente verifica una piccola funzione di calcolo dei prezzi in Python con pytest, poi mostra la stessa idea in JavaScript con Jest (Vitest usa la stessa sintassi). Entrambe le versioni seguono lo schema Arrange, Act, Assert.
La funzione sotto test applica uno sconto percentuale e rifiuta le percentuali non valide:
import pytest
from pricing import apply_discount
def test_applies_percentage_discount():
assert apply_discount(200.0, 25) == 150.0
def test_zero_percent_returns_original_price():
assert apply_discount(99.99, 0) == 99.99
def test_rejects_percent_above_100():
with pytest.raises(ValueError):
apply_discount(50.0, 120)
Ogni test verifica un solo comportamento: uno sconto normale, il caso limite dello zero e un input non valido che deve sollevare un errore. pytest trova ogni funzione il cui nome inizia con test_, la esegue e riporta quali asserzioni sono fallite. L’intero file gira in pochi millisecondi, perché nulla tocca un disco, un database o una rete.
// discount.test.js
const { applyDiscount } = require('./discount');
test('applies a percentage discount', () => {
const price = 200; // Arrange
const result = applyDiscount(price, 25); // Act
expect(result).toBe(150); // Assert
});
test('rejects a negative percent', () => {
expect(() => applyDiscount(50, -5)).toThrow(RangeError);
});
La versione JavaScript indica esplicitamente i tre passaggi AAA. Nei progetti reali questi commenti di solito si omettono quando il team si è abituato allo schema, ma l’ordine resta lo stesso. Noti che i nomi dei test si leggono come requisiti. Quando rejects a negative percent fallisce in una pull request, il revisore sa che cosa si è rotto senza aprire il codice.
Perché lo unit testing è importante?
Lo unit testing è importante perché intercetta i difetti nel momento e nel punto in cui correggerli costa meno, offre agli sviluppatori una rete di sicurezza per il refactoring e documenta come dovrebbe comportarsi ogni porzione di codice. Senza di esso i bug avanzano lungo la pipeline e costano di più a ogni fase.
L’argomento economico è ben documentato. Il Planning Report 02-3 del NIST, pubblicato nel 2002, stimava che un’infrastruttura di test del software inadeguata costasse all’economia statunitense circa 59,5 miliardi di dollari l’anno, e che circa 22,2 miliardi di dollari di questa cifra si potessero realisticamente evitare con test migliori. Più di recente il Consortium for Information & Software Quality (CISQ) ha stimato, nel suo rapporto del 2022, che il costo della scarsa qualità del software negli Stati Uniti avesse raggiunto almeno 2.410 miliardi di dollari. I dati differiscono per ambito e metodo, ma portano alla stessa conclusione: i difetti che sfuggono ai controlli iniziali diventano costosi.
I test unitari cambiano anche il lavoro quotidiano dei team:
- Feedback rapido. Lo sviluppatore scopre in pochi secondi che una modifica ha rotto qualcosa, mentre ha ancora il codice in testa.
- Refactoring sicuro. Gli ingegneri possono ristrutturare o aggiornare il codice perché la suite dimostra che il comportamento non è cambiato.
- Documentazione viva. I nomi dei test e le asserzioni descrivono le regole di business in modo più affidabile di una pagina wiki.
- Design migliore. Il codice facile da testare tende ad avere funzioni piccole e dipendenze esplicite.
- Debug più economico. Un test unitario fallito indica una sola funzione, non un intero percorso utente.
È il cuore dell’approccio shift left: spostare i controlli al primo momento possibile, e il test unitario è il primo controllo automatico che esista.
Come funziona lo unit testing nel flusso di sviluppo?
In un flusso di lavoro moderno i test unitari si scrivono insieme al codice, si eseguono sulla macchina dello sviluppatore e poi girano di nuovo in automatico nella continuous integration su ogni pull request. Una modifica viene integrata solo quando l’intera suite è verde. La sequenza tipica è questa:
- Scegliere l’unità. Individuare la funzione o la classe che si sta aggiungendo o modificando.
- Definire il comportamento atteso. Elencare il caso normale, i casi limite (vuoto, zero, massimo) e i casi di errore.
- Isolare le dipendenze. Sostituire database, orologi, client di rete e generatori casuali con test double o valori iniettati.
- Scrivere i test in forma AAA. Un comportamento per test, con un nome che si legga come un requisito.
- Eseguirli in locale. Usare la modalità watch o un hook di pre-commit, così i test girano prima che il codice lasci il portatile.
- Eseguirli nella CI su ogni pull request. La pipeline blocca il merge se un test unitario fallisce o se cala la copertura delle righe modificate.
- Tenere i test allineati. Quando il comportamento cambia di proposito, si aggiorna il test nello stesso commit; quando si trova un bug, si aggiunge prima un test che lo riproduce.
I passi 6 e 7 sono quelli in cui molti team scivolano. Una suite che gira solo sulle macchine degli sviluppatori si degrada in fretta. La nostra guida alla CI/CD nello sviluppo software mostra come lo stadio dei test unitari si inserisce nella pipeline, e l’articolo sulle pull request spiega come i revisori usano i risultati dei test come gate per il merge.
Unit testing, integration testing e test end-to-end a confronto
Lo unit testing verifica una porzione di codice in isolamento, l’integration testing verifica che le porzioni funzionino insieme e il test end-to-end verifica percorsi utente completi attraverso il sistema reale. Ogni livello intercetta un tipo diverso di difetto, quindi un progetto sano li usa tutti, in proporzioni diverse.
| Tipo | Che cosa verifica | Ambito | Velocità | Chi lo scrive | Strumenti tipici | Che cosa intercetta |
|---|---|---|---|---|---|---|
| Unitario | Una funzione, un metodo o una classe | Il più piccolo | Millisecondi | Sviluppatori | pytest, JUnit, Jest | Errori logici e nei casi limite |
| Integrazione | Più unità, o un’unità più una dipendenza reale | Da piccolo a medio | Secondi | Sviluppatori, QA | Testcontainers, Spring Test, Supertest | Collegamenti, query, configurazione |
| Funzionale / API | Una funzionalità attraverso la sua interfaccia pubblica | Medio | Secondi | QA, sviluppatori | Postman, REST Assured, Pact | Errori di contratto e nelle regole di business |
| End-to-end / UI | Un intero percorso utente in un’app distribuita | Intero sistema | Minuti | QA automation | Playwright, Cypress, Appium | Flussi interrotti tra servizi |
| Regressione | Che le vecchie funzionalità funzionino ancora dopo una modifica | Qualsiasi livello | Variabile | Tutto il team | Le suite esistenti, rieseguite | Effetti collaterali del nuovo codice |
| UAT | Che il prodotto soddisfi le esigenze di business | Intero sistema | Giorni | Utenti di business | Script di test, staging | Requisiti sbagliati |
La regressione non è tanto un livello a sé quanto uno scopo: rieseguire i test esistenti dopo ogni modifica. Lo user acceptance testing si trova all’estremo opposto rispetto ai test unitari, con gli utenti di business che verificano il prodotto rispetto alle esigenze reali. Per il quadro completo dei tipi di test, veda la nostra guida alla quality assurance nello sviluppo software.
Dove si collocano i test unitari nella piramide dei test
I test unitari formano l’ampia base della piramide dei test: molti test rapidi ed economici in basso, meno test di integrazione al centro e un piccolo numero di test end-to-end lenti in cima. Questa forma mantiene rapido il feedback e stabile la suite.
Un post del 2015 sul Google Testing Blog firmato da Mike Wacker, «Just Say No to More End-to-End Tests», ha reso popolare una regola empirica di circa il 70% di test unitari, il 20% di test di integrazione e il 10% di test end-to-end. Il post stesso precisa che il mix esatto cambia da team a team, ma che la suite dovrebbe mantenere la forma a piramide. Consideri il rapporto come un punto di partenza, non come un obbligo.
I team frontend preferiscono a volte il «testing trophy» descritto da Kent C. Dodds, che dà più peso ai test di integrazione dei componenti e meno ai test unitari isolati. Trofeo e piramide concordano sul punto principale: i test end-to-end, lenti e fragili, dovrebbero essere il gruppo più piccolo.
Lo unit testing nel V-model
Nel V-model lo unit testing è il passo di verifica abbinato alla progettazione di dettaglio o dei moduli. Il lato sinistro della V scende dai requisiti fino alla progettazione dei moduli e alla scrittura del codice; il lato destro risale dallo unit testing attraverso i test di integrazione, di sistema e di accettazione, e ogni livello di test verifica il livello di progettazione che gli sta di fronte. I settori regolamentati usano ancora questo modello, e il nostro articolo sul V-model nello sviluppo software spiega come i suoi livelli di test si collegano alla documentazione.
Mock, stub e fake: come isolare l’unità
I test double sono sostituti che rimpiazzano le dipendenze lente, imprevedibili o esterne, come database, gateway di pagamento, orologi e client HTTP, così che un’unità possa essere testata da sola. Mantengono i test unitari rapidi e deterministici e permettono di simulare errori difficili da provocare con la dipendenza reale.
| Double | Che cosa fa | Quando usarlo | Esempio |
|---|---|---|---|
| Dummy | Riempie un parametro ma non viene mai usato | Una firma richiede un argomento che al test non interessa | Un oggetto logger vuoto |
| Stub | Restituisce risposte fisse e predefinite | Serve che la dipendenza restituisca un valore specifico | Un client dei tassi di cambio che restituisce sempre 1,10 |
| Fake | Un’implementazione funzionante ma semplificata | Serve un comportamento realistico senza il sistema reale | Un repository in memoria al posto di PostgreSQL |
| Spy | Registra come è stato chiamato | Bisogna verificare a posteriori che una chiamata sia avvenuta | Un mittente email che memorizza i messaggi inviati |
| Mock | Preprogrammato con aspettative che poi verifica | L’interazione stessa è il comportamento sotto test | Un gateway di pagamento su cui l’addebito deve avvenire esattamente una volta |
I test double funzionano meglio con la dependency injection: invece di creare un client del database all’interno di una funzione, il codice lo riceve come parametro o come argomento del costruttore. Il codice di produzione passa il client reale e il test passa un fake. Il codice che crea da sé le proprie dipendenze, legge direttamente l’orologio di sistema o chiama servizi globali statici è difficile da testare, ed è di solito la prima cosa che un team rifattorizza quando inizia a fare unit testing sul serio.
L’eccesso di mock è il problema opposto. Quando ogni collaboratore è un mock e ogni test verifica sequenze di chiamate esatte, i test rispecchiano l’implementazione invece del comportamento. Qualsiasi refactoring rompe allora decine di test anche se il prodotto funziona ancora. Una regola pratica: usare i mock per ciò che non si possiede o non si controlla (reti, API di terze parti, tempo) e oggetti reali o fake per le proprie classi semplici.
Tecniche di unit testing: white-box, black-box e gray-box
I test unitari si progettano soprattutto con tecniche white-box, perché lo sviluppatore vede il codice, ma il ragionamento black-box e gray-box aiuta a scegliere input migliori. Combinandoli si ottengono test che coprono sia i rami interni sia il contratto esterno di un’unità.
- Test white-box. Gli input si scelgono per esercitare ogni ramo, ciclo e condizione del codice, con l’aiuto dei report di copertura.
- Test black-box. L’unità viene testata solo attraverso la sua interfaccia pubblica e rispetto alla sua specifica, senza basarsi sui dettagli interni.
- Test gray-box. Il tester conosce alcuni aspetti interni, come il modello dei dati, e li usa per progettare test a livello di interfaccia.
- Partizionamento in classi di equivalenza. Gli input si raggruppano in classi che dovrebbero comportarsi allo stesso modo e si testa un valore per ciascuna classe.
- Analisi dei valori limite. I test mirano ai bordi di ogni intervallo, come 0, 100 e 101 per una percentuale, dove si annidano gli errori off-by-one.
- Test parametrizzati. Il corpo di un solo test gira su una tabella di input e output attesi, così i casi limite restano compatti.
- Property-based testing. Strumenti come Hypothesis per Python e fast-check per JavaScript generano centinaia di input casuali e verificano che una proprietà, come «uno sconto non aumenta mai il prezzo», valga sempre.
Unit testing manuale o automatizzato
Nel 2026 lo unit testing è quasi interamente automatizzato. Scorrere una funzione passo dopo passo in un debugger o stampare valori in console può confermare un singolo caso, ma non lascia alcun controllo riutilizzabile e non regge oltre una manciata di funzioni.
- Ripetibilità. Un test automatico gira in modo identico migliaia di volte; un controllo manuale dipende da chi lo esegue e da quanta attenzione ci mette.
- Velocità. Una suite di diverse migliaia di test unitari si chiude di solito in un tempo che va da qualche secondo a pochi minuti nella CI.
- Protezione dalle regressioni. I test automatici continuano a sorvegliare il vecchio comportamento a lungo dopo che lo sviluppatore originale è passato ad altro.
- Evidenza. Log della CI e report di copertura danno a manager e auditor la prova che i controlli sono stati davvero eseguiti.
- Dove il manuale aiuta ancora. Il debug esplorativo è utile per capire un fallimento, ma ciò che si scopre dovrebbe concludersi con un nuovo test automatico.
Che cosa rende buono un test unitario? I principi FIRST
Un buon test unitario è rapido, indipendente, ripetibile, autovalidante e tempestivo: sono le cinque qualità racchiuse nell’acronimo FIRST, reso popolare da Tim Ottinger e Jeff Langr. I test che violano questi principi diventano lenti, instabili o ignorati.
| Principio | Significato | Segnale quando viene violato |
|---|---|---|
| Fast (rapido) | Gira in millisecondi, così l’intera suite gira a ogni modifica | Gli sviluppatori saltano i test in locale perché «ci mettono troppo» |
| Independent (indipendente) | Non dipende da altri test né dal loro ordine | I test passano da soli ma falliscono se eseguiti insieme |
| Repeatable (ripetibile) | Dà lo stesso risultato su qualsiasi macchina, in qualsiasi momento | Fallimenti il lunedì, a mezzanotte o solo nella CI |
| Self-validating (autovalidante) | Riporta superato o fallito senza interpretazione umana | Qualcuno deve leggere l’output dei log per decidere |
| Timely (tempestivo) | Scritto insieme al codice, non mesi dopo | Grandi moduli non testati che nessuno osa toccare |
Alcune altre abitudini separano i test utili dal rumore. Testare un comportamento per test e dargli un nome descrittivo, come should_reject_negative_percent, così che un fallimento si spieghi da solo. Tenere la logica fuori dai test: cicli e condizioni dentro un test possono nascondere bug propri. Controllare ogni fonte di non determinismo, compresi orologio, numeri casuali, fusi orari e chiamate di rete. Infine, trattare come difetti i test instabili, quelli che passano e falliscono senza modifiche al codice: metterli in quarantena, correggerne la causa e monitorarne il tasso, perché una suite di cui le persone non si fidano smette di essere eseguita.
Queste abitudini si sovrappongono alle più ampie best practice dello sviluppo software, come commit piccoli, code review e nomi chiari.
Quanta copertura del codice serve?
La copertura del codice misura quali righe o rami sono stati eseguiti durante i test, non se i loro risultati sono stati verificati, quindi non esiste un obiettivo universale che garantisca la qualità. Un riferimento utile viene dalla linea guida del blog sui test di Google («Code Coverage Best Practices», 2020), che descrive il 60% come accettabile, il 75% come lodevole e il 90% come esemplare.
La stessa linea guida sottolinea che la copertura del codice modificato in ogni commit conta più di una percentuale sull’intero progetto. Un sistema legacy al 45% complessivo può comunque migliorare, se ogni nuova pull request arriva con l’85% di copertura sulle righe modificate. La logica critica per il business, come prezzi, fatturazione, permessi e calcoli, merita una copertura dei rami quasi totale, mentre il semplice codice di raccordo ne richiede molta meno.
| Tipo di copertura | Che cosa misura | Note |
|---|---|---|
| Riga / istruzione | Quota di righe o istruzioni eseguite | La più facile da raccogliere; può sembrare alta anche quando mancano interi rami |
| Rami (branch) | Quota degli esiti di if/else e switch percorsi | Segnale migliore per il codice ricco di logica |
| Condizione | Se ogni sottocondizione booleana è stata vera e falsa | Intercetta condizioni complesse che la copertura dei rami non vede |
| MC/DC | Che ogni condizione influenzi in modo indipendente la decisione | Richiesta per il software avionico più critico |
| Mutation score | Quota dei bug iniettati che i test rilevano | Mostra se le asserzioni sono reali, non solo se il codice è stato eseguito |
Il mutation testing è la verifica onesta della copertura. Strumenti come PIT per Java, Stryker per JavaScript, TypeScript e C# e mutmut per Python apportano piccole modifiche al codice, come trasformare > in >=, e rieseguono i test. Se i test passano ancora, il «mutante» è sopravvissuto e le asserzioni sono troppo deboli. Una suite con il 90% di copertura delle righe e un mutation score basso sta soprattutto eseguendo il codice, non testandolo.
I framework di unit testing più diffusi per linguaggio (2026)
Ogni linguaggio diffuso ha un framework di unit testing maturo, di solito abbinato a una libreria di mocking, e la scelta dipende soprattutto dal linguaggio e dallo stack già in uso nel team. La tabella elenca le scelte predefinite più comuni nel 2026.
| Linguaggio | Framework | Libreria di mocking | Note |
|---|---|---|---|
| Java / Kotlin | JUnit 5 | Mockito, MockK (Kotlin) | Standard de facto sulla JVM; AssertJ per asserzioni leggibili |
| Python | pytest, unittest | unittest.mock, pytest-mock | pytest domina i nuovi progetti; unittest è incluso in Python |
| JavaScript / TypeScript | Jest, Vitest | Mock integrati | Vitest è diffuso nei frontend basati su Vite; stesso stile di API di Jest |
| C# / .NET | xUnit.net, NUnit, MSTest | Moq, NSubstitute | xUnit.net è la scelta predefinita più comune per il nuovo codice .NET |
| Go | testing integrato | testify, gomock | I test guidati da tabelle sono idiomatici in Go |
| Swift | XCTest, Swift Testing | Fake basati su protocolli | Swift Testing è il framework più recente di Apple, basato su macro |
| C / C++ | GoogleTest, Catch2 | GoogleMock | Diffusi nel codice embedded e critico per le prestazioni |
| PHP | PHPUnit, Pest | Mockery, mock integrati | Pest aggiunge una sintassi più leggera sopra PHPUnit |
| Ruby | RSpec, Minitest | rspec-mocks | Minitest è incluso in Ruby e Rails |
Raramente è il framework a decidere se lo unit testing ha successo. Lo decidono le abitudini del team: se i test girano su ogni pull request, se i fallimenti bloccano i merge e se le persone si fidano dei risultati.
Vantaggi e limiti dello unit testing
Lo unit testing offre un feedback rapido ed economico e modifiche più sicure, ma non può dimostrare che un intero sistema funzioni, e una suite progettata male può creare una falsa sicurezza. Conoscere entrambi i lati aiuta i team a investire la giusta quantità di unit testing.
| Vantaggi | Limiti |
|---|---|
| Trova i difetti nel momento in cui vengono introdotti | Non intercetta problemi di integrazione, di configurazione o di interfaccia utente |
| Rende sicuri refactoring e aggiornamenti | Richiede manutenzione continua man mano che il codice cambia |
| Documenta il comportamento in forma eseguibile | Asserzioni superficiali danno una falsa sicurezza |
| Velocizza il debug individuando l’unità che fallisce | I test con troppi mock si rompono con refactoring innocui |
| Spinge il codice verso un design modulare e poco accoppiato | Il codice legacy senza punti di separazione è inizialmente difficile da testare |
| Fornisce il feedback più economico della pipeline CI | Non può verificare che i requisiti stessi siano corretti |
Che cosa non conviene sottoporre a unit testing?
Non conviene spendere test unitari su codice privo di logica propria o che si verifica meglio a un altro livello. Testare tutto allo stesso modo spreca tempo e produce test fragili che rallentano il team.
- Getter e setter banali che si limitano a memorizzare e restituire un valore.
- Codice di framework e librerie che non avete scritto voi; gli autori del framework lo testano già.
- Codice generato, come modelli ORM o client API prodotti da un generatore.
- File di pura configurazione e costanti, che si verificano meglio con la validazione dello schema.
- Query al database e contratti HTTP, che per essere significativi richiedono un database reale o contract test a livello di integrazione.
- Dettagli minori del layout dell’interfaccia che cambiano spesso e sono coperti meglio da controlli visivi o end-to-end.
Il codice legacy è un caso particolare. Prima di modificare codice vecchio privo di test, conviene scrivere test di caratterizzazione: test che registrano ciò che il codice fa oggi, giusto o sbagliato che sia. Creano una rete di sicurezza, dopo la quale si può rifattorizzare verso unità testabili e sostituire i test di caratterizzazione con veri test di comportamento.
Unit testing e TDD: lo unit testing è la stessa cosa del test-driven development?
No. Lo unit testing è un tipo di test, mentre il test-driven development è un flusso di lavoro che scrive il test unitario prima del codice di produzione e lascia che sia il test a guidare il design. La maggior parte dei team scrive i test unitari dopo il codice o insieme a esso senza praticare un TDD rigoroso, e ottiene comunque una suite affidabile. Il TDD è un modo disciplinato per assicurarsi che i test siano tempestivi e che ogni test sia stato visto fallire. La nostra guida al TDD nello sviluppo software descrive questo flusso di lavoro, i suoi costi e i casi in cui ripaga.
Come stanno cambiando lo unit testing gli assistenti di programmazione basati sull’IA nel 2026?
Gli assistenti di programmazione basati sull’IA possono generare test unitari in pochi secondi, il che rende economico aumentare la copertura, ma i test generati verificano spesso ciò che il codice fa oggi invece di ciò che dovrebbe fare. Nel 2026 il lavoro passa dallo scrivere i test al rivederli, con il mutation testing come verifica oggettiva.
L’adozione è già ampia. Nello Stack Overflow Developer Survey 2025, l’84% dei partecipanti ha dichiarato di usare o di voler usare strumenti di IA nel proprio processo di sviluppo, contro il 76% del 2024. Nello stesso tempo la fiducia cala: il 46% ha dichiarato di non fidarsi dell’accuratezza dei risultati dell’IA, contro il 31% di un anno prima, e il 66% ha indicato le «soluzioni di IA quasi giuste, ma non del tutto» come la frustrazione principale. I partecipanti hanno inoltre indicato il testing tra gli ambiti in cui pensano di usare di più l’IA.
«Quasi giusto» è proprio il rischio dei test generati. Se il codice contiene un bug, un test generato a partire da quel codice lo blinderà senza esitazioni. I team che usano l’IA per lo unit testing in modo produttivo seguono alcune regole:
- Rivedere ogni asserzione generata rispetto al requisito, non rispetto all’output attuale.
- Preferire il comportamento all’implementazione. Respingere i test che verificano sequenze di chiamate interne senza una ragione di business.
- Eseguire mutation test sulle suite scritte dall’IA per dimostrare che i test falliscono quando il codice è rotto.
- Non lasciare mai che un agente sistemi un test rosso modificando l’asserzione. Un test che fallisce significa che il codice o il requisito richiedono una decisione umana.
- Tenere i test generati nel diff della pull request, così che i revisori li vedano e li approvino come qualsiasi altro codice.
I prodotti che includono funzionalità di IA richiedono un ulteriore livello di controlli oltre ai test unitari, perché l’output del modello non è deterministico. È l’ambito del testing dei prodotti di IA, che valuta risposte, sicurezza e regressioni nel comportamento dell’IA.
Lo unit testing nel software regolamentato
Nei settori regolamentati lo unit testing non è solo una buona pratica, ma un’evidenza documentata che auditor ed enti di certificazione si aspettano di vedere. Le regole cambiano a seconda del dominio, ma tutte chiedono la prova che le unità siano state verificate e che la verifica sia stata pianificata.
- Dispositivi medici. La IEC 62304 richiede la verifica delle unità software per il software delle classi di sicurezza B e C, con criteri di accettazione definiti in anticipo.
- Avionica. La DO-178C richiede la modified condition/decision coverage (MC/DC) per il software più critico di livello A, oltre alla copertura delle istruzioni e delle decisioni.
- Pagamenti e SaaS. Gli auditor PCI DSS e SOC 2 cercano evidenze di test automatici e di una gestione controllata delle modifiche nella pipeline di delivery.
In questi contesti i risultati dei test, i report di copertura e la tracciabilità dai requisiti ai test entrano a far parte della documentazione di rilascio. Il nostro articolo sullo sviluppo di software per dispositivi medici spiega come questa documentazione si inserisce in un processo di rilascio regolamentato.
Come valutare i test unitari di un team di sviluppo: una checklist per chi acquista
È possibile giudicare lo unit testing di un team di sviluppo senza leggere il codice, ponendo alcune domande dirette. Risposte chiare e specifiche sono un buon segno; risposte vaghe su una «copertura elevata» non lo sono.
- I test unitari girano in automatico su ogni pull request, e un fallimento blocca il merge?
- Qual è la copertura del codice modificato nelle pull request recenti, e non solo il dato sull’intero progetto?
- Esiste una policy sui test instabili, con un tasso monitorato e una scadenza per correggere i test in quarantena?
- Misurate un mutation score sui moduli critici, e quanto vale?
- Qual è la vostra policy sui test double, e che cosa sostituite con mock invece di testarlo con oggetti reali o fake?
- Quanto tempo impiega la suite di test unitari? L’obiettivo sono minuti, non ore.
- Chi rivede i test generati dall’IA, e come verificate che controllino il comportamento giusto?
Se le risposte sono deboli, o se ha ereditato una codebase di cui nessuno può garantire la qualità, un audit QA indipendente può misurare copertura, mutation score e tasso di test instabili e trasformare i risultati in un piano concreto per la piramide dei test.
Domande frequenti
Cos’è lo unit testing nello sviluppo software?
Lo unit testing nello sviluppo software è la pratica di verificare le più piccole porzioni di codice testabili, come una funzione, un metodo o una classe, isolandole da database, reti e altri moduli. Gli sviluppatori scrivono test unitari automatici che chiamano l’unità con un input noto e verificano il risultato atteso. I test girano in millisecondi a ogni modifica e costituiscono il primo e più rapido livello di test del software.
Cosa sono i test unitari nello sviluppo software, con un esempio?
I test unitari sono piccoli programmi automatici che verificano un singolo comportamento di una singola unità di codice. Per esempio, un test per la funzione apply_discount(price, percent) può chiamare apply_discount(200, 25) e verificare che il risultato sia 150, mentre un secondo test può verificare che una percentuale di 120 sollevi un errore. Ogni test segue lo schema Arrange, Act, Assert e gira senza database né rete.
Chi scrive i test unitari: sviluppatori o QA engineer?
I test unitari li scrivono gli sviluppatori, di solito nella stessa pull request del codice che testano, perché richiedono la conoscenza della struttura interna del codice. I QA engineer li scrivono raramente, ma definiscono la strategia di test complessiva, controllano la copertura delle aree a rischio, costruiscono le suite di integrazione ed end-to-end e affiancano gli sviluppatori nella progettazione dei test e nei casi limite.
Qual è la differenza tra unit testing e integration testing?
Lo unit testing verifica una singola unità di codice in isolamento, con le dipendenze sostituite da test double, quindi i test sono rapidi e indicano esattamente la riga difettosa. L’integration testing verifica che più unità o componenti reali, come un servizio e il suo database o un’API esterna, funzionino correttamente insieme. I test unitari intercettano gli errori logici, quelli di integrazione gli errori di collegamento, configurazione e contratto.
Quanta copertura dei test unitari è sufficiente?
Non esiste un numero universale, perché la copertura mostra quale codice è stato eseguito, non se è stato verificato. La linea guida del blog sui test di Google considera il 60 percento accettabile, il 75 percento lodevole e il 90 percento esemplare, e dà più peso alla copertura del codice modificato in ogni commit che a un dato sull’intero progetto. La logica di business critica merita una copertura dei rami quasi totale, mentre il codice banale ne richiede poca.
Lo unit testing è la stessa cosa del TDD?
No. Lo unit testing è un tipo di test, mentre il test-driven development (TDD) è un flusso di lavoro che stabilisce quando scrivere il test. Nel TDD lo sviluppatore scrive prima un test unitario che fallisce e poi il codice che lo fa passare. La maggior parte dei team scrive test unitari senza praticare un TDD rigoroso, ed entrambi gli approcci possono produrre una suite di test unitari affidabile.
L’IA può scrivere i test unitari per il mio codice?
Sì, gli assistenti di programmazione basati sull’IA generano test unitari in fretta, e il testing è uno degli ambiti in cui gli sviluppatori pensano di usare di più l’IA. Il rischio è che i test generati verifichino spesso ciò che il codice fa oggi invece di ciò che dovrebbe fare. Uno sviluppatore deve rivedere ogni asserzione, e il mutation testing deve confermare che i test falliscono davvero quando il codice è rotto.
Fonti
- NIST, Planning Report 02-3: The Economic Impacts of Inadequate Infrastructure for Software Testing (2002)
- CISQ, Cost of Poor Software Quality in the US: A 2022 Report
- Google Testing Blog, Just Say No to More End-to-End Tests (Mike Wacker, 22 aprile 2015)
- Google Testing Blog, Code Coverage Best Practices (7 agosto 2020)
- Stack Overflow, 2025 Developer Survey: AI; comunicato stampa