Golang afferma

Ci sono tre componenti principali nel ciclo di vita di uno sviluppatore: codice di scrittura, codice di prova, correggi il codice, ripeti. Sebbene sia un'estrema semplificazione eccessiva, illustra un concetto che tutti gli sviluppatori incontrano.

In questo articolo, ci concentreremo su una singola entità di un ciclo di vita di uno sviluppatore: test. Il codice di test è una funzionalità molto utile per qualsiasi sviluppatore. Consente di trovare e fissare i bug prima di distribuire il codice in produzione. Sebbene ci siano molti modi e funzionalità per implementare i test del codice, questo articolo si concentrerà sul pacchetto Go Assert.

Iniziare con i test

Prima di immergerci su come lavorare con il pacchetto Testy, impariamo come iniziare con GO Test.

Il primo passo è sapere cosa vuoi testare. Questa potrebbe essere una funzione semplice per una raccolta di metodi.

Facciamo un semplice programma di esempio che moltiplica il suo input per 10.

Inizia creando una directory per archiviare il tuo codice.

Test MKIDR

Naviga nella directory e crea un file GO contenente il tuo programma. Per semplicità, chiameremo questo file principale.andare

Test CD
Toccare Main.andare

Modifica il file con il tuo editor di testo e crea il tuo programma. Per seguire questo tutorial, è possibile aggiungere il codice come mostrato di seguito:

Pacchetto principale
importazione (
"FMT"
)
funcmultiply (x int) (risultato int)
risultato = x * 10
risultato di ritorno

funcmain ()
fmt.Println ("Inizio con i test")

Nel programma di esempio, abbiamo una funzione che prende un input intero e restituisce l'intero moltiplicato per 10.

Salva e chiudi il file.

Il prossimo passo è creare test per il programma sopra. Per fare ciò, dobbiamo creare un file nella stessa directory con il suffisso _test. Questo dice al modulo di test Go che questo file contiene una suite di test per il programma nella directory.

Dal momento che vogliamo creare un test per il principale.Programma GO, chiameremo il file di test come:

toccare main_test.andare

Nel file di test, possiamo creare istruzioni di test per il nostro programma.

Dal momento che vogliamo utilizzare l'uso del pacchetto Assert, dobbiamo importare i test e il pacchetto Assert.

Puoi includere le importazioni come:

pacchetto
importazione (
"Test"
"Github.com/stretchr/testfy/assert "
)

Successivamente, crea una funzione di test per testare il programma principale. Possiamo creare istruzioni di test come mostrato:

Pacchetto principale
importazione (
"Test"
"Github.com/stretchr/testfy/assert "
)
FUNCTestMultiply (T *Test.T)
affermare.Uguale (t, multiplica (10), 100)

Nel programma sopra, creiamo una funzione di test che effettua un test.T oggetto. Il framework di test consente alla funzione di scrivere non nella posizione appropriata a condizione che questo oggetto.

All'interno della funzione, utilizziamo il pacchetto Assert per verificare se la funzione restituisce un risultato pari ai parametri forniti. Se la funzione multiplica prende l'intero 10 e restituisce un valore pari a 100, quindi passa il test.

Salva il file di test ed esegui il test utilizzando il comando:

Vai a test

Il comando sopra dovrebbe prendere il file di test ed eseguire i test configurati.

Un output di esempio è come mostrato:

=== esegui TestMultiply
--- Pass: TestMultiply (0.00)
PASSAGGIO
ok linuxhint/go-assert
> Test Run è terminato al 31/01/2022, 13:38:17 <

Come noterai dall'output sopra, la funzione passa il test.

Cambiamo il valore della funzione per illustrare un'istruzione di fallimento. Ad esempio, modificare il terzo parametro della funzione di test in un valore errato. Per esempio:

FUNCTestMultiply (T *Test.T)
affermare.Uguale (t, multiplica (10), 10)

In questo esempio, stiamo dicendo al programma che se la funzione non restituisce 10, la funzione fallisce.

Nota: tieni presente che la funzione di test non è corretta.

Se eseguiamo il test, dovremmo fallire come:

=== esegui TestMultiply
Assert \ main_test.Vai: 10:
Traccia degli errori:
Errore: non uguale:
Previsto: 100
reale: 10
Test: TestMultiply
--- Fail: TestMultiply (0.00)
FALLIRE
Fail Linuxhint/Go-Assert 0.040s
> Test Run è terminato al 31/01/2022, 13:40:59 <

L'output sopra illustra un test non riuscito.

Golang afferma

Ora che abbiamo le basi dei test fuori mano, ci spostiamo sul pacchetto Assert. Nel nostro esempio precedente, abbiamo usato il metodo uguale per verificare se la funzione restituisce il valore previsto. Tuttavia, il pacchetto Assert fornisce una pletora di strumenti e metodi di test per semplificare il test del codice.

Esploriamo alcuni altri esempi per illustrare la funzionalità del pacchetto Assert.

Golang Test Inequality

Possiamo utilizzare il pacchetto Assert per verificare la disuguaglianza utilizzando il metodo NoteQual (). La sintassi della funzione è come mostrata:

Func NoteQual (T Testingt, previsto, interfaccia effettiva , msgandargs… interfaccia ) bool

La funzione prende una T.Oggetto di prova, il valore previsto e il valore effettivo e un messaggio di stampa. Controlla se il valore previsto e effettivo non è uguale. Se vero, il test passa, altrimenti, fallisci.

Un esempio è come mostrato:

FUNCTESTNoteQuel (T *Test.T)
affermare.NoteQual (t, 100, 10, "i valori non dovrebbero essere uguali")

Il codice sopra controlla se i valori non sono uguali. Un output di esempio è come mostrato:

=== esegui TestNotequal
--- Pass: TestNotequal (0.00)
PASSAGGIO
ok linuxhint/go-assert 0.037s

Golang Test HTTP Codice di stato

Possiamo utilizzare il metodo HTTPSTATICUDE () per verificare se un gestore restituisce il codice di stato specificato.

Supponiamo che abbiamo un server HTTP, che se facciamo una richiesta di restituzione del codice di stato di 200. Non ci immergeremo in profondità in come creare un server HTTP in GO. Dai un'occhiata al nostro tutorial sull'argomento per saperne di più.

Un esempio di esempio HTTP è mostrato:

Pacchetto principale
importazione (
"io"
"net/http"
)
var mux map [string] func (http.Responsewriter, *http.Richiesta)
funcmain ()
server: = http.Server
ADDR: ": 8080",
Gestore: & myhandler ,

MUX = make (mappa [string] func (http.Responsewriter, *http.Richiesta))
Mux ["/"] = Sayhello
server.Ascoltandserve ()

typemyHandlerstruct
func (*myhandler) servhttp (w http.Responsewriter, r *http.Richiesta)
Se H, ok: = Mux [R.URL.Corda()]; OK
H (W, R)
ritorno

io.Writestring (W, "Server in esecuzione:"+R.URL.Corda())

funcsayhello (w http.Responsewriter, r *http.Richiesta)
io.Writestring (W, "Ciao!")

Possiamo creare un test per verificare se la funzione HTTP Handler restituisce il codice di stato specificato. Nel nostro caso, la funzione HTTP Handler è il metodo Sayhello. La funzione di test è come mostrata:

Func TestStatusSode (T *Test.T)
affermare.HttpStatusSode (T, Sayhello, "Get", "/", nil, 200)

Nell'esempio sopra, creiamo una funzione di test per verificare l'invio di una richiesta GET al server con la funzione HTTP Handler Sayhello, restituisce il codice di stato di 200.

Il codice restituisce:

=== Esegui TestSTUSCODE
--- Pass: TestStatuSusde (0.00)
PASSAGGIO
ok linuxhint/go-assert 0.034s
> Test Run è terminato al 31/01/2022, alle 14:4:39 <

Golang Test Panic

Un altro test che possiamo eseguire è verificare se una funzione specifica viene. Possiamo usare l'affermazione.Metodo panico () come mostrato:

FUNCTestPanic (T *Test.T)
affermare.Panics (t, func ()
Panico ("Sicuramente il panico!")
, "Dovrebbe panico")

Nell'esempio sopra, controlliamo se la funzione se fa il panico.

Golang controlla se esiste la directory

Se si desidera verificare se esiste una directory specifica all'interno di un percorso specificato, è possibile utilizzare il metodo Direxists ().

Per esempio:

FUNCTESTDIR (T *Test.T)
affermare.Diressisti (t, "... /assert")

Conclusione

Questa è stata una guida completa su come iniziare con i test nel linguaggio di programmazione Go. Il test è pesantemente utilizzato nei progetti multi-sviluppo. Quindi, imparare a eseguire test è eccezionale.

C'è molto più fornito dal pacchetto Assert rispetto a quelli mostrati in questo tutorial. La documentazione si espande su questo.

https: // pkg.andare.dev/github.com/stretchr/testfy/assert