Rivelare un comportamento specifico negli oggetti

5.1 Il metodo verifiche()

Oltre alla creazione di oggetti virtuali, spesso sorge un altro compito interessante: assicurarsi che la classe sottoposta a test chiami i metodi giusti degli oggetti giusti. Inoltre, ha chiamato il numero di volte richiesto, con i parametri corretti e simili.

Per questo, Mockito ha anche un po' di magia: una famiglia di metodi Mockito.verify(…). La regola generale che specifica il controllo delle chiamate al metodo è:

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

Esempio:

@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 chiamata al metodo, verify()impostiamo la regola che mockitoListil metodo con il parametro 10 dovrebbe essere chiamato sull'oggetto get().

5.2 Il metodo verifiche() con il controllo del numero di chiamate

A volte ci sono scenari di verifica più complessi. Ad esempio, è necessario verificare non solo il fatto che il metodo sia stato chiamato, ma, ad esempio, che sia stato chiamato 3 volte. Oppure è stato chiamato da te in un ciclo e quindi avrebbe dovuto essere chiamato N volte.

Non ci chiederemo se si può fare, ci chiederemo subito: come scrivere una regola del genere? E ancora, Mockito non ci delude. La regola può essere specificata come:

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

Importante! La quantità non è un tipo int, ma un oggetto speciale che può definire vari modelli. Ricordi le diverse versioni del metodo any()? È lo stesso qui: ci sono metodi speciali con cui puoi impostare vari scenari:

Esempio:

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

È inoltre possibile richiedere che, a parte le chiamate al metodo specificate, non vengano effettuati altri riferimenti all'oggetto . C'è una regola per questo:

Mockito.verifyNoMoreInteractions(an object);

5.3 Ordine di chiamata del metodo

Le regole precedenti non regolavano in alcun modo l'ordine dei metodi di chiamata. La regola deve solo essere soddisfatta e basta. Ma ci sono situazioni in cui l'ordine delle chiamate di metodo è importante e Mockito ha una soluzione anche per questo.

Un ordine rigoroso di chiamate di metodo può essere specificato utilizzando un oggetto speciale InOrder. Per prima cosa devi crearlo:

InOrder inOrder = Mockito.inOrder(an object);

E poi aggiungi regole ad esso chiamando metodi verify().

Esempio:

    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 Controllo delle eccezioni in Mockito

Il fatto che siano state lanciate eccezioni viene verificato in modo leggermente diverso. Per fare questo, usa il metodo assertThrows(). Il formato generale per tale controllo è:

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

Niente di complicato.

Esempio:

@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());
    }
}