Diferencia entre @Mock, @MockBean y Mockito.mock()

Posteriormente a investigar con especialistas en esta materia, programadores de deferentes áreas y profesores hemos dado con la respuesta al problema y la compartimos en este post.

Solución:

Biblioteca simple Mockito

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

y

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

provienen de la biblioteca Mockito y son funcionalmente equivalentes.
Permiten simular una clase o una interfaz y registrar y verificar comportamientos en ella.

La forma de usar la anotación es más corta, por lo que es preferible y, a menudo, la preferida.

---

Tenga en cuenta que para habilitar las anotaciones de Mockito durante las ejecuciones de prueba, el
MockitoAnnotations.initMocks(this) static el método tiene que ser llamado.
Para evitar efectos secundarios entre pruebas, se recomienda hacerlo antes de cada ejecución de prueba:

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

Otra forma de habilitar las anotaciones de Mockito es anotar la clase de prueba con @RunWith especificando el MockitoJUnitRunner que hace esta tarea y también otras cosas útiles:

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

---

Biblioteca Spring Boot que envuelve la biblioteca Mockito

Esta es de hecho una clase Spring Boot:

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

La clase está incluida en el spring-boot-test Biblioteca.

Permite agregar simulacros de Mockito en un Spring ApplicationContext.
Si existe un bean compatible con la clase declarada en el contexto, reemplaza por el simulacro.
Si no es el caso, se agrega el simulacro en el contexto como un frijol.

Referencia Javadoc:

Anotación que se puede usar para agregar simulacros a Spring ApplicationContext.

…

Si cualquier bean único existente del mismo tipo definido en el contexto será reemplazado por el simulacro, si no se define ningún bean existente, se agregará uno nuevo.

---

Cuando se usa Mockito clásico/simple y cuando se usa @MockBean de Spring Boot?

Las pruebas unitarias están diseñadas para probar un componente aislado de otros componentes y las pruebas unitarias también tienen un requisito: ser lo más rápidas posible en términos de tiempo de ejecución, ya que estas pruebas pueden ejecutarse cada día docenas de veces en las máquinas del desarrollador.

En consecuencia, aquí hay una guía simple:

Mientras escribe una prueba que no necesita ninguna dependencia del contenedor Spring Boot, el Mockito clásico/simple es el camino a seguir: es rápido y favorece el aislamiento del componente probado.
Si su prueba necesita confiar en el contenedor Spring Boot y también desea agregar o burlarse de uno de los beans de contenedor: @MockBean de Spring Boot es el camino.

---

Uso típico de Spring Boot @MockBean

Mientras escribimos una clase de prueba anotada con @WebMvcTest (rebanada de prueba web).

La documentación de Spring Boot lo resume muy bien:

Con frecuencia @WebMvcTest se limitará a un único controlador y se utilizará en combinación con @MockBean para proporcionar implementaciones simuladas para los colaboradores requeridos.

Aquí hay un ejemplo :

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"));
    

Al final es fácil de explicar. Si solo mira los javadocs de las anotaciones, verá las diferentes:

@Mock: (org.mockito.Mock)

Marque un campo como simulacro.

• Permite la creación de simulacros abreviados.
• Minimiza el código de creación simulado repetitivo.
• Hace que la clase de prueba sea más legible.
• Hace que el error de verificación sea más fácil de leer porque el nombre del campo se usa para identificar el simulacro.

@MockBean: (org.springframework.boot.test.mock.mockito.MockBean)

Anotación que se puede usar para agregar simulacros a Spring ApplicationContext. Se puede usar como una anotación de nivel de clase o en campos en cualquiera de @Configuration clases, o clases de prueba que son @RunWith el SpringRunner.

Los simulacros se pueden registrar por tipo o por nombre de bean. Cualquier bean único existente del mismo tipo definido en el contexto será reemplazado por el simulacro, si no se define ningún bean existente, se agregará uno nuevo.

Cuándo @MockBean se usa en un campo, además de registrarse en el contexto de la aplicación, el simulacro también se inyectará en el campo.

Mockito.mock()

Es solo la representación de un @Mock.

Si estás contento con lo expuesto, tienes la opción de dejar una reseña acerca de qué le añadirías a este post.

---

---

Utiliza Nuestro Buscador