Mockito Verify - Leitfaden

Mockito Verify-Methoden werden verwendet, um zu überprüfen, ob bestimmtes Verhalten stattgefunden hat. Wir können Mockito Verify-Methoden am Ende des Testmethodencodes verwenden, um sicherzustellen, dass bestimmte Methoden aufgerufen werden.

• Die Mockito verify()-Methode kann auch verwendet werden, um die Anzahl der Methodenaufrufe zu testen. Wir können die genaue Anzahl der Aufrufe, mindestens einmal, mindestens, höchstens die Anzahl der Aufrufzeiten für eine gemockte Methode testen.
• Wir können verifyNoMoreInteractions() nach allen verify()-Methodenaufrufen verwenden, um sicherzustellen, dass alles verifiziert ist. Wenn eine Methodenverifikation noch aussteht, wird sie fehlschlagen und eine angemessene Nachricht liefern.
• Das Verhalten von verifyZeroInteractions() ist dasselbe wie das der verifyNoMoreInteractions()-Methode.
• Wir können die inOrder()-Methode verwenden, um die Reihenfolge der Methodenaufrufe zu überprüfen. Wir können einen Methodenaufruf überspringen, aber die überprüften Methoden müssen in derselben Reihenfolge sein.

Lassen Sie uns einige Beispiele für die Mockito Verify-Methode betrachten.

Mockito verify() einfaches Beispiel

<Test>
void test() {
    List<String> mockList = mock(List.class);
    mockList.add("Pankaj");
    mockList.size();
    
    verify(mockList).add("Pankaj");
}

Die oben genannte Verify-Methode wird bestehen, wenn add("Pankaj") nur einmal für das gemockte Listenobjekt aufgerufen wird. Es ist dasselbe, wie wenn man mit dem Argument times(1) mit der Verify-Methode aufruft.

verify(mockList, times(1)).size();

Wenn wir sicherstellen wollen, dass eine Methode aufgerufen wird, aber uns das Argument egal ist, dann können wir ArgumentMatchers mit der Verify-Methode verwenden.

verify(mockList).add(anyString());
verify(mockList).add(any(String.class));
verify(mockList).add(ArgumentMatchers.any(String.class));

Beachten Sie, dass die Klasse org.mockito.Mockito statische Methoden für die meisten nützlichen Methoden im Mockito-Framework bereitstellt, dies hilft uns, flüssigen Code zu schreiben, indem wir sie mit import static importieren.

Mockito verify mit Anzahl der Aufrufe

Die Mockito verify()-Methode ist überladen, die zweite ist verify(T mock, VerificationMode mode). Wir können sie verwenden, um die Anzahl der Aufrufe zu verifizieren.

verify(mockList, times(1)).size(); //same as normal verify method
verify(mockList, atLeastOnce()).size(); // must be called at least once
verify(mockList, atMost(2)).size(); // must be called at most 2 times
verify(mockList, atLeast(1)).size(); // must be called at least once
verify(mockList, never()).clear(); // must never be called

verifyNoMoreInteractions()

Diese Methode kann nach allen verify-Methoden verwendet werden, um sicherzustellen, dass alle Interaktionen verifiziert sind. Der Test wird fehlschlagen, wenn es irgendwelche nicht verifizierten Interaktionen am gemockten Objekt gibt.

// all interactions are verified, so below will pass
verifyNoMoreInteractions(mockList);
mockList.isEmpty();
// isEmpty() is not verified, so below will fail
verifyNoMoreInteractions(mockList);

verifyZeroInteractions()

Das Verhalten der verifyZeroInteractions()-Methode ist dasselbe wie das der verifyNoMoreInteractions()-Methode.

Map mockMap = mock(Map.class);
Set mockSet = mock(Set.class);
verify(mockList).isEmpty();
verifyZeroInteractions(mockList, mockMap, mockSet);

Mockito verify nur Methodenaufruf

Wenn wir verifizieren wollen, dass nur eine Methode aufgerufen wird, dann können wir only() mit der verify-Methode verwenden.

Map mockMap = mock(Map.class);
mockMap.isEmpty();
verify(mockMap, only()).isEmpty();

Mockito Verify Reihenfolge der Aufrufe

Wir können InOrder verwenden, um die Reihenfolge der Aufrufe zu verifizieren. Wir können jede Methode zum Verifizieren überspringen, aber die zu verifizierenden Methoden müssen in derselben Reihenfolge aufgerufen werden.

InOrder inOrder = inOrder(mockList, mockMap);
inOrder.verify(mockList).add("Pankaj");
inOrder.verify(mockList, calls(1)).size();
inOrder.verify(mockList).isEmpty();
inOrder.verify(mockMap).isEmpty();

Zusammenfassung

Mockito verify()-Methoden können verwendet werden, um sicherzustellen, dass die Methoden des Mock-Objekts aufgerufen werden. Wenn ein Methodenaufruf versehentlich gelöscht wird, wird die verify-Methode einen Fehler werfen.