Go
Testowanie

Wprowadzenie

Test podstawowy

main.go :

package main

import (
    "fmt"
)

func main() {
    fmt.Println(Sum(4,5))
}

func Sum(a, b int) int {
    return a + b
}

main_test.go :

package main

import (
    "testing"
)

// Test methods start with `Test`
func TestSum(t *testing.T) {
    got := Sum(1, 2)
    want := 3
    if got != want {
        t.Errorf("Sum(1, 2) == %d, want %d", got, want)
    }
}

Aby uruchomić test, wystarczy użyć komendy go test :

$ go test
ok      test_app    0.005s

Użyj flagi -v aby zobaczyć wyniki każdego testu:

$ go test -v
=== RUN   TestSum
--- PASS: TestSum (0.00s)
PASS
ok      _/tmp    0.000s

Użyj ścieżki ./... do rekursywnego testowania podkatalogów:

$ go test -v ./...
ok      github.com/me/project/dir1    0.008s
=== RUN   TestSum
--- PASS: TestSum (0.00s)
PASS
ok      github.com/me/project/dir2    0.008s
=== RUN   TestDiff
--- PASS: TestDiff (0.00s)
PASS

Przeprowadź szczegółowy test:
Jeśli istnieje wiele testów i chcesz uruchomić określony test, możesz to zrobić w następujący sposób:

go test -v -run=<TestName> // will execute only test with this name

Przykład:

go test -v run=TestSum

Testy porównawcze

Jeśli chcesz mierzyć testy porównawcze, dodaj metodę testowania:

sum.go :

package sum

// Sum calculates the sum of two integers
func Sum(a, b int) int {
    return a + b
}

sum_test.go :

package sum

import "testing"

func BenchmarkSum(b *testing.B) {
    for i := 0; i < b.N; i++ {
        _ = Sum(2, 3)
    }
}

Następnie, aby uruchomić prosty test porównawczy:

$ go test -bench=. 
BenchmarkSum-8    2000000000             0.49 ns/op
ok      so/sum    1.027s

Testy jednostkowe na podstawie tabeli

Ten rodzaj testowania jest popularną techniką testowania z predefiniowanymi wartościami wejściowymi i wyjściowymi.

Utwórz plik o nazwie main.go z zawartością:

package main

import (
    "fmt"
)

func main() {
    fmt.Println(Sum(4, 5))
}

func Sum(a, b int) int {
    return a + b
}

Po uruchomieniu z zobaczysz, że wynik to 9 . Chociaż funkcja Sum wygląda dość prosto, dobrym pomysłem jest przetestowanie kodu. W tym celu tworzymy kolejny plik o nazwie main_test.go w tym samym folderze co main.go , zawierający następujący kod:

package main

import (
    "testing"
)

// Test methods start with Test
func TestSum(t *testing.T) {
    // Note that the data variable is of type array of anonymous struct,
    // which is very handy for writing table-driven unit tests.
    data := []struct {
        a, b, res int
    }{
        {1, 2, 3},
        {0, 0, 0},
        {1, -1, 0},
        {2, 3, 5},
        {1000, 234, 1234},
    }

    for _, d := range data {
        if got := Sum(d.a, d.b); got != d.res {
            t.Errorf("Sum(%d, %d) == %d, want %d", d.a, d.b, got, d.res)
        }
    }
}

Jak widać, tworzony jest kawałek anonimowych struktur, z których każdy zawiera zestaw danych wejściowych i oczekiwany wynik. Umożliwia to utworzenie dużej liczby przypadków testowych razem w jednym miejscu, a następnie wykonanie ich w pętli, co zmniejsza powtarzanie kodu i poprawia przejrzystość.

Przykładowe testy (testy samok dokumentujące)

Tego typu testy zapewniają, że kod poprawnie się kompiluje i pojawi się w wygenerowanej dokumentacji projektu. Oprócz tego w przykładowych testach można stwierdzić, że test zapewnia prawidłowe wyniki.

sum.go :

package sum

// Sum calculates the sum of two integers
func Sum(a, b int) int {
    return a + b
}

sum_test.go :

package sum

import "fmt"

func ExampleSum() {
    x := Sum(1, 2)
    fmt.Println(x)
    fmt.Println(Sum(-1, -1))
    fmt.Println(Sum(0, 0))

    // Output:
    // 3
    // -2
    // 0
}

Aby wykonać test, uruchom polecenie go test w folderze zawierającym te pliki LUB umieść te dwa pliki w podfolderze o nazwie sum a następnie z folderu nadrzędnego wykonaj polecenie go test ./sum . W obu przypadkach otrzymasz wynik podobny do tego:

ok      so/sum    0.005s

Jeśli zastanawiasz się, jak to testuje twój kod, oto kolejna przykładowa funkcja, która tak naprawdę kończy się niepowodzeniem:

func ExampleSum_fail() {
    x := Sum(1, 2)
    fmt.Println(x)

    // Output:
    // 5
}

Po uruchomieniu go test otrzymujesz następujące dane wyjściowe:

$ go test
--- FAIL: ExampleSum_fail (0.00s)
got:
3
want:
5
FAIL
exit status 1
FAIL    so/sum    0.006s

Jeśli chcesz zobaczyć dokumentację pakietu sum - po prostu uruchom:

go doc -http=:6060

i przejdź do http: // localhost: 6060 / pkg / FOLDER / sum / , gdzie FOLDER to folder zawierający pakiet sum (w tym przykładzie so ). Dokumentacja metody sumowania wygląda następująco:

Testowanie żądań HTTP

main.go:

package main

import (
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
)

func fetchContent(url string) (string, error) {
    res, err := http.Get(url)
    if err != nil {
        return "", nil
    }
    defer res.Body.Close()

    body, err := ioutil.ReadAll(res.Body)
    if err != nil {
        return "", err
    }
    return string(body), nil
}

func main() {
    url := "https://example.com/"
    content, err := fetchContent(url)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Content:", content)
}

main_test.go:

package main

import (
    "fmt"
    "net/http"
    "net/http/httptest"
    "testing"
)

func Test_fetchContent(t *testing.T) {
    ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprint(w, "hello world")
    }))
    defer ts.Close()

    content, err := fetchContent(ts.URL)
    if err != nil {
        t.Error(err)
    }

    want := "hello world"
    if content != want {
        t.Errorf("Got %q, want %q", content, want)
    }
}

Ustaw / Resetuj funkcję próbną w testach

Ten przykład pokazuje, jak wykpić wywołanie funkcji, które nie ma znaczenia dla naszego testu jednostkowego, a następnie użyć instrukcji defer , aby ponownie przypisać wyśmiewane wywołanie funkcji do pierwotnej funkcji.

var validate = validateDTD

// ParseXML parses b for XML elements and values, and returns them as a map of 
// string key/value pairs.
func ParseXML(b []byte) (map[string]string, error) {
    // we don't care about validating against DTD in our unit test
    if err := validate(b); err != nil {
        return err
    }

    // code to parse b etc.
}

func validateDTD(b []byte) error {
    // get the DTD from some external storage, use it to validate b etc.
}

W naszym teście jednostkowym

func TestParseXML(t *testing.T) {
    // assign the original validate function to a variable.
    originalValidate = validate
    // use the mockValidate function in this test.
    validate = mockValidate
    // defer the re-assignment back to the original validate function.
    defer func() {
       validate = originalValidate
    }()

    var input []byte
    actual, err := ParseXML(input)
    // assertion etc.
}

func mockValidate(b []byte) error {
    return nil // always return nil since we don't care
}

Testowanie za pomocą funkcji setUp i tearDown

Możesz ustawić funkcję setUp i tearDown.

• Funkcja setUp przygotowuje środowisko do testów.
• Funkcja tearDown wykonuje wycofywanie.

Jest to dobra opcja, gdy nie można zmodyfikować bazy danych i trzeba utworzyć obiekt, który symuluje obiekt wniesiony z bazy danych lub trzeba zainicjować konfigurację w każdym teście.

Głupi przykład to:

// Standard numbers map
var numbers map[string]int = map[string]int{"zero": 0, "three": 3}

// TestMain will exec each test, one by one
func TestMain(m *testing.M) {
    // exec setUp function
    setUp("one", 1)
    // exec test and this returns an exit code to pass to os
    retCode := m.Run()
    // exec tearDown function
    tearDown("one")
    // If exit code is distinct of zero,
    // the test will be failed (red)
    os.Exit(retCode)
}

// setUp function, add a number to numbers slice
func setUp(key string, value int) {
    numbers[key] = value
}

// tearDown function, delete a number to numbers slice
func tearDown(key string) {
    delete(numbers, key)
}

// First test
func TestOnePlusOne(t *testing.T) {
    numbers["one"] = numbers["one"] + 1

    if numbers["one"] != 2 {
        t.Error("1 plus 1 = 2, not %v", value)
    }
}

// Second test
func TestOnePlusTwo(t *testing.T) {
    numbers["one"] = numbers["one"] + 2

    if numbers["one"] != 3 {
        t.Error("1 plus 2 = 3, not %v", value)
    }
}

Innym przykładem może być przygotowanie bazy danych do przetestowania i wycofanie

 // ID of Person will be saved in database
personID := 12345
// Name of Person will be saved in database
personName := "Toni"

func TestMain(m *testing.M) {
    // You create an Person and you save in database
    setUp(&Person{
            ID:   personID,
            Name: personName,
            Age:  19,
        })
    retCode := m.Run()
    // When you have executed the test, the Person is deleted from database
    tearDown(personID)
    os.Exit(retCode)
}

func setUp(P *Person) {
    // ...
    db.add(P)
    // ...
}

func tearDown(id int) {
    // ...
    db.delete(id)
    // ...
}

func getPerson(t *testing.T) {
    P := Get(personID)
    
    if P.Name != personName {
        t.Error("P.Name is %s and it must be Toni", P.Name)
    }
}

Zobacz pokrycie kodu w formacie HTML

Uruchom go test normalnie, ale z flagą coverprofile . Następnie użyj go tool aby wyświetlić wyniki w formacie HTML.

    go test -coverprofile=c.out
    go tool cover -html=c.out