Dublês de teste: mocks e stubs
Use interfaces para facilitar testes e a injeção de dependências
Dublês de teste: mocks e stubs é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.
Visão geral dos dublês de teste
Um dublê de teste substitui uma dependência real nos testes. Tipos: dublê de respostas (retorna respostas predefinidas), simulação (verifica interações), espião (registra chamadas), implementação falsa (implementação funcional em memória).
Interfaces permitem dublês de teste
Projete as funções para aceitarem interfaces em vez de tipos concretos. Em produção, forneça a implementação real; nos testes, forneça um dublê de teste.
type UserStore interface {
FindByID(id int) (*User, error)
}
func GetUser(store UserStore, id int) (*User, error) {
return store.FindByID(id)
}Dublê de respostas manual
Um dublê de respostas é uma estrutura simples que implementa uma interface e retorna valores pré-configurados:
type stubStore struct{ user *User; err error }
func (s *stubStore) FindByID(_ int) (*User, error) { return s.user, s.err }
// In test:
store := &stubStore{user: &User{Name: "Alice"}}
result, _ := GetUser(store, 1)Simulação manual
Uma simulação registra chamadas e faz asserções sobre elas:
type mockStore struct {
called bool
gotID int
user *User
}
func (m *mockStore) FindByID(id int) (*User, error) {
m.called = true; m.gotID = id
return m.user, nil
}
// Assert: if !mock.called { t.Error(...) }testify/mock
O pacote testify/mock gera ou escreve objetos de simulação com expectativas de chamadas e configuração de valores de retorno:
type MockStore struct { mock.Mock }
func (m *MockStore) FindByID(id int) (*User, error) {
args := m.Called(id)
return args.Get(0).(*User), args.Error(1)
}
// In test:
m := new(MockStore)
m.On("FindByID", 1).Return(&User{}, nil)
m.AssertExpectations(t)gomock
go.uber.org/mock/gomock (anteriormente golang/mock) gera simulações a partir de interfaces. Use a CLI mockgen para gerar; use EXPECT() para definir expectativas.
Implementação falsa
Uma implementação falsa é uma implementação funcional em memória. Por exemplo, um armazenamento de usuários em memória que armazena usuários em um mapa. Implementações falsas exigem mais trabalho para serem escritas, mas são mais realistas e menos frágeis que simulações.
type fakeStore struct{ users map[int]*User }
func (f *fakeStore) FindByID(id int) (*User, error) {
u, ok := f.users[id]
if !ok { return nil, ErrNotFound }
return u, nil
}httptest para clientes HTTP
net/http/httptest fornece um servidor HTTP de teste no processo e um registrador — o dublê padrão para dependências baseadas em HTTP.
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
json.NewEncoder(w).Encode(User{Name: "Alice"})
}))
defer ts.Close()Quando usar cada dublê
Dublê de respostas: resposta fixa simples. Simulação: verifica a quantidade de chamadas e os argumentos. Implementação falsa: comportamento complexo. Evite simular em excesso — implementações falsas e componentes reais em testes de integração são mais confiáveis.
Como evitar testes frágeis
Simulações que verificam a ordem exata das chamadas ou os valores exatos dos argumentos tornam-se frágeis à medida que a implementação evolui. Prefira dublês de respostas com asserções sobre a saída ou implementações falsas quando possível.
Descoberta de interfaces
Extraia interfaces depois de identificar a superfície do tipo concreto usada pelos chamadores (ISP). Go oferece satisfação implícita de interfaces — não é necessária nenhuma modificação no tipo concreto.
Verificação rápida
Qual é a principal diferença entre um dublê de respostas e uma simulação?
Recapitulação: dublês de teste
Pontos principais:
- Projete com base em interfaces para permitir dublês de teste
- Dublê de respostas: retorna dados predefinidos; simulação: verifica interações
- httptest para HTTP; implementações falsas em memória para armazenamento
- Evite simular em excesso — prefira implementações falsas para comportamentos complexos
Aprenda Go com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 51
- Aulas
- 203
Perguntas Frequentes
A aula “Dublês de teste: mocks e stubs” é grátis?
Sim — o texto completo de “Dublês de teste: mocks e stubs” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.
O que vou aprender em “Dublês de teste: mocks e stubs”?
Use interfaces para facilitar testes e a injeção de dependências Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Go Academy?
Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.
Quanto tempo leva a aula “Dublês de teste: mocks e stubs”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Go Academy?
Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Escrevendo testes unitários com testing
- Testes orientados por tabelas
- Dublês de teste: mocks e stubs
- Cobertura de testes e testify