Unajaribuje code ya Go?

Question

Accepted Answer

Go ina **testing iliyojengwa ndani** kupitia package ya `testing` na amri ya `go test` — hakuna framework ya nje inayohitajika. Tests hukaa katika faili za `_test.go`, na Go inasisitiza sana **table-driven tests**, benchmarks, na tooling nzuri kama vipengele vya daraja la kwanza.

## Test ya msingi

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

Function ya test huanza na `Test`, huchukua `*testing.T`, na huripoti failures kupitia `t.Errorf`/`t.Fatalf`. Hakuna maneno ya assertion — unakagua masharti kwa `if` ya kawaida na kuripoti failures (Go inapendelea mtindo huu wa wazi).

## Table-driven tests — mfumo wa kiidiomatiki wa 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)
            }
        })
    }
}
```

**Table-driven tests** ndio mfumo mkuu wa Go — fafanua slice ya cases, zungukia kwa `t.Run` subtests. Hii hufanya kuongeza cases iwe rahisi na kutoa ripoti wazi, ya mtu mmoja mmoja ya pass/fail kwa kila case.

## Benchmarks — testing ya utendaji iliyojengwa ndani

```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 na tooling nyingine

```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 ya `-race`** ni muhimu hasa — hugundua data races katika code ya concurrent, zana muhimu ikizingatiwa msisitizo wa Go juu ya concurrency.

## Test helpers na 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
```

## Kwa nini ni muhimu

Testing ni sehemu ya daraja la kwanza, iliyojengwa ndani ya Go — package ya `testing` na `go test` hazihitaji framework ya nje, zikionyesha msisitizo wa Go juu ya testing kama desturi ya msingi.

Kuelewa kanuni ni maarifa muhimu ya kila siku: muundo wa faili ya `_test.go` na `TestXxx(t *testing.T)`, mtindo wa wazi (usio na assertion) wa kuripoti failure, na hasa mfumo wa **table-driven test** unaotawala Go ya kiidiomatiki (ukifunika cases nyingi kwa ufupi na ripoti wazi ya kila case kupitia subtests).

Muhimu vile vile ni **benchmarks** za Go zilizojengwa ndani (utendaji kama jambo linaloweza kujaribiwa) na **tooling** yenye nguvu — uchambuzi wa coverage na hasa **detector ya `-race`**, ambayo hugundua data races katika code ya concurrent (muhimu ikizingatiwa matumizi ya Go yenye concurrency nyingi).

Kujua jinsi ya kuandika tests bora, za kiidiomatiki za Go, kutumia race detector, na kutumia `httptest`/interfaces kwa kujaribu vipengele halisi ni alama ya utengenezaji wa kitaaluma wa Go na mada ya mara kwa mara inayoonyesha ufasaha wa ubora wa code.