wake-up-neo.net

Java verifiziere void Methodenaufrufe n mal mit Mockito

Ich versuche zu überprüfen, ob eine (leere) Methode in einem DAO aufgerufen wird. Ich verwende einen Festschreibungspunkt, der eine Liste der Ergebnisse bis zu diesem Punkt sendet, die Liste zurücksetzt und fortfährt. Angenommen, ich habe 4 Dinge in der Liste und einen Festschreibungspunkt von 1. Ich würde erwarten, dass die "send" -Methode 4 Mal aufgerufen wird. Ich kann überprüfen, ob die Methode einmal aufgerufen wird, indem ich schreibe

Mockito.verify(mock).send()

es vergeht .. aber ich möchte überprüfen, wie oft es aufgerufen wurde. Ich würde das denken

Mockito.verify(mock.send(), times(4))

wäre ausreichend, aber es heißt, dass die Parameter für die Überprüfung nicht korrekt sind.

Übrigens, wenn ich Mockito.verify(mock).send() in Mockito.verify(mock.send()) oder Mockito.verify((mock).send()) ändere, erhalte ich den gleichen Fehler. Gedanken dazu?

javaunit-testingjunitmockitoverify
116
nbpeth

Die notwendige Methode ist Mockito # verify :

public static <T> T verify(T mock,
                           VerificationMode mode)

mock ist Ihr verspottetes Objekt und mode ist das VerificationMode, das beschreibt, wie die Verspottung überprüft werden soll. Mögliche Modi sind :

verify(mock, times(5)).someMethod("was called five times");
verify(mock, never()).someMethod("was never called");
verify(mock, atLeastOnce()).someMethod("was called at least once");
verify(mock, atLeast(2)).someMethod("was called at least twice");
verify(mock, atMost(3)).someMethod("was called at most 3 times");
verify(mock, atLeast(0)).someMethod("was called any number of times"); // useful with captors
verify(mock, only()).someMethod("no other method has been called on the mock");

Sie benötigen diese statischen Importe aus der Klasse Mockito , um die Methode verify und die folgenden Überprüfungsmodi zu verwenden:

import static org.mockito.Mockito.atLeast;
import static org.mockito.Mockito.atLeastOnce;
import static org.mockito.Mockito.atMost;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.only;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;

In Ihrem Fall lautet die korrekte Syntax also:

Mockito.verify(mock, times(4)).send()

Dies stellt sicher, dass die Methode send für das verspottete Objekt 4 mal aufgerufen wurde. Es wird fehlschlagen, wenn es weniger oder mehr als 4 Mal aufgerufen wurde.

Wenn Sie nur überprüfen möchten, ob die Methode einmal aufgerufen wurde, müssen Sie kein VerificationMode übergeben. Eine einfache

verify(mock).someMethod("was called once");

wäre genug. Es verwendet intern verify(mock, times(1)).someMethod("was called once");.

Es ist möglich, dass mehrere Überprüfungsaufrufe auf den gleichen Mock angewendet werden, um eine "Zwischen" -Überprüfung zu erzielen. Mockito unterstützt so etwas nicht verify(mock, between(4,6)).someMethod("was called between 4 and 6 times");, aber wir können schreiben

verify(mock, atLeast(4)).someMethod("was called at least four times ...");
verify(mock, atMost(6)).someMethod("... and not more than six times");

stattdessen, um das gleiche Verhalten zu erhalten. Die Grenzen sind inklusive, der Testfall ist also grün, als die Methode 4, 5 oder 6 Mal aufgerufen wurde.

200
Tom