Como verificar várias chamadas de método com parâmetros diferentes

Tenho o seguinte método no qual desejo verificar o comportamento.

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

    ...
}

Na minha classe @Test, eu esperava fazer algo assim para verificar se errors.add()é chamado com "exception.message" e novamente com "exception.detail"

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

no entanto Mockito reclama da seguinte forma

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

Como posso dizer ao Mockito para verificar os dois valores?

Leituras adicionais me levaram a tentar usar ArgumentCaptors e os trabalhos a seguir, embora muito mais prolixos do que eu gostaria.

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

Se a ordem de ambas as add()chamadas for relevante, você pode usar 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));

Experimente algo assim:

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

você provavelmente tem um problema no seu código. Porque na verdade você escreve este código:

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

Observe que a primeira verificação não está uniforme em relação às invocações reais.

Além disso, recomendo que você realmente não zombe de tipos que você não possui, por exemplo, o tipo struts.

[EDIT @Brad]

Depois de executar o código de Brice (acima) em meu IDE, posso ver que usei ActionError em vez de ActionMessage, então é por isso que meu verify () não estava combinando. A mensagem de erro que postei inicialmente estava me enganando, fazendo-me pensar que era o primeiro argumento incompatível. Acontece que foi o segundo argumento.

Então, a resposta à minha pergunta é

/** 
 * 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));

Você pode usar o Mockito.atLeastOnce()qual permite que o Mockito passe no teste, mesmo se o mockObject for chamado muitas vezes.

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

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

1) Diga a Mokito a expectativa total de ligações.

2) Diga a Mokito quantas vezes cada combinação de parâmetro era esperada.

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 forma semelhante a @ sendon1928, podemos usar:

Mockito.times(wantedInvocationCount)

para ter certeza de que o método foi chamado um número exato de vezes (solução preferível na minha opinião). Depois, podemos ligar

Mockito.verifyNoMoreInteractions(mock)

Para ter certeza de que a simulação não foi mais usada em nenhum contexto. Exemplo completo:

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

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

Mockito.verifyNoMoreInteractions(mockObject)