X'inhu l-mocks, stubs, u test doubles?

Question

Accepted Answer

**Test doubles** huma oġġetti li jinqalbu għal dipendentzi reali fit-tests — inklużi **mocks**, **stubs**, **spies**, **fakes**, u **dummies**. Jiizolaw il-kodiċi test minn id-dipendentzi tiegħu (databases, APIs, servizzi), li jippermettu unit tests mabdula, fokussati, u kkontrollati.

## Għaliex 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)
```

## It-tipi ta' 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 (il-distinzjoni ewlenija)

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

## Għaliex huwa importanti

L-għarfien ta' test doubles (mocks, stubs, eċċ.) huwa importanti għax huma **essenzjali biex tikteb unit tests iżolati**, għalhekk huwa għarfien ta' valur u applikat spiss.
">Biex tittestja unità iżolata (l-għan ta' unit testing), trid tibdel id-dipendentzi reali tagħha (databases, APIs, servizzi) b' **test doubles** — li jippermettu tests li huma **veloċi** (l-ebda I/O reali), **kkontrollati** (setup ta' sennarji eżatti inklużi kundizzjonijiet ta' żball li huma diffiċli biex jittriggeru b'dipendentzi reali), u **determinisitki** (l-ebda flakiness esterna).

L-għarfien tal-**tipi** u l-iskopji tagħhom huwa neċessarju: **stubs** (jipprovdu responses miftuħa biex jikkontrolla dak li jirritornaw id-dipendentzi — jagħtaw lill-unità data speċifika), **mocks** (stubs li wkoll jivverifikaw l-interazzjonijiet — jikkontrollaw l-unità kkjamata dipendentza korrettament), **spies** (jirreġistraw ċ-ċjawk fuq oġġetti reali jew falsi), **fakes** (implimentazzjonijiet simplifikat li jaħdmu bħal in-memory databases), u **dummies** (placeholders).

L-għarfien tal-**distinzjoni ewlenija mock-vs-stub** — stubs jikkontrolla inputs (state verification: jipprovdu data) filwaqt li mocks jivverifikaw outputs/interazzjonijiet (behavior verification: jikkontrollaw l-unità kkjamata id-dipendentzi korrettament) — huwa għarfien kunċettwali importanti spiss konfuż, u l-użu kull waħda kif xieraq huwa importanti.

L-għarfien tal-**pitfall ta' over-mocking** (excessive mocking jgħaqqadx tests għad-dettalji ta' implimentazzjoni, jagħmilhom fragili, għalhekk għandek mock fil-ħdud it-tajba) jirrifletti ġudizzju ta' testing maturi.

Test doubles jintużaw kostantement fil-unit testing biex jiżolaw il-kodiċi test.

Minkejja li l-unit testing iżolat jirrikjedi li tibdel id-dipendentzi reali b'test doubles (għall-veloċità, il-kontroll, u d-determinizmu), u minkejja li l-għarfien tal-tipi, il-distinzjoni mock-vs-stub, u l-pitfall ta' over-mocking huwa neċessarju biex tikteb tests tajba iżolati, l-għarfien ta' test doubles huwa valur u għarfien applikat spiss — essenzjali għall-unit testing, użat kostantement biex jiżolaw il-kodiċi test, u importanti għall-kitba ta' tests fokussati u kkontrollati filwaqt li jiġu evitati l-fragility ta' over-mocking, skill bażiku għal unit testing effettiv.