Go code-ஐ எவ்வாறு test செய்வீர்கள்?

Question

Accepted Answer

Go ஆனது `testing` package மற்றும் `go test` command வழியாக **built-in testing** வைத்துள்ளது — எந்த external framework-ம் தேவையில்லை. Tests ஆனவை `_test.go` files-இல் வாழ்கின்றன, மேலும் Go ஆனது **table-driven tests**, benchmarks, மற்றும் நல்ல tooling-ஐ first-class features-ஆக வலுவாக வலியுறுத்துகிறது.

## ஒரு அடிப்படை test

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

ஒரு test function ஆனது `Test`-உடன் தொடங்குகிறது, `*testing.T`-ஐ எடுக்கிறது, மேலும் `t.Errorf`/`t.Fatalf` வழியாக failures-ஐ அறிக்கையிடுகிறது. assertion keywords இல்லை — நீங்கள் conditions-ஐ plain `if`-உடன் சரிபார்த்து failures-ஐ அறிக்கையிடுகிறீர்கள் (Go இந்த explicit style-ஐ விரும்புகிறது).

## Table-driven tests — idiomatic Go pattern

```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** ஆனவை மேலாதிக்க Go idiom ஆகும் — cases-இன் ஒரு slice-ஐ வரையறுத்து, `t.Run` subtests-உடன் அவற்றின் மீது loop செய்யவும். இது cases சேர்ப்பதை எளிதாக்குகிறது மற்றும் ஒவ்வொரு case-க்கும் தெளிவான, தனிப்பட்ட pass/fail அறிக்கையிடலை வழங்குகிறது.

## Benchmarks — built-in performance testing

```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 மற்றும் பிற tooling

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

**`-race` flag** குறிப்பாக முக்கியமானது — இது concurrent code-இல் data races-ஐ கண்டறிகிறது, Go-வின் concurrency கவனத்தைக் கருத்தில் கொண்டால் ஒரு முக்கிய கருவி.

## Test helpers மற்றும் 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
```

## இது ஏன் முக்கியம்

Testing ஆனது Go-வின் ஒரு first-class, built-in பகுதியாகும் — `testing` package மற்றும் `go test` எந்த external framework-ஐயும் தேவைப்படுத்துவதில்லை, இது testing-ஐ ஒரு core practice-ஆக Go-வின் வலியுறுத்தலை பிரதிபலிக்கிறது.

conventions-ஐ புரிந்துகொள்வது அத்தியாவசிய அன்றாட அறிவாகும்: `_test.go` file மற்றும் `TestXxx(t *testing.T)` structure, explicit (assertion-இல்லாத) failure-அறிக்கையிடல் style, மற்றும் குறிப்பாக idiomatic Go-வில் மேலாதிக்கம் செலுத்தும் **table-driven test** pattern (subtests வழியாக தெளிவான ஒவ்வொரு case-க்கான அறிக்கையிடலுடன் பல cases-ஐ சுருக்கமாக உள்ளடக்கி).

Go-வின் built-in **benchmarks** (testable concern-ஆக performance) மற்றும் சக்திவாய்ந்த **tooling** — coverage analysis மற்றும் குறிப்பாக **`-race` detector**, இது concurrent code-இல் data races-ஐ கண்டறிகிறது (Go-வின் concurrency-கனமான பயன்பாட்டைக் கருத்தில் கொண்டால் முக்கியம்) — சமமாக முக்கியமானவை.

பயனுள்ள, idiomatic Go tests எழுதுவது, race detector-ஐ பயன்படுத்துவது, மற்றும் உண்மையான components-ஐ test செய்ய `httptest`/interfaces-ஐ பயன்படுத்துவது ஆகியவற்றை அறிவது, தொழில்முறை Go development-இன் ஒரு அடையாளம் மற்றும் code-quality புலமையை பிரதிபலிக்கும் ஒரு அடிக்கடி வரும் தலைப்பாகும்.