Mockery para Go: guia completo com exemplos práticos

1. O que é e para que serve

Mockery é uma ferramenta poderosa para gerar objetos mock (mock objects) na linguagem Go. No desenvolvimento moderno com Go, onde as interfaces desempenham um papel fundamental, testar componentes isolados frequentemente exige a criação de substitutos para dependências externas. O Mockery automatiza esse processo, gerando implementações completas de interfaces que podem ser usadas em testes unitários. Em vez de escrever dezenas de linhas de código manualmente para cada interface, você executa um único comando e obtém um mock pronto com todos os métodos necessários.

O principal objetivo do Mockery é simplificar o teste de código que depende de serviços externos (bancos de dados, APIs, sistemas de arquivos, etc.). Os mocks gerados permitem controlar os valores retornados, verificar o número de chamadas de métodos e os argumentos com os quais foram chamados. Isso é especialmente útil no desenvolvimento de microsserviços, onde cada componente deve ser testado isoladamente. A biblioteca usa o popular pacote testify/mock como base, garantindo compatibilidade com a maioria dos projetos Go.

O Mockery suporta desde interfaces simples com poucos métodos até hierarquias complexas. Ele consegue gerar mocks para tipos embutidos, interfaces de pacotes de terceiros e até mesmo interfaces genéricas (a partir do Go 1.18). Graças a um sistema flexível de configuração, você pode controlar nomes de arquivos, pacotes onde os mocks são colocados e até adicionar métodos personalizados. Isso torna o Mockery uma ferramenta indispensável no arsenal de qualquer desenvolvedor Go que busca código de qualidade e fácil manutenção.

2. Instalação

A instalação do Mockery é feita através do gerenciador de pacotes padrão do Go. Para isso, execute o comando:

go install github.com/vektra/mockery/v2@latest

Após a instalação, verifique se o arquivo binário está no seu $PATH. Geralmente ele é instalado em $GOPATH/bin ou $HOME/go/bin. Você pode confirmar a instalação com o comando:

mockery --version

Se você usa módulos Go, é recomendável adicionar o Mockery como uma ferramenta de desenvolvimento. Para isso, crie ou edite o arquivo tools.go na raiz do projeto:

//go:build tools
// +build tools

package tools

import (
    _ "github.com/vektra/mockery/v2"
)

Em seguida, execute:

go mod tidy

Isso garante que a versão do Mockery seja fixada no seu arquivo go.mod.

3. Início rápido — exemplo mínimo funcional

Vamos a um exemplo simples. Suponha que temos a interface UserRepository:

// user.go
package main

type User struct {
    ID   int
    Name string
}

type UserRepository interface {
    GetUser(id int) (*User, error)
    SaveUser(user *User) error
}

Para gerar o mock, execute o comando na raiz do projeto:

mockery --name=UserRepository --output=mocks --with-expecter

Este comando criará o arquivo mocks/UserRepository.go com a implementação do mock. Agora podemos usá-lo em um teste:

// user_test.go
package main

import (
    "testing"
    "github.com/stretchr/testify/assert"
    "seu-projeto/mocks"
)

func TestGetUser(t *testing.T) {
    // Criamos o mock
    mockRepo := mocks.NewUserRepository(t)
    
    // Configuramos o comportamento esperado
    expectedUser := &User{ID: 1, Name: "Alice"}
    mockRepo.On("GetUser", 1).Return(expectedUser, nil)
    
    // Chamamos a função sendo testada
    user, err := mockRepo.GetUser(1)
    
    // Verificamos os resultados
    assert.NoError(t, err)
    assert.Equal(t, expectedUser, user)
    
    // Verificamos se todas as expectativas foram cumpridas
    mockRepo.AssertExpectations(t)
}