1. Introduction to Mockito

Mockito is a popular Java framework used for creating mock objects in unit tests. It helps in isolating the unit being tested by replacing real dependencies with mock objects. It is especially useful for mocking service classes, repositories, and other components that interact with external systems.

1.1. Why Use Mockito?

Mockito is used for the following reasons:

• Isolate units: Test a specific unit of code by mocking its dependencies.
• Control behavior: Define specific behavior for the mock objects, such as return values or exceptions.
• Verify interactions: Ensure that the mock objects are used as expected, such as verifying method calls.

2. Mocking Dependencies in Spring Boot Tests

In Spring Boot, services often depend on other services or repositories. With Mockito, we can mock these dependencies to focus on testing the logic of the service itself.

2.1. Example: Mocking a Service Dependency

Suppose we have a ProductService that depends on a ProductRepository for CRUD operations. We want to test the service without involving the actual database, so we mock the repository.

import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest
public class ProductServiceTest {

    @Mock
    private ProductRepository productRepository;

    @InjectMocks
    private ProductService productService;

    @Test
    void testFindProductById() {
        // Arrange: Mock repository behavior
        Product mockProduct = new Product(1L, "Laptop", 1000.0);
        when(productRepository.findById(1L)).thenReturn(Optional.of(mockProduct));

        // Act: Call the service method
        Product result = productService.findProductById(1L);

        // Assert: Verify the result
        assertNotNull(result);
        assertEquals("Laptop", result.getName());
        assertEquals(1000.0, result.getPrice());

        // Verify interaction with repository
        verify(productRepository, times(1)).findById(1L);
    }
}
        

Explanation of Annotations:

• @Mock: Creates a mock instance of the ProductRepository.
• @InjectMocks: Injects the mock ProductRepository into the ProductService.
• @Test: Marks the method as a unit test.

2.2. Mocking Behavior

Mockito allows you to define the behavior of mock objects. In the example above, we used when(...).thenReturn(...) to specify that when findById(1L) is called on the productRepository, it should return a mock product.

2.3. Verifying Interactions

We used the verify() method to check that the findById(1L) method was called exactly once. This helps ensure that the service interacts with its dependencies as expected.

3. Mocking Service Method Calls

In addition to mocking repositories, you may need to mock service method calls within a service class. Mockito makes it easy to mock these method calls to simulate various scenarios, such as successful results, exceptions, or timeouts.

3.1. Example: Mocking Service Method Calls

Assume we have a ProductService that calls another method calculateDiscount() to calculate a discount for a product. We can mock this method to return a fixed value.

import static org.mockito.Mockito.*;

public class ProductServiceTest {

    @Mock
    private ProductService productService;

    @Test
    void testCalculateDiscount() {
        // Arrange: Mock calculateDiscount method
        when(productService.calculateDiscount(any(Product.class))).thenReturn(100.0);

        // Act: Call the service method
        double discount = productService.calculateDiscount(new Product(1L, "Laptop", 1000.0));

        // Assert: Verify the mocked method behavior
        assertEquals(100.0, discount);

        // Verify interaction
        verify(productService, times(1)).calculateDiscount(any(Product.class));
    }
}
        

Explanation of Methods:

• when(...).thenReturn(...): Defines what should be returned when a method is called on a mock object.
• verify(...): Verifies that a specific method was called on a mock object.
• any(...): A Mockito matcher to match any parameter of a specific type.

4. Mocking Exceptions in Methods

Sometimes you need to simulate an exception being thrown by a mocked method. Mockito makes this easy with the thenThrow() method.

4.1. Example: Mocking Exceptions

In this example, we will simulate an exception when attempting to find a product by ID.

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

@Test
void testFindProductByIdThrowsException() {
    // Arrange: Mock method to throw exception
    when(productRepository.findById(1L)).thenThrow(new ProductNotFoundException("Product not found"));

    // Act and Assert: Test that exception is thrown
    Exception exception = assertThrows(ProductNotFoundException.class, () -> {
        productService.findProductById(1L);
    });

    assertEquals("Product not found", exception.getMessage());
}
        

In this case, when findById(1L) is called, we simulate an exception, and the unit test checks whether the exception is properly thrown.

5. Summary

Mockito is a powerful tool for mocking dependencies in unit tests. It allows you to:

• Mock service methods to isolate the unit being tested.
• Verify method interactions to ensure the system behaves as expected.
• Simulate exceptions for testing error scenarios in service methods.

By using Mockito, you can effectively test the behavior of Spring Boot services and ensure their correctness without involving actual databases or external systems.