testify, httptest & Test Doubles

Asserções, testes de manipuladores HTTP e mocks de interface.

Resumo

A biblioteca padrão cobre a execução de testes e a gravação de respostas HTTP.

testify adiciona falhas de asserção legíveis; httptest é stdlib para manipuladores; test doubles em Go são geralmente fakes escritos à mão por trás de interfaces pequenas.

Receita

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

import (
	"net/http"
	"net/http/httptest"
	"testing"
 
	"github.com/stretchr/testify/require"
)
 
func TestHandler(t *testing.T) {
	req := httptest.NewRequest(http.MethodGet, "/health", nil)
	rec := httptest.NewRecorder()
	HealthHandler(rec, req)
	require.Equal(t, http.StatusOK, rec.Code)
	require.JSONEq(t, `{"status":"ok"}`, rec.Body.String())
}

Quando usar isso:

• Manipuladores HTTP precisam de testes rápidos sem ListenAndServe
• Falhas de asserção devem mostrar diffs para structs e JSON
• O código de produção já depende de interfaces que você pode simular
• Você quer que require pare a configuração após uma pré-condição falha
• Limites gRPC ou de DB precisam de dependências injetáveis

Exemplo de Trabalho

package api
 
import (
	"context"
	"encoding/json"
	"errors"
	"net/http"
	"net/http/httptest"
	"testing"
 
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)
 
var ErrNotFound = errors.New("não encontrado")
 
type UserStore interface {
	Get(ctx context.Context, id string) (string, error)
}
 
type fakeStore struct {
	users map[string]string
}
 
func (f *fakeStore) Get(ctx context.Context, id string) (string, error) {
	if name, ok := f.users[id]; ok {
		return name, nil
	}
	return "", ErrNotFound
}
 
func UserHandler(store UserStore) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		id := r.URL.Query().Get("id")
		name, err := store.Get(r.Context(), id)
		if err != nil {
			http.Error(w, err.Error(), http.StatusNotFound)
			return
		}
		_ = json.NewEncoder(w).Encode(map[string]string{"name": name})
	}
}
 
func TestUserHandler(t *testing.T) {
	store := &fakeStore{users: map[string]string{"1": "Ada"}}
	srv := httptest.NewServer(UserHandler(store))
	t.Cleanup(srv.Close)
 
	resp, err := http.Get(srv.URL + "?id=1")
	require.NoError(t, err)
	defer resp.Body.Close()
	require.Equal(t, http.StatusOK, resp.StatusCode)
 
	var body map[string]string
	require.NoError(t, json.NewDecoder(resp.Body).Decode(&body))
	assert.Equal(t, "Ada", body["name"])
}

O que isso demonstra:

• fakeStore implementa UserStore sem um gerador de mock
• httptest.NewServer exercita o comportamento real do http.Client
• t.Cleanup fecha o servidor após o teste
• testify separa pré-condições fatais (require) de verificações extras (assert)

Mergulho Profundo

Como Funciona

• httptest.NewRecorder implementa http.ResponseWriter em memória.
• httptest.NewServer vincula 127.0.0.1:0 e retorna uma URL pronta para o cliente.
• testify compara valores com reflect.DeepEqual e formata diffs.
• Fakes implementam a mesma interface que os adaptadores de produção (SQL, gRPC, S3).

httptest vs Cliente net/http

Notas Go

// gomock (opcional): go.uber.org/mock/mockgen
// Gerar: mockgen -destination=mocks/store_mock.go . UserStore

Fakes escritos à mão permanecem legíveis para um ou dois métodos; geradores ajudam interfaces amplas.

Armadilhas

• Esquecer de fechar Response.Body - vaza conexões sob -count=100. Correção: defer resp.Body.Close() após cada chamada do cliente.
• Afirmar ordem de iteração de mapa em JSON - comparação de string instável. Correção: Use require.JSONEq ou decodifique em structs.
• Mockar structs concretas - Mocks Go visam interfaces. Correção: Extraia uma interface estreita no local da chamada.
• Mockar excessivamente helpers internos - testes quebram em refatorações sem mudança de comportamento. Correção: Mockar apenas limites de IO.
• Estado global de suíte testify - suite.Suite compartilha campos entre testes. Correção: Prefira TestXxx simples com tabelas, a menos que hooks sejam essenciais.
• Não definir o contexto da requisição - manipuladores que honram o cancelamento falham em testes. Correção: req = req.WithContext(ctx) na configuração.

Alternativas

FAQs

Relacionados

• Noções Básicas de Teste em Go - introdução a httptest e testify
• Testes Orientados a Tabela & Subtestes - casos de manipulador parametrizados
• Exemplos como Documentação Executável - exemplos de API pública
• Cobertura, Detector de Corrida & Arquivos Golden - snapshots e CI
• Melhores Práticas de Teste - pirâmide e política de doubles

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