Comment vérifier plusieurs appels de méthode avec différents paramètres

J'ai la méthode suivante sur laquelle je souhaite vérifier le comportement.

public void methodToTest(Exception e, ActionErrors errors) {
    ...

    errors.add("exception.message", 
            ActionMessageFactory.createErrorMessage(e.toString()));

    errors.add("exception.detail",
            ActionMessageFactory.createErrorMessage(e.getStackTrace()[0].toString()));

    ...
}

Dans ma classe @Test, j'espérais faire quelque chose comme ça pour vérifier que cela errors.add()est appelé avec "exception.message" et à nouveau avec "exception.detail"

verify(errors).add(eq("exception.message"), any(ActionError.class));
verify(errors).add(eq("exception.detail"), any(ActionError.class));

cependant Mockito se plaint comme suit

Argument(s) are different! Wanted:
actionErrors.add(
    "exception.message",
    <any>
);

Actual invocation has different arguments:
actionErrors.add(
    "exception.detail",
    org.apache.struts.action.ActionError@38063806
);

Comment puis-je dire à Mockito de vérifier les deux valeurs?

Une lecture plus approfondie m'a amené à essayer d'utiliser ArgumentCaptors et les travaux suivants, bien que beaucoup plus verbeux que je ne le souhaiterais.

ArgumentCaptor<String> argument = ArgumentCaptor.forClass(String.class);

verify(errors, atLeastOnce()).add(argument.capture(), any(ActionMessage.class));

List<String> values = argument.getAllValues();

assertTrue(values.contains("exception.message"));
assertTrue(values.contains("exception.detail"));

Si l'ordre des deux add()appels est pertinent, vous pouvez utiliser InOrder:

InOrder inOrder = inOrder(errors);
inOrder.verify(errors).add(eq("exception.message"), any(ActionError.class));
inOrder.verify(errors).add(eq("exception.detail"), any(ActionError.class));

Essayez quelque chose comme ceci:

verify(errors, times(2))
     .add(AdditionalMatchers.or(eq("exception.message"), eq("exception.detail")),
          any(ActionError.class));

vous avez probablement un problème dans votre code. Parce qu'en fait, vous écrivez ce code:

Map<Character, String> map = mock(Map.class);

map.put('a', "a");
map.put('b', "b");
map.put('c', "c");

verify(map).put(eq('c'), anyString());
verify(map).put(eq('a'), anyString());
verify(map).put(eq('b'), anyString());

Notez que la première vérification n'est même pas dans l'ordre en ce qui concerne les invocations réelles.

De plus, je vous recommande de ne pas vous moquer des types que vous ne possédez pas, par exemple le type struts.

[MODIFIER @Brad]

Après avoir exécuté le code de Brice (ci-dessus) dans mon IDE, je peux voir que j'ai utilisé ActionError au lieu d'ActionMessage, c'est pourquoi mon verify () ne correspondait pas. Le message d'erreur que j'ai initialement publié m'a induit en erreur en pensant que c'était le premier argument qui ne correspondait pas. Il s'avère que c'était le deuxième argument.

Donc la réponse à ma question est

/** 
 * note that ActionMessageFactory.createErrorMessage() returns ActionMessage
 * and ActionError extends ActionMessage
 */
verify(errors).add(eq("exception.message"), any(ActionMessage.class));
verify(errors).add(eq("exception.detail"), any(ActionMessage.class));

Vous pouvez utiliser Mockito.atLeastOnce()ce qui permet à Mockito de passer le test même si ce mockObject sera appelé plusieurs fois.

Mockito.verify(mockObject, Mockito.atLeastOnce()).testMethod(Mockito.eq(1));

Mockito.verify(mockObject, Mockito.atLeastOnce()).testMethod(Mockito.eq(2));

1) Dites à Mokito l'attente totale des appels.

2) Dites à Mokito combien de fois chaque combinaison de paramètres était attendue.

verify(errors, times(2)).add(any(), any(ActionMessage.class));

verify(errors, atLeastOnce()).add(eq("exception.message"), any());
verify(errors, atLeastOnce()).add(eq("exception.detail"), any());

De la même manière que @ sendon1928, nous pouvons utiliser:

Mockito.times(wantedInvocationCount)

pour s'assurer que la méthode a été appelée le nombre exact de fois (solution préférable à mon avis). Ensuite, nous pouvons appeler

Mockito.verifyNoMoreInteractions(mock)

Pour s'assurer que ce simulacre n'est plus utilisé dans aucun contexte. Exemple complet:

Mockito.verify(mockObject, Mockito.times(wantedInvocationCount)).testMethod(Mockito.eq(1));

Mockito.verify(mockObject, Mockito.times(wantedInvocationCount)).testMethod(Mockito.eq(2));

Mockito.verifyNoMoreInteractions(mockObject)