Aufdecken spezifischer Verhaltensweisen in Objekten

5.1 Die verify()-Methode

Neben der Erstellung virtueller Objekte stellt sich oft noch eine weitere interessante Aufgabe: sicherzustellen, dass die zu testende Klasse die richtigen Methoden der richtigen Objekte aufruft. Darüber hinaus rief er die erforderliche Anzahl von Malen mit den richtigen Parametern usw. an.

Dafür verfügt Mockito auch über etwas Zauberhaftes – eine Methodenfamilie Mockito.verify(…). Die allgemeine Regel zur Festlegung der Methodenaufrufprüfung lautet:

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

Beispiel:

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

Beim Methodenaufruf verify()legen wir die Regel fest, dass mockitoListdie Methode mit dem Parameter 10 auf dem Objekt aufgerufen werden soll get().

5.2 Die Methode verify() mit Überprüfung der Anzahl der Aufrufe

Manchmal gibt es komplexere Verifizierungsszenarien. Sie müssen beispielsweise nicht nur überprüfen, ob die Methode aufgerufen wurde, sondern beispielsweise auch, ob sie dreimal aufgerufen wurde. Oder es wurde in einem Zyklus von Ihnen aufgerufen und hätte daher N-mal aufgerufen werden müssen.

Wir werden nicht fragen, ob dies möglich ist, sondern sofort fragen: Wie schreibt man eine solche Regel auf? Und wieder lässt uns Mockito nicht im Stich. Die Regel kann wie folgt angegeben werden:

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

Wichtig! Menge ist kein Typ int, sondern ein spezielles Objekt, das verschiedene Muster definieren kann. Erinnern Sie sich an die verschiedenen Versionen der Methode any()? Auch hier ist es das Gleiche – es gibt spezielle Methoden, mit denen Sie verschiedene Szenarien einstellen können:

Beispiel:

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

Sie können auch verlangen, dass außer den angegebenen Methodenaufrufen keine weiteren Verweise auf das Objekt erfolgen . Dafür gibt es eine Regel:

Mockito.verifyNoMoreInteractions(an object);

5.3 Reihenfolge des Methodenaufrufs

Die bisherigen Regeln regelten in keiner Weise die Reihenfolge der Methodenaufrufe. Die Regel muss nur erfüllt werden und das war's. Aber es gibt Situationen, in denen die Reihenfolge der Methodenaufrufe wichtig ist, und Mockito hat auch hierfür eine Lösung.

Mithilfe eines speziellen Objekts kann eine strikte Reihenfolge der Methodenaufrufe festgelegt werden InOrder. Zuerst müssen Sie es erstellen:

InOrder inOrder = Mockito.inOrder(an object);

Und fügen Sie dann Regeln hinzu, indem Sie Methoden aufrufen verify().

Beispiel:

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 Ausnahmen in Mockito prüfen

Die Tatsache, dass Ausnahmen ausgelöst wurden, wird etwas anders überprüft. Verwenden Sie dazu die Methode assertThrows(). Das allgemeine Format für eine solche Prüfung ist:

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

Nichts Kompliziertes.

Beispiel:

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