Go possui testes integrados via o pacote testing e o comando go test — nenhum framework externo necessário. Os testes vivem em arquivos _test.go, e Go enfatiza fortemente testes table-driven, benchmarks e bom ferramental como características de primeira classe.
// math.go
func Add(a, b int) int { return a + b }
// math_test.go — same package, _test.go suffix
import "testing"
func TestAdd(t *testing.T) { // Test prefix + *testing.T parameter
result := Add(2, 3)
if result != 5 {
t.Errorf("Add(2,3) = %d; want 5", result) // report failure (continues)
// t.Fatalf stops the test immediately
}
}
// run with: go test (or `go test -v` for verbose, `go test ./...` for all packages)
Uma função de teste começa com Test, recebe *testing.T e relata falhas via t.Errorf/t.Fatalf. Não há palavras-chave de asserção — você verifica condições com um simples if e relata falhas (Go favorece este estilo explícito).
func TestAdd(t *testing.T) {
tests := []struct { // a table of test CASES
name string
a, b int
expected int
}{
{"positives", 2, 3, 5},
{"with zero", 0, 5, 5},
{"negatives", -1, -1, -2},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { // a SUBTEST per case (named, isolated)
if got := Add(tt.a, tt.b); got != tt.expected {
t.Errorf("Add(%d,%d) = %d; want %d", tt.a, tt.b, got, tt.expected)
}
})
}
}
Testes table-driven são o idioma dominante em Go — defina um slice de casos, percorra-os com subtestes t.Run. Isso torna trivial adicionar casos e fornece relatórios claros e individuais de sucesso/falha por caso.
func BenchmarkAdd(b *testing.B) {
for i := 0; i < b.N; i++ { // the framework chooses b.N for statistical accuracy
Add(2, 3)
}
}
// go test -bench=. → reports ns/op (and -benchmem for allocations)
go test -cover # coverage percentage
go test -coverprofile=c.out # then: go tool cover -html=c.out (visual report)
go test -race # the RACE DETECTOR — finds data races (crucial for concurrency)
go test -run TestAdd # run specific tests
A flag -race é especialmente importante — ela detecta data races em código concorrente, uma ferramenta chave dada a ênfase de Go em concorrência.
func TestMain(m *testing.M) { // package-level setup/teardown
setup()
code := m.Run()
teardown()
os.Exit(code)
}
// t.Helper() marks a function as a test helper (better failure line reporting)
// httptest package for testing HTTP handlers; interfaces for mocking dependencies
Os testes são uma parte integrada de primeira classe em Go — o pacote testing e go test não requerem nenhum framework externo, refletindo a ênfase de Go nos testes como uma prática central.
Compreender as convenções é conhecimento essencial do dia a dia: a estrutura do arquivo _test.go e TestXxx(t *testing.T), o estilo de relatório de falha explícito (sem asserções), e especialmente o padrão teste table-driven que domina o Go idiomático (cobrindo muitos casos de forma compacta com relatório claro por caso via subtestes).
Igualmente importantes são os benchmarks integrados de Go (desempenho como uma preocupação testável) e o ferramental poderoso — análise de cobertura e particularmente o detector -race, que encontra data races em código concorrente (vital dada a utilização intensiva de concorrência em Go).
Saber como escrever testes Go eficazes e idiomáticos, usar o detector de race, e aproveitar httptest/interfaces para testar componentes reais é uma característica do desenvolvimento Go profissional e um tópico frequente refletindo fluência em qualidade de código.