Use JUnit 5 and Mockito to effectively isolate dependencies for unit testing. 1. Create mock objects through @Mock, @InjectMocks inject the tested instance, @ExtendWith enables Mockito extension; 2. Use when().thenReturn() to define simulation behavior, verify() to verify the number of method calls and parameters; 3. Can simulate exception scenarios and verify error handling; 4. Recommend constructor injection, avoid over-simulation, and maintain test atomicity; 5. Use assertAll() to merge assertions, and @Nested organizes test scenarios to improve test maintainability and reliability.

Unit testing and mocking are important means to ensure code quality in Java, and JUnit 5 and Mockito are the most popular combination of testing frameworks. They work together to efficiently isolate business logic, especially for scenarios that rely on external services, databases, or complex objects.

Why use JUnit 5 Mockito?

JUnit 5 is a mainstream unit testing framework in Java, providing more flexible annotation models, extension mechanisms and assertion functions. Mockito is a powerful mocking framework that allows you to create and configure "fake" objects to replace real dependencies, thus focusing on testing the behavior of target classes.

Combining the two will allow you to:

• Isolate the tested code from external dependencies
• Verify the number of method calls and parameters
• Simulate exceptions and boundary conditions
• Improve test maintainability and execution speed

1. Basic environment construction

First make sure that the project introduces JUnit 5 and Mockito dependencies. If you are using Maven, add the following to pom.xml :

 <dependencies>
    <!-- JUnit 5 -->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter</artifactId>
        <version>5.10.0</version>
        <scope>test</scope>
    </dependency>

    <!-- Mockito -->
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-core</artifactId>
        <version>5.7.0</version>
        <scope>test</scope>
    </dependency>

    <!-- Mockito JUnit Jupiter support (optional, used for automatic initialization of @Mock annotation) -->
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-junit-jupiter</artifactId>
        <version>5.7.0</version>
        <scope>test</scope>
    </dependency>
</dependencies>

Also, make sure to use a build configuration that supports JUnit 5 (such as Surefire plugin version >= 2.22.0).

2. Use Mockito to simulate dependency objects

Suppose we have an order service OrderService which relies on a payment gateway PaymentGateway interface:

 public interface PaymentGateway {
    boolean charge(double amount);
}

public class OrderService {
    private final PaymentGateway paymentGateway;

    public OrderService(PaymentGateway paymentGateway) {
        this.paymentGateway = paymentGateway;
    }

    public boolean processOrder(double amount) {
        if (amount <= 0) return false;
        return paymentGateway.charge(amount);
    }
}

We want to test OrderService.processOrder() but don't want to actually call the payment system. At this time, you can use Mockito to create a simulated PaymentGateway .

Write test classes

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

class OrderServiceTest {

    @Mock
    private PaymentGateway paymentGateway;

    @InjectMocks
    private OrderService orderService;

    // Must cooperate with MockitoExtension to automatically initialize @Mock and @InjectMocks
    @org.junit.jupiter.api.extension.ExtendWith(MockitoExtension.class)
    static class Nested {}

    @Test
    void shouldReturnFalse_WhenAmountIsInvalid() {
        // Call the method under test boolean result = orderService.processOrder(-100);

        // Assert result assertFalse(result);

        // Verify that the payment gateway is not called verify(paymentGateway, never()).charge(anyDouble());
    }

    @Test
    void shouldReturnTrue_WhenPaymentSucceeds() {
        // Simulate dependency behavior when(paymentGateway.charge(100.0)).thenReturn(true);

        // Execute boolean result = orderService.processOrder(100.0);

        // Assert assertTrue(result);
        verify(paymentGateway).charge(100.0);
    }

    @Test
    void shouldReturnFalse_WhenPaymentFails() {
        when(paymentGateway.charge(100.0)).thenReturn(false);

        boolean result = orderService.processOrder(100.0);

        assertFalse(result);
        verify(paymentGateway).charge(100.0);
    }
}

Key points description:

• @Mock : Create a mock object (mock)
• @InjectMocks : Create a target class instance and automatically inject the @Mock tagged fields (through constructor or field injection)
• @ExtendWith(MockitoExtension.class) : Enable the JUnit extension of Mockito to automatically initialize annotations
• when(...).thenReturn(...) : Define the return value of the simulation method
• verify(...) : Verify whether a method has been called, as well as the number of calls, parameters, etc.

3. Behavior Verification

In addition to asserting the return value, you can also verify that the method is called correctly. For example:

 @Test
void shouldAttemptChargeExactlyOnce() {
    when(paymentGateway.charge(50.0)).thenReturn(true);

    orderService.processOrder(50.0);

    // Verify that the charge method is called once and the parameter is 50.0
    verify(paymentGateway, times(1)).charge(eq(50.0));
}

Other common verification methods:

• never() : Never called
• atLeastOnce() : at least once
• timeout(100) : Called within a specified time (for asynchronous)
• inOrder(...) : Verify the call order

 // Example: Verify the call order InOrder inOrder = inOrder(paymentGateway);
inOrder.verify(paymentGateway).charge(30.0);
inOrder.verify(paymentGateway).charge(20.0);

4. Handle exceptions and boundary situations

You can have the mock object throw exceptions and test the error handling logic:

 @Test
void shouldHandlePaymentFailureDueToException() {
    when(paymentGateway.charge(100.0)).thenThrow(new RuntimeException("Network error"));

    assertThrows(RuntimeException.class, () -> {
        orderService.processOrder(100.0);
    });

    verify(paymentGateway).charge(100.0);
}

You can also use doThrow() to cooperate with doReturn() to deal with void methods or special scenarios.

5. Tips and best practices

• Avoid oversimulation : only simulate dependencies that really need isolation, and do not simulate the entire link
• Preferred constructor injection : easy to pass mock objects during testing
• Maintain test atomicity : A test only validates one behavior
• Batch assertions using assertAll()

 @Test
void multipleAssertions() {
    when(paymentGateway.charge(100.0)).thenReturn(true);

    boolean result = orderService.processOrder(100.0);

    assertAll(
        () -> assertTrue(result),
        () -> verify(paymentGateway).charge(100.0)
    );
}

• Use the @Nested test class to organize different scenarios:

 @Nested
class WhenAmountIsPositive {
    @Test
    void shouldChargePaymentGateway() { ... }
}

Basically that's it. The combination of JUnit 5 Mockito makes Java unit testing intuitive and powerful. The key is to understand "test behavior" rather than "test implementation" and control dependencies through mock to ensure that the test is fast, stable and repeatable.

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