Cobertura, Detector de Carreras y Archivos Dorados

Perfiles de cobertura, -race en CI y pruebas de instantáneas.

Resumen

La cobertura te dice qué código se ejecutó; el detector de carreras te dice si el acceso concurrente fue inseguro; los archivos dorados capturan la salida esperada para regresiones.

Juntos fortalecen la CI cuando se combinan con aserciones significativas, no como métricas de vanidad por sí solas.

Receta

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

go test -race -coverprofile=coverage.out ./...
go tool cover -func=coverage.out
go test -update ./...   # patrón: flag personalizado actualiza archivos dorados

func TestRenderGolden(t *testing.T) {
	got := Render()
	want, err := os.ReadFile("testdata/render.out")
	if err != nil {
		t.Fatal(err)
	}
	if diff := cmp.Diff(string(want), got); diff != "" {
		t.Fatalf("diff:\n%s", diff)
	}
}

Cuándo usar esto:

• La CI necesita una puerta de enlace de fusión en tendencias de pruebas, race y cobertura
• La salida del renderizador o de la CLI no debe cambiar accidentalmente
• El código concurrente utiliza mapas compartidos, cachés o singletons perezosos
• Las refactorizaciones deben demostrar que el comportamiento no ha cambiado a través de diffs dorados
• Los operadores desean mapas de cobertura HTML para ramas de error no probadas

Ejemplo de Trabajo

package report
 
import (
	"flag"
	"os"
	"path/filepath"
	"strconv"
	"sync"
	"testing"
)
 
var updateGolden = flag.Bool("update", false, "actualizar archivos dorados")
 
var cache = struct {
	mu sync.Mutex
	m  map[string]int
}{m: make(map[string]int)}
 
func Inc(key string) {
	cache.mu.Lock()
	cache.m[key]++
	cache.mu.Unlock()
}
 
func FormatReport(keys []string) string {
	out := ""
	for _, k := range keys {
		cache.mu.Lock()
		n := cache.m[k]
		cache.mu.Unlock()
		out += k + ":" + strconv.Itoa(n) + "\n"
	}
	return out
}
 
func TestIncRaceSafe(t *testing.T) {
	var wg sync.WaitGroup
	for i := 0; i < 100; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			Inc("x")
		}()
	}
	wg.Wait()
}
 
func TestFormatReportGolden(t *testing.T) {
	Inc("a")
	Inc("a")
	Inc("b")
	got := FormatReport([]string{"a", "b"})
	path := filepath.Join("testdata", "report.golden")
	if *updateGolden {
		if err := os.WriteFile(path, []byte(got), 0644); err != nil {
			t.Fatal(err)
		}
	}
	want, err := os.ReadFile(path)
	if err != nil {
		t.Fatal(err)
	}
	if string(want) != got {
		t.Fatalf("desajuste dorado\n--- want\n%s--- got\n%s", want, got)
	}
}

Lo que esto demuestra:

• go test -race ejercita TestIncRaceSafe con instrumentación
• El archivo dorado bajo testdata/ captura la salida formateada
• El flag -update reescribe los archivos dorados intencionalmente después de la revisión
• El uso de Mutex mantiene el detector de carreras en silencio en la cache compartida

Profundización

Cómo Funciona

• La cobertura registra los recuentos de ejecución de sentencias por ejecución a través de -coverprofile.
• go tool cover -html colorea las líneas en verde/rojo para análisis manual de brechas.
• El detector de carreras instrumenta los accesos a memoria; el costo es aproximadamente 2-10x la CPU.
• Las pruebas doradas comparan los bytes de salida; los diffs resaltan cambios no intencionados del renderizador.

Modos de Cobertura

Detector de Carreras en CI

go test -race -timeout=10m ./...

Ejecutar en agentes de CI Linux; el soporte de macOS/Windows existe pero Linux es el predeterminado común.

Notas de Go

import "github.com/google/go-cmp/cmp"
 
if diff := cmp.Diff(want, got); diff != "" {
	t.Fatalf("desajuste (-want +got):\n%s", diff)
}

go-cmp produce diffs dorados legibles para structs y JSON.

Trampas

• Perseguir el 100% de cobertura - las pruebas no afirman nada significativo. Solución: Controlar paquetes críticos; requerir aserciones en rutas de error.
• Omitir -race porque la CI es lenta - las carreras se envían a producción. Solución: Ejecutar race al menos en paquetes con goroutines; fragmentar pruebas.
• Confirmar archivos dorados sin revisión - -update oculta errores. Solución: Tratar los diffs dorados como material de revisión de código.
• Archivos dorados no deterministas - las marcas de tiempo y el orden de los mapas causan inestabilidad. Solución: Normalizar la salida; ordenar claves; simular relojes.
• Archivos dorados fuera de testdata - contamina la raíz del paquete. Solución: Usar testdata/ por convención.
• Cobertura sin -covermode=atomic en pruebas paralelas - recuentos inexactos. Solución: Usar modo atómico cuando las pruebas usan t.Parallel().

Alternativas

Preguntas Frecuentes

Relacionados

• Conceptos Básicos de Pruebas en Go - Introducción rápida a -race
• Pruebas de Fuzzing con testing.F - corpus bajo testdata
• Pruebas Basadas en Tablas y Subpruebas - casos antes de instantáneas
• testify, httptest y Test Doubles - aserciones JSON vs archivos dorados
• Puertas de Calidad de CI: Lint, Test, Race, Vuln - plantilla de pipeline

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