What are mocks, stubs, and test doubles?

Question

Accepted Answer

**Test doubles** are objects that stand in for real dependencies in tests — including **mocks**, **stubs**, **spies**, **fakes**, and **dummies**. They isolate the code under test from its dependencies (databases, APIs, services), enabling fast, focused, controlled unit tests.

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

## The types of 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 (the key distinction)

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

## Why it matters

Understanding test doubles (mocks, stubs, etc.) is important because they're **essential for writing isolated unit tests**, so it's valuable, frequently-applied testing knowledge.

To test a unit in isolation (the goal of unit testing), you must replace its real dependencies (databases, APIs, services) with **test doubles** — enabling tests that are **fast** (no real I/O), **controlled** (setting up exact scenarios including error conditions that are hard to trigger with real dependencies), and **deterministic** (no external flakiness).

Understanding the **types** and their purposes is necessary: **stubs** (providing canned responses to control what dependencies return — feeding the unit specific data), **mocks** (stubs that also verify interactions — checking the unit called a dependency correctly), **spies** (recording calls on real or fake objects), **fakes** (working simplified implementations like in-memory databases), and **dummies** (placeholders).

Understanding the **key mock-vs-stub distinction** — stubs control inputs (state verification: providing data) while mocks verify outputs/interactions (behavior verification: checking the unit called dependencies correctly) — is important conceptual knowledge often confused, and using each appropriately matters.

Understanding the **over-mocking pitfall** (excessive mocking couples tests to implementation details, making them brittle, so you should mock at the right boundaries) reflects mature testing judgment.

Test doubles are used constantly in unit testing to isolate the code under test.

Since isolated unit testing requires replacing real dependencies with test doubles (for speed, control, and determinism), and since understanding the types, the mock-vs-stub distinction, and the over-mocking pitfall is necessary to write good isolated tests, understanding test doubles is valuable, frequently-applied testing knowledge — essential for unit testing, used constantly to isolate code under test, and important for writing focused, controlled tests while avoiding the brittleness of over-mocking, a core skill for effective unit testing.