Test unitari, di integrazione e end-to-end: dove l'IA aiuta di più
By Mirko Peters · · Updated
Test unitari, di integrazione ed end-to-end: cosa verifica ciascuno, quanti scriverne e dove l'IA aiuta di più, dalla bozza dei test unitari alla revisione dei flussi nel browser.
Automatically translated with AI from the original post. Read the English original
Test unitari, di integrazione ed end-to-end: la domanda alla base di ogni strategia di test del software. Ogni livello verifica una cosa diversa, costa una cifra diversa e offre un tipo diverso di sicurezza. Questa guida è pensata per i QA lead a cui viene chiesto dove debba inserirsi l'IA nei test del software. Vedrai cosa verifica ciascun livello, quanti test di ogni tipo contiene una suite sana, dove l'IA aiuta di più e dove aggiunge rischio. Un esempio svolto, con numeri inventati, mostra come un team ha deciso dove concentrare i propri sforzi.
Punti chiave
- Un test unitario verifica un singolo pezzo di codice, un test di integrazione verifica il collegamento con qualcosa che sta fuori dall'applicazione e un test end-to-end esercita il sistema distribuito attraverso la sua interfaccia.
- La piramide dei test suggerisce di scrivere molti test unitari piccoli e rapidi, alcuni test a granularità più ampia e pochissimi test di alto livello, perché i livelli superiori sono più lenti e richiedono più manutenzione.
- L'IA è più utile dove il risultato è piccolo e facile da verificare, come nella bozza di test unitari e di API, e dove una persona può rivedere ogni test generato.
- I test generati dall'IA possono gonfiare la copertura senza validare il comportamento, ad esempio test che eseguono il codice ma con asserzioni deboli o assenti.
- Tratta l'output dell'IA come una bozza a ogni livello e riserva il giudizio umano ai flussi ambigui, ai controlli visivi e alle verifiche di accessibilità.
Test unitari, di integrazione ed end-to-end: cosa verifica ciascuno
L'articolo di Martin Fowler The Practical Test Pyramid offre definizioni chiare.
- I test unitari assicurano che una certa unità della tua codebase, il soggetto del test, funzioni come previsto. Hanno l'ambito più ristretto di qualsiasi tipo di test. Questo è il livello di test unitario che gli sviluppatori scrivono più spesso.
- I test di integrazione verificano l'integrazione della tua applicazione con le parti che si trovano al suo esterno, come un database, un file system o un servizio separato. Fowler preferisce quelli ristretti, che verificano un solo punto di integrazione esterno alla volta. È il compito dei test di integrazione.
- I test end-to-end verificano l'applicazione distribuita attraverso la sua interfaccia utente e coprono l'intero sistema integrato. Fowler li chiama test di stack ampio. Questo è il test end-to-end.
La differenza principale tra test unitari e test di integrazione è l'ambito: una parte del codice contro il collegamento tra parti. I test funzionali e i test di sistema verificano anch'essi il software dall'esterno, e l'e2e è la forma guidata dal browser, quindi mettiamoci d'accordo sui termini.
Gli sviluppatori di solito scrivono test unitari ed eseguono i test unitari a ogni commit. Ricorda la differenza in base alla domanda a cui risponde ciascun livello: un test unitario chiede se questa funzione è corretta. Un test di integrazione chiede se comunichiamo correttamente con quest'altro sistema. Un test end-to-end chiede se un utente riesce a completare questo percorso.
Quanti test di ciascun tipo: la piramide dei test
La piramide dei test è il modo più comune per descrivere questo equilibrio. Il consiglio di Fowler è scrivere molti unit test piccoli e veloci, alcuni test a granularità più grossa e pochissimi test di alto livello. Lo enuncia come una regola: più alto è il livello, meno test dovresti avere.
Il motivo è il costo. Secondo l'articolo, lo unit testing viene eseguito molto rapidamente, l'integration testing tende a essere molto più lento perché coinvolge parti esterne reali, e l'end-to-end testing gira piuttosto lentamente. L'end-to-end testing richiede inoltre molta manutenzione ed è notoriamente instabile.
Questa instabilità è misurabile su larga scala. Un post del Google Testing Blog, Flaky Tests at Google and How We Mitigate Them, riferisce che circa l'1,5 per cento delle esecuzioni dei test ha dato un risultato instabile e quasi il 16 per cento dei test presentava una qualche instabilità.
Tutti e tre i livelli contribuiscono al regression testing, perché vengono rieseguiti dopo ogni modifica.
Fowler mette in guardia anche contro la forma opposta, che chiama test ice-cream cone: molti test manuali e a livello di browser in cima, pochi unit test alla base. La descrive come un incubo da mantenere che richiede un tempo di esecuzione eccessivo. Se la tua suite ha questa forma, aggiungere l'AI non ne correggerà la struttura. Potrebbe solo produrre più test lenti, più in fretta.
Unit testing e integration testing: quando usare ciascun livello
Il confronto di TestRail tra unit e integration testing elenca differenze pratiche. Gli unit test sono rapidi da implementare e veloci da eseguire, e di solito sono gestiti dagli sviluppatori. L'integration testing coinvolge spesso ingegneri QA e tester. Gli unit test usano mock e stub per evitare sistemi esterni, mentre l'integration testing si concentra sulle interazioni reali, ma può comunque ricorrere ai mock quando un servizio esterno non è disponibile, non è affidabile o è costoso.
I vantaggi dello unit testing sono il feedback rapido, il rilevamento precoce dei bug e un codice più modulare. Il suo punto debole è che una suite di unit test non mostra se le parti funzionano insieme, ed è proprio ciò che aggiunge l'integration testing. TestRail suggerisce di usare gli unit test per la logica isolata nelle fasi iniziali dello sviluppo, e i test di integrazione per i flussi di lavoro che attraversano moduli, database o servizi di terze parti. Descrive due modi per eseguire questi ultimi: Big Bang, che testa tutto insieme dopo lo sviluppo ed è più difficile da debuggare, e incrementale, che testa piccoli gruppi passo dopo passo e rende più facile individuare i problemi.
Fowler offre una regola per decidere il livello: se un test di livello superiore individua un errore e nessun test di livello inferiore fallisce, scrivi un test di livello inferiore. Spingi i test il più in basso possibile nella piramide e rimuovi i test di alto livello che duplicano ciò che i livelli inferiori già coprono. Una strategia di test completa utilizza tutti e tre i livelli, con ciascun livello superiore concentrato su ciò che quelli inferiori non possono coprire.
Ci sono due domande correlate che ricorrono spesso. Fowler osserva che alcuni chiamano il livello intermedio integration test e altri component test, e che mettersi d'accordo sui termini conta più del nome. Afferma inoltre che gli acceptance test, che verificano il software dal punto di vista dell'utente, possono collocarsi a qualsiasi livello, quindi sono ortogonali alla piramide. Lo unit testing e l'end-to-end testing sono perciò le due estremità di un'unica scala, non scuole rivali.
Questi test sono facili da automatizzare in una pipeline. TestRail afferma che gli unit test di solito vengono eseguiti per primi, spesso subito dopo un push o una pull request, mentre i test di integrazione girano più tardi, una volta che l'app è stata distribuita in un ambiente di staging o di test. Insieme formano un quality gate.
Dove l'AI aiuta di più
Gli strumenti basati sull'AI generativa differiscono tra loro, ma nelle indicazioni dei fornitori emerge un modello. L'articolo di Parasoft su come l'AI viene usata nel software testing consiglia ai team di generare unit test e test API mentre le modifiche sono ancora fresche, e menziona l'aiuto dell'AI nella creazione di test API, nel suggerire asserzioni e nel costruire scenari di dati. Osserva inoltre che la service virtualization, che simula dipendenze lente, costose o non disponibili, supporta l'integration testing.
Questo si adatta alla piramide. Le ragioni sono una nostra deduzione, non una misurazione:
- Un output piccolo è facile da revisionare. Uno unit test generato è composto da poche righe. Chi revisiona può leggerlo, eseguirlo e decidere in un minuto se controlla la cosa giusta.
- Un feedback rapido fa emergere i test sbagliati. Uno unit test errato fallisce o passa subito, quindi il problema emerge lo stesso giorno.
- Input e output chiari. Funzioni e chiamate API hanno input e output definiti, quindi uno strumento ha un obiettivo preciso.
- Molti casi ripetitivi. Valori limite e percorsi di errore sono ripetitivi nello unit testing, e una bozza fa risparmiare tempo di scrittura.
Lascia che sia l'AI a preparare la bozza, ma la responsabilità resta a una persona: chi accetta un test generato risponde di ciò che verifica, esattamente come per un test scritto a mano.
Per l'integration testing, l'AI può preparare un caso di test o dati di test e simulare le dipendenze, ma una persona deve decidere quale sia il contratto con l'altro sistema, perché l'integration testing verifica proprio quel contratto.
A livello di end-to-end testing, l'AI aiuta in modo diverso. Gli strumenti che eseguono passaggi descritti in linguaggio naturale in un browser possono ridurre il costo di scrittura di un test di percorso utente. Non cambiano però il costo della sua esecuzione e non eliminano la necessità di una regola chiara di superamento o fallimento.
Dove l'AI aiuta meno, e a cosa fare attenzione
L'articolo di Parasoft è diretto sui limiti. Raccomanda di mantenere la revisione umana su ogni modifica generata dall'AI e di trattare l'output dell'AI come una bozza. Avverte che, se usata male, l'AI può far crescere la copertura senza validare il comportamento, e mette in guardia dai test vuoti che eseguono percorsi di codice ma hanno asserzioni deboli o assenti. Tra i segnali d'allarme cita gli output che cambiano tra un'esecuzione e l'altra con gli stessi input. Aggiunge che l'AI non può approvare modifiche critiche per la sicurezza né sostituire il giudizio umano nei flussi ambigui, nei controlli visivi e nelle verifiche di accessibilità. Per i dati, mette in guardia dai prompt che contengono segreti o dati regolamentati.
Le strategie di test che usano l'AI richiedono quattro verifiche:
- Copertura che cresce ma non intercetta nulla. Controlla le asserzioni, non solo i valori di copertura.
- Test che replicano il codice. Un test che ripete l'implementazione supererà la prova anche quando la logica è sbagliata.
- Output instabile. Se un test generato cambia tra un'esecuzione e l'altra, blocca la versione che hai revisionato.
- Dati che escono dall'azienda. Non incollare segreti, dati dei clienti o dati regolamentati in un prompt.
Esempio: dove un team concentra il proprio impegno
I numeri sono inventati.
Un team ha 600 test automatizzati: 450 unit test, 110 integration test e 40 end-to-end test. I test sul browser occupano 50 minuti di una pipeline da 60, e ogni settimana sei di essi falliscono in modo casuale.
Il QA lead prende tre decisioni. Primo, un assistente AI prepara unit test per il nuovo codice, e uno sviluppatore revisiona ogni bozza. Nel primo mese l'assistente prepara 120 test. I revisori ne scartano 30 perché le asserzioni sono deboli, quindi 90 entrano nella suite.
Secondo, l'AI prepara i dati di test per gli integration test, mentre i contratti restano scritti a mano.
Terzo, i 40 end-to-end test non ricevono alcun aiuto dall'AI. Il lead elimina sei duplicati che un test di livello inferiore, più veloce, già copre, e la pipeline scende da 60 a 48 minuti. Lo sforzo sull'AI è andato dove la revisione costa meno, e il livello lento si è ridotto.
Errori comuni
- Usare l'AI per aggiungere altri test sul browser. Il livello lento e instabile cresce, e la pipeline rallenta.
- Accettare test generati senza leggerli. Asserzioni deboli danno copertura senza sicurezza.
- Misurare il successo dal numero di test. Conta invece i difetti intercettati e i minuti risparmiati.
- Saltare l'integration testing. Unit test più qualche percorso utente possono non individuare contratti rotti tra sistemi.
- Incollare dati sensibili nei prompt. Definisci un criterio prima del primo prompt.
Come può aiutare il software
I tuoi framework di test e il sistema di CI registrano già tempi di esecuzione e tassi di fallimento. Parti da lì e raggruppa i numeri per livello. Gli strumenti di code review aiutano con le bozze dell'AI, perché i revisori vedono il test generato accanto al codice. Affianca gli strumenti di copertura a un controllo delle asserzioni, così la copertura non viene scambiata per qualità. Aggiungi un assistente AI a un solo livello di test del software e confronta tempi di revisione, bozze scartate e difetti sfuggiti prima di estendere il pilota.
Prossimo passo
Conta i test a ogni livello, annota il tempo di esecuzione e il tasso di instabilità di ciascuno. Poi scegli un livello per il pilota con l'AI e scrivi cosa misurerai, così il prossimo confronto tra unit, integration ed end-to-end test partirà dai dati.