Czy Mockito może przechwytywać argumenty metody wywoływanej wielokrotnie?

Mam metodę, która jest wywoływana dwukrotnie i chcę uchwycić argument drugiego wywołania metody.

Oto, co próbowałem:

ArgumentCaptor<Foo> firstFooCaptor = ArgumentCaptor.forClass(Foo.class);
ArgumentCaptor<Foo> secondFooCaptor = ArgumentCaptor.forClass(Foo.class);
verify(mockBar).doSomething(firstFooCaptor.capture());
verify(mockBar).doSomething(secondFooCaptor.capture());
// then do some assertions on secondFooCaptor.getValue()

Ale dostaję TooManyActualInvocationswyjątek, ponieważ Mockito uważa, że doSomethingnależy to nazwać tylko raz.

Jak mogę zweryfikować argument drugiego wywołania doSomething?

Myślę, że tak powinno być

verify(mockBar, times(2)).doSomething(...)

Przykład z mockito javadoc :

ArgumentCaptor<Person> peopleCaptor = ArgumentCaptor.forClass(Person.class);
verify(mock, times(2)).doSomething(peopleCaptor.capture());

List<Person> capturedPeople = peopleCaptor.getAllValues();
assertEquals("John", capturedPeople.get(0).getName());
assertEquals("Jane", capturedPeople.get(1).getName());

Od wersji Mockito 2.0 istnieje również możliwość użycia metody statycznej Matchers.argThat (ArgumentMatcher) . Przy pomocy Java 8 pisanie jest teraz znacznie łatwiejsze i bardziej czytelne:

verify(mockBar).doSth(argThat((arg) -> arg.getSurname().equals("OneSurname")));
verify(mockBar).doSth(argThat((arg) -> arg.getSurname().equals("AnotherSurname")));

Jeśli jesteś przywiązany do niższej wersji Java, jest też niezły:

verify(mockBar).doSth(argThat(new ArgumentMatcher<Employee>() {
        @Override
        public boolean matches(Object emp) {
            return ((Employee) emp).getSurname().equals("SomeSurname");
        }
    }));

Oczywiście żaden z nich nie może zweryfikować kolejności połączeń - do których należy użyć InOrder :

InOrder inOrder = inOrder(mockBar);

inOrder.verify(mockBar).doSth(argThat((arg) -> arg.getSurname().equals("FirstSurname")));
inOrder.verify(mockBar).doSth(argThat((arg) -> arg.getSurname().equals("SecondSurname")));

Proszę spojrzeć na projekt mockito-java8 , który umożliwia wykonywanie połączeń takich jak:

verify(mockBar).doSth(assertArg(arg -> assertThat(arg.getSurname()).isEqualTo("Surname")));

Jeśli nie chcesz sprawdzać poprawności wszystkich połączeń doSomething(), możesz użyć tylko ostatniego ArgumentCaptor.getValue(). Według Mockito javadoc :

Jeśli metoda została wywołana wiele razy, wówczas zwraca ostatnią zarejestrowaną wartość

To by zadziałało (zakładając, że Fooma metodę getName()):

ArgumentCaptor<Foo> fooCaptor = ArgumentCaptor.forClass(Foo.class);
verify(mockBar, times(2)).doSomething(fooCaptor.capture());
//getValue() contains value set in second call to doSomething()
assertEquals("2nd one", fooCaptor.getValue().getName());

Możesz także użyć @Captor z komentarzem ArgumentCaptor. Na przykład:

@Mock
List<String> mockedList;

@Captor
ArgumentCaptor<String> argCaptor;

@BeforeTest
public void init() {
    //Initialize objects annotated with @Mock, @Captor and @Spy.
    MockitoAnnotations.initMocks(this);
}

@Test
public void shouldCallAddMethodTwice() {
    mockedList.add("one");
    mockedList.add("two");
    Mockito.verify(mockedList, times(2)).add(argCaptor.capture());

    assertEquals("one", argCaptor.getAllValues().get(0));
    assertEquals("two", argCaptor.getAllValues().get(1));
}

W lambdach Java 8 wygodnym sposobem jest użycie

org.mockito.invocation.InvocationOnMock

when(client.deleteByQuery(anyString(), anyString())).then(invocationOnMock -> {
    assertEquals("myCollection", invocationOnMock.getArgument(0));
    assertThat(invocationOnMock.getArgument(1), Matchers.startsWith("id:"));
}

Po pierwsze: zawsze powinieneś importować mockito static, w ten sposób kod będzie znacznie bardziej czytelny (i intuicyjny) - poniższe przykłady kodu wymagają jego działania:

import static org.mockito.Mockito.*;

W metodzie Verse () można przekazać ArgumentCaptor, aby zapewnić wykonanie testu, oraz ArgumentCaptor, aby ocenić argumenty:

ArgumentCaptor<MyExampleClass> argument = ArgumentCaptor.forClass(MyExampleClass.class);
verify(yourmock, atleast(2)).myMethod(argument.capture());

List<MyExampleClass> passedArguments = argument.getAllValues();

for (MyExampleClass data : passedArguments){
    //assertSometing ...
    System.out.println(data.getFoo());
}

Lista wszystkich przekazanych argumentów podczas testu jest dostępna za pomocą metody argument.getAllValues ​​().

Wartość pojedynczego (ostatnio wywoływanego) argumentu jest dostępna poprzez argument.getValue () w celu dalszej manipulacji / sprawdzania lub cokolwiek innego, co chcesz zrobić.