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:

Nombre de la clase nombre de la variable = Mockito.mock(Nombre de la clase.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);
        //estos métodos no harán nada - son 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() {
        //estos métodos no harán nada - son 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:

Nombre de la clase nombre de la variable = Mockito.spy(un objeto);

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>());
        // ¡estos métodos funcionarán!
        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() {
        // ¡estos métodos funcionarán!
        mockList.add("one");
        mockList.add("two");
    }
}

Estos dos ejemplos de código son equivalentes.

Java university