Go
analisi

introduzione

Test di base

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)
    }
}

Per eseguire il test basta usare il comando go test :

$ go test
ok      test_app    0.005s

Usa il flag -v per vedere i risultati di ogni test:

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

Utilizzare il percorso ./... per verificare in modo ricorsivo le sottodirectory:

$ 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

Esegui un test particolare:
Se ci sono più test e si desidera eseguire un test specifico, può essere fatto in questo modo:

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

Esempio:

go test -v run=TestSum

Test di riferimento

Se si desidera misurare parametri di riferimento, aggiungere un metodo di prova come questo:

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)
    }
}

Quindi, per eseguire un semplice benchmark:

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

Test unitari basati su tabella

Questo tipo di test è una tecnica diffusa per testare valori di input e output predefiniti.

Crea un file chiamato main.go con il contenuto:

package main

import (
    "fmt"
)

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

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

Dopo averlo eseguito, vedrai che l'output è 9 . Sebbene la funzione Sum piuttosto semplice, è una buona idea testare il codice. Per fare ciò, creiamo un altro file chiamato main_test.go nella stessa cartella di main.go , contenente il seguente codice:

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)
        }
    }
}

Come puoi vedere, viene creata una porzione di strutture anonime, ciascuna con un insieme di input e il risultato previsto. Ciò consente di creare un gran numero di casi di test tutti insieme in un unico punto, quindi eseguiti in un ciclo, riducendo la ripetizione del codice e migliorando la chiarezza.

Test di esempio (test di auto-documentazione)

Questo tipo di test assicura che il codice venga compilato correttamente e venga visualizzato nella documentazione generata per il progetto. In aggiunta a ciò, i test di esempio possono affermare che il test produce un output corretto.

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
}

Per eseguire il test, eseguire go test nella cartella contenente quei file OPPURE mettere questi due file in una sottocartella denominata sum e quindi dalla cartella padre eseguire go test ./sum . In entrambi i casi otterrai un risultato simile a questo:

ok      so/sum    0.005s

Se ti stai chiedendo come questo sta testando il tuo codice, ecco un'altra funzione di esempio, che in realtà fallisce il test:

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

    // Output:
    // 5
}

Quando esegui il go test , ottieni il seguente risultato:

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

Se vuoi vedere la documentazione per il tuo pacchetto sum - esegui semplicemente:

go doc -http=:6060

e vai a http: // localhost: 6060 / pkg / FOLDER / sum / , dove FOLDER è la cartella contenente il pacchetto sum (in questo esempio so ). La documentazione per il metodo sum si presenta così:

Test delle richieste 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)
    }
}

Imposta / Reimposta la funzione fittizia nei test

Questo esempio mostra come prendere in giro una chiamata di funzione che è irrilevante per il nostro test di unità, e quindi utilizzare l'istruzione di defer per riassegnare la funzione di chiamata simulata alla sua funzione originale.

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.
}

Nel nostro test unitario,

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
}

Test utilizzando la funzione setUp e tearDown

Puoi impostare una funzione setUp e tear-down.

• Una funzione setUp prepara il tuo ambiente ai test.
• Una funzione di TearDown esegue un rollback.

Questa è una buona opzione quando non è possibile modificare il database ed è necessario creare un oggetto che simuli un oggetto portato da un database o che sia necessario avviare una configurazione in ciascun test.

Un esempio stupido potrebbe essere:

// 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)
    }
}

Un altro esempio potrebbe essere la preparazione del database per testare e eseguire il rollback

 // 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)
    }
}

Visualizza la copertura del codice in formato HTML

Esegui il go test di go test normalmente, ma con la bandiera del profilo di coverprofile . Quindi utilizzare lo go tool per visualizzare i risultati in formato HTML.

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