Ano ang Unit Testing?
Ang unang hakbang ay upang maunawaan kung ano pagsubok ng yunit ibig sabihin. Pagsubok sa yunit ay tumutukoy sa proseso ng pagsubok ng maliliit na mga yunit ng code o mga module upang matiyak na ang bawat isa sa kanila ay gumagana tulad ng inaasahan. Pagsubok sa yunit ay ginagamit upang alisin ang mga problema mula sa code, pagbutihin ang katatagan ng code, at tiyakin ang tama kapag nag-a-update ng code. Ang unang yugto ng pagsubok ng software ay ang pagsubok ng yunit , na sinusundan ng UI test at integration test.
Ang Testing Package
sa Golang, pagsubok ng yunit ay isinagawa gamit ang isang package na tinatawag pagsubok . Nagbibigay ang package ng iba't ibang function na nagbibigay-daan sa amin na subukan ang aming code. Maaaring awtomatikong masuri ang Go code sa tulong ng testing package.
Halimbawang Programa na Susubukan
Kailangan namin ng ilang code para masuri ng aming mga pagsubok bago kami makapagsulat ng anuman mga pagsubok sa yunit . Gagawa kami ng isang maliit na programa na nagdaragdag ng dalawang numero.
pangunahing pakete
angkat (
'fmt'
)
funcAdd ( a int , b int ) int {
bumalik a + b
}
func main ( ) {
fmt. Println ( Idagdag ( 2 , 3 ) )
}
Ang code sa itaas ay tumutukoy sa Magdagdag () function, na nagdaragdag ng dalawang numero, a at b , bilang mga input at output ang resulta bilang isang integer. Ang pagdaragdag ng mga numero 2 at 3 ay ang lahat na ginagawa ng pangunahing function bago i-print ang kinalabasan.
Convention of Writing Unit Tests in the Go
Ang bawat proyekto ng Go ay dapat may hiwalay na test file na naglalaman ng lahat ng pagsubok para sa proyektong iyon. Ang file ay dapat magkaroon ng parehong pangalan ng file na sinusuri at dapat ay mayroon _test.go idinagdag sa dulo ng filename. Halimbawa, kung gusto naming subukan ang isang file na pinangalanan calculator.go , dapat naming pangalanan ang aming test file calculator_test.go .
Ito ay karaniwang pagsasanay para sa Pumunta sa pagsubok ng mga file na matatagpuan sa parehong pakete o direktoryo ng code na kanilang sinusuri. Kapag ginamit mo ang command na go build, hindi ginagawa ng compiler ang mga file na ito, kaya hindi mo kailangang mag-alala tungkol sa pagpapakita ng mga ito sa mga deployment.
Upang magsulat ng a pagsubok ng yunit sa Go, kailangan nating gamitin ang pagsubok pakete. Maaari nating simulan ang bawat function ng pagsubok gamit ang salita Pagsusulit at pagkatapos ay magdagdag ng isang paglalarawan ng kung ano ang gusto naming subukan. Halimbawa, TestAddition o TestSubtraction . Pagkatapos ay maaari naming isulat ang test code na nagsusuri kung ang function na aming sinusubok ay nagbabalik ng mga inaasahang resulta.
Sa Go, dapat magsimula ang bawat test function sa statement t := pagsubok.T{}. Lumilikha ng bago ang pahayag na ito pagsubok bagay na maaari naming gamitin upang suriin kung ang pagsubok ay pumasa o nabigo. Magagamit natin ang t.Errorf() function na mag-print ng mensahe ng error kung nabigo ang pagsubok.
Paano Isulat ang Testing Code?
Pagdating sa pagsulat ng mga unit test sa Go, mahalagang magsimula sa pamamagitan ng pagtukoy sa package na gusto mong subukan. Pagkatapos mag-import ng testing package, maa-access mo ang iba't ibang uri at pamamaraan na ine-export ng package, kabilang ang pagsubok.T uri. Ang lohika ng pagsubok mismo ay isinusulat sa isang function na nagsisimula sa keyword 'Pagsusulit' sinusundan ng isang mapaglarawang pangalan, tulad ng TestAdd() . Sa loob ng function na ito, maaari mong isama ang code para sa pagsubok at anumang assertion na kailangan upang i-verify ang inaasahang gawi.
Sa kabuuan, ang mga katangian ng isang pagsubok sa Go ay ang mga sumusunod:
- Ang nag-iisa at tanging kinakailangang parameter ay t *pagsusubok.T
- Ang testing function ay nagsisimula sa salitang Test at pagkatapos ay sinusundan ng isang salita o parirala na nagsisimula sa malaking titik.
- Upang ipahiwatig ang isang pagkabigo, ang testing function ay dapat tumawag sa alinman t.Errorf o t. Nabigo, at upang magbigay ng karagdagang impormasyon sa pag-debug nang hindi nagiging sanhi ng pagkabigo, maaaring gamitin ang t.Log.
- Upang maghatid ng hindi nabigong impormasyon sa pag-debug, gumamit ng t.Log.
- Ang mga pagsubok ay nakaimbak sa mga file na may pangalan foo_test.go , Halimbawa, math_test.go .
Isara ang file pagkatapos i-save ito.
pangunahing paketeangkat (
'pagsubok'
)
functionTestAdd ( t * pagsubok. T ) {
resulta := Idagdag ( 2 , 3 )
kung resulta != 5 {
t. Errorf ( 'Add(2, 3) = %d; want 5' , resulta )
}
}
Ang Magdagdag () ang function ay sinubok ng TestAdd() function, na tinukoy sa pagsubok na ito. Ginagamit nito ang mga numero 2 at 3 upang tawagan ang Add, at pagkatapos ay kinukumpirma nito na ang kinalabasan ay 5. Ang isang mensahe ng error ay naka-print kung ang resulta ay mas mababa sa 5 kapag t.Errorf() ay hinihingi.
Panghuli, mahalagang malaman na ang Go ay may built-in na tool sa pagsubok na tinatawag mag test. Pinapatakbo ng tool na ito ang lahat ng pagsubok sa proyekto at nagbibigay ng ulat ng mga resulta. Mag test dapat i-type sa terminal habang nasa direktoryo ng proyekto upang simulan ang mga pagsubok. Ang lahat ng mga pagsubok sa direktoryo na iyon ay tatakbo bilang isang resulta.
< malakas > mag test < pagsusulit - file - pangalan > _pagsusulit. pumunta ka malakas > 
Mga Resulta ng Unit Test
Ipapakita sa iyo ng output ang mga function ng pagsubok na pumasa, nabigo, o nilaktawan.
PASS o OK nagsasaad na ang code ay gumagana ayon sa nilalayon. Matatanggap mo FAIL kung nabigo ang isang pagsubok.
Ang _test.go suffix lang ang sinusuri ng go test subcommand sa mga file. Pagkatapos, go test ay hahanapin ang (mga) file na iyon para sa anumang mga espesyal na function, gaya ng func PagsubokXXX at marami pang iba. Binubuo at tinawag ng Go test ang mga function na ito nang tama, isinasagawa ang mga ito, tinitipon, at iniuulat ang mga resulta, at sa wakas ay nililinis ang lahat sa isang pansamantalang pangunahing pakete.
Ang huling hakbang ay isama ang iyong mga pagsubok sa iyong daloy ng trabaho sa pag-unlad. Ang pinakamahusay na kasanayan ay ang patakbuhin ang iyong mga pagsubok sa bawat oras na ibibigay mo ang iyong code sa isang repositoryo. Ang pagsasama ng iyong mga pagsubok sa iyong development workflow ay nagsisiguro na ang iyong code ay patuloy na sinusubok, at anumang mga isyu ay malulutas bago ang pag-deploy.
Konklusyon
Pagsusulat mga pagsubok sa yunit ay isang mahalagang bahagi ng software development dahil ginagarantiyahan nito na ang iyong code ay scalable, functional, at epektibo. Ang Go testing library ay walang hirap at diretsong gamitin. Dapat ay magagawa mo ang Golang mga pagsubok sa yunit ng pinakamataas na kalidad sa pamamagitan ng pagsunod sa mga pamamaraang nakalista sa itaas. Tandaang isama ang iyong mga pagsubok sa iyong development workflow upang matiyak na ang iyong code ay patuloy na sinusubok, at anumang mga isyu ay malulutas bago ang pag-deploy.