Testify: assert, require, mock, suite

1 · ติดตั้ง

go get github.com/stretchr/testify

# แล้วก็
go mod tidy

2 · assert vs require — คู่แฝดของ Error/Fatal

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

result, err := CalculateDiscount(100, 10)

require.NoError(t, err)
assert.Equal(t, 90, result)

ผมรันทดสอบยืนยันแล้ว:

=== RUN   TestAssertVsRequire_assert
        Error: Not equal: expected: 1  actual: 2
    testify_test.go:33: assert -> บรรทัดนี้ยังรัน    ← มา
--- FAIL: TestAssertVsRequire_assert

=== RUN   TestAssertVsRequire_require
        Error: Not equal: expected: 1  actual: 2
--- FAIL: TestAssertVsRequire_require              ← ไม่มี log ตามมา

3 · ⚠️ กับดักใหญ่: assert.Equal เข้มเรื่อง type

// CalculateDiscount คืน (int, error)
result, err := CalculateDiscount(100, 10)

require.NoError(t, err)
assert.Equal(t, 90.0, result)     // สังเกต .0

Error: Not equal:
       expected: float64(90)
       actual  : int(90)

ญาติของกับดักนี้: float

a, b := 0.1, 0.2
assert.Equal(t, 0.3, a+b)      // ✗ ไม่ผ่าน!

ผลรันจริง:

a+b = 0.30000000000000004441
0.3 = 0.29999999999999998890

Error: Not equal:
       expected: 0.3
       actual  : 0.30000000000000004

assert.InDelta(t, 0.3, a+b, 0.0001)   // ✓ ผ่าน — เทียบแบบมีค่าคลาดเคลื่อน

เหตุผลที่เลขทศนิยมเชื่อไม่ได้แบบนั้น คิดเหมือนตอนหารค่าข้าว 1 บาทให้เพื่อน 3 คน ได้คนละ 0.333… บาท เขียนทศนิยมยาวแค่ไหนก็ไม่จบ ต้องตัดสักตำแหน่ง พอรวมกลับจึงไม่ได้ 1 บาทเป๊ะ
ที่ไม่เหมือนกัน: ที่ 1/3 เขียนไม่จบ เพราะเราเขียนกันด้วยฐานสิบ แต่คอมพิวเตอร์เก็บเลขด้วยฐานสอง ตัวที่เขียนไม่จบจึงเป็นคนละตัว — 0.1 0.2 0.3 เขียนในฐานสองไม่จบ (เก็บได้แค่ใกล้เคียง) ส่วน 0.5 กับ 0.25 ฐานสองเก็บได้เป๊ะสบาย ๆ ทั้งที่ในฐานสิบก็มีทศนิยมเหมือนกัน
คนละตัวเลขที่ซวย แต่อาการเดียวกัน คือตัดทิ้งแล้วรวมกลับไม่ตรงเป๊ะ เทียบ float จึงต้องบอกว่า “ต่างกันไม่เกินเท่าไหร่ถือว่าเท่ากัน” ซึ่งก็คือตัวเลขตัวสุดท้ายใน InDelta

4 · Diff ที่อ่านรู้เรื่อง — เหตุผลหลักที่คนใช้ Testify

got  := UserProfile{ID: 1, Name: "Alice", Email: "alice@test.com", Age: 30}
want := UserProfile{ID: 1, Name: "Alice", Email: "alice@test.com", Age: 25}

assert.Equal(t, want, got)

ผลรันจริง — มันชี้ field ที่ต่างให้เลย:

Error: Not equal:
       expected: UserProfile{ID:1, Name:"Alice", Email:"alice@test.com", Age:25, ...}
       actual  : UserProfile{ID:1, Name:"Alice", Email:"alice@test.com", Age:30, ...}

       Diff:
       --- Expected
       +++ Actual
       @@ -4,3 +4,3 @@
         Email: (string) (len=14) "alice@test.com",
       - Age: (int) 25,
       + Age: (int) 30,
         Roles: ([]string) <nil>

ถ้าเขียนเองด้วย t.Errorf("got %v; want %v", got, want) คุณจะได้ struct สองก้อนยาว ๆ แล้วต้องนั่งไล่สายตาเองว่า field ไหนต่าง — ยิ่ง struct ใหญ่ยิ่งทรมาน

5 · แคตตาล็อก assert ที่ใช้บ่อย

ทั้งหมดนี้ผมรันผ่านจริงบน testify v1.11.1:

// --- ค่าปกติ ---
assert.Equal(t, expected, actual)               // เท่ากัน (type ต้องตรงด้วย!)
assert.NotEqual(t, unexpected, actual)          // ไม่เท่ากัน
assert.ElementsMatch(t, []int{3,1,2}, list)     // slice เท่ากัน "ไม่สนลำดับ"

// --- สถานะ ---
assert.Nil(t, err)
assert.NotNil(t, obj)
assert.Empty(t, slice)                          // ว่าง (nil ก็นับ)
assert.Len(t, slice, 3)                        // ยาว 3

// --- บูลีน ---
assert.True(t, ok)
assert.False(t, failed)

// --- error (อย่าเทียบข้อความสตริง!) ---
require.Error(t, err)                            // มี error
assert.NoError(t, err)                           // ไม่มี error
assert.ErrorIs(t, err, ErrNotFound)              // ใช่ sentinel ตัวนี้ (แม่นกว่า)
assert.ErrorAs(t, err, &appErr)                  // เป็นชนิดนี้ + ดึงตัวจริง
assert.ErrorContains(t, err, "not found")      // ข้อความมีคำนี้ (หลวม)

// --- float (ห้ามใช้ Equal!) ---
assert.InDelta(t, 3.14, result, 0.001)

// --- slice/map/string ---
assert.Contains(t, "hello world", "world")       // substring
assert.Contains(t, []int{1,2,3}, 2)              // element
assert.Contains(t, map[string]int{"a":1}, "a")     // key

// --- เปรียบเทียบ ---
assert.Greater(t, a, b)                          // a > b
assert.Less(t, a, b)                             // a < b

// --- แสดงข้อมูลเพิ่มเมื่อพัง (arg ท้ายสุด) ---
assert.Equal(t, 10, x, "input ตอนนั้นคือ %d", input)

6 · Dependency Injection — เตรียมโค้ดให้ mock ได้

ก่อนจะ mock ได้ โค้ดต้องออกแบบมาให้รับ dependency เข้ามา ไม่ใช่สร้างเองข้างใน — ตรงกับ บทเรียน 10 เป๊ะ ๆ

type Result struct { A, B, Sum int }

type Store interface {
    Save(r Result) error
}

type Calculator struct {
    store Store         // ← dependency: Calculator "พึ่ง" Store
}

func NewCalculator(s Store) *Calculator {   // ← constructor รับเข้ามา
    return &Calculator{store: s}
}

func (c *Calculator) Add(a, b int) (int, error) {
    sum := a + b
    if err := c.store.Save(Result{A: a, B: b, Sum: sum}); err != nil {
        return 0, err
    }
    return sum, nil
}

7 · mock — ของปลอมที่ตอบอะไรก็ได้ และจำได้ว่าถูกเรียกกี่ครั้ง

ก่อนอ่านโค้ด: mock.Mock คือของสำเร็จรูปจาก testify เราแค่เอามาแปะไว้ใน struct ของเรา — เรียกว่า embed เหมือนกัน แต่ บทเรียน 11 คือการฝัง interface (เอา interface ไปรวมรายชื่อ method ของ interface อื่น) ส่วนอันนี้คือ การฝัง struct ซึ่งได้มาสองอย่าง:
1) method ติดมาให้ใช้ อย่าง On, Return, Assert… โดยไม่ต้องเขียนเอง
2) ที่เก็บข้อมูลภายในติดมาด้วย — mock.Mock มีฟิลด์ของมันเอง ไว้จำว่าเราตั้งท่าอะไรไว้บ้าง และใครเรียก method ไหนไปแล้วกี่ครั้ง ตัวนี้แหละที่ทำให้ AssertExpectations ตอบได้ว่าครบไหม

type MockStore struct {
    mock.Mock            // ← embed เข้ามา (บทเรียน 11)
}

func (m *MockStore) Save(r Result) error {
    args := m.Called(r)      // บันทึกว่าถูกเรียกด้วย r
    return args.Error(0)     // คืนค่าตัวที่ 0 ที่ตั้งไว้
}

func TestCalculator_Add_Success(t *testing.T) {
    mockStore := new(MockStore)

    // ตั้งโปรแกรมล่วงหน้า: ถ้าถูกเรียก Save ด้วยค่านี้ ให้คืน nil
    mockStore.On("Save", Result{A: 2, B: 3, Sum: 5}).Return(nil)

    calc := NewCalculator(mockStore)
    result, err := calc.Add(2, 3)

    require.NoError(t, err)
    assert.Equal(t, 5, result)

    mockStore.AssertExpectations(t)   // ← ตรวจว่าทุกอันที่ On ไว้ ถูกเรียกจริง
}

ทดสอบเส้นทางที่พัง — จุดที่ mock มีค่าที่สุด

func TestCalculator_Add_StoreFails(t *testing.T) {
    mockStore := new(MockStore)

    // สั่งให้ของปลอม "พัง" ตามที่เราต้องการ
    mockStore.On("Save", mock.AnythingOfType("main.Result")).
        Return(errors.New("disk full"))

    calc := NewCalculator(mockStore)
    _, err := calc.Add(2, 3)

    require.Error(t, err)
    assert.ErrorContains(t, err, "disk full")
    mockStore.AssertExpectations(t)
}

ตัวช่วยจับคู่ argument และตรวจการเรียก

// จับคู่แบบหลวม ๆ
mockStore.On("Save", mock.AnythingOfType("main.Result")).Return(nil)
mockStore.On("Transfer", 1, mock.Anything, mock.Anything).Return(nil)

// ตรวจหลังเรียกเสร็จ
mockStore.AssertExpectations(t)                    // ทุกอันที่ On ไว้ ถูกเรียกครบ
mockStore.AssertCalled(t, "Save", mock.Anything)   // ถูกเรียกจริง
mockStore.AssertNotCalled(t, "Update")             // ไม่ถูกเรียก
mockStore.AssertNumberOfCalls(t, "Save", 2)        // ถูกเรียก 2 ครั้งพอดี

// จำกัดจำนวนครั้ง
mockStore.On("Save", mock.Anything).Return(nil).Once()
mockStore.On("Save", mock.Anything).Return(nil).Twice()
mockStore.On("Save", mock.Anything).Return(nil).Times(3)

panic:
	mock: Unexpected Method Call
	-----------------------------

	Save(day5check.Result)
			0: day5check.Result{A:2, B:3, Sum:5}

	The closest call I have is:

	Save(mock.anythingOfTypeArgument)
			0: "main.Result"

	Diff: 0: FAIL:  type main.Result != type Result - (day5check.Result={2 3 5})

8 · suite — จัดกลุ่มเทสที่ใช้ setup ร่วมกัน

type UserServiceSuite struct {
    suite.Suite                    // ← embed
    store *MockUserStore           // สิ่งที่ใช้ร่วมในทุกเทส
    svc   *UserService
}

func (s *UserServiceSuite) SetupTest() {
    s.store = new(MockUserStore)     // สร้างใหม่ทุกเทส → ไม่ปนกัน
    s.svc = NewUserService(s.store)
}

func (s *UserServiceSuite) TestFindUser_ReturnsUser() {
    s.store.On("GetByID", 1).Return(&User{Name: "Bob"}, nil)

    user, err := s.svc.FindUser(1)
    s.Require().NoError(err)              // ⚠️ s.Require() ไม่ใช่ require.X(t, …)
    s.Assert().Equal("Bob", user.Name)     // ⚠️ ไม่ต้องส่ง t
}

func (s *UserServiceSuite) TestFindUser_PropagatesError() {
    s.store.On("GetByID", 2).Return(nil, errors.New("db down"))

    _, err := s.svc.FindUser(2)
    s.Assert().Error(err)
}

// ต้องมีตัวนี้ ไม่งั้น go test ไม่เห็น suite
func TestUserServiceSuite(t *testing.T) {
    suite.Run(t, new(UserServiceSuite))
}

$ go test -v ./...
=== RUN   TestUserServiceSuite
--- PASS: TestUserServiceSuite (0.00s)
PASS
ok  	day5check	0.480s

Hook ทั้งหมด

ผลรันจริงของลำดับ hook:

=== RUN   TestUserServiceSuite
    SetupSuite: ครั้งเดียวก่อนทุกเทส
=== RUN   TestUserServiceSuite/TestFindUser_PropagatesError
    SetupTest: ก่อนทุกเทส
    TearDownTest: หลังทุกเทส
=== RUN   TestUserServiceSuite/TestFindUser_ReturnsUser
    SetupTest: ก่อนทุกเทส
    TearDownTest: หลังทุกเทส
    TearDownSuite: ครั้งเดียวหลังทุกเทสจบ
--- PASS: TestUserServiceSuite

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

10 · ลงมือทำ

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

แหล่งหลักที่แนะนำ: pkg.go.dev — testify/assert มีรายการฟังก์ชันครบทุกตัว กด Ctrl+F หาสิ่งที่ต้องการเร็วกว่าเดา · ส่วน testify/mock มีตัวอย่างครบตั้งแต่ On ถึง Run
ข้อควรรู้: testify เป็น library ของบุคคลที่สาม ไม่ใช่ของทีม Go — บางทีมเลือกไม่ใช้เลยเพราะอยากให้เทสพึ่งพา standard library อย่างเดียว รู้ทั้งสองแบบไว้ดีที่สุด บทเรียน 15–16 คือแบบไม่ใช้ บทนี้คือแบบใช้

อ้างอิง

• testify/assert — รายการฟังก์ชันครบทุกตัว
• testify/require — เวอร์ชันที่หยุดเทส
• testify/mock — On, Return, Assert*
• testify/suite — hook ทั้งหมด
• github.com/stretchr/testify — README มีตัวอย่างครบ
• pkg.go.dev — reflect.DeepEqual — กฎการเทียบที่ assert.Equal ใช้