Go tiene pruebas integradas mediante el paquete testing y el comando go test — no se necesita un framework externo. Las pruebas viven en archivos _test.go, y Go enfatiza fuertemente las pruebas dirigidas por tabla, benchmarks y herramientas de calidad como características de primera clase.
// 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)
Una función de prueba comienza con Test, recibe *testing.T e informa fallos mediante t.Errorf/t.Fatalf. No hay palabras clave de aserción — se verifican condiciones con if simple y se reportan fallos (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)
}
})
}
}
Las pruebas dirigidas por tabla son el idioma dominante en Go — define un slice de casos, itera sobre ellos con subtests t.Run. Esto hace trivial agregar casos y proporciona un reporte claro de éxito/fallo individual 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
La bandera -race es especialmente importante — detecta condiciones de carrera en código concurrente, una herramienta clave dado el enfoque de concurrencia de Go.
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
Las pruebas son una parte integrada de primera clase en Go — el paquete testing y go test no requieren framework externo, reflejando el énfasis de Go en las pruebas como una práctica central.
Comprender las convenciones es conocimiento esencial del día a día: la estructura del archivo _test.go y TestXxx(t *testing.T), el estilo de reporte de fallos explícito (sin aserciones), y especialmente el patrón de pruebas dirigidas por tabla que domina el Go idiomático (cubriendo compactamente muchos casos con reporte claro por caso mediante subtests).
Igualmente importante son los benchmarks integrados de Go (el rendimiento como una preocupación comprobable) y las herramientas poderosas — análisis de cobertura y particularmente el detector -race, que encuentra condiciones de carrera en código concurrente (vital dado el uso concurrente intensivo de Go).
Saber cómo escribir pruebas de Go efectivas e idiomáticas, usar el detector de carreras y aprovechar httptest/interfaces para probar componentes reales es una marca de desarrollo profesional en Go y un tema frecuente que refleja fluidez en la calidad del código.
Una biblioteca de preguntas de entrevista de IT con respuestas detalladas — de Junior a Senior.
Donar