Java verifica las llamadas al método nulo n veces con Mockito

Estoy tratando de verificar que se está llamando a un método (vacío) dentro de un DAO: estoy usando un punto de confirmación que envía una lista de resultados hasta ese punto, restablece la lista y continúa. Digamos que tengo 4 cosas en la lista y tengo un punto de confirmación de 1, esperaría que el método "enviar" se llame 4 veces. Puedo verificar que el método se llame una vez escribiendo

Mockito.verify(mock).send()

pasa .. pero quiero verificar la cantidad de veces que se llamó. Yo pensaría que

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

sería suficiente, pero dice que los parámetros no son correctos para verificar.

Por cierto, si cambio Mockito.verify(mock).send()de Mockito.verify(mock.send())o Mockito.verify((mock).send())me sale el mismo error. ¿Pensamientos sobre esto?

El método necesario es Mockito # verificar :

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

mockes su objeto simulado y modees el VerificationModeque describe cómo se debe verificar el simulacro. Los modos posibles son :

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

Necesitará estas importaciones estáticas de la Mockitoclase para usar el verifymétodo y estos modos de verificación:

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;

Entonces, en su caso, la sintaxis correcta será:

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

Esto verifica que el método sendfue llamado 4 veces en el objeto burlado. Fallará si se llamó menos o más de 4 veces.

Si solo desea verificar, si el método ha sido llamado una vez, entonces no necesita pasar a VerificationMode. Un simple

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

seria suficiente. Se utiliza internamente verify(mock, times(1)).someMethod("was called once");.

Es posible tener múltiples llamadas de verificación en el mismo simulacro para lograr una verificación "entre". Mockito no admite algo como esto verify(mock, between(4,6)).someMethod("was called between 4 and 6 times");, pero podemos escribir

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

en cambio, para obtener el mismo comportamiento. Los límites están incluidos , por lo que el caso de prueba es verde cuando el método se llamó 4, 5 o 6 veces.