Avoiding Over-Mocking
What you'll learn: You'll discover how to recognize when you've crossed the line from helpful mocking to tests that break whenever you refactor implementation details.
The Over-Mocking Trap
When you mock too many things or mock the wrong things, your tests become tightly coupled to how your code works internally rather than what it does. This defeats a major purpose of testing: enabling confident refactoring. If every small implementation change breaks dozens of tests—even though the actual behavior didn't change—you've over-mocked.
Signs You're Over-Mocking
Mocking internal collaborators: If you're mocking private methods or internal helper functions, you're testing implementation instead of observable behavior.
Brittle tests: When you rename a method or reorder operations and tests fail despite correct output, that's a red flag.
Complex mock setup: If arranging your mocks takes more lines than the actual code being tested, you might be mocking too much detail.
Testing through mocks: When your assertions verify mock interactions instead of actual results (state), you're often testing how rather than what.
The Fix
Mock at architectural boundaries—external APIs, databases, file systems—not your own internal objects. Ask: "Would the end user care if I changed this internal implementation?" If not, don't mock it; use the real thing.
Think of over-mocking like a stage play where you're testing whether the actor moved their left foot before their right foot, rather than whether they actually reached the door. The audience (users) only cares about the outcome, not the choreography details.
Key Takeaway: Mock external dependencies at system boundaries, not internal collaborators—test observable behavior, not implementation choreography.