Testando com testify & mockery

O pacote testing do Go é suficiente para correção, mas testify melhora as mensagens de falha e mockery gera implementações mock a partir de interfaces.

Juntos, eles aceleram testes baseados em tabelas, verificações de manipuladores HTTP e duplos de camada de serviço sem abandonar interfaces idiomáticas do Go.

Receita

Cartão de receita de referência rápida - pronto para copiar e colar.

import (
    "testing"
    "github.com/stretchr/testify/require"
)
 
func TestSum(t *testing.T) {
    require.Equal(t, 5, sum(2, 3))
}

# mockery v2+ (instale o binário separadamente)
mockery --name=UserRepository --dir=./internal/user --output=./internal/user/mocks

Quando usar isso:

• Testes com muitas verificações de igualdade onde o ruído de t.Fatalf esconde a primeira diferença
• Suítes de estilo de integração compartilhando servidores httptest e bancos de dados
• Serviços definidos contra interfaces que precisam de mocks gerados em CI
• Equipes padronizando o estilo de asserção em dezenas de pacotes

Exemplo de Trabalho

package user_test
 
import (
    "context"
    "errors"
    "testing"
 
    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/mock"
    "github.com/stretchr/testify/require"
 
    "example.com/libdemo/internal/user"
)
 
type mockRepo struct{ mock.Mock }
 
func (m *mockRepo) FindByID(ctx context.Context, id string) (user.User, error) {
    args := m.Called(ctx, id)
    return args.Get(0).(user.User), args.Error(1)
}
 
func TestService_GetUser(t *testing.T) {
    repo := new(mockRepo)
    repo.On("FindByID", mock.Anything, "u1").Return(user.User{ID: "u1"}, nil)
 
    svc := user.NewService(repo)
    got, err := svc.GetUser(context.Background(), "u1")
    require.NoError(t, err)
    assert.Equal(t, "u1", got.ID)
    repo.AssertExpectations(t)
}
 
func TestService_GetUser_NotFound(t *testing.T) {
    repo := new(mockRepo)
    repo.On("FindByID", mock.Anything, "missing").Return(user.User{}, errors.New("not found"))
 
    svc := user.NewService(repo)
    _, err := svc.GetUser(context.Background(), "missing")
    require.Error(t, err)
}

O que isso demonstra:

• require para pré-condições fatais, assert para verificações adicionais no mesmo teste
• Mock escrito à mão usando mock.Mock do testify (mockery gera essa forma)
• AssertExpectations verifica se todas as chamadas esperadas ocorreram
• A expansão baseada em tabela é natural: adicione casos a uma fatia e itere

Mergulho Profundo

Como Funciona

• testify/assert registra falhas e continua; require para o teste imediatamente.
• testify/suite incorpora suite.Suite para hooks de setup/teardown em métodos nomeados TestX.
• mockery lê definições de interface e emite structs mock tipados com helpers On/Return.
• Go prefere interfaces pequenas no consumidor; mockery visa essas interfaces, não structs concretas.

require vs assert

Fluxo de Trabalho do mockery

1. Defina type UserRepository interface { ... } no pacote de produção.
2. Execute mockery em CI ou go generate com uma diretiva //go:generate.
3. Commite mocks gerados ou regenere em CI antes do teste (política da equipe).
4. Prefira fakes (mapas em memória) quando o comportamento for simples; mocks quando verificar contratos de chamada.

Notas Go

//go:generate mockery --name=UserRepository --output=./mocks --outpkg=mocks

• Mantenha mocks em subpacotes mocks para evitar ciclos de importação.
• Passe context.Context através de mocks da mesma forma que o código de produção faz.
• Não mocke tipos da biblioteca padrão; encapsule clientes externos atrás da sua interface em vez disso.

Armadilhas

• Mockar tipos concretos em excesso - mockery precisa de interfaces; mockar structs acopla testes à implementação. Correção: extraia interfaces estreitas no local da chamada.
• Afirmar strings de erro - frágil quando as mensagens mudam. Correção: use errors.Is / errors.As com ErrorIs do testify.
• Estado global da suíte - campos compartilhados são mutados entre testes paralelos. Correção: execute suítes sem t.Parallel() ou isole o estado por teste.
• Mocks gerados desatualizados - mudanças na interface quebram a compilação em CI. Correção: go generate ./... em CI ou pre-commit.
• Abuso de mock.Anything - esconde argumentos incorretos. Correção: use mock.MatchedBy para correspondentes parciais quando necessário.
• testify em bibliotecas - publicar pacotes não deve forçar testify nos consumidores. Correção: mantenha as asserções apenas em arquivos _test.go.

Alternativas

FAQs

Relacionados

• testify, httptest & Test Doubles - httptest e fakes
• Noções Básicas de Bibliotecas Essenciais - asserção rápida com testify
• Noções Básicas de Testes Go - padrões baseados em tabelas
• Definindo e Implementando Interfaces - design de interface para mocks
• Camadas de Handler, Serviço, Repositório - onde os duplos se conectam

Versões da Stack: Esta página foi escrita para Go 1.26.x (GC padrão Green Tea, go fix modernizers - verifique o patch na compilação), chi (última versão - verifique na compilação), gin (última versão - verifique na compilação), echo (última versão - verifique na compilação), google.golang.org/grpc (última versão - verifique na compilação), sigs.k8s.io/controller-runtime (última versão - verifique na compilação), kubebuilder (última versão - verifique na compilação), tinygo (última versão - verifique os alvos de placa na compilação), wazero (última versão - verifique na compilação) e golangci-lint (última versão - verifique o conjunto de linters na compilação). NzA2MjAyfDA5NG9pZ2N8b2kuc2VkaXVnZWRvYw==