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 mockitoList
a 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:
Módszer | Leírás | |
---|---|---|
1 | soha() | A módszert soha nem szabad meghívni |
2 | alkalommal(n) | n-szer |
3 | legalább (n) | n vagy több alkalommal |
4 | legalább egyszer() | 1 vagy több alkalommal |
5 | maximum(n) | n vagy kevesebb alkalommal |
6 | csak() | Csak egy hívásnak kell lennie, és csak erre a metódusra |
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());
}
}
GO TO FULL VERSION