Which Mocking Approach is Right for You: @Mock, @MockBean, or Mockito.mock()?

Understanding the Differences Between @Mock, @MockBean, and Mockito.mock()

Unit testing often involves mocking dependencies, but there are different approaches to do so in Java. To differentiate between these options, let's explore the distinct purposes and functionalities of @Mock, @MockBean, and Mockito.mock().

@Mock and Mockito.mock()

Both @Mock and Mockito.mock() originate from the Mockito library, which provides an annotation-based syntax and direct method invocation for creating mocks.

Using @Mock with the @RunWith annotation enables the Mockito annotations during test executions. This annotation marks the variable it's attached to as a Mockito mock.

import org.mockito.Mock;
import org.junit.runner.RunWith;
import org.mockito.runners.MockitoJUnitRunner;

@RunWith(MockitoJUnitRunner.class)
public class MyClassTest {
    @Mock
    private MyService myservice;
}

In contrast, Mockito.mock() creates a mock directly:

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

@MockBean from Spring Boot

@MockBean, on the other hand, is provided by the Spring Boot test library, specifically under the org.springframework.boot.test.mock.mockito.MockBean class. This annotation is specifically designed for use with Spring Boot contexts.

@MockBean allows for adding mocked beans to a Spring ApplicationContext, effectively overriding or adding mocks in place of actual bean instances.

Choosing the Right Option: Classic Mockito vs. @MockBean

When to use which approach depends on the test scenario and how dependencies are managed:

• Classic Mockito: Ideal for unit tests where you don't rely on the Spring Boot container and want to isolate the tested component. This approach is highly efficient and promotes isolation.
• @MockBean: Preferred for tests requiring interaction with the Spring Boot container, particularly when mocking beans managed by the container.

Typical @MockBean Usage with Spring WebMVC

For example, in a web testing scenario annotated with @WebMvcTest, @MockBean is commonly used to mock beans used by the controller under test:

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.test.web.servlet.MockMvc;
...
@WebMvcTest(FooController.class)
public class FooControllerTest {
    @Autowired
    private MockMvc mvc;

    @MockBean
    private FooService fooServiceMock;
}

By understanding these differences and choosing the appropriate approach based on your testing needs, you can effectively manage dependencies and ensure efficient and accurate testing in Java with Mockito and Spring Boot.

The above is the detailed content of Which Mocking Approach is Right for You: @Mock, @MockBean, or Mockito.mock()?. For more information, please follow other related articles on the PHP Chinese website!