Cómo verificar múltiples llamadas a métodos con diferentes parámetros

Tengo el siguiente método en el que deseo verificar el comportamiento.

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

    ...
}

En mi clase @Test esperaba hacer algo como esto para verificar que errors.add()se llama con "exception.message" y nuevamente con "exception.detail"

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

sin embargo Mockito se queja de la siguiente manera

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

¿Cómo puedo decirle a Mockito que verifique ambos valores?

Leer más me ha llevado a intentar usar ArgumentCaptors y los siguientes trabajos, aunque mucho más detallados de lo que me gustaría.

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 el orden de ambas add()llamadas es relevante, puede 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));

Intente algo como esto:

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

probablemente tenga un problema en su código. Porque, de hecho, escribes 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());

Tenga en cuenta que la primera verificación ni siquiera está en orden con respecto a las invocaciones reales.

Además, le recomendaría que no se burle de los tipos que no le pertenecen, por ejemplo, el tipo struts.

[EDITAR @Brad]

Después de ejecutar el código de Brice (arriba) en mi IDE, puedo ver que he usado ActionError en lugar de ActionMessage, por eso mi verify () no coincide. El mensaje de error que publiqué inicialmente me engañó haciéndome pensar que era el primer argumento que no coincidía. Resulta que fue el segundo argumento.

Entonces la respuesta a mi pregunta es

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

Puede usar lo Mockito.atLeastOnce()que le permite a Mockito pasar la prueba incluso si ese mockObject se llamará muchas veces.

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

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

1) Dile a Mokito la expectativa total de llamadas.

2) Dígale a Mokito cuántas veces se esperaba cada combinación de parámetros.

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 manera similar a @ sendon1928 podemos usar:

Mockito.times(wantedInvocationCount)

para asegurarse de que se haya llamado al método el número exacto de veces (solución preferible en mi opinión). Luego, podemos llamar

Mockito.verifyNoMoreInteractions(mock)

Para asegurarse de que el simulacro no se use más en ningún contexto. Ejemplo completo:

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

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

Mockito.verifyNoMoreInteractions(mockObject)