¿Puede Mockito capturar argumentos de un método llamado varias veces?

Tengo un método que se llama dos veces y quiero capturar el argumento de la segunda llamada al método.

Esto es lo que he intentado:

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

Pero obtengo una TooManyActualInvocationsexcepción, ya que Mockito piensa que doSomethingsolo debería llamarse una vez.

¿Cómo puedo verificar el argumento de la segunda llamada de doSomething?

Creo que debería ser

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

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

Desde Mockito 2.0 también existe la posibilidad de utilizar el método estático Matchers.argThat (ArgumentMatcher) . Con la ayuda de Java 8, ahora es mucho más limpio y legible escribir:

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

Si está atado a una versión inferior de Java, también hay no tan malo:

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

Por supuesto, ninguno de ellos puede verificar el orden de las llamadas, para lo cual debe usar 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")));

Eche un vistazo al proyecto mockito-java8 que hace posible realizar llamadas como:

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

Si no desea validar todas las llamadas doSomething(), solo la última, puede usarlas ArgumentCaptor.getValue(). Según el Mockito javadoc :

Si el método se llamó varias veces, devuelve el último valor capturado

Entonces esto funcionaría (se supone que Footiene un método 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());

También puede usar @Captor anotado ArgumentCaptor. Por ejemplo:

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

Con las lambdas de Java 8, una forma conveniente es usar

org.mockito.invocation.InvocationOnMock

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

En primer lugar: siempre debe importar mockito static, de esta manera el código será mucho más legible (e intuitivo); los ejemplos de código a continuación requieren que funcione:

import static org.mockito.Mockito.*;

En el método verificar () puede pasar el ArgumentCaptor para asegurar la ejecución en la prueba y el ArgumentCaptor para evaluar los argumentos:

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

Se puede acceder a la lista de todos los argumentos pasados ​​durante su prueba a través del método argumento.getAllValues ​​().

Se puede acceder al valor del argumento único (último llamado) a través del argumento.getValue () para una mayor manipulación / verificación o lo que sea que desee hacer.