Mockito is a popular Java library that helps you create mock objects for unit testing. In this chapter, you will learn how mocking works, why it is useful in Spring Boot applications, and how to use Mockito to isolate components during tests. By mastering these basics, you will be able to write more reliable and focused tests for your Spring projects.

What Is Mocking?

Mocking means creating fake versions of classes or objects so you can test your code without relying on real implementations. In unit testing, you often want to test one piece of logic without worrying about its dependencies, such as databases, APIs, or other services.

Why Use Mocking in Spring Testing?

When you write tests for your Spring application, you usually want to test only your own code, not external systems. Mocking helps you:

• Isolate the code you are testing;
• Avoid slow or unreliable external systems, like databases or web services;
• Control the behavior of dependencies by setting up specific responses;
• Test edge cases that are hard to reproduce with real systems.

How Mockito Helps

Mockito is a popular Java library for creating mocks. It lets you replace real dependencies with mock objects so you can focus on testing your own code.

Example: Mocking a Service Dependency

Suppose you have a UserService class that depends on a UserRepository. You want to test UserService without connecting to a real database.

public class UserService {
    private final UserRepository userRepository;

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

    public String getUserEmail(Long userId) {
        User user = userRepository.findById(userId);
        return user.getEmail();
    }
}

You can use Mockito to mock the UserRepository:

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

public class UserServiceTest {
    @Test
    void testGetUserEmail() {
        // Create a mock UserRepository
        UserRepository mockRepo = mock(UserRepository.class);
        // Set up the mock to return a fake User
        when(mockRepo.findById(1L)).thenReturn(new User(1L, "alice@example.com"));
        // Inject the mock into the service
        UserService userService = new UserService(mockRepo);
        // Call the method and check the result
        String email = userService.getUserEmail(1L);
        // Assert the expected email
        assert email.equals("alice@example.com");
    }
}

Key Points

• Use mock(ClassName.class) to create a mock object.
• Use when(...).thenReturn(...) to control the behavior of the mock.
• Inject the mock into the class you want to test.
• Focus your test on your logic, not external systems.

Mocking with Mockito makes your Spring tests faster, more reliable, and easier to write.