Write testable code using dependency injection to enable loose coupling, as seen by replacing hard-coded dependencies with injected ones; 2. Use JUnit 5 for structured testing with features like @BeforeEach, @Test, and assertThrows to ensure clean, readable, and reliable tests; 3. Mock external dependencies with Mockito using mock(), when().thenReturn(), and verify() to isolate behavior and avoid reliance on real systems; 4. Follow best practices such as descriptive test names, the AAA pattern, avoiding implementation detail tests, keeping tests independent, not over-mocking, and covering edge cases to ensure maintainable and effective tests; ultimately, designing for testability improves code quality, making it easier to change, debug, and trust.

Writing testable Java code is a critical skill for building maintainable, robust applications. With JUnit 5 as the modern testing framework and Mockito for mocking dependencies, you can write clean, reliable unit tests that verify behavior without relying on external systems. Here’s how to structure your code and tests effectively.

1. Write Testable Code: Dependency Injection and Loose Coupling

The foundation of testable code is dependency injection (DI) and loose coupling. Avoid hard-coded dependencies or static calls that make testing difficult.

Bad example (hard to test):

public class OrderService {
    private EmailService emailService = new EmailService(); // Hard dependency

    public void process(Order order) {
        // logic
        emailService.sendConfirmation(order);
    }
}

This tightly couples OrderService to EmailService, making it impossible to test process() without actually sending emails.

Good approach (testable with DI):

public class OrderService {
    private final EmailService emailService;

    public OrderService(EmailService emailService) {
        this.emailService = emailService;
    }

    public void process(Order order) {
        // business logic
        emailService.sendConfirmation(order);
    }
}

Now you can inject a mocked EmailService during testing using Mockito.

2. Use JUnit 5 for Structured, Readable Tests

JUnit 5 offers a modern syntax with improved lifecycle management and expressive assertions.

Example test class:

import org.junit.jupiter.api.*;
import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

@TestInstance(TestInstance.Lifecycle.PER_METHOD)
class OrderServiceTest {

    private EmailService emailService;
    private OrderService orderService;

    @BeforeEach
    void setUp() {
        emailService = mock(EmailService.class);
        orderService = new OrderService(emailService);
    }

    @Test
    @DisplayName("Should send confirmation email when processing order")
    void shouldSendEmailOnProcess() {
        // Given
        Order order = new Order("123", 100.0);

        // When
        orderService.process(order);

        // Then
        verify(emailService, times(1)).sendConfirmation(order);
    }

    @Test
    @DisplayName("Should throw exception for null order")
    void shouldThrowExceptionForNullOrder() {
        // When & Then
        assertThrows(IllegalArgumentException.class, () -> {
            orderService.process(null);
        });
    }
}

Key JUnit 5 features used:

• @BeforeEach – runs before each test (clean state)
• @Test – marks test methods
• @DisplayName – improves readability in test reports
• assertThrows – verifies expected exceptions
• verify() – checks interaction with mocks

3. Mock Dependencies with Mockito

Mockito allows you to simulate external services (e.g., databases, APIs, email) so your unit tests run fast and isolate behavior.

Common Mockito patterns:

• Mock creation: mock(ClassName.class)
• Stubbing methods: when(mock.method()).thenReturn(value)
• Verifying interactions: verify(mock).method()

Example: Stubbing a repository call

public class UserService {
    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public User findUserById(String id) {
        return userRepository.findById(id)
                .orElseThrow(() -> new UserNotFoundException("User not found"));
    }
}

Test with Mockito:

@Test
@DisplayName("Should return user when found in repository")
void shouldReturnUserWhenFound() {
    // Given
    UserRepository userRepository = mock(UserRepository.class);
    User mockUser = new User("1", "Alice");
    when(userRepository.findById("1")).thenReturn(Optional.of(mockUser));

    UserService userService = new UserService(userRepository);

    // When
    User result = userService.findUserById("1");

    // Then
    assertEquals("Alice", result.getName());
    verify(userRepository).findById("1");
}

You’re testing only the logic in UserService, not the real database.

4. Best Practices for Clean, Maintainable Tests

Follow these guidelines to keep your tests effective:

• Use descriptive test names
  Prefer shouldThrowExceptionWhenOrderIsNull() over testProcess().

• Follow AAA pattern
  Organize tests into Arrange, Act, Assert blocks for clarity.

• Avoid testing implementation details
  Test what the method does, not how it does it. Don’t verify internal private methods.

• Keep tests independent and fast
  No shared state between tests. Use @BeforeEach or factory methods instead.

• Don’t over-mock
  Only mock external dependencies. Don’t mock value objects or simple utilities.

• Test edge cases
  Null inputs, empty collections, exceptions – these are common failure points.

Final Thoughts

Writing testable Java code isn’t just about adding tests—it’s about designing your classes with testability in mind. Use dependency injection, favor composition over instantiation, and separate concerns cleanly.

With JUnit 5 and Mockito, you get powerful tools to:

• Write expressive, readable tests
• Isolate units of behavior
• Simulate dependencies safely

The result? Code that’s easier to change, debug, and trust.

Basically, if you can’t test it easily, rethink the design.

The above is the detailed content of Writing Testable Java Code with JUnit 5 and Mockito. For more information, please follow other related articles on the PHP Chinese website!