Table-Driven Test: เพิ่มเคสใหม่ด้วยการพิมพ์บรรทัดเดียว

1 · ปัญหาที่มันแก้

สมมติ CalculateDiscount(price, percent) ต้องเทส 5 เคส ถ้าเขียนแบบตรงไปตรงมาจะได้แบบนี้:

func TestCalculateDiscount_HappyPath(t *testing.T) {
    result, err := CalculateDiscount(100, 10)
    if err != nil {
        t.Errorf("did not expect error, got %v", err)
    }
    if result != 90 {
        t.Errorf("CalculateDiscount(100, 10) = %v; want 90", result)
    }
}

func TestCalculateDiscount_NoDiscount(t *testing.T) {
    result, err := CalculateDiscount(100, 0)
    if err != nil {              // ← copy มาทั้งดุ้น
        t.Errorf("did not expect error, got %v", err)
    }
    if result != 100 {           // ← แก้แค่ตัวเลข
        t.Errorf("CalculateDiscount(100, 0) = %v; want 100", result)
    }
}

// ... อีก 3 ฟังก์ชัน หน้าตาเหมือนกันหมด

• ซ้ำซาก — ตรรกะเดิม 5 รอบ ต่างกันแค่ตัวเลข
• แก้ยาก — เปลี่ยน signature ของฟังก์ชันทีต้องแก้ 5 ที่ (signature = หน้าตาของฟังก์ชัน คือสิ่งที่รับเข้าและสิ่งที่คืนออกมา · เวลาคุยกันมักพ่วงชื่อฟังก์ชันไปด้วย แต่ทางการนับแค่สองอย่างนี้ ฟังก์ชันคนละชื่อจึงมี signature เดียวกันได้)
• ตกหล่นง่าย — copy แล้วลืมแก้ค่าใดค่าหนึ่ง เทสจะผ่านทั้งที่ไม่ควรผ่าน
• มองไม่เห็นภาพรวม — ตอบไม่ได้ทันทีว่าเทสครอบคลุมเคสไหนแล้วบ้าง

2 · รูปแบบ Table-Driven

วิธีแก้ไม่ซับซ้อนเลย: เอาตัวเลขทุกเคสไปกองไว้ในตารางก่อน แล้วเขียนขั้นตอนการตรวจไว้ครั้งเดียว จากนั้นให้โปรแกรมวนอ่านตารางทีละแถว แล้วส่งเข้าขั้นตอนเดิมนั้น — อยากเพิ่มเคสก็แค่เติมแถว

tests := []struct {      // ← ส่วนที่ 1: ประกาศ "หน้าตาของหนึ่งแถว" ตรงนี้เลย
    name    string       //    (struct ที่ไม่ต้องตั้งชื่อ type เพราะใช้ที่นี่ที่เดียว)
    price   int
    percent int
    want    int
    wantErr bool
}{                       // ← ส่วนที่ 2: เปิดปีกกาแล้วใส่แถวข้อมูลต่อได้เลย
    {"ลด 10%", 100, 10, 90, false},
}

func TestCalculateDiscount(t *testing.T) {
    // ── ส่วนที่ 1: ตาราง (ข้อมูล) ──
    tests := []struct {
        name    string
        price   int
        percent int
        want    int
        wantErr bool
    }{
        {"ลด 10%",              100,  10,  90,  false},
        {"ไม่ลด",                100,   0, 100,  false},
        {"ลดเต็ม",               100, 100,   0,  false},
        {"เปอร์เซ็นต์ติดลบ",      100,  -5,   0,   true},
        {"เปอร์เซ็นต์เกิน 100",   100, 101,   0,   true},
    }

    // ── ส่วนที่ 2: ตรรกะ (เขียนครั้งเดียว) ──
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got, err := CalculateDiscount(tt.price, tt.percent)

            if (err != nil) != tt.wantErr {
                t.Fatalf("CalculateDiscount(%d, %d) err = %v; wantErr %v",
                    tt.price, tt.percent, err, tt.wantErr)
            }
            if got != tt.want {
                t.Errorf("CalculateDiscount(%d, %d) = %d; want %d",
                    tt.price, tt.percent, got, tt.want)
            }
        })
    }
}

3 · ผลรันจริง

// ในตารางตั้งชื่อเคสไว้ว่า
{"ลด 10%", 100, 10, 90, false},

go test -v -run 'TestCalculateDiscount/ลด_10' .    ✓ เจอ
go test -v -run 'TestCalculateDiscount/ลด 10' .    ✓ เจอเหมือนกัน

$ go test -v -run TestCalculateDiscount .
=== RUN   TestCalculateDiscount
=== RUN   TestCalculateDiscount/ลด_10%
=== RUN   TestCalculateDiscount/ไม่ลด
=== RUN   TestCalculateDiscount/ลดเต็ม
=== RUN   TestCalculateDiscount/เปอร์เซ็นต์ติดลบ
=== RUN   TestCalculateDiscount/เปอร์เซ็นต์เกิน_100
--- PASS: TestCalculateDiscount (0.00s)
    --- PASS: TestCalculateDiscount/ลด_10% (0.00s)
    ...

$ go test -v -run 'TestCalculateDiscount/ลด_10' .   # เจาะเคสเดียว

4 · องค์ประกอบที่ทำให้มันดี

4.1 field name — สำคัญกว่าที่คิด

tests := []struct{
    price, percent, want int
}{
    {100, 10, 90},
    {100,  0, 100},
}

for i, tt := range tests {
    t.Run(fmt.Sprint(i), ...)
}

// เวลาพัง: "case 1 failed"
// แล้ว case 1 คือเคสอะไร?

tests := []struct{
    name                 string
    price, percent, want int
}{
    {"ลด 10%", 100, 10, 90},
    {"ไม่ลด",  100,  0, 100},
}

for _, tt := range tests {
    t.Run(tt.name, ...)
}

// เวลาพัง: "ลด_10% failed"
// อ่านออกทันที

4.2 ข้อความ error ต้องบอกครบ 3 อย่าง

t.Errorf("CalculateDiscount(%d, %d) = %d; want %d",
    tt.price, tt.percent,  // 1. input อะไร
    got,                   // 2. ได้อะไรมา
    tt.want)               // 3. อยากได้อะไร

4.3 wantErr bool — เทสเส้นทางที่พังด้วย

if (err != nil) != tt.wantErr {
    t.Fatalf("err = %v; wantErr %v", err, tt.wantErr)
}

แปลทีละชิ้น: err != nil คือคำถาม "ตอนนี้มี error จริงไหม" ได้คำตอบเป็น true/false · tt.wantErr คือ "เราคาดว่าจะมีไหม" ก็ true/false เหมือนกัน · เอาสองอันมา != กัน = ถาม "สองคำตอบนี้ขัดกันหรือเปล่า" ขัดกันเมื่อไหร่ = เทสพัง — ครอบคลุมทั้งสองทิศทางในบรรทัดเดียว

• คาดว่าไม่มี error แต่มี → fail ✅
• คาดว่ามี error แต่ไม่มี → fail ✅ (คนมักลืมเทสด้านนี้)

ถ้าอยากเช็คให้แน่นกว่านั้น เปลี่ยนเป็น wantErr error แล้วใช้ errors.Is จาก บทเรียน 12:

tests := []struct{
    name    string
    percent int
    wantErr error       // ← เก็บ sentinel ไปเลย
}{
    {"ปกติ",      10, nil},
    {"ติดลบ",     -5, ErrPercentOutOfRange},
}

if !errors.Is(err, tt.wantErr) {
    t.Fatalf("err = %v; want %v", err, tt.wantErr)
}

5 · จับคู่กับ t.Parallel()

for _, tt := range tests {
    t.Run(tt.name, func(t *testing.T) {
        t.Parallel()          // ทุกเคสวิ่งพร้อมกัน
        got, err := CalculateDiscount(tt.price, tt.percent)
        // ...
    })
}

t.Parallel() คือการบอก Go ว่า “เคสนี้ไม่ต้องรอเคสอื่น ปล่อยวิ่งพร้อมกันได้” เทสทั้งชุดจะเสร็จเร็วขึ้น — แต่มีกับดักอยู่หนึ่งข้อที่โค้ดเก่าต้องดักไว้เอง

6 · ทดสอบความจำ

7 · ลงมือทำ

อ่านต่อจากต้นทาง

แหล่งหลักที่แนะนำ: Go Wiki — Table Driven Tests สั้นมาก และมีลิงก์ไปดูตัวอย่างจริงใน standard library
ที่ผมแนะนำให้ทำจริง ๆ คือ เปิดซอร์สของ Go เองมาดู — strings_test.go เขียนแบบตารางเกือบทั้งไฟล์ เห็นแล้วจะรู้ว่าสำนวนนี้ไม่ใช่ทฤษฎี แต่เป็นวิธีที่ทีม Go ใช้จริง

อ้างอิง

• Go Wiki — Table Driven Tests — สำนวนมาตรฐาน
• strings_test.go — ตัวอย่างจริงใน standard library
• The Go Blog — Using Subtests and Sub-benchmarks
• The Go Blog — Fixing For Loops in Go 1.22 — ที่มาของการเลิกเขียน tt := tt
• Go Code Review Comments — Useful Test Failures — รูปแบบข้อความ error ที่ควรใช้