How do you write unit tests for Spring components?

Table of Contents

• Introduction
  • 1. Unit Testing Spring Services
    • a. Example Service
    • b. Writing Unit Test for the Service
  • 2. Unit Testing Spring Controllers
    • a. Example Controller
    • b. Writing Unit Test for the Controller
  • 3. Unit Testing Spring Repositories
    • a. Example Repository
    • b. Writing Unit Test for the Repository
  • 4. Mocking External Dependencies
    • Example: Mocking a REST Client
  • 5. Best Practices for Unit Testing in Spring
• 6. Conclusion

Introduction

Unit testing is essential in modern software development, as it helps ensure that individual components of your application work correctly in isolation. In the context of Spring applications, unit tests allow you to verify the functionality of services, controllers, and repositories, ensuring that each component behaves as expected.

In this guide, we will explore how to write unit tests for various Spring components using JUnit and Mockito. We’ll cover testing Spring services, controllers, and repositories, along with best practices and practical examples.

1. Unit Testing Spring Services

Services in Spring are the core components that often contain business logic. Unit testing a service usually involves testing its methods and ensuring that they behave correctly, while mocking dependencies to avoid interactions with external systems like databases.

a. Example Service

Consider the following service that calculates the total price of items in a shopping cart:

Here, ShoppingCartService relies on ProductService to fetch product details. In unit tests, we will mock ProductService to isolate the ShoppingCartService.

b. Writing Unit Test for the Service

To test ShoppingCartService, we will mock ProductService using Mockito. We use JUnit 5 for writing the test.

In this example:

• **@MockBean** is used to mock the ProductService bean.
• **@Autowired** is used to inject the real ShoppingCartService bean, which is tested.
• **when(...).thenReturn(...)** is used to define the mocked behavior of ProductService.
• The test checks that the ShoppingCartService correctly calculates the total price.

2. Unit Testing Spring Controllers

Spring controllers handle HTTP requests and responses, and unit tests for controllers generally focus on verifying that the controller returns the correct response for different requests. We will use MockMvc to simulate HTTP requests in controller tests.

a. Example Controller

Let’s consider a simple Spring MVC controller for a shopping cart:

This controller exposes an endpoint that returns the total price of the items in the shopping cart.

b. Writing Unit Test for the Controller

We can write a unit test for this controller using **@WebMvcTest**, which is a specialized annotation to load only the controller and related beans (like ControllerAdvice, Filter, etc.). **MockMvc** is used to simulate HTTP requests.

In this example:

• **@WebMvcTest** is used to load only the controller and relevant Spring MVC components.
• **MockMvc** is used to simulate a GET request to the /cart/total endpoint.
• **@MockBean** is used to mock the ShoppingCartService dependency.
• The test verifies that the correct total price is returned in the response.

3. Unit Testing Spring Repositories

Spring Data JPA repositories provide access to the database. Unit testing repositories generally involves mocking the repository’s behavior without interacting with the actual database.

a. Example Repository

Consider a ProductRepository that extends JpaRepository:

b. Writing Unit Test for the Repository

For unit tests, we will mock the repository using Mockito. In this case, we don’t need to use the actual database or Spring Data JPA.

Here:

• **@DataJpaTest** is used to test the repository layer with an in-memory database like H2.
• The test ensures that the repository can retrieve a product by name from the database.

4. Mocking External Dependencies

In unit tests, we often need to mock external services or dependencies to isolate the component being tested. Mockito is commonly used for this purpose.

Example: Mocking a REST Client

If your service makes HTTP calls to an external API, you can mock the REST client:

In this example:

• **@MockBean** is used to mock a RestTemplate that performs HTTP calls.
• The service method is tested by simulating an external API response.

5. Best Practices for Unit Testing in Spring

• Test in isolation: Use mocking (e.g., with Mockito) to isolate the component under test and avoid dependencies on external systems (like databases, APIs, or third-party services).
• Test behaviors, not implementations: Focus on verifying the behavior of methods rather than how they are implemented internally.
• Use **@MockBean** for Spring beans: Mock Spring beans in service or controller tests using **@MockBean**.
• Keep tests small and focused: Each unit test should test a small piece of functionality. Break down large tests into smaller ones.
• Test edge cases: Make sure to test for null inputs, empty collections, and other edge cases that could break your code.

6. Conclusion

Writing unit tests for Spring components is an essential part of developing reliable applications. By using JUnit, Mockito, and Spring’s testing annotations like **@MockBean**, **@WebMvcTest**, and **@DataJpaTest**, you can effectively test services, controllers, and repositories in isolation. This ensures that your components behave correctly, and you can maintain a clean, reliable codebase with high test coverage.