Go
Pruebas

Introducción

Prueba basica

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

Para ejecutar la prueba solo usa el comando go test :

$ go test
ok      test_app    0.005s

Use la bandera -v para ver los resultados de cada prueba:

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

Use la ruta ./... para probar los subdirectorios recursivamente:

$ 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

Ejecutar una prueba particular:
Si hay varias pruebas y desea ejecutar una prueba específica, se puede hacer así:

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

Ejemplo:

go test -v run=TestSum

Pruebas de referencia

Si desea medir los puntos de referencia, agregue un método de prueba como este:

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

Entonces para ejecutar un simple benchmark:

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

Pruebas unitarias de mesa

Este tipo de prueba es una técnica popular para realizar pruebas con valores de entrada y salida predefinidos.

Crea un archivo llamado main.go con contenido:

package main

import (
    "fmt"
)

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

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

Después de ejecutarlo con, verá que la salida es 9 . Aunque la función Sum parece bastante simple, es una buena idea probar su código. Para hacer esto, creamos otro archivo llamado main_test.go en la misma carpeta que main.go , que contiene el siguiente código:

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

Como puede ver, se crea un segmento de estructuras anónimas, cada una con un conjunto de entradas y el resultado esperado. Esto permite crear una gran cantidad de casos de prueba en un solo lugar, luego ejecutarse en un bucle, reduciendo la repetición del código y mejorando la claridad.

Pruebas de ejemplo (auto documentar pruebas)

Este tipo de pruebas se aseguran de que su código se compile correctamente y aparecerá en la documentación generada para su proyecto. Además de eso, las pruebas de ejemplo pueden afirmar que su prueba produce un resultado adecuado.

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
}

Para ejecutar su prueba, ejecute go test en la carpeta que contiene esos archivos O coloque esos dos archivos en una subcarpeta denominada sum y luego, desde la carpeta principal, ejecute go test ./sum . En ambos casos obtendrás una salida similar a esta:

ok      so/sum    0.005s

Si se está preguntando cómo está probando su código, aquí hay otra función de ejemplo, que realmente falla la prueba:

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

    // Output:
    // 5
}

Cuando ejecutas go test , obtienes el siguiente resultado:

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

Si desea ver la documentación de su paquete de sum , simplemente ejecute:

go doc -http=:6060

y navegue a http: // localhost: 6060 / pkg / FOLDER / sum / , donde FOLDER es la carpeta que contiene el paquete de la sum (en este ejemplo, so ). La documentación para el método de suma se ve así:

Pruebas de solicitudes 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)
    }
}

Establecer / restablecer la función simulada en las pruebas

Este ejemplo muestra cómo simular una llamada de función que es irrelevante para nuestra prueba de unidad, y luego usar la instrucción de defer para volver a asignar la llamada de función simulada a su función original.

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

En nuestra prueba de unidad,

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
}

Pruebas usando la función setUp y tearDown

Puede configurar una función setUp y tearDown.

• Una función de configuración prepara su entorno para las pruebas.
• Una función tearDown hace un rollback.

Esta es una buena opción cuando no puede modificar su base de datos y necesita crear un objeto que simule un objeto traído de la base de datos o necesite iniciar una configuración en cada prueba.

Un ejemplo estúpido sería:

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

Otro ejemplo sería preparar la base de datos para probar y hacer la reversión

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

Ver cobertura de código en formato HTML

Ejecute go test como lo hace normalmente, pero con la coverprofile . Luego usa la go tool para ver los resultados como HTML.

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