Go dispose de tests intégrés via le package testing et la commande go test — aucun framework externe nécessaire. Les tests se trouvent dans des fichiers _test.go, et Go met fortement l'accent sur les tests basés sur des tableaux, les benchmarks et les bons outils comme des fonctionnalités de première 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)
Une fonction de test commence par Test, prend *testing.T et signale les défaillances via t.Errorf/t.Fatalf. Il n'y a pas de mots-clés d'assertion — vous vérifiez les conditions avec un simple if et signalez les défaillances (Go favorise ce style explicite).
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)
}
})
}
}
Les tests basés sur des tableaux sont l'idiome dominant de Go — définissez une tranche de cas, parcourez-les avec des sous-tests t.Run. Cela rend l'ajout de cas trivial et fournit des rapports clairs de passage/défaillance individuels par cas.
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
Le flag -race est particulièrement important — il détecte les races de données dans le code concurrent, un outil clé compte tenu de l'accent de Go sur la concurrence.
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
Les tests sont une partie intégrée et de première classe de Go — le package testing et go test ne nécessitent aucun framework externe, reflétant l'accent de Go sur les tests comme pratique fondamentale.
Comprendre les conventions est une connaissance essentielle au quotidien : la structure du fichier _test.go et TestXxx(t *testing.T), le style de signalisation explicite de défaillance (sans assertion), et en particulier le modèle de test basé sur des tableaux qui domine le Go idiomatique (couvrant de manière compacte de nombreux cas avec un rapport clair par cas via les sous-tests).
Sont également importants les benchmarks intégrés de Go (la performance comme préoccupation testable) et les outils puissants — analyse de couverture et en particulier le détecteur -race, qui trouve les races de données dans le code concurrent (vital compte tenu de l'utilisation intensive de la concurrence par Go).
Savoir comment écrire des tests Go efficaces et idiomatiques, utiliser le détecteur de races et exploiter httptest/les interfaces pour tester les composants réels est une marque du développement Go professionnel et un sujet fréquent reflétant la maîtrise de la qualité du code.