In this lesson, you will learn how to configure mocks to prioritize expected outcomes over specific internal implementation details, ensuring your test suite remains robust even when you refactor your code.
The Problem: Implementation-Coupled Mocks
A "fragile" test is one that breaks not because the code's behavior is wrong, but because the code’s internal implementation changed. This often happens when we over-configure mocks—for example, by asserting exactly how many times a method was called, the order of intermediate calls, or verifying private helper methods that don't affect the final result.
If your test asserts that helper_function() must be called exactly three times with specific arguments, but you later refactor your logic to use a more efficient algorithm that calls a different helper, your test will fail even if the output is still correct. This creates a "brittle" dependency between your test and the underlying code.
Focusing on Behavior
To avoid fragility, configure your mocks to verify the observable result rather than the execution path.
Consider this example where we test a PaymentProcessor:
# Fragile approach: asserting internal steps
def test_process_payment(mocker):
mock_db = mocker.patch("app.db.save")
mock_email = mocker.patch("app.email.send")
process_payment(100)
# Brittle: What if we stop sending emails or change the call order?
mock_db.assert_called_once_with(100)
mock_email.assert_called_once()
If you refactor the code to call db.save twice or change the email logic to run asynchronously, this test breaks. Instead, focus on the result:
# Robust approach: Focus on the public contract
def test_process_payment(mocker):
# Only mock the dependency boundary to return a status
mocker.patch("app.db.save", return_value=True)
# Assert the outcome of the function, not the internal steps
result = process_payment(100)
assert result == "Success"
By stubbing the external boundary and asserting the return value or the final state, you allow yourself the freedom to rewrite the internal implementation entirely without touching the test. Use specific assertions only when the interaction is the core requirement (e.g., ensuring a security-critical API is called).
Key Takeaway: Configure your mocks to verify what the system achieves, not how it achieves it, to keep your tests resilient during refactoring.