Jak zweryfikować wiele wywołań metod z różnymi parametrami

Mam następującą metodę, na której chcę sprawdzić zachowanie.

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

    ...
}

W mojej klasie @Test miałem nadzieję zrobić coś takiego, aby sprawdzić, czy errors.add()jest wywoływane z „wyjątkiem.message” i ponownie z „wyjątkiem.detail”

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

jednak Mockito narzeka w następujący sposób

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

Jak mogę powiedzieć Mockito, aby sprawdzał obie wartości?

Dalsza lektura skłoniła mnie do wypróbowania ArgumentCaptors i następnych prac, chociaż znacznie bardziej rozwlekłych, niż bym chciał.

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

Jeśli kolejność obu add()połączeń jest istotna, możesz użyć 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));

Spróbuj czegoś takiego:

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

prawdopodobnie masz problem w swoim kodzie. Ponieważ w rzeczywistości piszesz ten kod:

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

Zauważ, że pierwsza weryfikacja nie jest równa w odniesieniu do rzeczywistych wywołań.

Radziłbym również, aby właściwie nie kpić z typów, których nie jesteś właścicielem, np. Typu rozpórki.

[EDYCJA @Brad]

Po uruchomieniu kodu Brice'a (powyżej) w moim IDE widzę, że użyłem ActionError zamiast ActionMessage, dlatego moja weryfikacja () nie pasuje. Komunikat o błędzie, który opublikowałem początkowo, wprowadzał mnie w błąd, myśląc, że to pierwszy niezgodny argument. Okazuje się, że był to drugi argument.

Tak więc odpowiedź na moje pytanie brzmi

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

Możesz użyć, Mockito.atLeastOnce()który pozwala Mockito przejść test, nawet jeśli ten mockObject będzie wywoływany wiele razy.

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

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

1) Powiedz Mokito o całkowitym oczekiwaniu na rozmowy.

2) Powiedz Mokito, ile razy każda kombinacja parametrów była oczekiwana.

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

W podobny sposób jak @ sendon1928 możemy użyć:

Mockito.times(wantedInvocationCount)

aby upewnić się, że metoda została wywołana dokładną liczbę razy (moim zdaniem preferowane rozwiązanie). Potem możemy zadzwonić

Mockito.verifyNoMoreInteractions(mock)

Aby upewnić się, że makieta nie była dalej używana w żadnym kontekście. Pełny przykład:

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

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

Mockito.verifyNoMoreInteractions(mockObject)