How do you implement mocking with Mockito in Spring Boot tests?

Table of Contents

• Introduction
  • Steps to Implement Mocking with Mockito in Spring Boot Tests
    • 1. Set Up Dependencies
    • 2. Create a Service to Test
    • 3. Write a Unit Test with Mockito
    • 4. Run the Unit Test
    • 5. Interpret the Results
• Conclusion

Introduction

Mockito is a powerful framework used for mocking objects in unit tests. In Spring Boot, Mockito allows you to mock service dependencies and other components that your classes interact with, making it easier to isolate the code being tested. By mocking external dependencies, you can focus on testing the specific logic of the class without worrying about the behavior of those dependencies. This is especially useful when writing unit tests for services, controllers, or repositories in Spring Boot.

In this guide, we will show you how to use Mockito for mocking dependencies in Spring Boot tests, and walk you through an example of writing a unit test with mocked services and repositories.

Steps to Implement Mocking with Mockito in Spring Boot Tests

1. Set Up Dependencies

To use Mockito with Spring Boot, ensure that the following dependency is included in your pom.xml. The spring-boot-starter-test starter includes Mockito by default, so you don't need to add it separately.

Add Dependency for Spring Boot Testing:

The spring-boot-starter-test includes essential libraries like JUnit, Mockito, and Hamcrest, which you can use to write unit and integration tests.

2. Create a Service to Test

Let’s assume we have a simple service class that we want to test. The service interacts with a repository to fetch data from the database. We will mock the repository dependency in the test.

Example Service (**ProductService**):

The ProductService uses a ProductRepository to fetch a product from the database and calculate its discounted price.

3. Write a Unit Test with Mockito

In this section, we will use Mockito to mock the ProductRepository in the unit test for the ProductService.

Example Unit Test with Mockito:

Explanation of the Code:

• **@Mock**: This annotation is used to create a mock instance of the ProductRepository. Mockito will generate a mock version of this class, allowing us to define its behavior without actually interacting with the database.
• **@InjectMocks**: This annotation is used to automatically inject the mocked ProductRepository into the ProductService. This allows us to test the ProductService independently of the actual repository.
• **when()** and **thenReturn()**: These Mockito methods define the behavior of the mocked repository. In this case, we specify that when findById() is called with a product ID, it should return a mocked product object.
• **verify()**: This method ensures that the mocked method was called as expected during the test execution.
• Assertions (**assertNotNull()**, **assertEquals()**): These methods verify the expected results of the test, such as checking if the returned product is not null and if the discounted price is correct.

4. Run the Unit Test

You can run the unit tests using your IDE or via the command line. If you're using Maven, you can execute the following command:

Alternatively, you can run the tests directly from your IDE by right-clicking the test class or method and selecting "Run".

5. Interpret the Results

After running the tests:

• If the tests pass, you'll see a success message in the console.
• If any tests fail, the console will provide details of the failure, helping you identify what went wrong.

Conclusion

Using Mockito in Spring Boot tests allows you to mock external dependencies, such as repositories or services, and focus on testing the specific behavior of the class under test. By using @Mock and @InjectMocks, you can isolate the class logic and avoid the complexities of database or external service calls in your unit tests. Mockito provides a simple and effective way to create mock objects, define their behavior, and verify that interactions are performed correctly. This approach improves test efficiency and ensures that your application components are working as expected in isolation.