To master Java testing with JUnit 5 and Mockito, use unit tests for isolated code with mocked dependencies and integration tests for real component interactions. 1. Unit tests focus on single methods or classes using @Mock and @InjectMocks to isolate logic. 2. Integration tests validate full workflows, often with @SpringBootTest to load real beans. 3. Write clear, focused tests following AAA (Arrange, Act, Assert). 4. Use @ParameterizedTest for multiple inputs. 5. Follow best practices: name tests clearly, avoid test logic, and keep tests independent. Mockito enables behavior simulation, JUnit 5 provides structure, and Spring Boot supports integration scenarios, together ensuring reliable, maintainable applications.

Testing is a critical part of building reliable Java applications. With JUnit 5 and Mockito, you get a powerful combination for writing effective unit and integration tests. Here’s how to master them in practice.

1. Understanding Unit vs. Integration Testing

Before diving into tools, clarify the purpose of each test type:

• Unit Testing: Focuses on isolated pieces of code (like a single method or class). Dependencies are mocked or stubbed to ensure the test runs quickly and predictably.
• Integration Testing: Tests how multiple components work together—e.g., service layer with repository, or API endpoints with real database interactions.

Key difference: Unit tests are fast and narrow; integration tests are slower but validate real interactions.

Use JUnit 5 for both, but structure and configuration differ. Mockito shines in unit tests by simulating dependencies.

2. Writing Effective Unit Tests with JUnit 5 and Mockito

Start by adding dependencies (Maven example):

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.10.0</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>5.7.0</version>
    <scope>test</scope>
</dependency>

Example: Service Layer with Mocked Repository

public class UserService {
    private final UserRepository userRepository;

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

    public User createUser(String name, String email) {
        if (name == null || name.isBlank()) {
            throw new IllegalArgumentException("Name is required");
        }
        User user = new User(name, email);
        return userRepository.save(user);
    }
}

Test with Mockito:

@ExtendWith(MockitoExtension.class)
class UserServiceTest {

    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private UserService userService;

    @Test
    void should_CreateUser_When_ValidInput() {
        // Arrange
        User savedUser = new User("John", "john@example.com");
        when(userRepository.save(any(User.class))).thenReturn(savedUser);

        // Act
        User result = userService.createUser("John", "john@example.com");

        // Assert
        assertNotNull(result);
        assertEquals("John", result.getName());
        verify(userRepository, times(1)).save(any(User.class));
    }

    @Test
    void should_ThrowException_When_NameIsEmpty() {
        // Act & Assert
        assertThrows(IllegalArgumentException.class, () -> {
            userService.createUser("", "invalid@example.com");
        });
    }
}

Key Mockito Features:

• @Mock – Creates a mock instance.
• @InjectMocks – Injects mocks into the target class.
• when(...).thenReturn(...) – Defines mock behavior.
• verify(...) – Ensures certain methods were called.

Keep unit tests focused. One test per scenario. Test edge cases.

3. Writing Integration Tests with JUnit 5 and Spring Boot (Optional but Common)

For integration tests, you often use Spring Boot Test support. This boots up the application context with real beans.

Add dependency:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

Example:

@SpringBootTest
class UserServiceIntegrationTest {

    @Autowired
    private UserService userService;

    @Autowired
    private UserRepository userRepository;

    @Test
    void should_SaveUser_ToDatabase() {
        // Act
        User user = userService.createUser("Alice", "alice@example.com");

        // Assert
        assertNotNull(user.getId()); // DB-generated
        assertTrue(userRepository.findById(user.getId()).isPresent());
    }

    @AfterEach
    void tearDown() {
        userRepository.deleteAll();
    }
}

Use @SpringBootTest to load full context. For lighter tests, consider @DataJpaTest if only testing repository layer.

Tip: Use @TestPropertySource or @DynamicPropertySource to override DB URLs or ports during testing.

4. Best Practices to Master Testing

• Name Tests Clearly: Use should_doX_when_condition() pattern.
• Follow AAA: Arrange, Act, Assert – structure every test.
• Avoid Logic in Tests: No loops, conditionals, or complex calculations.
• Test One Thing: Each test should verify a single behavior.
• Use Assertions Wisely: JUnit 5 offers rich assertions like assertAll(), assertThrows(), assertTimeout().
• Don’t Mock Value Objects: Only mock dependencies that cross boundaries (repositories, services, APIs).
• Keep Tests Independent: No shared state between tests.

Also, consider:

• Using @DisplayName for readable test output.
• Group related tests with @Nested.
• Leveraging @ParameterizedTest for multiple input variations.

Example:

@ParameterizedTest
@ValueSource(strings = {"test@example.com", "admin@domain.com"})
void should_AcceptValidEmails(String email) {
    User user = userService.createUser("Valid", email);
    assertEquals(email, user.getEmail());
}

Basically, mastering testing in Java comes down to consistency, clarity, and using the right tool for the job: JUnit 5 for structure and execution, Mockito for isolation, and Spring Boot test utilities when integrating real components. The more you write tests like this, the more natural they become—not just as a chore, but as a design tool.

The above is the detailed content of Mastering Unit and Integration Testing in Java with JUnit 5 and Mockito. For more information, please follow other related articles on the PHP Chinese website!