Specifiek gedrag in objecten onthullen

5.1 De verifieer() methode

Naast het maken van virtuele objecten, doet zich vaak een andere interessante taak voor: ervoor zorgen dat de te testen klasse de juiste methoden van de juiste objecten aanroept. Bovendien belde hij het vereiste aantal keren, met de juiste parameters, en dergelijke.

Hiervoor heeft Mockito ook wat magie - een familie van methoden Mockito.verify(…). De algemene regel die methodeaanroepcontrole specificeert is:

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

Voorbeeld:

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

Tijdens de methodeaanroep verify()stellen we de regel in dat mockitoListde methode met de parameter 10 moet worden aangeroepen op het object get().

5.2 De verifieer() methode met het controleren van het aantal oproepen

Soms zijn er complexere verificatiescenario's. U moet bijvoorbeeld niet alleen controleren of de methode is aangeroepen, maar bijvoorbeeld of deze 3 keer is aangeroepen. Of het is door jou in een cyclus gebeld en had daarom N keer moeten worden gebeld.

We zullen niet vragen of dit mogelijk is, we zullen meteen vragen: hoe schrijf je zo'n regel op? En nogmaals, Mockito stelt ons niet teleur. De regel kan worden gespecificeerd als:

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

Belangrijk! Hoeveelheid is geen type int, maar een speciaal object dat verschillende patronen kan definiëren. Herinner je je de verschillende versies van de methode any()? Hier is het hetzelfde - er zijn speciale methoden waarmee u verschillende scenario's kunt instellen:

Voorbeeld:

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

U kunt ook eisen dat er, afgezien van de gespecificeerde methodeaanroepen, geen andere verwijzingen naar het object worden gemaakt . Hiervoor is een regel:

Mockito.verifyNoMoreInteractions(an object);

5.3 Methode oproepvolgorde

De vorige regels regelden op geen enkele manier de volgorde van aanroepmethoden. De regel moet gewoon worden vervuld en dat is alles. Maar er zijn situaties waarin de volgorde van methodeaanroepen belangrijk is, en ook daar heeft Mockito een oplossing voor.

Een strikte volgorde van methodeaanroepen kan worden gespecificeerd met behulp van een speciaal object InOrder. Eerst moet je het maken:

InOrder inOrder = Mockito.inOrder(an object);

En voeg er vervolgens regels aan toe door methoden aan te roepen verify().

Voorbeeld:

    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 Uitzonderingen controleren in Mockito

Het feit dat uitzonderingen zijn gegenereerd, wordt iets anders gecontroleerd. Gebruik hiervoor de methode assertThrows(). Het algemene formaat voor een dergelijke controle is:

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

Niets ingewikkelds.

Voorbeeld:

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