Java verifica il metodo void chiamate n volte con Mockito

Sto cercando di verificare che un metodo (vuoto) venga chiamato all'interno di un DAO - Sto usando un punto di commit che invia un elenco di risultati fino a quel punto, reimposta l'elenco e continua. Supponiamo che io abbia 4 elementi nell'elenco e che abbia un punto di commit 1, mi aspetto che il metodo "invia" venga chiamato 4 volte. Posso verificare che il metodo venga chiamato una volta scrivendo

Mockito.verify(mock).send()

passa .. ma voglio verificare il numero di volte che è stato chiamato. Lo penso

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

sarebbe sufficiente, ma dice che i parametri non sono corretti per la verifica.

Per inciso, se cambio Mockito.verify(mock).send()a Mockito.verify(mock.send())o Mockito.verify((mock).send())ottengo lo stesso errore. Pensi su questo?

Il metodo necessario è Mockito # verifica :

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

mockè il tuo oggetto deriso ed modeè quello VerificationModeche descrive come verificare la derisione. Le modalità possibili sono :

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

MockitoPer utilizzare il verifymetodo e queste modalità di verifica sono necessarie queste importazioni statiche dalla classe :

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;

Quindi nel tuo caso la sintassi corretta sarà:

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

Ciò verifica che il metodo sia sendstato chiamato 4 volte sull'oggetto deriso. Fallirà se è stato chiamato meno o più di 4 volte.

Se vuoi solo controllare, se il metodo è stato chiamato una volta, non è necessario passare a VerificationMode. Un semplice

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

sarebbe abbastanza. Usa internamente verify(mock, times(1)).someMethod("was called once");.

È possibile avere più chiamate di verifica sullo stesso mock per ottenere una verifica "tra". Mockito non supporta qualcosa del genere verify(mock, between(4,6)).someMethod("was called between 4 and 6 times");, ma possiamo scrivere

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

invece, per ottenere lo stesso comportamento. I limiti sono inclusi , quindi il test case è verde quando il metodo è stato chiamato 4, 5 o 6 volte.