Révéler le comportement spécifique des objets

5.1 La méthode verify()

En plus de créer des objets virtuels, une autre tâche intéressante se présente souvent - pour s'assurer que la classe testée appelle les bonnes méthodes des bons objets. De plus, il a appelé le nombre de fois requis, avec les paramètres corrects, etc.

Pour cela, Mockito a aussi de la magie - une famille de méthodes Mockito.verify(…). La règle générale qui spécifie la vérification des appels de méthode est :

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

Exemple:

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

Lors de l'appel de la méthode, verify()nous définissons la règle selon laquelle mockitoListla méthode avec le paramètre 10 doit être appelée sur l'objet get().

5.2 La méthode verify() avec vérification du nombre d'appels

Parfois, il existe des scénarios de vérification plus complexes. Par exemple, vous devez vérifier non seulement le fait que la méthode a été appelée, mais, par exemple, qu'elle a été appelée 3 fois. Ou il a été appelé par vous dans un cycle et aurait donc dû être appelé N fois.

Nous ne demanderons pas si cela peut être fait, nous demanderons immédiatement : comment écrire une telle règle ? Et encore une fois, Mockito ne nous laisse pas tomber. La règle peut être spécifiée comme suit :

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

Important! La quantité n'est pas un type int, mais un objet spécial qui peut définir divers modèles. Vous souvenez-vous des différentes versions de la méthode any()? C'est la même chose ici - il existe des méthodes spéciales avec lesquelles vous pouvez définir différents scénarios :

Exemple:

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

Vous pouvez également exiger qu'à part les invocations de méthode spécifiées, aucune autre référence à l'objet ne soit faite . Il y a une règle pour cela :

Mockito.verifyNoMoreInteractions(an object);

5.3 Ordre d'appel de la méthode

Les règles précédentes ne réglementaient en aucune façon l'ordre d'appel des méthodes. La règle doit juste être respectée et c'est tout. Mais il existe des situations où l'ordre des appels de méthode est important, et Mockito a également une solution pour cela.

Un ordre strict des appels de méthode peut être spécifié à l'aide d'un objet spécial InOrder. Vous devez d'abord le créer :

InOrder inOrder = Mockito.inOrder(an object);

Et puis ajoutez-y des règles en appelant des méthodes verify().

Exemple:

    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 Vérification des exceptions dans Mockito

Le fait que des exceptions aient été levées est vérifié un peu différemment. Pour cela, utilisez la méthode assertThrows(). Le format général d'un tel chèque est le suivant :

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

Rien de compliqué.

Exemple:

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