คุณทดสอบโค้ด Go อย่างไร?

Question

Accepted Answer

Go มี **testing ในตัว** ผ่าน package `testing` และคำสั่ง `go test` โดยไม่ต้องใช้ framework ภายนอก test อยู่ในไฟล์ `_test.go` และ Go เน้นอย่างหนักไปที่ **table-driven test**, benchmark และ tooling ที่ดีในฐานะฟีเจอร์ระดับชั้นหนึ่ง

## 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 ขึ้นต้นด้วย `Test` รับ `*testing.T` และรายงานความล้มเหลวผ่าน `t.Errorf`/`t.Fatalf` ไม่มี keyword สำหรับ assertion คุณตรวจสอบเงื่อนไขด้วย `if` ธรรมดาแล้วรายงานความล้มเหลว (Go ชอบสไตล์ที่ชัดเจนแบบนี้)

## Table-driven test — pattern ที่ idiomatic ของ 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 test** เป็น idiom ที่โดดเด่นของ Go กำหนด slice ของ case แล้ววนซ้ำด้วย subtest `t.Run` ทำให้การเพิ่ม case ทำได้ง่ายและให้รายงาน pass/fail ที่ชัดเจนแยกเป็นรายกรณี

## Benchmark — การทดสอบประสิทธิภาพในตัว

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

**flag `-race`** สำคัญเป็นพิเศษ มันตรวจจับ data race ในโค้ด concurrent ซึ่งเป็นเครื่องมือสำคัญเมื่อพิจารณาจากความเน้น concurrency ของ Go

## Test helper และ 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 package `testing` และ `go test` ไม่ต้องการ framework ภายนอก สะท้อนถึงการที่ Go ให้ความสำคัญกับ testing ในฐานะแนวทางหลัก

การเข้าใจ convention เป็นความรู้พื้นฐานที่จำเป็นในทุกวัน: โครงสร้างไฟล์ `_test.go` และ `TestXxx(t *testing.T)`, สไตล์การรายงานความล้มเหลวที่ชัดเจน (ไม่มี assertion) และโดยเฉพาะอย่างยิ่ง pattern **table-driven test** ที่โดดเด่นในโค้ด Go ที่ idiomatic (ครอบคลุมหลายกรณีอย่างกระชับพร้อมรายงานรายกรณีที่ชัดเจนผ่าน subtest)

ที่สำคัญไม่แพ้กันคือ **benchmark** ในตัวของ Go (ประสิทธิภาพเป็นเรื่องที่ทดสอบได้) และ **tooling** ที่ทรงพลัง ได้แก่ การวิเคราะห์ coverage และโดยเฉพาะ **`-race` detector** ซึ่งค้นหา data race ในโค้ด concurrent (สำคัญมากเมื่อพิจารณาจากการใช้งานที่เน้น concurrency ของ Go)

การรู้วิธีเขียน test ของ Go ที่มีประสิทธิภาพและ idiomatic, การใช้ race detector และการใช้ประโยชน์จาก `httptest`/interface เพื่อทดสอบ component จริง เป็นเครื่องหมายของการพัฒนา Go อย่างมืออาชีพ และเป็นหัวข้อที่พบบ่อยซึ่งสะท้อนถึงความคล่องแคล่วด้านคุณภาพโค้ด