Java überprüft die Methode void ungültig mit Mockito

Ich versuche zu überprüfen, ob eine (void) -Methode innerhalb eines DAO aufgerufen wird. Ich verwende einen Festschreibungspunkt, der eine Ergebnisliste 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 viermal aufgerufen wird. Ich kann durch Schreiben überprüfen, ob die Methode einmal aufgerufen wird

Mockito.verify(mock).send()

es geht vorbei .. 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, die Parameter sind nicht korrekt für die Überprüfung.

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

Die notwendige Methode ist Mockito # verify :

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

mockObjekt ist Ihr verspottet und modeist die , VerificationModedie beschreibt , wie die Mock überprüft werden sollte. 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 MockitoKlasse, um die verifyMethode und diese Überprüfungsmodi verwenden zu können:

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 bestätigt , dass das Verfahren sendaufgerufen wurde 4 mal am verspott Objekt. Es schlägt fehl, wenn es weniger oder mehr als viermal aufgerufen wurde.

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

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

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

Es ist möglich, mehrere Überprüfungsaufrufe auf demselben Mock durchzuführen, um eine "Zwischen" -Verifizierung zu erreichen. Mockito unterstützt so etwas nichtverify(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 enthalten , sodass der Testfall grün ist, wenn die Methode 4, 5 oder 6 Mal aufgerufen wurde.