Mocks, stubs และ test doubles คืออะไร?

Question

Accepted Answer

**Test doubles** เป็น object ที่ทำหน้าที่แทน dependency จริงใน test — รวมถึง **mocks**, **stubs**, **spies**, **fakes** และ **dummies** มันแยกโค้ดที่กำลังทดสอบออกจาก dependency ของมัน (ฐานข้อมูล, API, service) ช่วยให้สามารถทำ unit test ที่รวดเร็ว มุ่งเน้น และควบคุมได้

## ทำไมต้องใช้ test double

```text
To test a unit in ISOLATION, replace its real dependencies (DB, API, services) with
TEST DOUBLES (fake stand-ins):
  → isolate the unit (test ONLY it, not its dependencies)
  → FAST (no real DB/network); CONTROLLED (set up exact scenarios, including errors);
    DETERMINISTIC (no external flakiness)
```

## ประเภทของ test double

```text
STUB → provides canned RESPONSES to calls (returns preset data):
  → "when getUser is called, return this fake user" — controls inputs to the unit
MOCK → a stub that also VERIFIES interactions (was it called? how? with what?):
  → "verify save() was called once with these arguments" — checks behavior/interactions
SPY → wraps a real (or fake) object and RECORDS calls (verify how it was used)
FAKE → a working but simplified implementation (e.g. an in-memory database)
DUMMY → a placeholder passed but not actually used
```

```js
// stub: control what a dependency returns
const userService = { getUser: jest.fn().mockReturnValue({ name: 'Ann' }) };
// mock verification: check an interaction happened
expect(emailService.send).toHaveBeenCalledWith('ann@x.com');
```

## mock กับ stub (ความแตกต่างสำคัญ)

```text
STUB → controls INPUTS (provides data the unit needs) — "state" verification
MOCK → verifies OUTPUTS/interactions (was the dependency called correctly?) — "behavior"
  verification
→ Use stubs to provide data; mocks to verify the unit called a dependency correctly.
⚠️ Over-mocking → tests coupled to implementation (brittle); mock at the right boundaries.
```

## ทำไมจึงสำคัญ

การเข้าใจ test double (mocks, stubs ฯลฯ) เป็นสิ่งสำคัญ เพราะมัน **จำเป็นต่อการเขียน unit test แบบแยกเดี่ยว** จึงเป็นความรู้ด้านการทดสอบที่มีคุณค่าและประยุกต์ใช้บ่อย

ในการทดสอบ unit แบบแยกเดี่ยว (เป้าหมายของ unit testing) คุณต้องแทนที่ dependency จริงของมัน (ฐานข้อมูล, API, service) ด้วย **test double** — ช่วยให้ test **รวดเร็ว** (ไม่มี I/O จริง) **ควบคุมได้** (ตั้งค่า scenario ที่แม่นยำ รวมถึงเงื่อนไขข้อผิดพลาดที่ยากจะกระตุ้นด้วย dependency จริง) และ **คาดเดาผลได้** (ไม่มี flakiness จากภายนอก)

การเข้าใจ **ประเภท** และวัตถุประสงค์ของมันเป็นสิ่งจำเป็น: **stub** (ให้ response สำเร็จรูปเพื่อควบคุมสิ่งที่ dependency คืนค่า — ป้อนข้อมูลเฉพาะให้กับ unit) **mock** (stub ที่ตรวจสอบปฏิสัมพันธ์ด้วย — ตรวจสอบว่า unit เรียก dependency อย่างถูกต้อง) **spy** (บันทึกการเรียกบน object จริงหรือปลอม) **fake** (implementation ที่ทำงานได้แต่ถูกทำให้เรียบง่ายอย่าง in-memory database) และ **dummy** (placeholder)

การเข้าใจ **ความแตกต่างสำคัญระหว่าง mock กับ stub** — stub ควบคุม input (state verification: ให้ข้อมูล) ในขณะที่ mock ตรวจสอบ output/ปฏิสัมพันธ์ (behavior verification: ตรวจสอบว่า unit เรียก dependency อย่างถูกต้อง) — เป็นความรู้เชิงแนวคิดที่สำคัญที่มักสับสนกัน และการใช้แต่ละอย่างอย่างเหมาะสมเป็นเรื่องสำคัญ

การเข้าใจ **กับดักของ over-mocking** (การ mock มากเกินไปทำให้ test ผูกติดกับรายละเอียดการ implement ทำให้เปราะบาง จึงควร mock ที่ขอบเขตที่ถูกต้อง) สะท้อนถึงวิจารณญาณด้านการทดสอบที่เป็นผู้ใหญ่

test double ถูกใช้อยู่ตลอดเวลาใน unit testing เพื่อแยกโค้ดที่กำลังทดสอบ

เนื่องจาก unit testing แบบแยกเดี่ยวต้องแทนที่ dependency จริงด้วย test double (เพื่อความรวดเร็ว การควบคุม และความคาดเดาผลได้) และเนื่องจากการเข้าใจประเภท ความแตกต่างระหว่าง mock กับ stub และกับดักของ over-mocking เป็นสิ่งจำเป็นในการเขียน test แบบแยกเดี่ยวที่ดี การเข้าใจ test double จึงเป็นความรู้ด้านการทดสอบที่มีคุณค่าและประยุกต์ใช้บ่อย — จำเป็นต่อ unit testing ถูกใช้อยู่ตลอดเวลาเพื่อแยกโค้ดที่กำลังทดสอบ และสำคัญต่อการเขียน test ที่มุ่งเน้นและควบคุมได้ในขณะที่หลีกเลี่ยงความเปราะบางของ over-mocking เป็นทักษะหลักสำหรับ unit testing ที่มีประสิทธิภาพ