Docs
README
20.3 Mocking & Test Doubles
Overview
Mocking and test doubles are techniques for replacing real dependencies with controlled substitutes during testing. They allow you to isolate the code under test and verify behavior without relying on external systems.
Learning Objectives
By the end of this section, you'll understand:
- •Types of test doubles (Dummy, Stub, Spy, Mock, Fake)
- •When to use each type
- •Implementing test doubles manually
- •Using mocking libraries
- •Best practices for mocking
Types of Test Doubles
┌────────────────────────────────────────────────────────────────┐
│ Test Double Spectrum │
├────────────────────────────────────────────────────────────────┤
│ │
│ Simple ◄─────────────────────────────────────────► Complex │
│ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ Dummy │ │ Stub │ │ Spy │ │ Mock │ │
│ │ │ │ │ │ │ │ │ │
│ │ Passed │ │ Returns │ │ Records │ │ Verifies│ │
│ │ but not │ │ canned │ │ calls │ │ expecta-│ │
│ │ used │ │ answers │ │ & args │ │ tions │ │
│ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │
│ │ │ │ │ │
│ └─────────────┴─────────────┴─────────────┘ │
│ │ │
│ ┌──────┴──────┐ │
│ │ Fake │ │
│ │ │ │
│ │ Working but │ │
│ │ simplified │ │
│ │ implementation │
│ └─────────────┘ │
│ │
└────────────────────────────────────────────────────────────────┘
Test Double Comparison
| Type | Purpose | Behavior | Example |
|---|---|---|---|
| Dummy | Fill parameters | Not actually used | null, empty object |
| Stub | Provide canned answers | Returns predefined values | getUser() => user |
| Spy | Track calls | Records calls + can return values | sinon.spy() |
| Mock | Verify behavior | Has expectations, can fail | expect(fn).toHaveBeenCalled() |
| Fake | Working substitute | Simpler implementation | In-memory database |
When to Use Test Doubles
┌────────────────────────────────────────────────────────────────┐
│ When to Use Test Doubles │
├────────────────────────────────────────────────────────────────┤
│ │
│ USE Mocks When: DON'T Mock When: │
│ ┌────────────────────────┐ ┌────────────────────────┐ │
│ │ │ │ │ │
│ │ ✓ Dependency is slow │ │ ✗ Simple value objects │ │
│ │ (database, network) │ │ │ │
│ │ │ │ ✗ Pure utility funcs │ │
│ │ ✓ Dependency is costly │ │ │ │
│ │ (payment APIs) │ │ ✗ Everything - only │ │
│ │ │ │ what's needed │ │
│ │ ✓ Dependency is │ │ │ │
│ │ non-deterministic │ │ ✗ Implementation │ │
│ │ (time, random) │ │ details │ │
│ │ │ │ │ │
│ │ ✓ Dependency has │ │ │ │
│ │ side effects │ │ │ │
│ │ (sending emails) │ │ │ │
│ │ │ │ │ │
│ └────────────────────────┘ └────────────────────────┘ │
│ │
└────────────────────────────────────────────────────────────────┘
Test Double Examples
Dummy
┌────────────────────────────────────────────────────────────────┐
│ Dummy │
├────────────────────────────────────────────────────────────────┤
│ │
│ function createUser(name, logger) { │
│ return { name }; │
│ } │
│ │
│ // Test - logger not used but required │
│ const dummyLogger = null; ◄── Dummy │
│ const user = createUser('John', dummyLogger); │
│ │
│ Purpose: Satisfy parameter requirements │
│ Behavior: Never actually called │
│ │
└────────────────────────────────────────────────────────────────┘
Stub
┌────────────────────────────────────────────────────────────────┐
│ Stub │
├────────────────────────────────────────────────────────────────┤
│ │
│ class UserService { │
│ constructor(userRepository) { │
│ this.repo = userRepository; │
│ } │
│ async getUser(id) { │
│ return this.repo.findById(id); │
│ } │
│ } │
│ │
│ // Stub - returns canned data │
│ const stubRepo = { ◄── Stub │
│ findById: (id) => ({ │
│ id, name: 'John' │
│ }) │
│ }; │
│ │
│ const service = new UserService(stubRepo); │
│ const user = await service.getUser(1); │
│ // user = { id: 1, name: 'John' } │
│ │
│ Purpose: Control indirect inputs │
│ Behavior: Returns predefined values │
│ │
└────────────────────────────────────────────────────────────────┘
Spy
┌────────────────────────────────────────────────────────────────┐
│ Spy │
├────────────────────────────────────────────────────────────────┤
│ │
│ class NotificationService { │
│ constructor(emailSender) { │
│ this.sender = emailSender; │
│ } │
│ notify(user, message) { │
│ this.sender.send(user.email, message); │
│ } │
│ } │
│ │
│ // Spy - records calls │
│ const spySender = { ◄── Spy │
│ calls: [], │
│ send(to, msg) { │
│ this.calls.push({ to, msg }); │
│ } │
│ }; │
│ │
│ const service = new NotificationService(spySender); │
│ service.notify({ email: 'a@b.com' }, 'Hello'); │
│ │
│ // Assert on recorded calls │
│ assert(spySender.calls[0].to === 'a@b.com'); │
│ assert(spySender.calls[0].msg === 'Hello'); │
│ │
│ Purpose: Verify indirect outputs │
│ Behavior: Records all calls for later inspection │
│ │
└────────────────────────────────────────────────────────────────┘
Mock
┌────────────────────────────────────────────────────────────────┐
│ Mock │
├────────────────────────────────────────────────────────────────┤
│ │
│ // Mock with expectations │
│ const mockPayment = { ◄── Mock │
│ expectations: [], │
│ calls: [], │
│ │
│ expect(method, args, returns) { │
│ this.expectations.push({ method, args, returns }); │
│ }, │
│ │
│ charge(amount) { │
│ this.calls.push({ method: 'charge', args: [amount] });
│ const exp = this.expectations.find( │
│ e => e.method === 'charge' │
│ ); │
│ return exp?.returns; │
│ }, │
│ │
│ verify() { │
│ this.expectations.forEach(exp => { │
│ const call = this.calls.find( │
│ c => c.method === exp.method │
│ ); │
│ if (!call) throw new Error('Expectation not met');
│ }); │
│ } │
│ }; │
│ │
│ mockPayment.expect('charge', [100], { success: true }); │
│ processOrder(mockPayment, order); │
│ mockPayment.verify(); // Throws if charge wasn't called │
│ │
│ Purpose: Verify behavior + provide returns │
│ Behavior: Has expectations that must be met │
│ │
└────────────────────────────────────────────────────────────────┘
Fake
┌────────────────────────────────────────────────────────────────┐
│ Fake │
├────────────────────────────────────────────────────────────────┤
│ │
│ // Fake - working but simplified implementation │
│ class FakeDatabase { ◄── Fake │
│ constructor() { │
│ this.data = new Map(); │
│ } │
│ │
│ insert(table, record) { │
│ const id = this.data.size + 1; │
│ this.data.set(`${table}:${id}`, { ...record, id }); │
│ return id; │
│ } │
│ │
│ find(table, id) { │
│ return this.data.get(`${table}:${id}`); │
│ } │
│ │
│ update(table, id, data) { │
│ const key = `${table}:${id}`; │
│ const existing = this.data.get(key); │
│ this.data.set(key, { ...existing, ...data }); │
│ } │
│ │
│ delete(table, id) { │
│ this.data.delete(`${table}:${id}`); │
│ } │
│ } │
│ │
│ Purpose: Simplified working implementation │
│ Behavior: Works like real thing but simpler/faster │
│ │
└────────────────────────────────────────────────────────────────┘
Mocking Strategies
┌────────────────────────────────────────────────────────────────┐
│ Mocking Strategies │
├────────────────────────────────────────────────────────────────┤
│ │
│ 1. Dependency Injection │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ class Service { │ │
│ │ constructor(dependency) { ← Injected │ │
│ │ this.dep = dependency; │ │
│ │ } │ │
│ │ } │ │
│ │ // Test: new Service(mockDependency) │ │
│ └──────────────────────────────────────────────────────┘ │
│ │
│ 2. Module Mocking │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ // Mock the entire module │ │
│ │ jest.mock('./database', () => ({ │ │
│ │ query: jest.fn().mockResolvedValue([...]) │ │
│ │ })); │ │
│ └──────────────────────────────────────────────────────┘ │
│ │
│ 3. Monkey Patching (Last Resort!) │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ const original = obj.method; │ │
│ │ obj.method = mockFn; │ │
│ │ // ... test ... │ │
│ │ obj.method = original; // Restore! │ │
│ └──────────────────────────────────────────────────────┘ │
│ │
└────────────────────────────────────────────────────────────────┘
Mock Patterns
┌────────────────────────────────────────────────────────────────┐
│ Common Mock Patterns │
├────────────────────────────────────────────────────────────────┤
│ │
│ Time Mock │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ const realDate = Date; │ │
│ │ global.Date = class extends Date { │ │
│ │ constructor() { │ │
│ │ super(); │ │
│ │ return new realDate('2024-01-01'); │ │
│ │ } │ │
│ │ }; │ │
│ └──────────────────────────────────────────────────────┘ │
│ │
│ Random Mock │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ const originalRandom = Math.random; │ │
│ │ Math.random = () => 0.5; // Deterministic │ │
│ │ // ... test ... │ │
│ │ Math.random = originalRandom; │ │
│ └──────────────────────────────────────────────────────┘ │
│ │
│ Async Mock │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ const mockFetch = (url) => Promise.resolve({ │ │
│ │ ok: true, │ │
│ │ json: () => Promise.resolve({ data: 'test' }) │ │
│ │ }); │ │
│ └──────────────────────────────────────────────────────┘ │
│ │
│ Error Mock │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ const failingMock = () => { │ │
│ │ throw new Error('Simulated failure'); │ │
│ │ }; │ │
│ └──────────────────────────────────────────────────────┘ │
│ │
└────────────────────────────────────────────────────────────────┘
Mock Best Practices
| Practice | Description | Why |
|---|---|---|
| Mock at boundaries | Mock external systems, not internals | Reduces brittleness |
| Verify behavior | Check interactions, not implementation | Tests stay relevant |
| Keep mocks simple | Only mock what's needed | Easier maintenance |
| Use real objects when possible | Prefer integration over isolation | More realistic tests |
| Reset mocks between tests | Clear state for isolation | Prevents test pollution |
| Name mocks clearly | mockUserRepo, stubLogger | Better readability |
Anti-Patterns to Avoid
┌────────────────────────────────────────────────────────────────┐
│ Mocking Anti-Patterns │
├────────────────────────────────────────────────────────────────┤
│ │
│ ✗ Over-mocking │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ // DON'T mock everything │ │
│ │ mock(Array); │ │
│ │ mock(Object); │ │
│ │ mock(everyInternalClass); │ │
│ └──────────────────────────────────────────────────────┘ │
│ │
│ ✗ Implementation-dependent mocks │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ // DON'T verify private method calls │ │
│ │ expect(service._privateMethod).toHaveBeenCalled(); │ │
│ └──────────────────────────────────────────────────────┘ │
│ │
│ ✗ Brittle assertions │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ // DON'T check exact call count if not important │ │
│ │ expect(mock).toHaveBeenCalledTimes(3); │ │
│ │ │ │
│ │ // DO check that it was called │ │
│ │ expect(mock).toHaveBeenCalled(); │ │
│ └──────────────────────────────────────────────────────┘ │
│ │
│ ✗ Mocking what you own │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ // DON'T mock your own classes if not needed │ │
│ │ // Use the real implementation │ │
│ └──────────────────────────────────────────────────────┘ │
│ │
└────────────────────────────────────────────────────────────────┘
Key Takeaways
┌────────────────────────────────────────────────────────────────┐
│ Test Doubles Summary │
├────────────────────────────────────────────────────────────────┤
│ │
│ ✓ Use dummies for unused but required parameters │
│ ✓ Use stubs to control indirect inputs │
│ ✓ Use spies to verify indirect outputs │
│ ✓ Use mocks for behavior verification │
│ ✓ Use fakes for complex working substitutes │
│ │
│ Key Principles: │
│ • Mock external dependencies, not internal code │
│ • Use dependency injection for testability │
│ • Keep mocks simple and focused │
│ • Verify behavior, not implementation │
│ • Reset mocks between tests │
│ │
└────────────────────────────────────────────────────────────────┘
Navigation
- •Previous: 20.2 Integration & E2E Testing
- •Next: 20.4 Debugging Techniques