Come verificare più chiamate di metodo con parametri diversi

Ho il seguente metodo su cui desidero verificare il 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()));

    ...
}

Nella mia classe @Test speravo di fare qualcosa di simile per verificare che errors.add()venga chiamato con "exception.message" e di nuovo con "exception.detail"

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

tuttavia Mockito si lamenta come segue

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

Come posso dire a Mockito di controllare entrambi i valori?

Ulteriori letture mi hanno portato a provare a usare ArgumentCaptors e le seguenti opere, anche se molto più prolisse di quanto vorrei.

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 l'ordine di entrambe le add()chiamate è pertinente, puoi utilizzare 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));

Prova qualcosa di simile:

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

probabilmente hai un problema nel codice. Perché in realtà scrivi questo codice:

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

Notare che la prima verifica non è nemmeno in ordine rispetto alle invocazioni effettive.

Inoltre, ti consiglio di non prendere in giro tipi che non possiedi, ad esempio il tipo struts.

[EDIT @Brad]

Dopo aver eseguito il codice di Brice (sopra) nel mio IDE, posso vedere che ho usato ActionError invece di ActionMessage, quindi è per questo che la mia verifica () non corrispondeva. Il messaggio di errore che ho inizialmente pubblicato mi ha indotto a pensare che fosse il primo argomento che non corrispondeva. Si scopre che era il secondo argomento.

Quindi la risposta alla mia domanda è

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

Puoi usare Mockito.atLeastOnce()che consente a Mockito di superare il test anche se quel mockObject verrà chiamato molte volte.

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

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

1) Di 'a Mokito l'aspettativa totale delle chiamate.

2) Di 'a Mokito quante volte era prevista ogni combinazione di parametri.

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

In modo simile a @ sendon1928 possiamo usare:

Mockito.times(wantedInvocationCount)

per assicurarsi che il metodo sia stato chiamato il numero esatto di volte (soluzione preferibile a mio parere). Successivamente, possiamo chiamare

Mockito.verifyNoMoreInteractions(mock)

Per assicurarsi che la simulazione non sia stata ulteriormente utilizzata in nessun contesto. Esempio completo:

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

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

Mockito.verifyNoMoreInteractions(mockObject)