Testing Anti-Patterns

Overview

Tests must verify real behavior, not mock behavior. Mocks are a means to isolate, not the thing being tested.

Core principle: Test what the code does, not what the mocks do.

Following strict TDD prevents these anti-patterns.

The Iron Laws

1. NEVER test mock behavior
2. NEVER add test-only methods to production classes
3. NEVER mock without understanding dependencies

Anti-Pattern 1: Testing Mock Behavior

BAD: expect(screen.getByTestId('sidebar-mock')).toBeInTheDocument() - testing mock exists, not real behavior.

GOOD: expect(screen.getByRole('navigation')).toBeInTheDocument() - test real component or don't mock.

Gate: Before asserting on mock element → "Am I testing real behavior or mock existence?" If mock → delete assertion or unmock.

Anti-Pattern 2: Test-Only Methods in Production

BAD: session.destroy() method only used in tests - pollutes production, dangerous if called.

GOOD: cleanupSession(session) in test-utils/ - keeps production clean.

Gate: "Is this method only used by tests?" → Put in test utilities. "Does this class own this lifecycle?" → If no, wrong class.

Anti-Pattern 3: Mocking Without Understanding

BAD: Mocking discoverAndCacheTools breaks config write test depends on - test passes for wrong reason.

GOOD: Mock only the slow part (MCPServerManager), preserve behavior test needs.

Gate: Before mocking → (1) What side effects does real method have? (2) Does test depend on them? If yes → mock at lower level. Red flags: "Mock to be safe", "might be slow", mocking without understanding.

Anti-Pattern 4: Incomplete Mocks

BAD: Partial mock missing metadata field - breaks when downstream code accesses response.metadata.requestId.

GOOD: Complete mock mirroring real API - ALL fields real API returns.

Iron Rule: Mock COMPLETE data structure, not just fields your test uses. Partial mocks fail silently.

Gate: Before mock → Check real API response, include ALL fields. If uncertain → include all documented fields.

Anti-Pattern 5: Integration Tests as Afterthought

BAD: "Implementation complete" without tests. FIX: TDD cycle: write test → implement → refactor → claim complete.

When Mocks Become Too Complex

Warning signs: Mock setup longer than test logic, mocking everything, mocks missing methods real components have. Consider: Integration tests with real components often simpler than complex mocks.

TDD Prevents These Anti-Patterns

TDD forces: (1) Think about what you're testing, (2) Watch fail confirms real behavior not mocks, (3) See what test needs before mocking. If testing mock behavior, you violated TDD.

Quick Reference

Anti-Pattern	Fix
Assert on mock elements	Test real component or unmock it
Test-only methods in production	Move to test utilities
Mock without understanding	Understand dependencies first, mock minimally
Incomplete mocks	Mirror real API completely
Tests as afterthought	TDD - tests first
Over-complex mocks	Consider integration tests

Red Flags

• Assertion checks for *-mock test IDs
• Methods only called in test files
• Mock setup is >50% of test
• Test fails when you remove mock
• Can't explain why mock is needed
• Mocking "just to be safe"

The Bottom Line

Mocks are tools to isolate, not things to test.

If TDD reveals you're testing mock behavior, you've gone wrong.

Fix: Test real behavior or question why you're mocking at all.

Blocker Criteria

STOP and report if:

Decision Type	Blocker Condition	Required Action
Mock Justification	Cannot explain what real behavior the mock enables testing	STOP and report
Test-Only Method	Method exists only for test purposes in production code	STOP and report
Incomplete Mock	Mock missing fields that real API returns	STOP and report
TDD Violation	Tests written after implementation complete	STOP and report

Cannot Be Overridden

The following requirements CANNOT be waived:

• Tests MUST verify real behavior, not mock existence
• Production code CANNOT contain test-only methods
• Mocks MUST mirror real API structures completely
• Understanding dependencies is REQUIRED before mocking

Severity Calibration

Severity	Condition	Required Action
CRITICAL	Asserting on mock elements (*-mock test IDs)	MUST fix immediately
CRITICAL	Test-only methods in production classes	MUST fix immediately
HIGH	Mocking without understanding side effects	MUST fix before completing
HIGH	Incomplete mocks missing required fields	MUST fix before completing
MEDIUM	Mock setup exceeds 50% of test logic	Should fix
LOW	Test coverage gaps in non-critical paths	Fix in next iteration

Pressure Resistance

User Says	Your Response
"Just mock it to make the test pass quickly"	"CANNOT mock without understanding what behavior I'm enabling tests for. Let me analyze the real dependencies first."
"Add a test-only method, it's the fastest solution"	"CANNOT add test-only methods to production code. I'll create a test utility instead."
"The mock doesn't need all those fields"	"CANNOT use incomplete mocks. Partial mocks fail silently when downstream code accesses missing fields."
"Skip TDD, we're behind schedule"	"CANNOT skip TDD. Writing tests after leads to testing mock behavior instead of real behavior."

Anti-Rationalization Table

Rationalization	Why It's WRONG	Required Action
"Mock makes the test simpler"	Simpler test ≠ correct test. You may be testing mock existence, not behavior.	MUST verify assertion tests real behavior
"Test-only method is small, doesn't hurt"	Any test pollution in production is dangerous if called accidentally.	MUST move to test utilities
"I know what the mock needs"	Assumption ≠ verification. Check real API response.	MUST verify mock completeness against real API
"Tests after is the same as TDD"	Order matters. TDD reveals what to mock; tests-after tests mocks blindly.	MUST follow RED-GREEN-REFACTOR
"Mocking to be safe"	"Safe" mocking without understanding breaks tests that depend on real behavior.	MUST understand dependencies before mocking