Cos'è il test unitario?
Il primo passo è capire cosa test unitario significa. Test unitario si riferisce al processo di test di unità o moduli di codice di piccole dimensioni per garantire che ciascuno di essi funzioni come previsto. Test unitario viene utilizzato per rimuovere i problemi dal codice, migliorare la stabilità del codice e garantire la correttezza durante l'aggiornamento del codice. La fase iniziale del test del software è il prova unitaria , seguito dal test dell'interfaccia utente e dal test di integrazione.
Il pacchetto di prova
a Golang, test unitario viene eseguito utilizzando un pacchetto chiamato test . Il pacchetto fornisce varie funzioni che ci permettono di testare il nostro codice. Il codice Go può essere testato automaticamente con l'aiuto del pacchetto testing.
Programma di esempio da testare
Abbiamo bisogno di un codice da analizzare per i nostri test prima di poterne scrivere uno qualsiasi test unitari . Creeremo un piccolo programma che aggiunge due numeri.
pacchetto principale
importare (
'fmt'
)
funcAdd ( UN int , B int ) int {
ritorno UN + B
}
funzione principale ( ) {
fmt. Stampaln ( Aggiungere ( 2 , 3 ) )
}
Il codice di cui sopra definisce il Aggiungere() funzione, che somma due numeri, UN E B , come input e output il risultato come numero intero. L'aggiunta dei numeri 2 e 3 è tutto ciò che fa la funzione principale prima di stampare il risultato.
Convenzione di test unitari di scrittura in movimento
Ogni progetto Go dovrebbe avere un file di test separato che contiene tutti i test per quel progetto. Il file dovrebbe avere lo stesso nome del file in fase di test e dovrebbe avere _test.vai aggiunto alla fine del nome del file. Ad esempio, se vogliamo testare un file denominato calcolatrice.go , dovremmo nominare il nostro file di test calcolatrice_test.go .
È una pratica standard per Vai a testare i file trovarsi nello stesso pacchetto o directory del codice che stanno valutando. Quando usi il comando go build, il compilatore non crea questi file, quindi non devi preoccuparti che vengano visualizzati nelle distribuzioni.
Per scrivere un prova unitaria in Go, dobbiamo usare il test pacchetto. Possiamo iniziare ogni funzione di test con la parola Test e quindi aggiungere una descrizione di ciò che vogliamo testare. Per esempio, TestAggiunta O TestSottrazione . Possiamo quindi scrivere il codice di test che controlla se la funzione che stiamo testando restituisce i risultati attesi.
In Go, ogni funzione di test dovrebbe iniziare con l'istruzione t := test.T{}. Questa affermazione crea un nuovo test oggetto che possiamo utilizzare per verificare se il test è stato superato o meno. Possiamo quindi utilizzare il t.Errorf() funzione per stampare un messaggio di errore se il test fallisce.
Come scrivere il codice di test?
Quando si tratta di scrivere unit test in Go, è importante iniziare specificando il pacchetto che si desidera testare. Dopo aver importato il pacchetto di test, puoi accedere a vari tipi e metodi che il pacchetto esporta, incluso il file test.T tipo. La stessa logica di test viene quindi scritta in una funzione che inizia con la parola chiave 'Test' seguito da un nome descrittivo, ad esempio ProvaAggiungi() . All'interno di questa funzione è possibile includere il codice per il test e qualsiasi asserzione necessaria per verificare il comportamento previsto.
Riassumendo, le caratteristiche di un test in Go sono le seguenti:
- L'unico e unico parametro richiesto è t *test.T
- La funzione di test inizia con la parola Test ed è quindi seguita da una parola o frase che inizia con una lettera maiuscola.
- Per indicare un errore, la funzione di test dovrebbe chiamare entrambi t.Error O t.Fail, e per fornire ulteriori informazioni di debug senza causare un errore, è possibile utilizzare t.Log.
- Per fornire informazioni di debug non in errore, utilizzare t.Log.
- I test sono memorizzati in file con il nome foo_test.go , Per esempio, math_test.go .
Chiudi il file dopo averlo salvato.
pacchetto principaleimportare (
'test'
)
funcTestAdd ( T * test. T ) {
risultato := Aggiungere ( 2 , 3 )
Se risultato != 5 {
T. Errore f ( 'Aggiungi(2, 3) = %d; vuoi 5' , risultato )
}
}
IL Aggiungere() funzione è testata dal ProvaAggiungi() funzione, definita in questo test. Utilizza i numeri 2 e 3 per chiamare Add, quindi conferma che il risultato è 5. Viene stampato un messaggio di errore se il risultato è inferiore a 5 quando t.Errorf() viene invocato.
Infine, è importante sapere che Go ha uno strumento di test integrato chiamato vai alla prova. Questo strumento esegue tutti i test del progetto e fornisce un report dei risultati. Vai alla prova deve essere digitato nel terminale mentre si è nella directory del progetto per avviare i test. Tutti i test in quella directory verranno eseguiti come risultato.
< forte > vai alla prova < test - file - nome > _test. andare forte > 
Risultati del test unitario
L'output mostrerà le funzioni di test che sono state superate, fallite o saltate.
PASSA o OK denota che il codice funziona come previsto. Riceverai FALLIRE se un test fallisce.
IL _test.vai suffix è l'unico che il sottocomando go test verifica nei file. Successivamente, go test cerca in quei file eventuali funzioni speciali, come func TestXxx e molti altri. Vai a testare compila e chiama correttamente queste funzioni, le esegue, raccoglie e riporta i risultati e infine ripulisce tutto in un pacchetto principale temporaneo.
L'ultimo passaggio consiste nell'integrare i test nel flusso di lavoro di sviluppo. La best practice consiste nell'eseguire i test ogni volta che si esegue il commit del codice in un repository. L'integrazione dei test nel flusso di lavoro di sviluppo garantisce che il codice venga continuamente testato e che eventuali problemi vengano risolti prima della distribuzione.
Conclusione
Scrivere test unitari è un componente cruciale dello sviluppo del software perché garantisce che il tuo codice sia scalabile, funzionale ed efficace. La libreria di test Go è facile e semplice da usare. Dovresti essere in grado di creare Golang test unitari della massima qualità seguendo le procedure sopra elencate. Ricorda di integrare i tuoi test nel tuo flusso di lavoro di sviluppo per garantire che il tuo codice venga continuamente testato e che eventuali problemi vengano risolti prima della distribuzione.