Apa itu mocks, stubs, dan test doubles?

Question

Accepted Answer

**Test doubles** adalah objek yang menggantikan dependensi nyata dalam tes — termasuk **mocks**, **stubs**, **spies**, **fakes**, dan **dummies**. Mereka mengisolasi kode yang diuji dari dependensinya (database, API, layanan), memungkinkan tes unit yang cepat, fokus, dan terkontrol.

## Mengapa ini penting

```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 (perbedaan 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 ini penting

Memahami test doubles (mocks, stubs, dll.) penting karena mereka **penting untuk menulis tes unit yang terisolasi**, jadi ini adalah pengetahuan pengujian yang berharga dan sering diterapkan.

Untuk menguji unit secara terisolasi (tujuan unit testing), Anda harus mengganti dependensi nyatanya (database, API, layanan) dengan **test doubles** — memungkinkan tes yang **cepat** (tanpa I/O nyata), **terkontrol** (menyiapkan skenario tepat termasuk kondisi kesalahan yang sulit dipicu dengan dependensi nyata), dan **deterministik** (tanpa ketidakstabilan eksternal).

Memahami **jenis-jenis** dan tujuannya diperlukan: **stubs** (menyediakan respons yang telah ditentukan untuk mengontrol apa yang dikembalikan dependensi — memberi unit data spesifik), **mocks** (stubs yang juga memverifikasi interaksi — memeriksa unit memanggil dependensi dengan benar), **spies** (merekam panggilan pada objek nyata atau palsu), **fakes** (implementasi sederhana yang berfungsi seperti database dalam memori), dan **dummies** (pengganti).

Memahami **perbedaan utama mock-vs-stub** — stubs mengontrol input (verifikasi state: menyediakan data) sementara mocks memverifikasi output/interaksi (verifikasi behavior: memeriksa unit memanggil dependensi dengan benar) — adalah pengetahuan konseptual penting yang sering membingungkan, dan menggunakan masing-masing dengan tepat penting.

Memahami **jebakan over-mocking** (mocking berlebihan menghubungkan tes ke detail implementasi, membuatnya rapuh, jadi Anda harus mock di batas yang tepat) mencerminkan keputusan pengujian yang matang.

Test doubles digunakan terus-menerus dalam unit testing untuk mengisolasi kode yang diuji.

Karena unit testing terisolasi memerlukan penggantian dependensi nyata dengan test doubles (untuk kecepatan, kontrol, dan determinisme), dan karena memahami jenis-jenis, perbedaan mock-vs-stub, dan jebakan over-mocking diperlukan untuk menulis tes terisolasi yang baik, memahami test doubles adalah pengetahuan pengujian yang berharga dan sering diterapkan — penting untuk unit testing, digunakan terus-menerus untuk mengisolasi kode yang diuji, dan penting untuk menulis tes yang fokus dan terkontrol sambil menghindari rapuhnya over-mocking, keterampilan inti untuk unit testing yang efektif.