testify, httptest y Test Doubles

Aserciones, pruebas de manejadores HTTP y mocks de interfaces.

Resumen

La biblioteca estándar cubre la ejecución de pruebas y el registro de respuestas HTTP.

testify añade fallos de aserción legibles; httptest es la biblioteca estándar para manejadores; los test doubles en Go suelen ser fakes escritos a mano detrás de interfaces pequeñas.

Receta

Tarjeta de referencia rápida - lista para copiar y pegar.

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())
}

Cuándo recurrir a esto:

• Los manejadores HTTP necesitan pruebas rápidas sin ListenAndServe
• Los fallos de aserción deben mostrar diferencias para structs y JSON
• El código de producción ya depende de interfaces que puedes simular (fake)
• Quieres que require detenga la configuración después de una precondición fallida
• Los límites de gRPC o DB necesitan dependencias inyectables

Ejemplo de Trabajo

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("not found")
 
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"])
}

Lo que esto demuestra:

• fakeStore implementa UserStore sin un generador de mocks
• httptest.NewServer ejercita el comportamiento real de http.Client
• t.Cleanup cierra el servidor después de la prueba
• testify separa las precondiciones fatales (require) de las comprobaciones adicionales (assert)

Inmersión Profunda

Cómo Funciona

• httptest.NewRecorder implementa http.ResponseWriter en memoria.
• httptest.NewServer enlaza 127.0.0.1:0 y devuelve una URL lista para el cliente.
• testify compara valores con reflect.DeepEqual y formatea las diferencias.
• Los fakes implementan la misma interfaz que los adaptadores de producción (SQL, gRPC, S3).

httptest vs Cliente net/http

Notas de Go

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

Los fakes escritos a mano se mantienen legibles para uno o dos métodos; los generadores ayudan con interfaces amplias.

Trampas Comunes

• Olvidar cerrar Response.Body - fuga conexiones bajo -count=100. Solución: defer resp.Body.Close() después de cada llamada al cliente.
• Aserción del orden de iteración de mapas en JSON - comparación de cadenas inestable. Solución: Usar require.JSONEq o decodificar en structs.
• Mockear structs concretos - los mocks de Go apuntan a interfaces. Solución: Extraer una interfaz estrecha en el punto de llamada.
• Mockear excesivamente ayudantes internos - las pruebas fallan en refactorizaciones sin cambio de comportamiento. Solución: Mockear solo los límites de E/S.
• Estado global de suite testify - suite.Suite comparte campos entre pruebas. Solución: Preferir TestXxx simples con tablas a menos que los hooks sean esenciales.
• No establecer el contexto de la solicitud - los manejadores que honran la cancelación fallan en las pruebas. Solución: req = req.WithContext(ctx) en la configuración.

Alternativas

Preguntas Frecuentes

Relacionado

• Conceptos Básicos de Pruebas en Go - Introducción a httptest y testify
• Pruebas Basadas en Tablas y Subpruebas - Casos de manejadores parametrizados
• Ejemplos como Documentación Ejecutable - Ejemplos de API pública
• Cobertura, Detector de Carreras y Archivos Dorados - snapshots y CI
• Mejores Prácticas de Pruebas - pirámide y política de doubles

Versiones de Stack: Esta página fue escrita para Go 1.26.x (Valor por defecto de GC Green Tea, go fix modernizers - verificar parche en la compilación), chi (última versión - verificar en la compilación), gin (última versión - verificar en la compilación), echo (última versión - verificar en la compilación), google.golang.org/grpc (última versión - verificar en la compilación), sigs.k8s.io/controller-runtime (última versión - verificar en la compilación), kubebuilder (última versión - verificar en la compilación), tinygo (última versión - verificar objetivos de placa en la compilación), wazero (última versión - verificar en la compilación) y golangci-lint (última versión - verificar conjunto de linters en la compilación).