Apakah itu mocks, stubs, dan test doubles?

Question

Accepted Answer

**Test doubles** ialah objek yang menggantikan dependencies sebenar dalam ujian — termasuk **mocks**, **stubs**, **spies**, **fakes**, dan **dummies**. Ia mengasingkan kod yang diuji daripada dependencies-nya (databases, APIs, services), membolehkan unit test yang pantas, fokus, dan terkawal.

## Mengapa test doubles

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

## Jenis-jenis test doubles

```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 vs stub (perbezaan utama)

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

## Mengapa ia penting

Memahami test doubles (mocks, stubs, dll.) adalah penting kerana ia **penting untuk menulis unit test yang terasing**, jadi ia merupakan pengetahuan pengujian yang bernilai dan kerap digunakan.

Untuk menguji sesuatu unit secara berasingan (matlamat unit testing), anda mesti menggantikan dependencies sebenarnya (databases, APIs, services) dengan **test doubles** — membolehkan ujian yang **pantas** (tiada I/O sebenar), **terkawal** (menyediakan senario tepat termasuk keadaan ralat yang sukar dicetuskan dengan dependencies sebenar), dan **deterministik** (tiada flakiness luaran).

Memahami **jenis-jenis** dan tujuannya adalah perlu: **stubs** (menyediakan respons terkalengkan untuk mengawal apa yang dikembalikan oleh dependencies — menyuap data spesifik kepada unit), **mocks** (stubs yang juga mengesahkan interaksi — memeriksa unit memanggil sesuatu dependency dengan betul), **spies** (merakam panggilan pada objek sebenar atau palsu), **fakes** (implementasi ringkas yang berfungsi seperti database dalam memori), dan **dummies** (placeholder).

Memahami **perbezaan utama mock-vs-stub** — stubs mengawal input (pengesahan keadaan: menyediakan data) manakala mocks mengesahkan output/interaksi (pengesahan tingkah laku: memeriksa unit memanggil dependencies dengan betul) — ialah pengetahuan konseptual penting yang sering dikelirukan, dan menggunakan setiap satu dengan sewajarnya adalah penting.

Memahami **perangkap over-mocking** (mocking yang berlebihan menggandingkan ujian dengan butiran implementasi, menjadikannya rapuh, jadi anda patut mock pada sempadan yang betul) mencerminkan pertimbangan pengujian yang matang.

Test doubles digunakan secara berterusan dalam unit testing untuk mengasingkan kod yang diuji.

Memandangkan unit testing terasing memerlukan penggantian dependencies sebenar dengan test doubles (untuk kelajuan, kawalan, dan determinisme), dan memandangkan memahami jenis-jenis, perbezaan mock-vs-stub, dan perangkap over-mocking adalah perlu untuk menulis ujian terasing yang baik, memahami test doubles adalah pengetahuan pengujian yang bernilai dan kerap digunakan — penting untuk unit testing, digunakan secara berterusan untuk mengasingkan kod yang diuji, dan penting untuk menulis ujian yang fokus dan terkawal sambil mengelakkan kerapuhan over-mocking, satu kemahiran teras untuk unit testing yang berkesan.