Differences Between @Mock, @MockBean, and Mockito.mock(): A Comprehensive Analysis

Introduction

In the development of tests for Java applications, mocking dependencies is a crucial technique for ensuring code quality and isolated testing. Mockito, as a widely used mocking framework, offers multiple methods for creating mock objects, including @Mock, @MockBean, and Mockito.mock(). While these methods overlap in functionality, each is suited to different testing scenarios and framework environments. This article aims to provide an in-depth analysis of the differences between these three methods, assisting developers in selecting the most appropriate mocking strategy based on specific requirements.

Mocking Methods in the Mockito Library

The Mockito library provides two primary ways to create mocks: the @Mock annotation and the Mockito.mock() static method. Both methods are functionally equivalent, used to create mock instances of classes or interfaces and allow recording and verification of their behavior.

An example using the @Mock annotation is as follows:

import org.mockito.Mock;
...
@Mock
MyService myservice;

An example using the Mockito.mock() method is as follows:

import org.mockito.Mockito;
...
MyService myservice = Mockito.mock(MyService.class);

The annotation approach is more concise and thus preferred in practice. However, to enable Mockito annotations, the MockitoAnnotations.initMocks(this) static method must be called during test execution. To avoid side effects between tests, it is recommended to initialize before each test execution:

@Before 
public void initMocks() {
    MockitoAnnotations.initMocks(this);
}

Another way to enable annotations is by using the @RunWith annotation with MockitoJUnitRunner, which handles initialization automatically and performs other useful tasks:

@RunWith(org.mockito.runners.MockitoJUnitRunner.class)
public MyClassTest{...}

@MockBean in Spring Boot

@MockBean is an extension of the Mockito library by the Spring Boot framework, included in the spring-boot-test library. It allows adding Mockito mock objects to the Spring ApplicationContext. If a bean compatible with the declared class exists in the context, @MockBean replaces it with the mock; otherwise, it adds the mock as a new bean to the context.

An example of usage is as follows:

import org.springframework.boot.test.mock.mockito.MockBean;
...
@MockBean
MyService myservice;

According to Spring Boot documentation, the primary use of @MockBean is to manage dependencies in the Spring container during integration testing, especially when using test slices such as @WebMvcTest.

Use Cases and Selection Guidelines

Unit tests are designed to isolate components and prioritize execution speed, as these tests may be run frequently during development. Therefore, when a test does not require any dependencies from the Spring Boot container, classic Mockito methods (@Mock or Mockito.mock()) should be used. This approach is fast and promotes component isolation.

Conversely, if a test relies on the Spring Boot container and you want to add or mock a bean within it, Spring Boot's @MockBean is the appropriate choice. This is common in integration testing, such as when using @WebMvcTest for web layer testing.

Typical Usage Example

The following is a typical example using @WebMvcTest and @MockBean, demonstrating how to mock service-layer dependencies in Spring Boot integration tests:

import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.MediaType;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.MockMvc;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

@RunWith(SpringRunner.class)
@WebMvcTest(FooController.class)
public class FooControllerTest {

    @Autowired
    private MockMvc mvc;

    @MockBean
    private FooService fooServiceMock;

    @Test
    public void testExample() throws Exception {
         Foo mockedFoo = new Foo("one", "two");

         Mockito.when(fooServiceMock.get(1))
                .thenReturn(mockedFoo);

         mvc.perform(get("foos/1")
            .accept(MediaType.TEXT_PLAIN))
            .andExpect(status().isOk())
            .andExpect(content().string("one two"));
    }

}

In this example, @MockBean is used to mock FooService, ensuring that the controller test does not depend on the actual service implementation, thereby achieving test isolation and repeatability.

Conclusion

The choice between @Mock, @MockBean, and Mockito.mock() depends on the specific needs of the test. For pure unit testing, Mockito's native methods are recommended due to their lightweight and efficient nature. For integration testing involving the Spring container, @MockBean offers seamless integration with the Spring ecosystem, simplifying dependency management. Understanding these differences helps in writing more efficient and reliable test code, enhancing software quality.