Co to są mocki, stuby i test doubles?

Question

Accepted Answer

**Test doubles** to obiekty zastępujące rzeczywiste zależności w testach — obejmujące **mocki**, **stuby**, **spy'e**, **fake'i** i **dummy'e**. Izolują kod testowany od jego zależności (bazy danych, API, usługi), umożliwiając szybkie, skoncentrowane, kontrolowane testy jednostkowe.

## Dlaczego to ważne

```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 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 (kluczowe rozróżnienie)

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

## Dlaczego to ważne

Zrozumienie test doubles (mocki, stuby itd.) jest ważne, ponieważ są **niezbędne do pisania izolowanych testów jednostkowych**, a zatem stanowią cenną, часto stosowaną wiedzę z zakresu testowania.

Aby testować jednostkę w izolacji (cel testowania jednostkowego), musisz zastąpić jej rzeczywiste zależności (bazy danych, API, usługi) **test doubles** — umożliwiając testy, które są **szybkie** (bez rzeczywistego I/O), **kontrolowane** (konfiguracja dokładnych scenariuszy, w tym warunków błędu, które są trudne do wywołania z rzeczywistymi zależnościami) i **deterministyczne** (bez zewnętrznej niestabilności).

Zrozumienie **typów** i ich celów jest konieczne: **stuby** (dostarczanie gotowych odpowiedzi w celu kontrolowania tego, co zwracają zależności — przekazywanie jednostce konkretnych danych), **mocki** (stuby, które również weryfikują interakcje — sprawdzanie, czy jednostka prawidłowo wywołała zależność), **spy'e** (rejestrowanie wywołań na rzeczywistych lub fałszywych obiektach), **fake'i** (działające uproszczone implementacje, takie jak in-memory bazy danych) i **dummy'e** (symbole zastępcze).

Zrozumienie **kluczowego rozróżnienia mock vs stub** — stuby kontrolują dane wejściowe (weryfikacja stanu: dostarczanie danych), podczas gdy mocki weryfikują dane wyjściowe/interakcje (weryfikacja zachowania: sprawdzenie, czy jednostka prawidłowo wywołała zależności) — jest ważną wiedzą koncepcyjną, którą często się myli, a prawidłowe zastosowanie każdej z nich ma znaczenie.

Zrozumienie **pułapki nadmiernego mockowania** (zbyt duże mockowanie wiąże testy ze szczegółami implementacji, czyniąc je kruche, dlatego powinieneś mockować na odpowiednich granicach) odzwierciedla dojrzałą ocenę testowania.

Test doubles są stale wykorzystywane w testowaniu jednostkowym do izolacji testowanego kodu.

Ponieważ izolowane testowanie jednostkowe wymaga zastąpienia rzeczywistych zależności test doubles (w celu szybkości, kontroli i determinizmu), a ponieważ zrozumienie typów, rozróżnienia mock vs stub oraz pułapki nadmiernego mockowania jest konieczne do napisania dobrych izolowanych testów, zrozumienie test doubles jest cenną, часto stosowaną wiedzą testową — niezbędną dla testowania jednostkowego, stale stosowaną do izolacji testowanego kodu i ważną dla pisania skoncentrowanych, kontrolowanych testów, jednocześnie unikając kruchości nadmiernego mockowania, podstawową umiejętnością efektywnego testowania jednostkowego.