Hogyan teszteljük a Go kódot?

Question

Accepted Answer

A Go beépített tesztelési lehetőséggel rendelkezik a `testing` csomagon és a `go test` parancson keresztül — nincs szükség külső keretrendszerre. A tesztek `_test.go` fájlokban helyezkednek el, és a Go erősen hangsúlyozza a **table-driven teszteket**, benchmarkokat és jó eszközöket mint első osztályú jellemzőket.

## Alapvető teszt

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

Egy teszt függvény `Test` előtaggal kezdődik, `*testing.T` paramétert vesz fel, és hibajelentéseket `t.Errorf`/`t.Fatalf` segítségével közöl. Nincsenek assertion kulcsszavak — egyszerű `if` utasításokkal ellenőrzöd a feltételeket és jelentesz hibákat (a Go ezt az explicit stílust részesíti előnyben).

## Table-driven tesztek — az idiomatikus Go minta

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

A **table-driven tesztek** a domináns Go idioma — egy szelet case-t definiálsz, és a `t.Run` segítségével végigmész rajtuk alszövetekként. Ez triviálissá teszi új esetek hozzáadását és egyértelmű, egyedi pass/fail jelentést nyújt minden case-hez.

## Benchmarkok — beépített teljesítménytesztelés

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

## Lefedettség és egyéb eszközök

```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
```
A **`-race` flag** különösen fontos — párhuzamos kódban adatversenyek észlelésére szolgál, ami kulcsfontosságú eszköz a Go párhuzamosság-központúsága miatt.

## Teszt segédek és inicializálás

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

## Miért fontos

A tesztelés a Go-ban első osztályú, beépített jellemző — a `testing` csomag és a `go test` parancs nem igényelnek külső keretrendszert, ami a Go tesztelésre mint alapvető gyakorlatra helyezett hangsúlyát tükrözi.

A konvenciók megértése napi szintű tudás: a `_test.go` fájl és a `TestXxx(t *testing.T)` struktúra, az explicit (assertion-mentes) hibajelentési stílus, és különösen a **table-driven teszt** minta, amely az idiomatikus Go-ban dominál (kompakt módon sok esetet fedve le világos, alszöveteken keresztüli eseti jelentéssel).

Egyelőre fontos a Go beépített **benchmarkjai** (teljesítmény mint tesztelhető szempont) és a hatékony **eszközök** — lefedettség-elemzés és különösen a **`-race` detektor**, amely párhuzamos kódban adatversenyeket talál (nélkülözhetetlen a Go párhuzamosság-alapú használata miatt).

Annak ismerete, hogyan kell hatékony, idiomatikus Go teszteket írni, hogyan kell használni a race detectort, és hogyan kell kihasználni a `httptest`/interfészeket valós komponensek teszteléséhez, a professzionális Go fejlesztés jellemzője és a kódminőség ismeretét tükröző gyakori témakör.