tdd

To write refactoring-resilient unit tests, anchor them to stable public interfaces instead of internal implementation details. This approach defines clear testing seams, ensuring your suite specifies observable behavior without becoming a maintenance burden.

The test-driven development red-green-refactor cycle enforces writing a failing test first, making it pass with minimal code, then refining. This loop discipline ensures tests act as tracer bullets verifying actual observable behavior.

Use mocking in unit testing exclusively at system boundaries to isolate external dependencies. Avoid mocking internal collaborators, as this practice promotes better architectural design and prevents tests from coupling to implementation details.

Identify testing seams by defining the public interfaces where tests should anchor before writing any failing test. This framework ensures your tests target stable boundaries, keeping the test suite reliable during subsequent code refactoring.

Tests break during refactoring when they are coupled to internal implementation details rather than observable behavior. TDD practices prevent this by enforcing strict seam identification and avoiding implementation-coupled anti-patterns in your test suite.

Test-driven development supports dependency injection by defining clear boundaries for mocking at system edges. This strategy clarifies when to inject dependencies for external collaborators while keeping internal module interactions unmocked for better software quality.