Test-Driven Development (TDD) and Domain-Driven Design (DDD): The Perfect Duo for Robust NestJS Applications

#tdd #programming #microservices #node

When working on complex applications, especially in the backend world, keeping domain clarity and code quality is a constant challenge. That's where DDD (Domain-Driven Design) and TDD (Test-Driven Development) shine as complementary approaches. In this article, I'll show you how to combine them in a project using NestJS with modern best practices.

🧠 What is DDD?

Domain-Driven Design is a software development philosophy that focuses on the business domain. Instead of forcing the domain to fit the code, we adapt the code to represent the domain.

Key components of DDD:

Entities: Objects with identity (e.g., a User).
Value Objects: Objects without identity, defined by their attributes (Email, Money).
Aggregates: Consistency boundaries grouping related entities.
Repositories: Abstractions for accessing aggregates.
Domain/Application Services.

🔀 What is TDD?

Test-Driven Development is a software development practice following this cycle:

Write a failing test (Red).
Write the minimum code to pass it (Green).
Refactor the code (Refactor).

TDD not only ensures your code works, but it also forces clean API and logic design from the beginning.

🤝 How Do DDD and TDD Complement Each Other?

DDD helps define what needs to be built and how to model it.
TDD ensures what is built is correct, testable, and maintainable.

With DDD, you design a rich domain model; with TDD, you continuously validate its expected behavior.

🛠️ Example: Changing a User's Name in NestJS using DDD + TDD

Step 1: Write the Test First (TDD)

// change-user-name.use-case.spec.ts

describe('ChangeUserNameUseCase', () => {
  it('should change the user name', async () => {
    const user = new User('1', 'John', 'john@example.com');
    const userRepository = {
      findById: jest.fn().mockResolvedValue(user),
      save: jest.fn(),
    };

    const useCase = new ChangeUserNameUseCase(userRepository);
    await useCase.execute('1', 'Jane');

    expect(user.name).toBe('Jane');
    expect(userRepository.save).toHaveBeenCalledWith(user);
  });
});

Step 2: Domain Logic with DDD

// user.entity.ts
export class User {
  constructor(
    public readonly id: string,
    public name: string,
    public readonly email: string
  ) {}

  changeName(newName: string) {
    if (!newName) throw new Error('Name cannot be empty');
    this.name = newName;
  }
}

Step 3: Application Layer Use Case

// change-user-name.use-case.ts

export class ChangeUserNameUseCase {
  constructor(private readonly userRepository: UserRepository) {}

  async execute(userId: string, newName: string) {
    const user = await this.userRepository.findById(userId);
    user.changeName(newName);
    await this.userRepository.save(user);
  }
}

🧹 Benefits of Combining DDD + TDD

Testable domain models from day one.
Better interface design thanks to the "test-first" approach.
High cohesion in business logic.
Low coupling between layers (presentation, application, domain, infrastructure).

🧼 Best Practices

✅ Use interfaces in repositories to decouple infrastructure from domain.
✅ Keep Value Objects immutable.
✅ Use case tests are more valuable than controller tests.
✅ Avoid domain logic in controllers: delegate to use cases.
✅ If a business rule changes, only the aggregate should be updated.

🏁 Conclusion

Adopting DDD to model your domain properly and using TDD to continuously validate its behavior not only improves code quality but also makes your app more scalable and maintainable. In NestJS, this combination is natural thanks to its modular architecture and built-in testing support.