Hvad er mocks, stubs og test doubles?

Question

Accepted Answer

**Test doubles** er objekter, der erstatter rigtige afhængigheder i test — herunder **mocks**, **stubs**, **spies**, **fakes** og **dummies**. De isolerer koden under test fra dens afhængigheder (databaser, API'er, tjenester), hvilket muliggør hurtige, fokuserede, kontrollerede enhedstests.

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

## Typerne af 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 (den vigtigste forskel)

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

## Hvorfor det betyder noget

At forstå test doubles (mocks, stubs osv.) er vigtig, fordi de er **essentielle for at skrive isolerede enhedstests**, så det er værdifuld, hyppigt anvendt testkendskab.

For at teste en enhed i isolation (målet med enhedstest) skal du erstatte dens rigtige afhængigheder (databaser, API'er, tjenester) med **test doubles** — hvilket muliggør test, der er **hurtig** (ingen rigtig I/O), **kontrolleret** (opsætning af præcise scenarier, herunder fejltilstande, der er svære at udløse med rigtige afhængigheder) og **deterministisk** (ingen ekstern ustabilitet).

At forstå **typerne** og deres formål er nødvendigt: **stubs** (levering af forudindstillede svar for at kontrollere, hvad afhængigheder returnerer — fodring af enheden med specifikke data), **mocks** (stubs, der også verificerer interaktioner — kontrol af, at enheden kaldte en afhængighed korrekt), **spies** (registrering af kald på rigtige eller falske objekter), **fakes** (arbejdende forenklede implementeringer som in-memory databaser) og **dummies** (pladsholdere).

At forstå **den vigtigste mock-vs-stub-forskel** — stubs kontrollerer input (tilstandsverifikation: levering af data), mens mocks verificerer output/interaktioner (adfærdsverifikation: kontrol af, at enheden kaldte afhængigheder korrekt) — er vigtig, ofte misforstået begrebslig viden, og at bruge hver passende betyder noget.

At forstå **over-mocking-fælden** (overdreven mocking forbinder test til implementeringsdetaljer, hvilket gør dem skrøbelige, så du bør mocke ved de rigtige grænser) afspejler modent testningsdomæne.

Test doubles bruges konstant i enhedstesting for at isolere koden under test.

Da isoleret enhedstest kræver udskiftning af rigtige afhængigheder med test doubles (for hastighed, kontrol og determinisme), og da forståelse af typerne, mock-vs-stub-sondringen og over-mocking-fælden er nødvendig for at skrive gode isolerede test, er forståelse af test doubles værdifuld, hyppigt anvendt testkendskab — essentiel for enhedstest, brugt konstant til at isolere kode under test og vigtig for at skrive fokuserede, kontrollerede test, mens man undgår skrøbeligheden af over-mocking, en kernekompetence for effektiv enhedstest.