Writing Unit Tests for Spring Boot Services

Writing effective unit tests is crucial for ensuring the quality and reliability of your software. When developing Spring Boot applications, the service layer often encapsulates critical business logic. Testing this layer thoroughly helps ensure that your application behaves as expected.

This guide will show you how to write unit tests for Spring Boot services using JUnit and Mockito. We’ll cover avoiding autowiring in unit tests, mocking dependencies like Repositories or REST clients, and understanding when to use @SpringBootTest versus isolated unit tests.

Why Test the Service Layer?

The service layer in Spring Boot acts as the middleman between the controller (which handles HTTP requests) and the repository (which manages data persistence). It typically contains core business logic, validation, and flow orchestration.

By unit testing the service layer, you can:

• Ensure that core functionality works correctly.
• Verify integration with mocked dependencies like repositories or external APIs.
• Catch logic errors early in development.

Unlike integration tests, unit tests focus only on the specific class under test, isolating it from external dependencies.

---

Testing the Service Layer with JUnit and Mockito

To test your Spring Boot services, combine JUnit (for structuring tests) and Mockito (for mocking external dependencies). Together, they allow you to focus on the service logic without worrying about other layers.

Setting Up Dependencies

Include the following dependencies in your build configuration:

For Maven:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>5.x</version>
    <scope>test</scope>
</dependency>

For Gradle:

testImplementation 'org.springframework.boot:spring-boot-starter-test'
testImplementation 'org.mockito:mockito-core:5.x'

Example Unit Test Using Mockito and JUnit

Imagine a UserService class that depends on a UserRepository. Here’s an example of how you can write unit tests for it:

UserService Implementation:

@Service
public class UserService {

    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public User getUserById(Long id) {
        return userRepository.findById(id)
                             .orElseThrow(() -> new UserNotFoundException("User not found"));
    }
}

UserServiceTest:

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

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

class UserServiceTest {

    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private UserService userService;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this); // Initialize mocks
    }

    @Test
    void getUserById_ShouldReturnUser_WhenUserExists() {
        // Arrange
        User mockUser = new User(1L, "John Doe");
        when(userRepository.findById(1L)).thenReturn(Optional.of(mockUser));

        // Act
        User user = userService.getUserById(1L);

        // Assert
        assertNotNull(user);
        assertEquals("John Doe", user.getName());
        verify(userRepository, times(1)).findById(1L); // Check method interaction
    }

    @Test
    void getUserById_ShouldThrowException_WhenUserNotFound() {
        // Arrange
        when(userRepository.findById(anyLong())).thenReturn(Optional.empty());

        // Act & Assert
        assertThrows(UserNotFoundException.class, () -> userService.getUserById(99L));
    }
}

Key highlights:

• Mockito mocks UserRepository to simulate its behavior.
• Dependency injection is handled using @InjectMocks.
• Mocked methods use when().thenReturn() for predictable behavior.

---

Avoiding Autowiring in Unit Tests

Avoiding @Autowired in unit tests is essential to keep them lightweight and fast. Dependence on the Spring framework for unit testing slows down test execution and introduces unnecessary complexity.

Why Avoid @Autowired?

1. Performance:
   • Using @Autowired requires the Spring context to load, which increases test runtime.
2. Isolation:
   • Unit tests should test only the class under test and not rely on Spring’s dependency injection.

Use Constructor Injection Instead

Instead of using @Autowired, dependency injection can be achieved manually or with @InjectMocks.

Example without @Autowired:

@BeforeEach
void setUp() {
    userRepository = mock(UserRepository.class); // Manual mocking
    userService = new UserService(userRepository); // Constructor injection
}

This approach ensures that your tests run in complete isolation from the Spring context.

---

Mocking Dependencies Like Repositories or REST Clients

Spring Boot service layers often interact with dependencies like repositories, REST clients, or external APIs. Using Mockito, you can mock these dependencies to control their behavior in tests.

Mocking a Repository

Mocking repositories is straightforward. Use when().thenReturn() to define behavior for specific method calls.

Example:

when(userRepository.findById(1L))
    .thenReturn(Optional.of(new User(1L, "John Doe")));

Mocking a REST Client

If your service layer depends on a REST client (e.g., RestTemplate or WebClient), you can mock its behavior.

Example (with RestTemplate):

@Mock
private RestTemplate restTemplate;

@Test
void fetchUser_ShouldReturnUser() {
    // Arrange
    String mockResponse = "{ \"id\": 1, \"name\": \"Jane Doe\" }";
    when(restTemplate.getForObject("http://api.example.com/user/1", String.class))
        .thenReturn(mockResponse);

    // Act
    String response = userService.fetchUser(1);

    // Assert
    assertEquals("Jane Doe", response);
}

This approach ensures that your tests focus on how the service layer interacts with dependencies, not the dependencies’ actual implementation.

---

Testing with @SpringBootTest vs Isolated Unit Tests

Spring Boot offers @SpringBootTest for integration tests, but it may not always be suitable for unit tests. Understanding the differences is key to deciding when to use each.

What is @SpringBootTest?

@SpringBootTest loads the full Spring application context, allowing you to test multiple layers (e.g., controllers, services, and repositories) together.

Example:

@SpringBootTest
class UserServiceIntegrationTest {

    @Autowired
    private UserService userService;

    @Test
    void testWithRealDependencies() {
        User user = userService.getUserById(1L);
        assertNotNull(user);
    }
}

Pros of @SpringBootTest

• Useful for end-to-end tests involving multiple layers.
• Verifies real configurations like application properties.

Cons of @SpringBootTest

• Slow performance due to context loading.
• Not suitable for isolated unit testing.

Isolated Unit Tests

Isolated unit tests focus only on the business logic of the class under test. By mocking dependencies, you ensure that tests are lightweight and run quickly.

Key Benefits:

• Faster execution (no Spring context).
• Easier to pinpoint issues due to scoped testing.

When to Use Each

Scenario	Recommended Approach
Testing only service logic	Unit tests with Mockito
Testing multiple layers	@SpringBootTest integration test
Verifying configuration or beans	@SpringBootTest

The general rule of thumb is to use unit tests for business logic and reserve @SpringBootTest for scenarios where Spring’s context or configurations need to be verified.

---

Final Thoughts

Testing the service layer of your Spring Boot applications is crucial for maintaining clean, reliable, and error-free code. By using JUnit and Mockito, you can isolate the business logic, mock dependencies, and write efficient unit tests. Avoid autowiring in unit tests to keep them lightweight, and understand when to choose @SpringBootTest versus isolated tests based on your use case.

Start by testing simple methods, expand to more complex flows, and ensure you adhere to best practices for mocking and structuring tests. With a strong testing foundation, your Spring Boot services will be more robust and future-ready.