To write Java unit tests well, you need to master the advanced usage of JUnit 5 and Mockito. First, JUnit 5 supports nested testing and dynamic testing. It should standardize the naming of test classes such as UserServiceTest, and use @BeforeEach and @AfterEach to manage initialization; second, Mockito can mock complex objects and behaviors, support mocking of non-final classes and methods, control return values, simulate exception throwing, and verify whether the behavior occurs; third, tests should isolate external dependencies, such as using mock to replace real database calls to avoid instability in tests; finally, improving test maintainability requires keeping the method short, avoiding hard coding, and rationally using assertion libraries such as AssertJ to enhance expression and readability.

When writing Java unit tests well, it is not just a way to see if the return value is correct. A truly advanced test is to be able to cover complex logic, isolate external dependencies, verify behavioral interactions, and even discover potential problems in advance. To do this, JUnit 5 and Mockito are two unavoidable tools.

How to write a well-structured test code using JUnit 5?

One of the major advantages of JUnit 5 is that it has a more flexible structure and supports advanced functions such as nested testing and dynamic testing. But if you want to write high-quality tests, you still need to pay attention to organizational methods and naming specifications.

• The test class name should be clear : for example, UserServiceTest instead of Test1 .
• Manage initialization with @BeforeEach and @AfterEach : Avoid duplicate code while ensuring that each test does not affect each other.
• Make good use of @Nested to organize subtest scenarios : For example, a method performs differently under different inputs, and multiple nested classes can be used to group tests.

For example:

 @Nested
class WhenUserIsAdmin {
    @Test
    void shouldAllowAccessToSettings() {
        // Test logic}
}

This not only has a clear structure, but it can also tell at a glance which business state is being simulated.

How to mock complex objects and behaviors in Mockito?

Sometimes the object we face is not simply returning values, but requires constructing a mock object with a specific behavior. At this time, we have to rely on the advanced functions provided by Mockito.

• Mock non-final classes and methods : By default, Mockito does not support final classes or methods, but it can be done if mockito-inline is used.
• Use when(...).thenReturn(...) to control the return value : This is the most commonly used method, and can also be called in chains.
• Use doThrow().when(...) to simulate exception throwing : suitable for void methods or scenes where exceptions are forced to be triggered.

For example:

 when(userRepository.findById(1L)).thenReturn(Optional.of(user));
doNothing().when(emailService).sendEmail(anyString());

Don't forget to verify whether the behavior occurs:

 verify(emailService, times(1)).sendEmail("test@example.com");

This is especially useful when testing certain asynchronous operations or event-driven logic.

How to deal with testing that depends on external services?

In real projects, many classes rely on databases, remote APIs, or message queues. If every test is called in real terms, it is not only slow but also prone to failure. At this time, "isolation" must be done.

• Swap external dependencies into mock : for example, the database access layer (DAO) uses Mockito to simulate data return.
• Use injection instead of new instance : it is convenient to replace the implementation and is easier to mock.
• Don't test the functions of third-party libraries : For example, if you use Spring Data JPA, you don't need to test whether save() is really written to the database, you just need to verify that your code has called it correctly.

Let me give you a typical error:
Someone will new a real DAO in the test and then connect to the database. This approach will cause unstable factors and will not conform to the original intention of unit testing - it is the logic you write, not the entire process.

How to make the test more maintainable?

Test code is also code and needs maintenance. Especially for multi-person collaborative projects, the complicated test becomes a burden.

• Keep the test method short : a test only verifies one thing, don't pile up assertions.
• Avoid magic numbers and hard-coded strings : Extract into constants or private variables for greater readability.
• Reasonable use of assert library : In addition to assertTrue and assertEquals that come with JUnit, AssertJ can also be introduced to enhance expression power.

for example:

 assertThat(result).isNotNull().hasSize(3).contains("apple", "banana");

More intuitive than a bunch of assertTrue(...) .

Basically that's it. Using JUnit 5 and Mockito well is not as simple as writing test annotations. The key is to understand the purpose of testing, know how to isolate dependencies, and write clear and easy-to-maintain test logic. These things don’t seem difficult, but if you really implement them in the project, you still have to practice and modify them more.

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