The Project | About Us | Contribute | Donations | License

HOME

Introduction

Mockito is a popular mocking framework for Java that allows you to create mock objects for unit testing. Mocking is a technique where you create objects that simulate the behavior of real objects. This is particularly useful in unit testing when you want to isolate the class under test from its dependencies.

In this section, we will cover:

What is Mockito?
Setting up Mockito in a Spring Boot project
Creating and using mock objects
Writing unit tests with Mockito
Common mistakes and tips

What is Mockito?

Mockito is a Java-based framework that is used to create mock objects. It simplifies the process of writing unit tests by allowing you to:

Mock dependencies
Verify interactions
Stub methods to return specific values

Setting Up Mockito in a Spring Boot Project

To use Mockito in a Spring Boot project, you need to add the following dependencies to your pom.xml file:

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

Creating and Using Mock Objects

Example Scenario

Let's consider a simple service class UserService that depends on a repository UserRepository to fetch user data.

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
}

Creating a Mock Object

To create a mock object of UserRepository, you can use the @Mock annotation provided by Mockito.

@RunWith(MockitoJUnitRunner.class)
public class UserServiceTest {

    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private UserService userService;

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

        User user = userService.getUserById(1L);

        assertNotNull(user);
        assertEquals("John Doe", user.getName());
    }
}

Explanation

@RunWith(MockitoJUnitRunner.class): This annotation tells JUnit to use the Mockito test runner.
@Mock: This annotation creates a mock instance of UserRepository.
@InjectMocks: This annotation injects the mock objects into the UserService instance.
Mockito.when(...).thenReturn(...): This method stubs the findById method of UserRepository to return a specific value.

Writing Unit Tests with Mockito

Example: Testing a Service Method

Let's write a unit test for a method in UserService that fetches a user by ID.

@RunWith(MockitoJUnitRunner.class)
public class UserServiceTest {

    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private UserService userService;

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

        User user = userService.getUserById(1L);

        assertNotNull(user);
        assertEquals("John Doe", user.getName());
    }
}

Example: Verifying Interactions

You can also verify that certain methods were called on the mock objects.

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

    userService.getUserById(1L);

    Mockito.verify(userRepository).findById(1L);
}

Common Mistakes and Tips

Common Mistakes

Forgetting to annotate the test class with @RunWith(MockitoJUnitRunner.class):
- This will result in NullPointerException because the mocks are not initialized.
Not using @InjectMocks:
- This will result in the service class not having its dependencies injected, leading to NullPointerException.
Incorrect stubbing:
- Ensure that the method signature in Mockito.when(...) matches the actual method signature.

Tips

Use @MockBean for integration tests:
- In Spring Boot integration tests, use @MockBean to mock beans in the application context.
Use ArgumentCaptor to capture arguments:
- Use ArgumentCaptor to capture and assert the arguments passed to mock methods.

Conclusion

In this section, we covered the basics of using Mockito for mocking in Spring Boot applications. We learned how to set up Mockito, create and use mock objects, write unit tests, and verify interactions. By mastering these techniques, you can write more effective and isolated unit tests for your Spring Boot applications.

Next, we will delve into more advanced testing techniques in Spring Boot, including integration testing.

Mocking with Mockito

Introduction

What is Mockito?

Setting Up Mockito in a Spring Boot Project

Creating and Using Mock Objects

Example Scenario

Creating a Mock Object

Explanation

Writing Unit Tests with Mockito

Example: Testing a Service Method

Example: Verifying Interactions

Common Mistakes and Tips

Common Mistakes

Tips

Conclusion

Spring Boot Course

Module 1: Introduction to Spring Boot

Module 2: Spring Boot Basics

Module 3: Building RESTful Web Services

Module 4: Data Access with Spring Boot

Module 5: Spring Boot Security

Module 6: Testing in Spring Boot

Module 7: Advanced Spring Boot Features

Module 8: Deploying Spring Boot Applications

Module 9: Performance and Monitoring

Module 10: Best Practices and Tips