Java vérifie les appels de méthode void n fois avec Mockito

J'essaie de vérifier qu'une méthode (void) est appelée à l'intérieur d'un DAO - j'utilise un point de validation qui envoie une liste de résultats jusqu'à ce point, réinitialise la liste et continue. Disons que j'ai 4 choses dans la liste et que j'ai un point de commit de 1, je m'attendrais à ce que la méthode "send" soit appelée 4 fois. Je peux vérifier que la méthode est appelée une fois en écrivant

Mockito.verify(mock).send()

ça passe .. mais je veux vérifier le nombre de fois qu'il a été appelé. Je penserais que

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

serait suffisant, mais il indique que les paramètres ne sont pas corrects pour la vérification.

Incidemment, si je change Mockito.verify(mock).send()en Mockito.verify(mock.send())ou Mockito.verify((mock).send())j'obtiens la même erreur. Des pensées à ce sujet?

La méthode nécessaire est Mockito # verify :

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

mockest votre objet fictif et modeest le VerificationModequi décrit comment la maquette doit être vérifiée. Les modes possibles sont :

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

Vous aurez besoin de ces importations statiques de la Mockitoclasse pour utiliser la verifyméthode et ces modes de vérification:

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;

Donc, dans votre cas, la syntaxe correcte sera:

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

Cela vérifie que la méthode a sendété appelée 4 fois sur l'objet simulé. Il échouera s'il a été appelé moins ou plus de 4 fois.

Si vous voulez juste vérifier si la méthode a été appelée une fois, vous n'avez pas besoin de passer un VerificationMode. Un simple

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

suffirait. Il utilise en interne verify(mock, times(1)).someMethod("was called once");.

Il est possible d'avoir plusieurs appels de vérification sur le même simulacre pour réaliser une vérification «entre». Mockito ne supporte pas quelque chose comme ça verify(mock, between(4,6)).someMethod("was called between 4 and 6 times");, mais nous pouvons écrire

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

à la place, pour obtenir le même comportement. Les bornes sont incluses , donc le cas de test est vert lorsque la méthode a été appelée 4, 5 ou 6 fois.