Programvarutestning är en process som utvärderar mätvärdena för program med hjälp av verktyg, skript eller manuellt.

Testning är en integrerad del av mjukvaruutvecklingscykeln. Omfattande testning ger djupgående information om din applikations integritet.

Du kan förhindra och fixa buggar genom att skriva tester, utvärdera programprestanda och automatisera arbetsflöden.

Komma igång med Testing in Go

Go-standardbiblioteket ger en utveckling testning paket. De testning paketet har benchmarking, fuzzing, skipping, sub-testing, sub-benchmarking och andra funktioner.

Att testa med detta paket är enkelt. Här är en enkel teststruktur som kommer att fungera som en modell för testet:

typ Fall struktur {
// det förväntade resultatet av testet
 förväntas int
// utdata från funktionen
 faktisk int
// värdet du skickar till funktionen
 argument sträng
}

Här är en enkel funktion som konverterar strängar till heltal. Ditt test kommer att testa denna funktion.

importera (
 "strconv"
)
funcStringToInteger(str sträng)int {
 heltal, err := strconv. Atoi (str)


om fel!= noll {
lämna tillbaka0
 }
lämna tillbaka heltal
}
instagram viewer

De StringToInteger funktion returnerar 0 om det finns ett fel vid konvertering och heltal om det inte finns några fel.

Här är en testfunktion för StringToInteger:

funcTestStringToInteger(test *testning. T) {
 förväntadInt := StringToInteger("3")
caseInstance := Fall {
 förväntat: förväntatInt,
 faktisk: 3,
 }
om caseInstance.expected == caseInstance.actual {
// lite kod här
 } annan {
 testa. Misslyckas()
 }
}

De TestStringToInteger testfunktionen accepterar en testning. T objekt som dess argument. De förväntatInt variabeln innehåller resultatet av strängkonverteringen. De caseInstance variabel är den instansierade Cases-strukturen för testet. De om uttalande jämför förväntade och faktiska värden.

De Misslyckas metod returnerar ett misslyckat test i else-satsen om värdena inte är lika.

Go ger en testa kommando för att automatisera och hämta insikter om dina tester och program.

gå testa
gå hjälp testa

Hjälpsidan ger detaljerad information om hur gå testa Arbetar:

Go-ekosystemet är hem för många bibliotek som gör testning mer tillgänglig och flexibel. Det finns gott om funktionalitet utöver testning paket, inklusive regression och enhetstestning.

Vittnespaketet

Testify-paketet är ett av de mest populära Go-ramverken för att testa paket. Den tillhandahåller verktyg du behöver för att skriva effektiva tester, med enkla påståenden, hån och testfunktioner.

Testify lämpar sig för testdriven utveckling eftersom paketet ger en falsk paket. Detta ger en mekanism för att skriva skenobjekt som du kan använda i stället för riktiga objekt vid testning.

Paketet innehåller även:

  • En hävda paket som ger användbara metoder för att skriva vänliga, läsbara tester.
  • A behöva paket som liknar hävda paket för att returnera booleska resultat.
  • A svit paket för testsviter med strukturer.

Testify sträcker sig om testning paketet, och du kan använda gå testa kommando för att köra tester skrivna med Testify-paketet.

Testify stöder Go-versioner från 1.13. Du kan lägga till paketet som ett projektberoende med det här kommandot:

gå hämta github.com/stretchr/testify

Här är ett enkelt påståendetest med Testify-paketet hävda paket:

paket huvud
importera (
 "testning"
 "github.com/stretchr/testify/assert" // endast hävda paket
)


// funktionsnamn ska vara "Något" enligt konventionen
funcTesta något(t *testning. T) {
// hävdar jämlikhet
 hävda. Lika (t, 123, 123, "de borde vara lika")
// hävdar ojämlikhet
 hävda. NotEqual (t, 123, 456, "de borde inte vara lika")
}

De Testa något testfunktionen tar testtypens struktur av testning paket som argument. De Likvärdig och Inte lika med metoder är för jämlikhet och ojämlikhet baserade påståenden från Testify's hävda paket.

GoConvey-paketet

GoConvey är ett Go-testverktyg förutsatt för uttrycksfullhet över testning paket. Det inkluderar terminal (CLI) och webbläsare (GUI) testa funktionalitet.

GoConvey-paketet integreras med testning paket, som tillhandahåller ett webbanvändargränssnitt för att arbeta med inbyggda Go-tester. Den innehåller också funktionalitet för regressionstester, anpassningsbara utgångar och generering av testkod. Du kan köra tester automatiskt, komma åt täckningsformat i HTML och anpassa GUI.

Kör det här kommandot i terminalen på din Go-arbetsyta för att installera Go Convey-paketet.

gå hämta github.com/smartystreets/goconvey

Här är ett enkelt exempel på att skriva tester med GoConvey-paketet.

paket huvud
importera (
. "github.com/smartystreets/goconvey/convey"
 "testning"
)


funcTesta något(t *testning. T) {
// Skicka bara t till samtal på toppnivå
 Convey("Deklarera variabel", t, func() {
 x := 1


Convey("ökningsvariabel", func() {
 x++
Convey("sert equality", func() {
 Så (x, ShouldEqual, 2)
 })
 })
 })
}

Du måste importera framföra paket med hjälp av punktnotation för testet.

Convey-funktionen från Framföra paketet hjälper till med testomfattning. Den sista Framföra funktionsanrop i kodexemplet hävdar likhet mellan x variabel och 2, använda Bör Lika fungera.

HTTP Expect-paketet

De HTTP förväntar sig paket är ett lättanvänt, kortfattat, deklarativt paket för Gos end-to-end HTTP- och REST API-testning. Du kan använda den för att skapa HTTP-förfrågningar stegvis och inspektera svar och deras nyttolaster rekursivt.

De httpförvänta paketet är en uppsättning kedjabara byggare för HTTP-förfrågningar och påståenden om HTTP-svar och nyttolaster. Den är byggd på http, testning, och andra paket. Paketet fungerar även bra med det inbyggda httptest paket.

httpförvänta ger funktionalitet för att bygga förfrågningar med URL-konstruktion, rubriker, cookies och nyttolaster. Den hanterar svarspåståenden, nyttolastpåståenden, snygga utskrifter och WebSockets.

Kör det här kommandot i terminalen i din arbetskatalog för att installera httpförvänta paket.

gå hämta github.com/gavv/httpexpect

Här är ett enkelt exempel på att testa en hanterarfunktion med httpförvänta paket.

paket huvud
importera (
 "fmt"
 "github.com/gavv/httpexpect/v2"
 "net/http"
 "net/http/httptest"
 "testning"
)


funcexempelhanterare()http.Hanterare {
lämna tillbaka http. HandlerFunc(func(författare http. ResponseWriter, begär *http. Begäran) {
 fmt. Fprintln (författare, "Hello World")
 })
}


funcTestexempelHandler(t *testning. T) { 
// skapa http. Hanterare
 hanterare := exampleHandler()


// kör server med httptest
 server := httptest. NewServer (hanterare)
uppskjuta server. Stänga()


// skapa http förvänta instans
 förvänta := httpförvänta. Ny (t, server. URL)
// fungerar det?
 förvänta. SKAFFA SIG("/").
 Förvänta().
 Status (http. StatusOK).JSON().Array().Empty()
}

De exempelhanterare hanterarfunktionen returnerar en HTTP-hanterare för httpförvänta paket. De TestexempelHandler funktion deklarerar en instans av hanterarfunktionen. Den skapar sedan en ny server för att testa slutpunkten med httptest paket.

De förvänta variabel är din httpförvänta instans som träffar SKAFFA SIG begära slutpunktens rotsökväg på servern. De Status funktion returnerar statuskoden (I detta fall, 200) om testet lyckas.

Skriv omfattande och intuitiva tester

Tester går långt för att utvärdera integriteten hos din applikation, och det finns många testmönster och metoder du kan använda för dina program. Kärnan i ditt testarbetsflöde bör du skriva intuitiva test som du kan förbättra när dina program förändras över tiden.