Ce sunt mock-urile, stub-urile și test double-urile?

Question

Accepted Answer

**Test double-urile** sunt obiecte care înlocuiesc dependențele reale în teste — incluzând **mock-uri**, **stub-uri**, **spioni**, **fake-uri** și **dummy-uri**. Ele izolează codul testat de dependențele sale (baze de date, API-uri, servicii), permițând teste rapide, concentrate și controlate la nivel de unitate.

## De ce test double-uri

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

## Tipurile de test double-uri

```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 (distincția esențială)

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

## De ce este important

Înțelegerea test double-urilor (mock-uri, stub-uri, etc.) este importantă deoarece sunt **esențiale pentru scrierea testelor izolate la nivel de unitate**, așadar este o cunoaștere valoroasă și frecvent aplicată în testing.

Pentru a testa o unitate în izolare (scopul testării la nivel de unitate), trebuie să înlocuiți dependențele sale reale (baze de date, API-uri, servicii) cu **test double-uri** — permițând teste care sunt **rapide** (fără I/O real), **controlate** (configurând scenarii exacte inclusiv condiții de eroare greu de declanșat cu dependențe reale) și **deterministe** (fără probleme externe de instabilitate).

Înțelegerea **tipurilor** și scopurilor lor este necesară: **stub-uri** (furnizând răspunsuri predefinite pentru a controla ceea ce dependențele returnează — alimentând unitatea cu date specifice), **mock-uri** (stub-uri care verifică și interacțiunile — verificând că unitatea a apelat o dependență corect), **spioni** (înregistrând apeluri pe obiecte reale sau false), **fake-uri** (implementări simplificate dar funcționale cum ar fi baze de date în memorie), și **dummy-uri** (substituenți).

Înțelegerea **distincției esențiale mock vs stub** — stub-urile controlează intrările (verificarea stării: furnizând date) în timp ce mock-urile verifică ieșiri/interacțiuni (verificarea comportamentului: verificând că unitatea a apelat corect dependențele) — este o cunoaștere conceptuală importantă adesea confundată, iar utilizarea corespunzătoare a fiecăruia este importantă.

Înțelegerea **pericolului over-mocking** (mock-area excesivă leagă testele de detalii de implementare, făcând-le fragile, așadar ar trebui să faceți mock la granițele potrivite) reflectă judecata de testing matură.

Test double-urile sunt folosite constant în testarea la nivel de unitate pentru a izola codul testat.

Deoarece testarea izolată la nivel de unitate necesită înlocuirea dependențelor reale cu test double-uri (pentru viteză, control și determinism), și deoarece înțelegerea tipurilor, distincției mock vs stub și pericolul over-mocking este necesară pentru a scrie teste bune izolate, înțelegerea test double-urilor este o cunoaștere valoroasă și frecvent aplicată — esențială pentru testarea la nivel de unitate, folosită constant pentru a izola codul testat și importantă pentru scrierea testelor concentrate și controlate evitând în același timp fragilitatea over-mocking, o abilitate fundamentală pentru testare efectivă la nivel de unitate.