Java weryfikuje void wywołań metody n razy za pomocą Mockito

140

Próbuję sprawdzić, czy (void) metoda jest wywoływana wewnątrz DAO - używam punktu zatwierdzenia, który wysyła listę wyników do tego momentu, resetuje listę i kontynuuje. Powiedzmy, że mam 4 rzeczy na liście i mam punkt zatwierdzenia 1, spodziewałbym się, że metoda „wyślij” zostanie wywołana 4 razy. Mogę sprawdzić, czy metoda zostanie wywołana raz, pisząc

Mockito.verify(mock).send()

przechodzi ... ale chcę sprawdzić, ile razy został wywołany. Myślę, że tak

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

byłoby wystarczające, ale mówi, że parametry nie są poprawne do weryfikacji.

Nawiasem mówiąc, jeśli zmienię Mockito.verify(mock).send()na Mockito.verify(mock.send())lub Mockito.verify((mock).send())otrzymam ten sam błąd. Co o tym myślisz?

nbpeth
źródło
10
Spróbuj Mockito.verify(mock, times(4)).send(). Zastanawiam się, dlaczego „przeniosłeś” send()wywołanie metody wewnątrz verifymetody. Masz już odpowiednią składnię.
Tom,
Pamiętaj też, że jeśli nie obchodzi Cię, ile razy coś zostanie wywołane, możesz napisaćverify(mock, atLeastOnce()).send();
Dawood ibn Kareem
Dziękuję, zgadza się. Zmylające mnie było to, że Mockito.verify(mock).send()przeszło, ale samo hermetyzacja spowodowała błąd, który niczego nie zmienia. jednak to wygrana!
nbpeth

Odpowiedzi:

237

Niezbędna metoda to weryfikacja Mockito # :

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

mockto twój wyśmiewany obiekt i modeto on VerificationModeopisuje, jak powinna zostać zweryfikowana. Możliwe tryby to :

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

Będziesz potrzebować tych statycznych importów z Mockitoklasy, aby użyć verifymetody i tych trybów weryfikacji:

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;

Więc w twoim przypadku poprawna składnia będzie wyglądać następująco:

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

To sprawdza, czy metoda sendzostała wywołana 4 razy na mockowanym obiekcie. Nie powiedzie się, jeśli został wywołany mniej lub więcej niż 4 razy.


Jeśli chcesz tylko sprawdzić, czy metoda została wywołana raz, nie musisz przekazywać pliku VerificationMode. Prosty

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

powinno wystarczyć. Używa wewnętrznie verify(mock, times(1)).someMethod("was called once");.


Możliwe jest posiadanie wielu wywołań weryfikacyjnych na tym samym makiecie, aby uzyskać weryfikację „pomiędzy”. Mockito nie obsługuje czegoś takiego verify(mock, between(4,6)).someMethod("was called between 4 and 6 times");, ale możemy pisać

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

zamiast tego uzyskać to samo zachowanie. Granice są uwzględnione , więc przypadek testowy jest zielony, gdy metoda została wywołana 4, 5 lub 6 razy.

Tomek
źródło
1
Dla każdego, kto chce dowiedzieć się, gdzie znajdują się VerificationModemetody (w przypadku importu statycznego lub jawnego odwołania), są one dostępne org.mockito.internal.verification.VerificationModeFactory.
Steve Chambers
verify(mock, atLeast(0)).someMethod("was called any number of times");pomogło zignorowanie weryfikacji połączenia
tj-recess
2
czy jest coś takiego, verify(between(m,n))co weryfikuje liczbę połączeń między m a n?
nishant
2
@nishant Nie, Mockito nie wydaje się wspierać tego, ale możesz zadzwonić verifydo czasu z tym samym zachowaniem atLeast(M)i atMost(n)uzyskać takie samo zachowanie. Zredagowałem odpowiedź, żeby to wyjaśnić.
Tom
@KevinWelker Masz rację, usunąłem informacje o VerificationModeFactory. Jest nadal dostępny w najnowszej wersji, ale zgadzam się, że nie należy używać klas wewnętrznych.
Tom