Skill de Pruebas y Benchmarking de Go

Plantillas de pruebas basadas en tablas y fuzzing para agentes: una Skill de Agente estilo "cookbook" para la generación de pruebas de Go 1.26 a partir de criterios de aceptación.

Qué Hace Esta Skill

Produce plantillas de pruebas: subpruebas t.Run basadas en tablas, casos de httptest handler, semillas F.Add para fuzzing y stubs de benchmarking, con comandos de verificación go test, no reescrituras de código de producción.

Cuándo Invocar

• El agente solicitó "añadir pruebas" sin estructura
• Un nuevo paquete necesita cobertura basada en tablas a partir de viñetas de AC (Criterios de Aceptación)
• Se necesita un objetivo de fuzzing para analizadores de cadenas/JSON
• Stub de benchmarking antes del trabajo de rendimiento (se empareja con Skill de Perfilado de Rendimiento de Go)
• Falta de subpruebas para ramas de error en un PR

Entradas

Salidas

• Plantilla *_test.go con slice de tabla y subpruebas
• FuzzXxx opcional con semillas del corpus
• BenchmarkXxx opcional con b.Loop (estilo Go 1.24+) o bucle clásico
• Comandos: go test ./pkg/..., go test -race, go test -fuzz=FuzzParse -fuzztime=30s

Barreras

1. Comportamiento de prueba, no ayudantes no exportados, a menos que la política de caja blanca del mismo paquete lo permita.
2. No usar time.Sleep para sincronización: usar canales, synctest o interfaces.
3. Subpruebas paralelas solo cuando estén aisladas: t.Parallel() documentado por caso.
4. Fuzzing solo de analizadores puros: sin red/base de datos en el objetivo de fuzzing sin una configuración intensiva.
5. Ejecutar pruebas antes de entregar la plantilla: debe compilar.
6. Archivos dorados (Golden files): actualizar con el patrón de bandera -update explícito según la política del equipo.

Receta

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

func TestParseID(t *testing.T) {
    tests := []struct {
        name    string
        in      string
        want    string
        wantErr bool
    }{
        {name: "valid", in: "abc-123", want: "abc-123"},
        {name: "empty", in: "", wantErr: true},
        {name: "spaces", in: "  ", wantErr: true},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got, err := ParseID(tt.in)
            if tt.wantErr {
                if err == nil {
                    t.Fatal("expected error")
                }
                return
            }
            if err != nil {
                t.Fatalf("unexpected: %v", err)
            }
            if got != tt.want {
                t.Fatalf("got %q want %q", got, tt.want)
            }
        })
    }
}

go test ./internal/parse/... -count=1
go test -race ./internal/parse/...   # si el paquete usa goroutines

Cuándo recurrir a esta skill:

• La lista de AC del PM necesita subpruebas mapeadas antes de la fusión.
• El agente produjo una única función gigante TestEverything.
• El paquete del analizador necesita fuzzing antes de la revisión de seguridad.

Ejemplo de Trabajo

Paso 0 - Mapear AC a casos

AC:
- UUID válido devuelve forma normalizada
- UUID inválido devuelve ErrInvalid
- Entrada vacía devuelve ErrEmpty

Cada viñeta se convierte en el nombre de t.Run y una fila de la tabla.

Paso 1 - Prueba de manejador con httptest

func TestGetUserHandler(t *testing.T) {
    srv := httptest.NewServer(http.HandlerFunc(getUser))
    t.Cleanup(srv.Close)
 
    resp, err := http.Get(srv.URL + "/users/1")
    if err != nil {
        t.Fatal(err)
    }
    defer resp.Body.Close()
    if resp.StatusCode != http.StatusOK {
        t.Fatalf("status %d", resp.StatusCode)
    }
}

• Preferir probar el manejador a través de httptest.NewRecorder para el alcance unitario.
• Ver httptest para Pruebas de Integración de Handlers.

Paso 2 - Plantilla de fuzzing

func FuzzParseID(f *testing.F) {
    f.Add("abc-123")
    f.Add("")
    f.Fuzz(func(t *testing.T, in string) {
        _, _ = ParseID(in) // no debe entrar en pánico; documentar invariantes
    })
}

go test -fuzz=FuzzParseID -fuzztime=30s ./internal/parse/

Paso 3 - Stub de benchmarking

func BenchmarkParseID(b *testing.B) {
    for b.Loop() {
        _, _ = ParseID("abc-123")
    }
}

go test -bench=BenchmarkParseID -benchmem ./internal/parse/ -count=5

Análisis Profundo

testify / cmp: si el equipo usa github.com/stretchr/testify, la skill importa require por ADR.

De lo contrario, las aserciones solo de la biblioteca estándar mantienen las dependencias mínimas.

Ejemplos (ExampleXxx): para fragmentos verificados por godoc - ver Ejemplos como Documentación Ejecutable.

Cobertura: go test -cover ./... para el informe; la skill no persigue el 100% en la plantilla generada.

Etiquetas de compilación: pruebas de integración detrás de //go:build integration - la skill separa las tablas de unidades rápidas de las IT lentas.

Trampas Comunes

• Nombre de subprueba con / rompe la expresión regular -run - usar nombres seguros.
• Variable de bucle en subpruebas paralelas - capturar tt := tt antes de t.Parallel().
• Fuzzing en funciones que mutan estado global - aislar o omitir el fuzzing.
• Benchmarking sin restablecer la entrada - sesga las mediciones de asignación.

Alternativas

Preguntas Frecuentes

Relacionado

• Conceptos Básicos de las Skills de Agente - estructura de SKILL.md
• Conceptos Básicos de Pruebas en Go - introducción a las pruebas
• Pruebas Basadas en Tablas y Subpruebas - patrones
• Pruebas de Fuzzing con testing.F - referencia de fuzzing
• Benchmarks con testing.B y b.Loop - benchmarks
• testify, httptest y Test Doubles - doubles

Versiones de Stack: Esta página fue escrita para Go 1.26.x (Green Tea GC por defecto, 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).