So überprüfen Sie mehrere Methodenaufrufe mit unterschiedlichen Parametern

Ich habe die folgende Methode, mit der ich das Verhalten überprüfen möchte

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

    ...
}

In meiner @ Test-Klasse hatte ich gehofft, so etwas zu tun, um zu überprüfen, ob der errors.add()Aufruf mit "exception.message" und erneut mit "exception.detail" erfolgt.

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

Mockito beschwert sich jedoch wie folgt

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

Wie kann ich Mockito anweisen, nach beiden Werten zu suchen?

Weiterführende Literatur hat mich veranlasst, ArgumentCaptors und die folgenden Werke zu verwenden, obwohl sie viel ausführlicher sind, als ich es gerne hätte.

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

Wenn die Reihenfolge von beiden add() Anrufe relevant ist, können Sie Folgendes verwenden 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));

Versuchen Sie so etwas:

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

Sie haben wahrscheinlich ein Problem in Ihrem Code. Denn tatsächlich schreiben Sie diesen Code tatsächlich:

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

Beachten Sie, dass die erste Überprüfung nicht einmal in Bezug auf die tatsächlichen Aufrufe erfolgt.

Außerdem würde ich Ihnen empfehlen, keine Typen zu verspotten, die Sie nicht besitzen, z. B. den Strebentyp.

[EDIT @Brad]

Nachdem ich Brices Code (oben) in meiner IDE ausgeführt habe, kann ich feststellen, dass ich ActionError anstelle von ActionMessage verwendet habe. Aus diesem Grund stimmte mein verify () nicht überein. Die Fehlermeldung, die ich ursprünglich gepostet habe, hat mich irregeführt, dass es das erste Argument war, das nicht übereinstimmte. Es stellte sich heraus, dass es das zweite Argument war.

Die Antwort auf meine Frage lautet also

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

Sie können verwenden Mockito.atLeastOnce(), wodurch Mockito den Test bestehen kann, auch wenn dieses mockObject mehrmals aufgerufen wird.

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

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

1) Teilen Sie Mokito die gesamte Anruferwartung mit.

2) Sagen Sie Mokito, wie oft jede Parameterkombination erwartet wurde.

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

Ähnlich wie bei @ sendon1928 können wir Folgendes verwenden:

Mockito.times(wantedInvocationCount)

um sicherzustellen, dass die Methode genau so oft aufgerufen wurde (meiner Meinung nach bevorzugte Lösung). Danach können wir anrufen

Mockito.verifyNoMoreInteractions(mock)

Um sicherzustellen, dass Mock in keinem Zusammenhang weiter verwendet wurde. Vollständiges Beispiel:

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

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

Mockito.verifyNoMoreInteractions(mockObject)