Mockito peut-il capturer les arguments d'une méthode appelée plusieurs fois?

J'ai une méthode qui est appelée deux fois et je veux capturer l'argument du deuxième appel de méthode.

Voici ce que j'ai essayé:

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

Mais je reçois une TooManyActualInvocationsexception, car Mockito pense que cela doSomethingne devrait être appelé qu'une seule fois.

Comment puis-je vérifier l'argument du deuxième appel de doSomething?

Je pense que ça devrait être

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

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

Depuis Mockito 2.0, il est également possible d'utiliser la méthode statique Matchers.argThat (ArgumentMatcher) . Avec l'aide de Java 8, il est maintenant beaucoup plus propre et plus lisible d'écrire:

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

Si vous êtes lié à une version Java inférieure, il n'y a pas non plus si mal:

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

Bien sûr, aucun de ceux-ci ne peut vérifier l'ordre des appels - pour lequel vous devez utiliser 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")));

Veuillez jeter un œil au projet mockito-java8 qui permet de faire des appels tels que:

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

Si vous ne souhaitez pas valider tous les appels doSomething(), uniquement le dernier, vous pouvez simplement utiliser ArgumentCaptor.getValue(). Selon le javadoc Mockito :

Si la méthode a été appelée plusieurs fois, elle renvoie la dernière valeur capturée

Donc, cela fonctionnerait (suppose Fooune méthode 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());

Vous pouvez également utiliser ArgumentCaptor annoté @Captor. Par exemple:

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

Avec les lambdas de Java 8, un moyen pratique consiste à utiliser

org.mockito.invocation.InvocationOnMock

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

Tout d'abord: vous devez toujours importer mockito static, de cette façon le code sera beaucoup plus lisible (et intuitif) - les exemples de code ci-dessous nécessitent qu'il fonctionne:

import static org.mockito.Mockito.*;

Dans la méthode verify (), vous pouvez passer ArgumentCaptor pour assurer l'exécution dans le test et ArgumentCaptor pour évaluer les arguments:

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

La liste de tous les arguments passés pendant votre test est accessible via la méthode argument.getAllValues ​​().

La valeur de l'argument unique (dernier appelé) est accessible via l'argument.getValue () pour une manipulation / vérification supplémentaire ou tout ce que vous souhaitez faire.