web-dev-qa-db-fra.com

Java vérifier 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 validation 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 est dit que les paramètres ne sont pas corrects pour 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?

javaunit-testingjunitmockitoverify
116
nbpeth

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

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

mock est votre objet fictif et mode est le VerificationMode qui décrit comment le mock doit être vérifié. 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 classe Mockito pour pouvoir utiliser la méthode verify et les modes de vérification suivants:

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()

Ceci vérifie que la méthode send a é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");

serait suffisant. 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 modèle pour obtenir une vérification "entre". Mockito ne supporte pas quelque chose comme ceci 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");

au lieu de cela, pour avoir le même comportement. Les limites sont incluses , de sorte que le test élémentaire est vert lorsque la méthode a été appelée 4, 5 ou 6 fois.

200
Tom