Testes em Go (Golang): frameworks e ferramentas

Testes em Go (Golang): frameworks e ferramentas

Go (Golang) é uma das poucas linguagens onde os testes são incorporados ao nível da biblioteca padrão. Graças ao pacote embutido testing, bem como a poderosas ferramentas de terceiros, os desenvolvedores podem construir aplicações confiáveis e eficientes. Neste artigo, abordaremos os principais frameworks e utilitários para testar código em Go: desde testes unitários simples até mocks e verificação de vazamentos de goroutines.

Pacote embutido testing

O pacote testing é a base de todos os testes em Go. Os testes são escritos em arquivos com o sufixo _test.go. As funções de teste devem ter a assinatura func TestXxx(t *testing.T). A execução é feita com o comando go test.

package main

import (    "testing")

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

func TestSum(t *testing.T) {    result := Sum(2, 3)    expected := 5    if result != expected {        t.Errorf("Sum(2,3) = %d; want %d", result, expected)    }}

Para testes tabulares, utiliza-se um slice de structs:

func TestSumTable(t *testing.T) {    tests := []struct {        a, b, expected int    }{        {1, 2, 3},        {0, 0, 0},        {-1, 1, 0},    }    for _, tt := range tests {        result := Sum(tt.a, tt.b)        if result != tt.expected {            t.Errorf("Sum(%d,%d) = %d; want %d", tt.a, tt.b, result, tt.expected)        }    }}

Também são suportados:

• Benchmarks — funções func BenchmarkXxx(b *testing.B), executadas com go test -bench=.
• Exemplos — funções func ExampleXxx() para gerar documentação e verificar a saída.
• Subtestes — t.Run("nome", func(t *testing.T) {...}) para agrupamento e execução paralela.

Testify — expandindo possibilidades

Testify é o framework mais popular para testes em Go. Ele adiciona asserções convenientes, mocks e um conjunto de utilitários.

Principais pacotes do Testify:

• assert — verificações com mensagens de erro claras.
• require — como assert, mas interrompe o teste em caso de falha.
• mock — criação e verificação de objetos mock.
• suite — agrupamento de testes em classes (estilo TDD).

import (    "testing"    "github.com/stretchr/testify/assert"    "github.com/stretchr/testify/mock")

// Exemplo de uso do assertfunc TestSumWithTestify(t *testing.T) {    assert.Equal(t, 5, Sum(2, 3))    assert.NotEqual(t, 0, Sum(-1, 1))}

// Exemplo de mock com testify/mocktype Calculator interface {    Add(a, b int) int}

type MockCalculator struct {    mock.Mock}

func (m *MockCalculator) Add(a, b int) int {    args := m.Called(a, b)    return args.Int(0)}

func TestWithMock(t *testing.T) {    mockCalc := new(MockCalculator)    mockCalc.On("Add", 2, 3).Return(5)

    result := mockCalc.Add(2, 3)    assert.Equal(t, 5, result)    mockCalc.AssertExpectations(t)}

Gomock — geração de mocks a partir de interfaces

Gomock (fork do original do Google) é uma ferramenta para geração automática de mocks baseados em interfaces. É usado em conjunto com o utilitário mockgen.

Instalação e exemplo básico:

// Instalaçãogo install go.uber.org/mock/mockgen@latest

// Geração de mock para uma interface// mockgen -source=calculator.go -destination=mock_calculator.go -package=main

// Uso no testefunc TestWithGomock(t *testing.T) {    ctrl := gomock.NewController(t)    defer ctrl.Finish()

    mockCalc := NewMockCalculator(ctrl)    mock