Anotaciones básicas de Mockito

2.1 @Anotación simulada

Hay dos formas de trabajar con objetos simulados en Mockito. El primero es crear un objeto completamente virtual , el segundo es envolver un objeto existente en un envoltorio. Comencemos con el primero.

Para crear un objeto completamente virtual, debe escribir el código:

ClassName variable name = Mockito.mock(ClassName.class);

Vamos a crear una clase ArrayList simulada como ejemplo:

@ExtendWith(MockitoExtension.class)
class MockTest {
    @Test
    public void whenNotUseMockAnnotation_thenCorrect() {
        List mockList = Mockito.mock(ArrayList.class);
        //these methods won't do anything - they are stubs
        mockList.add("one");
        mockList.add("two");
    }
}

En este ejemplo, creamos una ArrayList falsa y almacenamos una referencia a ella en la variable mockList. Los métodos de este objeto no hacen nada.

Por cierto, este código se puede escribir aún más corto, ya que hay una anotación especial para esto @Mock.

@ExtendWith(MockitoExtension.class)
class MockTest {
    @Mock
    List mockList;

    @Test
    public void whenNotUseMockAnnotation_thenCorrect() {
        //these methods won't do anything - they are stubs
        mockList.add("one");
        mockList.add("two");
    }
}

En el segundo caso, MockitoExtensionanalizará el propio código de la clase y creará los stubs necesarios. No es necesario llamar al método Mockito.mock(). Una anotación y el objeto virtual está listo. Belleza.

2.2 Anotación @Spy

El segundo tipo importante de objetos en Mockito son los envoltorios sobre objetos existentes. Permiten, por un lado, utilizar clases existentes y, por otro lado, interceptar llamadas a todos los métodos y variables de dichos objetos: para corregir su trabajo cuando sea necesario. Se utilizan con la misma frecuencia que los objetos simulados.

Para crear un contenedor sobre un objeto, debe escribir el código:

ClassName variable name = Mockito.spy(an object);

Un ejemplo con un contenedor alrededor de la clase ArrayList:

@ExtendWith(MockitoExtension.class)
class SpyTest {
    @Test
    public void whenMockAnnotation() {
        List<String> mockList = Mockito.spy(new ArrayList<String>());
        //these methods will work!
        mockList.add("one");
        mockList.add("two");
    }
}

En su forma más simple, una llamada a un objeto contenedor simplemente redirige las llamadas al objeto original, cuya referencia guarda dentro de sí mismo . Todo funcionará igual que con el objeto original.

También puede crear un contenedor usando la anotación - @Spy.

@ExtendWith(MockitoExtension.class)
class SpyTest {
    @Spy
    List mockList = new ArrayList<String>();

    @Test
    public void whenMockAnnotation() {
        // these methods will work!
        mockList.add("one");
        mockList.add("two");
    }
}

Estos dos ejemplos de código son equivalentes.