TDD and Dependency Injection
You'll learn how writing tests first naturally pushes your code toward using dependency injection and loose coupling.
The Testing Pressure
When you write tests before implementation, you immediately face a practical problem: how do you test a class that creates its own dependencies? If a UserService constructs its own DatabaseConnection inside its methods, your test is forced to hit a real database. That's slow, fragile, and not a true unit test.
TDD creates healthy design pressure. To make your code testable, you stop creating dependencies internally and start receiving them from the outside—this is dependency injection.
From Hard-Coded to Injected
Before (hard to test):
class UserService
method createUser(name)
db = new DatabaseConnection() # creates its own dependency
db.save(name)
After (test-friendly):
class UserService
constructor(database) # dependency injected
this.database = database
method createUser(name)
this.database.save(name)
Now your test can pass in a stub or fake database instead of the real one.
The Design Benefit
This isn't just about testing—it's better design. Your UserService is now loosely coupled to any database implementation. You can swap databases, use a fake in tests, or use a cache in production without changing UserService itself.
TDD doesn't force you to learn dependency injection as a separate pattern; it makes you discover it naturally when you ask "How do I test this?"
Key Takeaway: Writing tests first reveals tight coupling immediately, naturally guiding you toward dependency injection and more flexible, testable designs.