Mocks, Stubs, Fakes, and Test Doubles

Test Doubles are substitute objects that replace real dependencies during testing. They let you test components in isolation, remove external systems from the equation, and make tests deterministic. Understanding the differences between Mocks, Stubs, Fakes, Dummies, and Spies helps you write more precise and maintainable tests.

In a Nutshell

• Test Doubles replace real dependencies in tests.
• Dummy, Stub, Fake, Spy, and Mock each serve different purposes and exhibit different behavior.
• Mocks verify interactions; Stubs provide fixed responses; Fakes contain simplified logic.
• Too many Mocks can make tests brittle.

Quick Definition

The term “Test Double” comes from the stunt double in film. Just as a stunt performer replaces an actor, a Test Double assumes the role of a real dependency in a test. The goal is to isolate the unit under test from the outside world, so you evaluate only its behavior.

The Five Test Doubles

Dummy

A Dummy is an object that gets passed in but is never actually used. It exists only to satisfy a method’s signature.

Stub

A Stub returns predetermined responses to calls. It replaces a real dependency with a fixed result, without implementing any real logic.

Fake

A Fake contains a simplified but functional implementation. An in-memory repository is a classic example of a Fake.

Spy

A Spy records calls so they can be verified later. It’s essentially a hand-rolled Mock.

Mock

A Mock is an object where you define expected interactions before the test runs. After the test, you verify that those calls actually happened.

Practical Example: Order Processing with Test Doubles

from unittest.mock import Mock

class OrderService:
    def __init__(self, payment_gateway, inventory_repository):
        self.payment_gateway = payment_gateway
        self.inventory_repository = inventory_repository

    def process_order(self, order):
        available = self.inventory_repository.is_available(order.product_id)
        if not available:
            return {"status": "failed", "reason": "out_of_stock"}
        payment_result = self.payment_gateway.charge(order.amount)
        if payment_result.success:
            return {"status": "success"}
        return {"status": "failed", "reason": payment_result.error}

class PaymentResult:
    def __init__(self, success, error=None):
        self.success = success
        self.error = error

def test_order_success():
    inventory = Mock()
    inventory.is_available.return_value = True

    payment = Mock()
    payment.charge.return_value = PaymentResult(success=True)

    service = OrderService(payment, inventory)
    result = service.process_order(Mock(product_id=1, amount=99.99))

    assert result["status"] == "success"
    payment.charge.assert_called_once_with(99.99)

Advantages and Disadvantages

Advantages

• Isolation: External systems and slow dependencies are removed.
• Speed: Tests run without real databases or network calls.
• Determinism: Fixed return values make tests predictable.
• Focus: You verify only the behavior of the unit in question.

Disadvantages

• False confidence: Mocks can create an unrealistic picture of how things actually work.
• Maintenance burden: Tightly coupled Mocks break during refactoring.
• Overhead: Too many Test Doubles obscure the real behavior.
• Learning curve: The subtle differences between Mock and Stub are often misunderstood.

Key Exam Topics

• Definition and purpose of Test Doubles.
• Differences between Dummy, Stub, Fake, Spy, and Mock.
• When to use each type of Double.
• Advantages and risks of Mocks.
• Relationship to the test pyramid and isolated testing.

Common Exam Questions (with Brief Answers)

1. What is a Test Double? A substitute object for a real dependency in a test.

2. What’s the difference between a Mock and a Stub? A Stub provides fixed responses; a Mock verifies interactions.

3. What is a Fake? A substitute with simplified but functional logic.

4. When do you use a Dummy? When an object must be passed as a parameter but is never used.

5. What is a disadvantage of Mocks? They can couple too tightly to the implementation and break during refactoring.

Key Sources

1. https://martinfowler.com/bliki/TestDouble.html
2. https://xunitpatterns.com/Test%20Double.html
3. https://en.wikipedia.org/wiki/Test_double

Continue Learning: Software Testing

The next article in the Software Testing learning path covers Test Driven Development: Red, Green, Refactor — the fundamentals of TDD and the Red-Green-Refactor cycle.