Az objektumok sajátos viselkedésének feltárása

5.1 A verify() metódus

A virtuális objektumok létrehozása mellett gyakran felmerül még egy érdekes feladat - annak biztosítása, hogy a tesztelés alatt álló osztály a megfelelő objektumok megfelelő metódusait hívja meg. Sőt, hívott a szükséges számú alkalommal, a megfelelő paraméterekkel és hasonlókkal.

Ehhez a Mockitonak is van némi varázsa – egy módszercsalád Mockito.verify(…). A metódushívás-ellenőrzést meghatározó általános szabály a következő:

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

Példa:

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

A metódushívás során verify()beállítjuk azt a szabályt, hogy mockitoLista 10-es paraméterű metódust kell meghívni az objektumon get().

5.2 A verify() metódus a hívások számának ellenőrzésével

Néha bonyolultabb ellenőrzési forgatókönyvek is léteznek. Például nemcsak azt kell ellenőriznie, hogy a metódust meghívták-e, hanem például azt, hogy háromszor hívták-e meg. Vagy tőled hívták egy ciklusban, és ezért N-szer kellett volna hívni.

Nem kérdezzük meg, hogy ezt meg lehet-e tenni, hanem azonnal: hogyan írjunk le egy ilyen szabályt? És ismét: Mockito nem hagy cserben minket. A szabály a következőképpen határozható meg:

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

Fontos! A mennyiség nem egy típus int, hanem egy speciális objektum, amely különféle mintákat tud meghatározni. Emlékszel a módszer különböző változataira any()? Itt is ugyanaz – vannak speciális módszerek, amelyekkel különféle forgatókönyveket állíthat be:

Példa:

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

Azt is megkövetelheti, hogy a megadott metódushívásokon kívül ne történjen más hivatkozás az objektumra . Erre van egy szabály:

Mockito.verifyNoMoreInteractions(an object);

5.3 Módszerhívási sorrend

A korábbi szabályok semmilyen módon nem szabályozták a hívási módok sorrendjét. A szabályt csak be kell tartani, és ennyi. De vannak olyan helyzetek, amikor fontos a metódushívások sorrendje, és erre is van megoldása a Mockitonak.

A metódushívások szigorú sorrendje egy speciális objektum segítségével adható meg InOrder. Először létre kell hoznia:

InOrder inOrder = Mockito.inOrder(an object);

Ezután adjon hozzá szabályokat metódusok meghívásával verify().

Példa:

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 Kivételek ellenőrzése a Mockitoban

Az a tény, hogy kivételeket dobtak, egy kicsit másképp ellenőrzik. Ehhez használja a módszert assertThrows(). Az ilyen ellenőrzés általános formátuma:

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

Semmi bonyolult.

Példa:

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