Test doubles zijn objecten die in tests als vervanging dienen voor echte afhankelijkheden — inclusief mocks, stubs, spies, fakes en dummies. Ze isoleren de code die getest wordt van zijn afhankelijkheden (databases, API's, services), waardoor snelle, gerichte, gecontroleerde unit tests mogelijk zijn.
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)
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
// stub: control what a dependency returns
const userService = { getUser: jest.fn().mockReturnValue({ name: 'Ann' }) };
// mock verification: check an interaction happened
expect(emailService.send).toHaveBeenCalledWith('[email protected]');
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.
Begrip van test doubles (mocks, stubs, enz.) is belangrijk omdat ze essentieel zijn voor het schrijven van geïsoleerde unit tests, dus het is waardevolle, veel toegepaste testkennis.
Om een unit in isolatie te testen (het doel van unit testing), moet je de echte afhankelijkheden (databases, API's, services) vervangen door test doubles — waardoor tests snel (geen echte I/O), gecontroleerd (het opzetten van exacte scenario's inclusief fouttoestanden die moeilijk te triggeren zijn met echte afhankelijkheden) en deterministisch (geen externe instabiliteit) zijn. "
Begrip van de soorten en hun doeleinden is noodzakelijk: stubs (het bieden van voorgeprogrammeerde reacties om te controleren wat afhankelijkheden retourneren — de unit specifieke gegevens verstrekken), mocks (stubs die ook interacties verifiëren — controleren dat de unit een afhankelijkheid correct aanriep), spies (aanroepen op echte of nep-objecten registreren), fakes (werkende vereenvoudigde implementaties zoals in-memory databases), en dummies (plaatsvervanger).
Begrip van het sleutelonderscheid tussen mock en stub — stubs controleren invoer (state verification: gegevens verstrekken) terwijl mocks uitvoer/interacties verifiëren (behavior verification: controleren dat de unit afhankelijkheden correct aanriep) — is belangrijke conceptuele kennis die vaak verward wordt, en het correct gebruiken van elk is belangrijk.
Begrip van de over-mocking-valkuil (excessief mocking koppelt tests aan implementatiedetails, waardoor ze fragiel worden, dus je moet op de juiste grenzen mocken) weerspiegelt volwassen testvaardigheid.
Test doubles worden voortdurend in unit testing gebruikt om de code die getest wordt te isoleren.
Omdat geïsoleerde unit testing het vervangen van echte afhankelijkheden door test doubles vereist (voor snelheid, controle en determinisme), en omdat het begrijpen van de soorten, het mock-versus-stub-onderscheid en de over-mocking-valkuil noodzakelijk is om goed geïsoleerde tests te schrijven, is het begrijpen van test doubles waardevolle, veel toegepaste testkennis — essentieel voor unit testing, voortdurend gebruikt om code te isoleren, en belangrijk voor het schrijven van gerichte, gecontroleerde tests terwijl je de fragility van over-mocking vermijdt, een kernvaardigheid voor effectieve unit testing.