Kann Mockito Argumente einer mehrfach aufgerufenen Methode erfassen?

Ich habe eine Methode, die zweimal aufgerufen wird, und ich möchte das Argument des zweiten Methodenaufrufs erfassen.

Folgendes habe ich versucht:

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

Aber ich bekomme eine TooManyActualInvocationsAusnahme, da Mockito meint, dass doSomethingdas nur einmal aufgerufen werden sollte.

Wie kann ich das Argument des zweiten Aufrufs von überprüfen doSomething?

Ich denke es sollte sein

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

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

Seit Mockito 2.0 besteht auch die Möglichkeit, die statische Methode Matchers.argThat (ArgumentMatcher) zu verwenden . Mit Hilfe von Java 8 ist es jetzt viel sauberer und lesbarer zu schreiben:

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

Wenn Sie an eine niedrigere Java-Version gebunden sind, gibt es auch nichts Schlimmes:

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

Natürlich kann keiner von diesen die Reihenfolge der Anrufe überprüfen - für die Sie InOrder verwenden sollten :

InOrder inOrder = inOrder(mockBar);

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

Bitte werfen Sie einen Blick auf das mockito-java8- Projekt, mit dem Sie Anrufe tätigen können wie:

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

Wenn Sie nicht alle Anrufe überprüfen möchten doSomething(), können Sie nur den letzten verwenden ArgumentCaptor.getValue(). Laut dem Mockito Javadoc :

Wenn die Methode mehrmals aufgerufen wurde, wird der zuletzt erfasste Wert zurückgegeben

Das würde also funktionieren (setzt Fooeine Methode voraus 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());

Sie können auch @Captor annotated ArgumentCaptor verwenden. Zum Beispiel:

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

Mit den Lambdas von Java 8 ist die Verwendung bequem

org.mockito.invocation.InvocationOnMock

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

Zuallererst: Sie sollten immer mockito static importieren, damit der Code viel besser lesbar (und intuitiv) ist - die folgenden Codebeispiele erfordern, dass er funktioniert:

import static org.mockito.Mockito.*;

In der verify () -Methode können Sie den ArgumentCaptor übergeben, um die Ausführung im Test sicherzustellen, und den ArgumentCaptor, um die Argumente auszuwerten:

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

Auf die Liste aller während Ihres Tests übergebenen Argumente kann über die argument.getAllValues ​​() -Methode zugegriffen werden.

Auf den Wert des einzelnen (zuletzt aufgerufenen) Arguments kann über argument.getValue () zugegriffen werden, um weitere Manipulationen / Überprüfungen vorzunehmen oder was auch immer Sie tun möchten.