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

141

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?

nbpeth
fuente
10
Tratar Mockito.verify(mock, times(4)).send(). Me pregunto por qué "moviste" la send()llamada al verifymétodo dentro del método. Ya tenías la sintaxis correcta.
Tom
También tenga en cuenta que si no le importa cuántas veces se llama algo, puede escribirverify(mock, atLeastOnce()).send();
Dawood ibn Kareem el
Gracias, eso es correcto. Lo que encontré confuso fue que Mockito.verify(mock).send()pasó, pero solo encapsularlo causó un error que no cambia nada. sin embargo, es una victoria!
nbpeth

Respuestas:

238

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.

Tom
fuente
1
Para cualquiera que busque encontrar dónde están los VerificationModemétodos (para importación estática o referencia explícita), están dentro org.mockito.internal.verification.VerificationModeFactory.
Steve Chambers,
verify(mock, atLeast(0)).someMethod("was called any number of times");fue útil para ignorar una verificación de llamada
tj-recess
2
¿Hay algo así como verify(between(m,n))que verifica el número de llamadas entre myn?
nishant
2
@nishant No, Mockito no parece apoyar eso, pero puede llamar verifya veces con atLeast(M)y atMost(n)obtener el mismo comportamiento. He editado la respuesta y explica eso.
Tom
@KevinWelker Tienes razón, he eliminado la información sobre VerificationModeFactory. Todavía está disponible en la versión más nueva, pero estoy de acuerdo en que las clases internas no deberían usarse.
Tom