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


141

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?


10
Essayez Mockito.verify(mock, times(4)).send(). Je me demande pourquoi vous avez "déplacé" l' send()appel de méthode à l'intérieur de la verifyméthode. Vous aviez déjà la bonne syntaxe.
Tom


Notez également que si vous ne vous souciez pas du nombre de fois où quelque chose est appelé, vous pouvez écrireverify(mock, atLeastOnce()).send();
Dawood ibn Kareem

Merci, c'est exact. Ce que j'ai trouvé déroutant, c'est que le fait d'être Mockito.verify(mock).send()passé, mais simplement l'encapsuler, a provoqué une erreur, qui ne change rien. cependant, c'est une victoire!
nbpeth

Réponses:


238

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.


1
Pour tous ceux qui cherchent à trouver où se trouvent les VerificationModeméthodes (pour l'importation statique ou une référence explicite), elles se trouvent dans org.mockito.internal.verification.VerificationModeFactory.
Steve Chambers

verify(mock, atLeast(0)).someMethod("was called any number of times");était utile pour ignorer une vérification d'appel
tj-recess

2
y a-t-il quelque chose comme verify(between(m,n))qui vérifie le nombre d'appels entre m et n?
nishant

2
@nishant Non, Mockito ne semble pas soutenir cela, mais vous pouvez appeler verifyà des moments avec atLeast(M)et atMost(n)obtenir le même comportement. J'ai édité la réponse pour l'expliquer.
Tom

@KevinWelker Vous avez raison, j'ai supprimé les informations sur VerificationModeFactory. Il est toujours disponible dans la dernière version, mais je suis d'accord que les classes internes ne devraient pas être utilisées.
Tom
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.