Co jsou mocky, stuby a testovací dvojníci?

Question

Accepted Answer

**Testovací dvojníci** jsou objekty, které nahrazují reálné závislosti v testech — včetně **mocků**, **stubů**, **spyů**, **fakes** a **dummies**. Izolují testovaný kód od jeho závislostí (databáze, API, služby), což umožňuje rychlé, zaměřené a kontrolované unit testy.

## Proč testovací dvojníci

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

## Typy testovacích dvojníků

```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 (klíčový rozdíl)

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

## Proč je to důležité

Rozvržení testovacích dvojníků (mocků, stubů atd.) je důležité, protože jsou **nezbytné pro psaní izolovaných unit testů** — jedná se tedy o hodnotné a často používané znalosti z testování.

Abyste mohli testovat jednotku v izolaci (cíl unit testování), musíte nahradit její reálné závislosti (databáze, API, služby) **testovacími dvojníky** — což umožňuje testy, které jsou **rychlé** (bez reálného I/O), **kontrolované** (nastavení přesných scénářů včetně chybových stavů, které je těžké vyvolat s reálnými závislostmi) a **deterministické** (bez externích nespolehlivostí).

Rozvržení **typů** a jejich účelů je nezbytné: **stuby** (poskytují připravené odpovědi pro kontrolu toho, co závislosti vracejí — jednotce poskytují konkrétní data), **mocky** (stuby, které také ověřují interakce — kontrolují, zda jednotka správně volala závislost), **spyové** (zaznamenávají volání na reálných nebo falešných objektech), **fakes** (fungující zjednodušené implementace jako in-memory databáze) a **dummies** (zástupné symboly).

Rozvržení **klíčového rozdílu mock vs stub** — stuby řídí vstupy (ověření stavu: poskytování dat), zatímco mocky ověřují výstupy/interakce (ověření chování: kontrola, zda jednotka správně volala závislosti) — je důležité koncepční znalosti, které jsou často zaměňovány, a správné použití každého z nich je významné.

Rozvržení **nebezpečí nadměrného mockování** (nadměrné mockování váže testy na detaily implementace, což je činí křehkými, proto byste měli mockovat ve správných hranicích) odráží zralý náhled na testování.

Testovací dvojníci se v unit testování používají neustále k izolaci testovaného kódu.

Protože izolované unit testování vyžaduje nahrazení reálných závislostí testovacími dvojníky (pro rychlost, kontrolu a determinismus), a protože pochopení typů, rozdílu mezi mockem a stubem a nebezpečí nadměrného mockování je nezbytné pro psaní kvalitních izolovaných testů, je porozumění testovacím dvojníkům hodnotnou a často používanou znalostí z testování — nezbytné pro unit testování, používáno neustále k izolaci kódu pod testem a důležité pro psaní zaměřených, kontrolovaných testů při zároveň vyhýbání se křehkosti nadměrného mockování, což je klíčová dovednost pro efektivní unit testování.