golang-testing

name golang-testing description Patrones de pruebas Go incluyendo pruebas basadas en tablas, subpruebas, benchmarks, fuzzing y cobertura de código. Sigue la metodología TDD con prácticas idiomáticas de Go. origin ECC Patrones de Pruebas Go Patrones completos de pruebas Go para escribir pruebas confiables y mantenibles siguiendo la metodología TDD. Cuándo Activar Escribir nuevas funciones o métodos Go Agregar cobertura de pruebas a código existente Crear benchmarks para código crítico en rendimiento Implementar pruebas fuzz para validación de entradas Seguir el flujo de trabajo TDD en proyectos Go Flujo de Trabajo TDD para Go El Ciclo RED-GREEN-REFACTOR RED → Escribir una prueba que falle primero GREEN → Escribir el código mínimo para pasar la prueba REFACTOR → Mejorar el código manteniendo las pruebas en verde REPEAT → Continuar con el siguiente requisito TDD Paso a Paso en Go // Paso 1: Definir la interfaz/firma // calculator.go package calculator func Add (a, b int ) int { panic ( "not implemented" ) // Marcador de posición } // Paso 2: Escribir prueba que falle (RED) // calculator_test.go package calculator import "testing" func TestAdd (t *testing.T) { got := Add( 2 , 3 ) want := 5 if got != want { t.Errorf( "Add(2, 3) = %d; want %d" , got, want) } } // Paso 3: Ejecutar prueba - verificar FALLO // $ go test // --- FAIL: TestAdd (0.00s) // panic: not implemented // Paso 4: Implementar código mínimo (GREEN) func Add (a, b int ) int { return a + b } // Paso 5: Ejecutar prueba - verificar PASA // $ go test // PASS // Paso 6: Refactorizar si es necesario, verificar que las pruebas sigan pasando Pruebas Basadas en Tablas El patrón estándar para pruebas Go. Permite cobertura comprensiva con código mínimo. func TestAdd (t *testing.T) { tests := [] struct { name string a, b int expected int }{ { "positive numbers" , 2 , 3 , 5 }, { "negative numbers" , -1 , -2 , -3 }, { "zero values" , 0 , 0 , 0 }, { "mixed signs" , -1 , 1 , 0 }, { "large numbers" , 1000000 , 2000000 , 3000000 }, } for _, tt := range tests { t.Run(tt.name, func (t *testing.T) { got := Add(tt.a, tt.b) if got != tt.expected { t.Errorf( "Add(%d, %d) = %d; want %d" , tt.a, tt.b, got, tt.expected) } }) } } Pruebas Basadas en Tablas con Casos de Error func TestParseConfig (t *testing.T) { tests := [] struct { name string input string want *Config wantErr bool }{ { name: "valid config" , input: `{"host": "localhost", "port": 8080}` , want: &Config{Host: "localhost" , Port: 8080 }, }, { name: "invalid JSON" , input: `{invalid}` , wantErr: true , }, { name: "empty input" , input: "" , wantErr: true , }, { name: "minimal config" , input: `{}` , want: &Config{}, // Valor cero de Config }, } for _, tt := range tests { t.Run(tt.name, func (t *testing.T) { got, err := ParseConfig(tt.input) if tt.wantErr { if err == nil { t.Error( "expected error, got nil" ) } return } if err != nil { t.Fatalf( "unexpected error: %v" , err) } if !reflect.DeepEqual(got, tt.want) { t.Errorf( "got %+v; want %+v" , got, tt.want) } }) } } Subpruebas y Sub-benchmarks Organizar Pruebas Relacionadas func TestUser (t *testing.T) { // Configuración compartida por todas las subpruebas db := setupTestDB(t) t.Run( "Create" , func (t *testing.T) { user := &User{Name: "Alice" } err := db.CreateUser(user) if err != nil { t.Fatalf( "CreateUser failed: %v" , err) } if user.ID == "" { t.Error( "expected user ID to be set" ) } }) t.Run( "Get" , func (t *testing.T) { user, err := db.GetUser( "alice-id" ) if err != nil { t.Fatalf( "GetUser failed: %v" , err) } if user.Name != "Alice" { t.Errorf( "got name %q; want %q" , user.Name, "Alice" ) } }) t.Run( "Update" , func (t *testing.T) { // ... }) t.Run( "Delete" , func (t *testing.T) { // ... }) } Subpruebas en Paralelo func TestParallel (t *testing.T) { tests := [] struct { name string input string }{ { "case1" , "input1" }, { "case2" , "input2" }, { "case3" , "input3" }, } for _, tt := range tests { tt := tt // Capturar variable del rango t.Run(tt.name, func (t *testing.T) { t.Parallel() // Ejecutar subpruebas en paralelo result := Process(tt.input) // aserciones... _ = result }) } } Helpers de Prueba Funciones Helper func setupTestDB (t *testing.T) *sql.DB { t.Helper() // Marca esta como función helper db, err := sql.Open( "sqlite3" , ":memory:" ) if err != nil { t.Fatalf( "failed to open database: %v" , err) } // Limpieza cuando la prueba termina t.Cleanup( func () { db.Close() }) // Ejecutar migraciones if _, err := db.Exec(schema); err != nil { t.Fatalf( "failed to create schema: %v" , err) } return db } func assertNoError (t *testing.T, err error ) { t.Helper() if err != nil { t.Fatalf( "unexpected error: %v" , err) } } func assertEqual [ T comparable ] (t *testing.T, got, want T) { t.Helper() if got != want { t.Errorf( "got %v; want %v" , got, want) } } Archivos y Directorios Temporales func TestFileProcessing (t *testing.T) { // Crear directorio temporal - se limpia automáticamente tmpDir := t.TempDir() // Crear archivo de prueba testFile := filepath.Join(tmpDir, "test.txt" ) err := os.WriteFile(testFile, [] byte ( "test content" ), 0644 ) if err != nil { t.Fatalf( "failed to create test file: %v" , err) } // Ejecutar prueba result, err := ProcessFile(testFile) if err != nil { t.Fatalf( "ProcessFile failed: %v" , err) } // Aserciones... _ = result } Golden Files Probar contra archivos de salida esperada almacenados en testdata/ . var update = flag.Bool( "update" , false , "update golden files" ) func TestRender (t *testing.T) { tests := [] struct { name string input Template }{ { "simple" , Template{Name: "test" }}, { "complex" , Template{Name: "test" , Items: [] string { "a" , "b" }}}, } for _, tt := range tests { t.Run(tt.name, func (t *testing.T) { got := Render(tt.input) golden := filepath.Join( "testdata" , tt.name+ ".golden" ) if *update { // Actualizar golden file: go test -update err := os.WriteFile(golden, got, 0644 ) if err != nil { t.Fatalf( "failed to update golden file: %v" , err) } } want, err := os.ReadFile(golden) if err != nil { t.Fatalf( "failed to read golden file: %v" , err) } if !bytes.Equal(got, want) { t.Errorf( "output mismatch:\ngot:\n%s\nwant:\n%s" , got, want) } }) } } Mocking con Interfaces Mocking Basado en Interfaces // Definir interfaz para dependencias type UserRepository interface { GetUser(id string ) (*User, error ) SaveUser(user *User) error } // Implementación de producción type PostgresUserRepository struct { db *sql.DB } func (r *PostgresUserRepository) GetUser(id string ) (*User, error ) { // Consulta real a base de datos } // Implementación mock para pruebas type MockUserRepository struct { GetUserFunc func (id string ) (*User, error ) SaveUserFunc func (user *User) error } func (m *MockUserRepository) GetUser(id string ) (*User, error ) { return m.GetUserFunc(id) } func (m *MockUserRepository) SaveUser(user *User) error { return m.SaveUserFunc(user) } // Prueba usando mock func TestUserService (t *testing.T) { mock := &MockUserRepository{ GetUserFunc: func (id string ) (*User, error ) { if id == "123" { return &User{ID: "123" , Name: "Alice" }, nil } return nil , ErrNotFound }, } service := NewUserService(mock) user, err := service.GetUserProfile( "123" ) if err != nil { t.Fatalf( "unexpected error: %v" , err) } if user.Name != "Alice" { t.Errorf( "got name %q; want %q" , user.Name, "Alice" ) } } Benchmarks Benchmarks Básicos func BenchmarkProcess (b *testing.B) { data := generateTestData( 1000 ) b.ResetTimer() // No contar el tiempo de configuración for i := 0 ; i < b.N; i++ { Process(data) } } // Ejecutar: go test -bench=BenchmarkProcess -benchmem // Salida: BenchmarkProcess-8 10000 105234 ns/op 4096 B/op 10 allocs/op Benchmark con Diferentes Tamaños func BenchmarkSort (b *testing.B) { sizes := [] int { 100 , 1000 , 10000 , 100000 } for _, size := range sizes { b.Run(fmt.Sprintf( "size=%d" , size), func (b *testing.B) { data := generateRandomSlice(size) b.ResetTimer() for i := 0 ; i < b.N; i++ { // Hacer una copia para evitar ordenar datos ya ordenados tmp := make ([] int , len (data)) copy (tmp, data) sort.Ints(tmp) } }) } } Benchmarks de Asignación de Memoria func BenchmarkStringConcat (b *testing.B) { parts := [] string { "hello" , "world" , "foo" , "bar" , "baz" } b.Run( "plus" , func (b *testing.B) { for i := 0 ; i < b.N; i++ { var s string for _, p := range parts { s += p } _ = s } }) b.Run( "builder" , func (b *testing.B) { for i := 0 ; i < b.N; i++ { var sb strings.Builder for _, p := range parts { sb.WriteString(p) } _ = sb.String() } }) b.Run( "join" , func (b *testing.B) { for i := 0 ; i < b.N; i++ { _ = strings.Join(parts, "" ) } }) } Fuzzing (Go 1.18+) Prueba Fuzz Básica func FuzzParseJSON (f *testing.F) { // Agregar corpus semilla f.Add( `{"name": "test"}` ) f.Add( `{"count": 123}` )