TDD in Java follows the red-green-refactor cycle: first write a failing test, then implement minimal code to pass it, and finally refactor while maintaining test coverage. For example, when building a Calculator class, start by writing a test for the add() method that fails (Red), implement the method to return the sum (Green), then improve code structure if needed (Refactor). Set up the environment using JUnit 5 via Maven by adding the dependency and organizing the project with separate src/main/java and src/test/java directories. Write tests with descriptive names like shouldReturnSumOfTwoPositiveNumbers(), ensure each test verifies one behavior, and keep them independent. Use assertion libraries like AssertJ for clearer assertions and Mockito to mock external dependencies such as repositories. Avoid common pitfalls including writing too much code before testing, focusing on implementation instead of behavior, skipping refactoring, or over-mocking. Integrate TDD into your workflow by running tests in the IDE, using build tools like Maven or Gradle to execute tests automatically, and incorporating them into CI/CD pipelines for continuous validation. Ultimately, TDD is a mindset that promotes clean design, reduces bugs, and increases confidence in code through disciplined, incremental development.

Test-Driven Development (TDD) is a software development practice where tests are written before the actual code. This approach helps ensure that your code behaves as expected, improves design, and reduces bugs. In Java, TDD is widely used thanks to mature testing frameworks like JUnit and AssertJ. Here’s a practical guide to applying TDD in Java projects.

What Is TDD? The Red-Green-Refactor Cycle

TDD follows a simple, repeatable cycle:

1. Red: Write a failing test for a small piece of functionality.
2. Green: Write the minimal code to make the test pass.
3. Refactor: Clean up the code while keeping all tests passing.

This cycle encourages writing only what’s necessary and ensures continuous test coverage.

For example, imagine you’re building a Calculator class. You start by writing a test for adding two numbers — and it fails because the method doesn’t exist yet (Red). Then you implement the add() method to make it pass (Green). Finally, you improve the code structure if needed (Refactor).

Setting Up Your Java TDD Environment

To get started with TDD in Java, you need a testing framework. JUnit 5 is the current standard.

1. Add Dependencies (Maven Example)

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.9.3</version>
    <scope>test</scope>
</dependency>

2. Use a Testing-Friendly Project Structure

src/
├── main/java/
│   └── Calculator.java
└── test/java/
    └── CalculatorTest.java

Keep production and test code separate. IDEs like IntelliJ or VS Code auto-detect test files and run them easily.

Writing Your First TDD Test in Java

Let’s walk through creating a Calculator using TDD.

Step 1: Write a Failing Test (Red)

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class CalculatorTest {
    @Test
    public void shouldReturnSumOfTwoNumbers() {
        Calculator calc = new Calculator();
        int result = calc.add(2, 3);
        assertEquals(5, result);
    }
}

Run this test — it will fail because Calculator or add() doesn’t exist yet.

Step 2: Make It Pass (Green)

Now create the minimal implementation:

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

Run the test again — it should pass.

Step 3: Refactor (If Needed)

There’s not much to refactor here, but if you had duplicated logic or unclear names, now’s the time to clean it up — without breaking the test.

Repeat this cycle for each new feature: subtract, multiply, divide, etc.

Best Practices for Effective TDD in Java

Follow these guidelines to get the most out of TDD:

• Test One Thing at a Time: Each test should verify a single behavior.

• Use Descriptive Test Names: Instead of testAdd(), use shouldReturnSumOfTwoPositiveNumbers().

• Keep Tests Independent: No test should depend on another’s state.

• Use Assertion Libraries: Consider AssertJ for more expressive assertions:

  assertThat(calc.add(2, 3)).isEqualTo(5);

• Mock External Dependencies: Use Mockito for services, databases, or APIs:

  @Test
  void shouldFetchUserFromRepository() {
      UserRepository mockRepo = mock(UserRepository.class);
      when(mockRepo.findById(1L)).thenReturn(new User("Alice"));
  
      UserService service = new UserService(mockRepo);
      User user = service.findUser(1L);
  
      assertThat(user.getName()).isEqualTo("Alice");
  }

Common Pitfalls to Avoid

• Writing Too Much Code Before Testing: Stick to small steps. Don’t implement five methods before writing a single test.
• Testing Implementation Instead of Behavior: Focus on what the code does, not how it does it.
• Ignoring Refactoring: Skipping refactoring leads to messy code over time.
• Over-Mocking: Mock only what’s necessary. Overuse makes tests brittle.

Integrating TDD into Your Workflow

• Write tests in your IDE with live feedback (plugins like JUnit Max or built-in runners help).
• Use build tools like Maven or Gradle to run tests automatically:

  mvn test

• Integrate with CI/CD pipelines so tests run on every commit.

TDD isn’t about eliminating bugs entirely — it’s about building confidence in your code, one test at a time.

---

TDD in Java works best when embraced as a mindset, not just a technique. Start small, stay consistent, and let your tests guide your design. With practice, you’ll write cleaner, more reliable code — and spend less time debugging.

Basically, just keep cycling: red, green, refactor. That’s the rhythm of TDD.

The above is the detailed content of A Guide to Test-Driven Development (TDD) in Java. For more information, please follow other related articles on the PHP Chinese website!