Was sind Mocks, Stubs und Test Doubles?

Question

Accepted Answer

**Test Doubles** sind Objekte, die in Tests an Stelle von echten Abhängigkeiten stehen — einschließlich **Mocks**, **Stubs**, **Spies**, **Fakes** und **Dummies**. Sie isolieren den zu testenden Code von seinen Abhängigkeiten (Datenbanken, APIs, Services) und ermöglichen schnelle, fokussierte, kontrollierte Unit Tests.

## Warum es wichtig ist

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

## Die Arten von 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 (die wesentliche Unterscheidung)

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

## Warum es wichtig ist

Test Doubles (Mocks, Stubs usw.) zu verstehen ist wichtig, weil sie **unverzichtbar für das Schreiben von isolierten Unit Tests** sind — es ist wertvolles, häufig angewendetes Testwissen.

Um eine Unit isoliert zu testen (das Ziel von Unit Testing), müssen Sie ihre echten Abhängigkeiten (Datenbanken, APIs, Services) durch **Test Doubles** ersetzen — was Tests ermöglicht, die **schnell** sind (keine echte I/O), **kontrolliert** (Einrichten von exakten Szenarien einschließlich Fehlerbedingungen, die mit echten Abhängigkeiten schwer auszulösen sind) und **deterministisch** (keine externe Instabilität).

Das Verstehen der **Typen** und ihrer Zwecke ist notwendig: **Stubs** (Bereitstellung vorgefertigter Antworten, um zu kontrollieren, was Abhängigkeiten zurückgeben — Füttern der Unit mit spezifischen Daten), **Mocks** (Stubs, die auch Interaktionen überprüfen — Kontrollieren, dass die Unit eine Abhängigkeit korrekt aufgerufen hat), **Spies** (Aufzeichnung von Aufrufen auf echten oder gefälschten Objekten), **Fakes** (funktionierende vereinfachte Implementierungen wie In-Memory-Datenbanken) und **Dummies** (Platzhalter).

Das Verstehen der **wesentlichen Mock-vs-Stub-Unterscheidung** — Stubs kontrollieren Eingaben (State Verification: Bereitstellung von Daten) während Mocks Ausgaben/Interaktionen überprüfen (Behavior Verification: Kontrollieren, dass die Unit Abhängigkeiten korrekt aufgerufen hat) — ist wichtiges konzeptionelles Wissen, das oft verwechselt wird, und die angemessene Verwendung jedes Typs ist wichtig.

Das Verstehen der **Over-Mocking-Falle** (übermäßiges Mocking koppelt Tests an Implementierungsdetails, macht sie spröde, daher sollten Sie an den richtigen Grenzen mocken) spiegelt reife Urteilskraft beim Testen wider.

Test Doubles werden beim Unit Testing ständig verwendet, um den zu testenden Code zu isolieren.

Da das isolierte Unit Testing das Ersetzen echter Abhängigkeiten durch Test Doubles erfordert (für Geschwindigkeit, Kontrolle und Determinismus), und da das Verstehen der Typen, der Mock-vs-Stub-Unterscheidung und der Over-Mocking-Falle notwendig ist, um gute isolierte Tests zu schreiben, ist das Verstehen von Test Doubles wertvolles, häufig angewendetes Testwissen — unverzichtbar für Unit Testing, ständig verwendet, um Code zu isolieren, und wichtig für das Schreiben von fokussierten, kontrollierten Tests, während man die Sprödigkeit von Over-Mocking vermeidet — eine Kernfähigkeit für effektives Unit Testing.