Golang hevder

Det er tre hovedkomponenter i en utviklers livssyklus: skrivekode, testkode, fikse koden, gjenta. Selv om det er en ekstrem forenkling, illustrerer det et konsept som alle utviklere møter.

I denne artikkelen vil vi fokusere på en enkelt enhet av en utviklers livssyklus: testing. Testkode er en veldig nyttig funksjon for enhver utvikler. Det tillater å finne og fikse feil før du distribuerer kode til produksjon. Selv om det er mange måter og funksjoner for å implementere kodetesting, vil denne artikkelen fokusere på Go Assult -pakken.

Komme i gang med testing

Før vi dykker inn i hvordan vi skal jobbe med vitnepakken, la oss lære å komme i gang med go -testing.

Det første trinnet er å vite hva du vil teste. Dette kan være en enkel funksjon for en samling metoder.

La oss ta et enkelt eksempelprogram som nettopp multipliserer det er innspill med 10.

Begynn med å opprette en katalog for å lagre koden din.

MKIDR -testing

Naviger inn i katalogen og opprette en GO -fil som inneholder programmet ditt. For enkelhets skyld vil vi kalle denne filen hoved.gå

CD -testing
berør Main.gå

Rediger filen med tekstredigereren din og opprett programmet ditt. For å følge med denne opplæringen, kan du legge til koden som vist nedenfor:

pakkehoved
import (
"FMT"
)
FUNCMULTIPLY (x int) (resultat int)
Resultat = x * 10
Returresultat

FUNCMAIN ()
fmt.Println ("Komme i gang med testing")

I eksempelprogrammet har vi en funksjon som tar et heltallinngang og returnerer heltallet multiplisert med 10.

Lagre og lukk filen.

Neste trinn er å lage test for programmet ovenfor. For å gjøre dette, må vi opprette en fil i samme katalog med _Test -suffikset. Dette forteller GO -testmodulen at denne filen inneholder en testsuite for programmet i katalogen.

Siden vi ønsker å lage en test for hoved.GO -program, vi vil ringe testfilen som:

Touch main_test.gå

I testfilen kan vi lage testinstruksjoner for programmet vårt.

Siden vi ønsker å bruke bruken på assert -pakken, må vi importere testingen og påståelsespakken.

Du kan inkludere importen som:

pakke
import (
"Testing"
"Github.com/stretchr/vitne/påstå "
)

Deretter lager du en testfunksjon for å teste for hovedprogrammet. Vi kan lage testinstruksjoner som vist:

pakkehoved
import (
"Testing"
"Github.com/stretchr/vitne/påstå "
)
functestmultiply (t *testing.T)
påstå.Lik (T, Multiply (10), 100)

I programmet ovenfor lager vi en testfunksjon som tar en testing.T objekt. Testrammen lar funksjonen skrive mislykkes til den aktuelle stedet forutsatt dette objektet.

Inne i funksjonen bruker vi påståelsespakken for å sjekke om funksjonen returnerer et resultat som tilsvarer de medfølgende parametrene. Hvis multipliserfunksjonen tar heltall 10 og returnerer en verdi lik 100, består den testen.

Lagre testfilen og kjør testen ved hjelp av kommandoen:

gå test

Kommandoen ovenfor skal ta testfilen og kjøre de konfigurerte testene.

Et eksempelutgang er som vist:

=== Kjør testmultiply
--- Pass: TestMultiply (0.00s)
SENDE
Ok Linuxhint/Go-Assert
> Testkjøring ferdig 1/31/2022, 13:38:17 PM <

Som du vil legge merke til fra output ovenfor, består funksjonen testen.

La oss endre verdien av funksjonen for å illustrere en feilinstruksjon. Endre for eksempel den tredje parameteren for testfunksjonen til en feil verdi. For eksempel:

functestmultiply (t *testing.T)
påstå.Lik (T, Multiply (10), 10)

I dette eksemplet forteller vi programmet at hvis funksjonen ikke returnerer 10, så mislykkes funksjonen.

Merk: Husk at testfunksjonen er feil.

Hvis vi kjører testen, bør vi få en mislykkethet som:

=== Kjør testmultiply
hevde \ main_test.Gå: 10:
Feilspor:
Feil: ikke lik:
Forventet: 100
Faktisk: 10
Test: Testmultiply
--- Mislykkes: testmultiply (0.00s)
Mislykkes
Fail Linuxhint/Go-Assert 0.040 -tallet
> Testkjøring ferdig 1/31/2022, 13:40:59 <

Ovennevnte utgang illustrerer en mislykket test.

Golang hevder

Nå som vi har det grunnleggende om å teste ut av veien, la oss flytte fokuset til påståelsespakken. I vårt forrige eksempel brukte vi lik metoden for å sjekke om funksjonen returnerer den forventede verdien. Assert -pakken gir imidlertid en mengde testverktøy og metoder for å gjøre kodetesting enklere.

La oss utforske noen flere eksempler for å illustrere funksjonaliteten til påståelsespakken.

Golang test ulikhet

Vi kan bruke påståelsespakken for å se etter ulikhet ved hjelp av Notequal () -metoden. Funksjonssyntaksen er som vist:

func notequal (t testingt, forventet, faktisk grensesnitt , msgandargs… grensesnitt ) bool

Funksjonen tar en T.Testobjekt, forventet og den faktiske verdien og en utskriftsmelding. Det sjekker om den forventede og faktiske verdien ikke er lik. Hvis det er sant, passerer testen, ellers, mislykkes.

Et eksempel er som vist:

functestnotequal (t *testing.T)
påstå.Notequal (t, 100, 10, "Verdier skal ikke være like")

Koden over sjekker om verdiene ikke er like. Et eksempelutgang er som vist:

=== Kjør testnotequal
--- Pass: testnotequal (0.00s)
SENDE
Ok Linuxhint/Go-Assert 0.037S

Golang test http statuskode

Vi kan bruke httpStatusCode () -metoden for å sjekke om en behandler returnerer den spesifiserte statuskoden.

La oss anta at vi har en HTTP -server, at hvis vi ber om en forespørsel om å returnere statuskode på 200. Vi vil ikke dykke dypt inn i hvordan du oppretter en HTTP -server i Go. Sjekk ut opplæringen vår om emnet for å lære mer.

Et eksempel HTTP -server er som vist:

pakkehoved
import (
"io"
"Nett/http"
)
var mux kart [streng] func (http.ResponseWriter, *http.Be om)
FUNCMAIN ()
Server: = http.Server
Addr: ": 8080",
Handler: & myhandler ,

mux = make (kart [streng] func (http.ResponseWriter, *http.Be om))
mux ["/"] = Sayhello
server.ListenandServe ()

typemyHandlerStruct
func (*myhandler) servehttp (w http.ResponseWriter, R *http.Be om)
Hvis H, OK: = mux [r.URL.Streng ()]; ok
h (w, r)
komme tilbake

io.Writestring (W, "Server Running:"+R.URL.Streng ())

funcsayhello (w http.ResponseWriter, R *http.Be om)
io.Writestring (W, "Hei!")

Vi kan opprette en test for å sjekke om HTTP -behandlerfunksjonen returnerer den spesifiserte statuskoden. I vårt tilfelle er HTTP -behandlerfunksjonen Sayhello -metoden. Testfunksjonen er som vist:

func teststatuscode (t *testing.T)
påstå.HttpStatusCode (T, Sayhello, "Get", "/", Nil, 200)

I eksemplet over oppretter vi en testfunksjon for å sjekke sending av en get -forespørsel til serveren med HTTP -behandlerfunksjonen Sayhello, returnerer statuskoden på 200.

Koden returnerer:

=== Kjør TestStatusCode
--- Pass: TestStatusCode (0.00s)
SENDE
Ok Linuxhint/Go-Assert 0.034s
> Testkjøring ferdig på 1/31/2022, 2:44:39 PM <

Golang Test Panic

En annen test vi kan kjøre er å sjekke om en spesifikk funksjon panikk. Vi kan bruke påstanden.PANICKS () -metode som vist:

functestpanic (t *testing.T)
påstå.Panics (T, func ()
Panikk ("Jeg får definitivt panikk!")
, "Bør panikk")

I eksemplet over sjekker vi om funksjonen hvis den får panikk.

Golang sjekk om katalogen eksisterer

Hvis du vil teste om en spesifikk katalog eksisterer i en spesifisert bane, kan du bruke Direxists () -metoden.

For eksempel:

functestdir (t *testing.T)
påstå.Direxists (t, "... /hevder")

Konklusjon

Dette var en omfattende guide for hvordan du kommer i gang med testing på Go -programmeringsspråket. Testing brukes sterkt i multi-utviklerprosjekter. Derfor er det eksepsjonelt å lære å utføre tester.

Det er mye mer levert av Assert Package enn de som er vist i denne opplæringen. Dokumentasjonen utvides med dette.

https: // pkg.gå.dev/github.com/stretchr/vitne/påstå