Cobertura, Detector de Corrida & Arquivos Golden

Perfis de cobertura, -race no CI e testes de snapshot.

Resumo

Cobertura informa qual código foi executado; o detector de corrida informa se o acesso concorrente foi inseguro; arquivos golden capturam a saída esperada para regressões.

Juntos, eles fortalecem o CI quando combinados com asserções significativas, não como métricas de vaidade isoladamente.

Receita

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

go test -race -coverprofile=coverage.out ./...
go tool cover -func=coverage.out
go test -update ./...   # padrão: flag customizada atualiza arquivos golden

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

Quando usar isso:

• O CI precisa de um portão de merge para tendências de teste, corrida e cobertura
• A saída do renderizador ou CLI não deve mudar acidentalmente
• Código concorrente usa mapas compartilhados, caches ou singletons preguiçosos
• Refatorações devem provar que o comportamento não mudou através de diffs golden
• Operadores querem mapas de cobertura HTML para branches de erro não testados

Exemplo de Trabalho

package report
 
import (
	"flag"
	"os"
	"path/filepath"
	"strconv"
	"sync"
	"testing"
)
 
var updateGolden = flag.Bool("update", false, "atualiza arquivos golden")
 
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("golden mismatch\n--- want\n%s--- got\n%s", want, got)
	}
}

O que isso demonstra:

• go test -race exercita TestIncRaceSafe com instrumentação
• Arquivo golden em testdata/ captura a saída formatada
• A flag -update reescreve os arquivos golden intencionalmente após revisão
• O uso de Mutex mantém o detector de corrida silencioso no cache compartilhado

Mergulho Profundo

Como Funciona

• Cobertura registra contagens de execução de instruções por execução via -coverprofile.
• go tool cover -html colore linhas de verde/vermelho para análise manual de lacunas.
• O detector de corrida instrumenta acessos à memória; o custo é aproximadamente 2-10x a CPU.
• Testes golden comparam bytes de saída; diffs destacam mudanças não intencionais no renderizador.

Modos de Cobertura

Detector de Corrida no CI

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

Executar em agentes CI Linux; suporte macOS/Windows existe, mas Linux é o padrão comum.

Notas Go

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

go-cmp produz diffs golden legíveis para structs e JSON.

Armadilhas

• Buscar 100% de cobertura - testes não afirmam nada significativo. Correção: Gate em pacotes críticos; exigir asserções em caminhos de erro.
• Pular -race porque o CI é lento - corridas vão para produção. Correção: Executar -race em pelo menos pacotes com goroutines; fragmentar testes.
• Commit de arquivos golden sem revisão - -update esconde bugs. Correção: Tratar diffs golden como material de revisão de código.
• Arquivos golden não determinísticos - timestamps e ordem de mapa causam instabilidade. Correção: Normalizar saída; ordenar chaves; simular relógios.
• Arquivos golden fora de testdata - polui a raiz do pacote. Correção: Usar testdata/ por convenção.
• Cobertura sem -covermode=atomic em testes paralelos - contagens imprecisas. Correção: Usar modo atômico quando os testes usam t.Parallel().

Alternativas

FAQs

Relacionado

• Noções Básicas de Teste em Go - Introdução rápida a -race
• Testes de Fuzzing com testing.F - corpus em testdata
• Testes Baseados em Tabela & Subtestes - casos antes de snapshots
• testify, httptest & Test Doubles - asserções JSON vs golden files
• Portões de Qualidade de CI: Lint, Teste, Corrida, Vulnerabilidade - template de pipeline

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