Cum testezi codul Go?

Question

Accepted Answer

Go are **testare încorporată** prin pachetul `testing` și comanda `go test` — nu este nevoie de framework extern. Testele se află în fișiere `_test.go`, iar Go pune accent puternic pe **teste conduse de tabel**, benchmark-uri și instrumente bune ca caracteristici de rang întâi.

## Un test de bază

```go
// 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)
```

O funcție de test începe cu `Test`, ia `*testing.T` și raportează eșecurile prin `t.Errorf`/`t.Fatalf`. Nu există cuvinte-cheie pentru aserțiuni — verifici condiții cu `if` obișnuit și raportezi eșecurile (Go favorizează acest stil explicit).

## Teste conduse de tabel — modelul idiomativ al Go

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

**Testele conduse de tabel** sunt idiomul dominant în Go — definești o felie de cazuri, iterezi peste ele cu subtesturile `t.Run`. Aceasta face trivial adăugarea de cazuri și oferă raportare clară și individuală de succes/eșec per caz.

## Benchmark-uri — testare încorporată a performanței

```go
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)
```

## Acoperire și alte instrumente

```bash
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
```

Flag-ul **`-race`** este deosebit de important — detectează curse de date în cod concurent, un instrument cheie având în vedere focusul Go pe concurență.

## Ajutoare de test și inițializare

```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
```

## De ce este important

Testarea este o parte de rang întâi, încorporată în Go — pachetul `testing` și `go test` nu necesită framework extern, reflectând accentul Go pe testare ca practică de bază.

Înțelegerea convențiilor este cunoștință esențială de zi cu zi: fișierul `_test.go` și structura `TestXxx(t *testing.T)`, stilul explicit de raportare a eșecurilor (fără aserțiuni), și în special modelul **test condus de tabel** care domină Go idiomativ (acoperind compact multe cazuri cu raportare clară per caz prin subtesturile).

Egal de importante sunt **benchmark-urile** încorporate ale Go (performanța ca preocupare testabilă) și **instrumentele** puternice — analiza de acoperire și în special **detectorul `-race`**, care găsește curse de date în cod concurent (vital având în vedere utilizarea intensivă a concurenței în Go).

Cunoașterea modului de a scrie teste eficiente și idiomatice în Go, utilizarea detectorului de curse și valorificarea `httptest`/interfețelor pentru testarea componentelor reale este o caracteristică a dezvoltării profesionale în Go și un subiect frecvent reflectând fluiditate în calitatea codului.