Siirry yksikkötesting

Mene yksikkötestiin

2024-07-12

Go-kielellä yksikkötestaus toteutetaan vakiokirjaston testauspaketin kautta, joka tarjoaa joukon toimintoja, jotka tekevät yksikkötestien kirjoittamisesta, suorittamisesta ja hallinnasta yksinkertaista ja tehokasta.

1. Säännöt

Testaa tiedostojen nimeämissääntöjä
Go:n testitiedoston nimeämissääntö on lisätä_test.go .Esimerkiksi, jos sinulla on acalculator.go tiedosto, vastaavan testitiedoston tulee ollacalculator_test.go。
Testifunktioiden nimeämissäännöt
Testitoiminnon tulee alkaaTest alkaa, ja sitä voi seurata esimerkiksi mikä tahansa ei-tyhjä merkkijonoTestAdd、TestSubtract odota.
käyttää testing.T Tee väitteitä ja raportoi virheistä
Käytä testitoiminnossatesting.T Kirjoita parametrit testin tilan ja tulosteen hallitsemiseksi.voit käyttäät.Error*、t.Fail* ja muut menetelmät testin epäonnistumisen osoittamiseksi ja asiaankuuluvien virhetietojen tulostamiseksi.

2. Yksikkötestiesimerkki

2.1 Yksi testitapaus

Laskintoiminto on määritelty laskinpaketissa, ja sen erityinen toteutus on seuraava:

package calculator

func Add(a, b int) int {
	return a + b
}
1
2
3
4
5

Luomme nykyiseen hakemistoon testitiedoston calculator_test.go ja määritämme testifunktion seuraavasti:

package calculator

import "testing"


func TestAdd(t *testing.T) {
	result := Add(1, 2)
	expected := 3
	if result != expected {
		t.Errorf("Add(1,2) return %d, expected %d", result, expected)
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

Suorita tämä yksikkötesti käyttämällä go test -komentoa.Kirjoita komentoriville hakemisto, joka sisältää calculator.go ja calculator_test.go, ja suorita sittengo test, nämä tulokset ovat seuraavat

go test
PASS
ok      modu    0.226s
1
2
3

2.2 Useita testitapauksia

Lisää seuraava testifunktio tiedostoon calculator_test.go:

func TestAdd2(t *testing.T) {
	result := Add(3, 2)
	expected := 3
	if result != expected {
		t.Errorf("Add(1,2) return %d, expected %d", result, expected)
	}
}
1
2
3
4
5
6
7

Voimme nähdä paremmin kunkin testitapauksen suorituksen tulostuloksissago test -vparametreja, jotta se tuottaa täydelliset testitulokset.

go test -v
=== RUN   TestAdd
--- PASS: TestAdd (0.00s)
=== RUN   TestAdd2
    calculator_test.go:17: Add(1,2) return 5, expected 3
--- FAIL: TestAdd2 (0.00s)
FAIL
exit status 1
FAIL    modu    0.216s
1
2
3
4
5
6
7
8
9

2.3 Määritä käynnissä olevat testitapaukset

go test -run Komento voi suorittaa testejä määritetyn tilan mukaan. Tämä komento tukee säännöllisiä lausekkeita suoritettavien testifunktioiden valitsemiseksi.

Esimerkiksi TestAdd2-käyttötapauksen korjaamisen jälkeen hyväksygo tes -run=Add2Suorita vain TestAdd2-testitapaus, tulos on

go test -run=Add2 -v
=== RUN   TestAdd2
--- PASS: TestAdd2 (0.00s)
PASS
ok      modu    0.198s
1
2
3
4
5

4. Ohita joitain testitapauksia
Lisää uusi testitoiminto

func TestAdd3(t *testing.T) {
	if testing.Short() {
        t.Skip("short模式下会跳过该测试用例")
    }
	
	result := Add(3, 2)
	expected := 5
	if result != expected {
		t.Errorf("Add(1,2) return %d, expected %d", result, expected)
	}
}
1
2
3
4
5
6
7
8
9
10
11

suoritettaessago test -shorKun t, se ohitetaantesting.Short()Merkitty testitapaus, tulos on

go test -short -v
=== RUN   TestAdd
--- PASS: TestAdd (0.00s)
=== RUN   TestAdd2
--- PASS: TestAdd2 (0.00s)
=== RUN   TestAdd3
    calculator_test.go:23: short模式下会跳过该测试用例
--- SKIP: TestAdd3 (0.00s)
PASS
ok      modu    0.635s
1
2
3
4
5
6
7
8
9
10

3. Testiryhmät ja osatestit

3.1 Testiryhmät ja osatestit

Testiryhmien ja osatestien avulla voit lisätä testitapauksia ja tarkastella tuloksia ystävällisemmin

func TestAdd(t *testing.T) {
	tests := []struct {
		name     string
		x, y     int
		expected int
	}{
		{"Add1", 1, 2, 3},
		{"Add2", 3, 3, 6},
		{"Add3", 4, 5, 8},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			result := Add(tc.x, tc.y)
			if result != tc.expected {
				t.Errorf("Add(%d, %d) returned %d, expected %d", tc.x, tc.y, result, tc.expected)
			}
		})
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

juostago test -v,osoittautua

go test -v
=== RUN   TestAdd
=== RUN   TestAdd/Add2
=== RUN   TestAdd/Add3
    calculator_test.go:51: Add(4, 5) returned 9, expected 8
--- FAIL: TestAdd (0.00s)
    --- PASS: TestAdd/Add1 (0.00s)
    --- PASS: TestAdd/Add2 (0.00s)
    --- FAIL: TestAdd/Add3 (0.00s)
FAIL
exit status 1
FAIL    modu    0.190s
1
2
3
4
5
6
7
8
9
10
11
12

3.2 Rinnakkaistestaus

Go-kieli tukee luonnostaan samanaikaisuutta, joten lisäämällät.Parallel()Kuljettajien testien rinnakkaisuuden saavuttamiseksi.

func TestAdd(t *testing.T) {
	t.Parallel()  // 将 TLog 标记为能够与其他测试并行运行
	// 这里使用匿名结构体定义了若干个测试用例
	// 并且为每个测试用例设置了一个名称
	tests := []struct {
		name     string
		x, y     int
		expected int
	}{
		{"Add1", 1, 2, 3},
		{"Add2", 3, 3, 6},
		{"Add3", 4, 5, 8},
	}

	for _, tc := range tests {
		tc := tc  // 注意这里重新声明tt变量（避免多个goroutine中使用了相同的变量）
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()  // 将每个测试用例标记为能够彼此并行运行
			result := Add(tc.x, tc.y)
			if result != tc.expected {
				t.Errorf("Add(%d, %d) returned %d, expected %d", tc.x, tc.y, result, tc.expected)
			}
		})
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

3.3 Testin kattavuus

käyttäägo test -covernähdäksesi testin kattavuuden

go test -cover
PASS
        modu    coverage: 100.0% of statements
ok      modu    1.149s
1
2
3
4

4. Mene yksikkötestauksen työkalupakkiin – todista

Kun suoritamme yksikkötestauksen Go-kielellä, koska virallista vahvistustoimintoa ei ole sisäänrakennettu, joudumme yleensä käyttämään suurta määrääif...else... lausunto testitulosten tarkistamiseksi.Kuitenkin käyttämällä kolmannen osapuolen kirjastoja, kutentestify/assert, voimme helposti kutsua useita yleisesti käytettyjä väitefunktioita, jotka eivät vain yksinkertaista testikoodia, vaan myös luovat selkeät ja helposti ymmärrettävät virheen kuvaustiedot, jotka auttavat meitä löytämään ongelman nopeasti.

Yllä olevassa esimerkissä käytämmeif...else...Lausunto testitulosten tarkistamiseksi

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			result := Add(tc.x, tc.y)
			if result != tc.expected {
				t.Errorf("Add(%d, %d) returned %d, expected %d", tc.x, tc.y, result, tc.expected)
			}
		})
	}
1
2
3
4
5
6
7
8

Saatavilla nyttestify/assertYllä oleva tuomioprosessi on yksinkertaistettu seuraavasti:

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			result := Add(tc.x, tc.y)
			assert.Equal(t, result, tc.expected)
		})
	}
1
2
3
4
5
6

testify/requireomistaatestify/assertKaikki väitefunktiot, ainoa ero niiden välillä ontestify/requireJos testitapaus epäonnistuu, testi keskeytetään välittömästi.

Teknologian jakaminen