Come si testano i codici Go?

Question

Accepted Answer

Go ha **test integrati** tramite il pacchetto `testing` e il comando `go test` — nessun framework esterno necessario. I test vivono in file `_test.go`, e Go enfatizza fortemente i **test guidati da tabelle**, i benchmark, e i buoni strumenti come funzionalità di prima classe.

## Un test di base

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

Una funzione di test inizia con `Test`, prende `*testing.T`, e segnala i fallimenti via `t.Errorf`/`t.Fatalf`. Non ci sono parole chiave di asserzione — controlli le condizioni con semplici `if` e segnali i fallimenti (Go favorisce questo stile esplicito).

## Test guidati da tabelle — il pattern idiomatico di 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)
            }
        })
    }
}
```

I **test guidati da tabelle** sono l'idioma dominante in Go — definisci una slice di casi, itera su di essi con subtest `t.Run`. Questo rende banale aggiungere casi e fornisce un reporting chiaro e individuale pass/fail per ogni caso.

## Benchmark — test di performance integrati

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

## Coverage e altri strumenti

```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
```
Il flag **`-race`** è particolarmente importante — rileva race condition nel codice concorrente, uno strumento chiave dato il focus di Go sulla concorrenza.

## Test helper e setup

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

## Perché è importante

I test sono una parte integrata e di prima classe di Go — il pacchetto `testing` e `go test` non richiedono alcun framework esterno, riflettendo l'enfasi di Go sui test come pratica fondamentale.

Comprendere le convenzioni è conoscenza essenziale quotidiana: il file `_test.go` e la struttura `TestXxx(t *testing.T)`, lo stile di segnalazione dei fallimenti esplicito (senza asserzione), e soprattutto il pattern dei **test guidati da tabelle** che domina il Go idiomatico (coprendo compattamente molti casi con un reporting chiaro per caso tramite subtest).

Equalmente importanti sono i **benchmark** integrati di Go (le performance come una preoccupazione testabile) e i potenti **strumenti** — analisi della copertura e particolarmente il **rilevatore di `race`**, che trova race condition nel codice concorrente (vitale dato l'uso di Go fortemente incentrato sulla concorrenza).

Sapere come scrivere test Go efficaci e idiomatici, usare il rilevatore di race, e sfruttare `httptest`/interfacce per testare componenti reali è un marchio di sviluppo Go professionale e un argomento frequente che riflette la fluidità della qualità del codice.