Probar código que acepta context.Context

Las funciones que aceptan context.Context necesitan pruebas para éxito, tiempo de espera excedido y cancelación manual, no solo el camino feliz.

El paquete context de Go y los ayudantes de testing hacen que esos caminos sean deterministas sin dormir en CI.

Resumen

Usa context.WithTimeout o WithCancel en las pruebas para generar resultados de ctx.Err().

Prefiere fakes basados en canales sobre time.Sleep al probar la propagación de cancelación.

Aserción con errors.Is para context.Canceled y context.DeadlineExceeded.

Receta

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

func TestWorkCanceled(t *testing.T) {
    ctx, cancel := context.WithCancel(context.Background())
    cancel()
 
    err := Work(ctx)
    if !errors.Is(err, context.Canceled) {
        t.Fatalf("got %v, want Canceled", err)
    }
}

Cuándo usar esto:

• Pruebas de tabla para resultados de ctx junto con entradas normales.
• Usa tiempos de espera cortos (milisegundos) en lugar de esperas de varios segundos.
• Prueba manejadores HTTP con httptest y contextos de solicitud.

Ejemplo de trabajo

package work_test
 
import (
    "context"
    "errors"
    "testing"
    "time"
 
    "example.com/ctxdemo/work"
)
 
func TestFetchDeadline(t *testing.T) {
    ctx, cancel := context.WithTimeout(context.Background(), 20*time.Millisecond)
    defer cancel()
 
    err := work.Fetch(ctx, slowStub{})
    if !errors.Is(err, context.DeadlineExceeded) {
        t.Fatalf("got %v", err)
    }
}
 
func TestFetchCancel(t *testing.T) {
    ctx, cancel := context.WithCancel(context.Background())
    go func() {
        time.Sleep(5 * time.Millisecond)
        cancel()
    }()
 
    err := work.Fetch(ctx, slowStub{})
    if !errors.Is(err, context.Canceled) {
        t.Fatalf("got %v", err)
    }
}
 
type slowStub struct{}
 
func (slowStub) Run(ctx context.Context) error {
    select {
    case <-time.After(200 * time.Millisecond):
        return nil
    case <-ctx.Done():
        return ctx.Err()
    }
}

Lo que esto demuestra:

• DeadlineExceeded de un WithTimeout corto sin esperas largas en la ruta de aserción.
• cancel() manual desde otra gorrutina simula la desconexión del cliente.
• La dependencia stub respeta ctx de la misma manera que lo haría la E/S de producción.
• errors.Is mantiene las aserciones estables si los errores se envuelven con %w.

Inmersión Profunda

Cómo funciona

• Las pruebas construyen contextos independientemente de los servidores de producción; no se requiere una API especial solo para pruebas.
• t.Context() (Go 1.24+) proporciona un contexto cancelado cuando la prueba termina, útil para pruebas de integración.
• httptest.NewRequest adjunta un contexto de fondo; reemplázalo con req.WithContext(ctx) para casos de cancelación.
• Los relojes falsos rara vez son necesarios; los tiempos de espera inferiores a 50 ms mantienen las pruebas rápidas en CI.

Matriz de pruebas

Prueba de manejador HTTP

req := httptest.NewRequest(http.MethodGet, "/", nil)
ctx, cancel := context.WithCancel(req.Context())
cancel()
req = req.WithContext(ctx)
 
rec := httptest.NewRecorder()
handler(rec, req)
// esperar que no haya cuerpo de respuesta en la cancelación

Notas de Go

func wait(ctx context.Context, d time.Duration) error {
    timer := time.NewTimer(d)
    defer timer.Stop()
    select {
    case <-ctx.Done():
        return ctx.Err()
    case <-timer.C:
        return nil
    }
}

Siempre detén los temporizadores en pruebas y producción para evitar fugas.

Trampas

• Dormir para alcanzar los tiempos de espera - Inestable en corredores de CI cargados. Solución: usa cancel() inmediato o tiempos de espera de 1-20 ms.
• Comparar errores con == - Los errores envueltos fallan ==. Solución: errors.Is y errors.As.
• No llamar a cancel en las pruebas - Advertencias de fuga de temporizador en ejecuciones con -race. Solución: defer cancel() siempre.
• Usar Background en pruebas de manejador - Omite el comportamiento de desconexión. Solución: inyecta ctx cancelable a través de WithContext.
• Probar solo DeadlineExceeded - Las rutas de cancelación difieren en el registro y las métricas. Solución: cubre ambos errores terminales.
• Compartir ctx entre subpruebas paralelas - Carrera en cancel(). Solución: contexto por subprueba con cuidado de t.Parallel().

Alternativas

Preguntas Frecuentes

Relacionado

• Conceptos básicos de context - Primitivas de API bajo prueba
• Propagación de cancelación en manejadores HTTP - Cableado de httptest
• Tiempos de espera y plazos entre límites de servicio - Lógica de presupuesto para afirmar
• Contexto en database/sql y gRPC - Comportamiento de cancelación de integración
• Antipatrones de mal uso de contexto - Errores que las pruebas deberían detectar

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