En introduktion till testning I Go

testning är oerhört viktigt i all programvara. Att kunna säkerställa korrektheten i din kod och se till att alla ändringar du gör inte slutar bryta något annat i olika delar av din kodbas är oerhört viktigt.

genom att ta dig tid att på ett adekvat sätt testa dina go-program tillåter du dig själv att utvecklas snabbare med en större känsla av förtroende för att det du utvecklar kommer att fortsätta att fungera när du släpper det till produktion.

mål

i slutet av denna handledning kommer du att ha ett bra grepp om att testa grundläggande funktioneroch metoder I Go med standardpaketet "testing".

du kommer att ha haft erfarenhet av att skriva tabelldrivna tester och du kommer också att sehur man genererar mer detaljerad utmatning från dina tester med hjälp av de olika flaggorna.

Video Tutorial

denna handledning kan hittas i videoformat om du föredrar:

introduktion

i denna handledning kommer vi att titta på hur du kan utveckla och köra test fördin Go-kod med kommandot go test.

Go-testfiler

om du har sett några go-projekt tidigare kanske du har märkt att de flesta, om inte alla filer i projektet, har en FILE_test.go motsvarighet i samma katalog.

Detta är inte en olycka. Dessa är de filer som innehåller alla enhetstester för projektet och de testar all kod inom sina motsvarigheter.

myproject/- calc.go- calc_test.go- main.go- main_test.go

en enkel testfil

Föreställ dig att vi hade ett mycket enkelt go-program som bestod av en fil ochfastställde en calculate() – funktion. Denna calculate() – funktion tar helt enkelt in 1number och lägger till 2 till den. Trevligt och enkelt att få oss igång:

om vi ville testa detta kunde vi skapa enmain_test.go fil i samedirectory och skriva följande test:

package mainimport ( "testing")func TestCalculate(t *testing.T) { if Calculate(2) != 4 { t.Error("Expected 2 + 2 to equal 4") }}

kör våra tester

nu när vi har skapat vårt första go-test är det dags att köra detta och se om ourcode beter sig som vi förväntar oss. Vi kan utföra våra tester genom att köra:

$ go test

detta bör sedan mata ut något som liknar följande:

PASSok _/Users/elliot/Documents/Projects/tutorials/golang/go-testing-tutorial 0.007s

Tabelldriven testning

nu när vi är glada att en beräkning fungerar, bör vi se till att förbättra förtroendet genom att lägga till några extra testfall i vår kod. Om vi villgradvis bygga upp en serie testfall som alltid testas kan vigenomföra en array av tester som så:

här förklarar vi en struktur som innehåller både en ingång och det förväntade värdet. Vi upprepar sedan genom listan över tester med vårt for _, test := range tests – samtal och kontrollerar att vår funktion alltid kommer att returnera de förväntade resultaten,oavsett inmatning.

när vi kör vår testsvit nu bör vi se samma utgång som tidigare:

PASSok _/Users/elliot/Documents/Projects/tutorials/golang/go-testing-tutorial 0.007s

Verbose Testutgång

ibland kanske du vill se exakt vilka tester som körs och hur länge de tog. Tack och lov är detta tillgängligt om du använder flaggan -v när du kör yourtests så:

du kan se att både vårt normala test och vårt bordstest körde och passerade och tog mindre än 0.00s att utföra.

kontroll Test täckning

test täckning är ett mått som jag har sett missbrukas ibland av företag. Dessa företag sätter upp mål på alla sina system, till exempel ”kodbasen måste vara minst 75% täckt av tester”.

men den här typen av mål kan leda till dåligt beteende och utvecklingsteam som ”spelar”systemet för att försöka träffa dessa mål. Jag har sett människor i vissa lagspendera dagar att skriva enhetstester som testar grundläggande getters och setters på språksom Java.

testning är oerhört viktigt, men du måste vara pragmatisk om hur du testar dina system så att de tester du skriver ger dig mest värde.

dagarna tillbringade skriva tester för att täcka oviktiga delar av din kodbas could have varit bättre tillbringade skriva testfall runt den kritiska verksamheten logiccaptured inom dina system och säkerställa fler kant fall täcks.

använda-täckflaggan

med den viktiga delen ur vägen, låt oss titta på hur du kan kontrolleratest täckning av ditt system med kommandot go test:

inom samma katalog som dina main.go och dina main_test.go filer, körföljande:

PASScoverage: 66.7% of statementsok github.com/TutorialEdge/an-intro-to-testing-in-go 0.006s

du kommer att se att du har 66.7% av din totala Go-kod som omfattas av testfall.

visualisera täckning

även om detta 66.7% – värde kan berätta för oss hur mycket av vår kod vi har testat,visar det oss inte exakt vilka kodvägar vi har eller inte testat.

det är här go test och go tool cover kommer in för att hjälpa oss att lösadetta speciella problem.

vi kan använda verktyget go test för att generera en coverprofile som sedan kan konverteras till en HTML-visualisering med kommandotgo tool cover:

PASScoverage: 66.7% of statementsok github.com/TutorialEdge/an-intro-to-testing-in-go 0.008s

du kan sedan ta den här genererade coverage.out – filen och använda den för att genereraen HTML-sida som visar exakt vilka linjer som har täckts så:

$ go tool cover -html=coverage.out

detta kommer att öppna upp en sida i din webbläsare val som kommer att se en littlesomething så här:

som du kan se är det mesta av koden inom vår Calculate – funktion testning ochfunktioner Green täckning. Medan utskriftssatsen i din main – funktionär Red eftersom detta inte har täckts av tester.

slutsats

förhoppningsvis hittade du denna handledning användbar! Om du behöver ytterligare hjälp thenplease gärna låta mig veta i kommentarerna nedan.