Revelar comportamiento específico en objetos

5.1 El método verificar()

Además de crear objetos virtuales, a menudo surge otra tarea interesante: asegurarse de que la clase bajo prueba llame a los métodos correctos de los objetos correctos. Además, llamó la cantidad requerida de veces, con los parámetros correctos y similares.

Para esto, Mockito también tiene algo de magia: una familia de métodos Mockito.verify(…). La regla general que especifica la verificación de llamadas a métodos es:

Mockito.verify(an object).method name(parameter);

Ejemplo:

@ExtendWith(MockitoExtension.class)
class VerifyTest {
 @Mock
 List<String> mockList;

 @Test
    public void whenMockAnnotation() {
        //method call
        String name = mockList.get(10);

        // check if the method was called
        Mockito.verify(mockList).get(10);
    }
}

Durante la llamada al método, verify()establecemos la regla de que mockitoListel método con el parámetro 10 debe llamarse en el objeto get().

5.2 El método de verificación () con la verificación del número de llamadas

A veces hay escenarios de verificación más complejos. Por ejemplo, debe verificar no solo el hecho de que se llamó al método, sino, por ejemplo, que se llamó 3 veces. O lo llamó usted en un ciclo y, por lo tanto, debería haberlo llamado N veces.

No preguntaremos si esto se puede hacer, inmediatamente preguntaremos: ¿cómo escribir tal regla? Y nuevamente, Mockito no nos defrauda. La regla se puede especificar como:

Mockito.verify(an object,quantity).method name(parameter);

¡Importante! La cantidad no es un tipo int, sino un objeto especial que puede definir varios patrones. ¿Recuerdas las diferentes versiones del método any()? Es lo mismo aquí: existen métodos especiales con los que puede configurar varios escenarios:

Ejemplo:

String name1 = mockList.get(1);  //method call
String name2 = mockList.get(2);  //method call
String name3 = mockList.get(3);  //method call

//check that the get() method was called 3 times
Mockito.verify(mockList, times(3)).get(anyInt());

También puede solicitar que, aparte de las invocaciones de métodos especificados, no se hagan otras referencias al objeto . Hay una regla para esto:

Mockito.verifyNoMoreInteractions(an object);

5.3 Orden de llamada de método

Las reglas anteriores no regulaban el orden de los métodos de llamada de ninguna manera. La regla solo tiene que cumplirse y ya está. Pero hay situaciones en las que el orden de las llamadas a métodos es importante, y Mockito también tiene una solución para esto.

Se puede especificar un orden estricto de llamadas a métodos utilizando un objeto especial InOrder. Primero necesitas crearlo:

InOrder inOrder = Mockito.inOrder(an object);

Y luego agregue reglas llamando a métodos verify().

Ejemplo:

    List<String> mockedList = mock(MyList.class);
    mockedList.size();
    mockedList.add("a parameter");
    mockedList.clear();
 
    InOrder inOrder = Mockito.inOrder(mockedList);
    inOrder.verify(mockedList).size();
    inOrder.verify(mockedList).add("a parameter");
    inOrder.verify(mockedList).clear();

5.4 Comprobación de excepciones en Mockito

El hecho de que se hayan lanzado excepciones se comprueba de forma un poco diferente. Para hacer esto, use el método assertThrows(). El formato general para tal verificación es:

Assertions.assertThrows(exception.class, () -> an object.methodname());

Nada complicado.

Ejemplo:

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

 @Test
    public void whenMockAnnotation() {
        //set the behavior of the method (needed for demonstration purposes only)
        Mockito.when(mockList.size()).thenThrow(IllegalStateException.class);

        //check if an IllegalStateException will be thrown when calling the size method
        assertThrows(IllegalStateException.class, () -> mockList.size());
    }
}