Mockito: attendre une invocation qui correspond aux arguments

Je suis en train d'écrire une sélénium tester et de vérifier le comportement de serveur avec mockito. Plus précisément, lorsque l'on clique sur un bouton, je veux assurez-vous que le contrôleur de la page appelle une méthode sur une dépendance dont je me suis moqué.

Parce que c'est une sélénium test, j'ai besoin d'attendre la maquette doit être invoquée dans un autre thread, donc je suis en utilisant mockito délai d'attente.

verify(myMock, timeout(5000).times(1)).myMethod("expectedArg");

Le problème que je rencontre est que myMethod est appelé à de nombreuses reprises... plutôt que d'attendre une invocation qui correspond à la arguments attendus, le délai d'attente n'attend pour la première invocation.
Si j'utilise du Fil.sommeil(50000) plutôt que de délai d'attente(50000), il fonctionne comme prévu... mais c'est sale, donc je suis en espérant éviter.

Comment dois-je attendre pour myMethod être invoquée à l'entrée?

source d'informationauteur Bryan Hart

  1. 11

    Si vous êtes en mesure de définir un nombre fixe d'appels à attendre, il peut être fait avec un ArgumentCaptor:

    import static org.hamcrest.CoreMatchers.hasItem;

@Captor ArgumentCaptor<String> arg;

@Before
public void setUp() throws Exception {
    //init the @Captor
    initMocks(this);
}

@Test
public void testWithTimeoutCallOrderDoesntMatter() throws Exception {
    //there must be exactly 99 calls
    verify(myMock, timeout(5000).times(99)).myMethod(arg.capture());
    assertThat(arg.getAllValues(), hasItem("expectedArg"));
}

    Une autre façon est de spécifier toutes les valeurs attendues pour vérifier, mais ceux qui doivent être fournis dans l'ordre exact qu'ils sont invoqués. La différence de la solution ci-dessus est que ce n'est pas l'échec, même si la maquette est en outre appelé à certains non-vérifié arguments. En d'autres termes, pas besoin de connaître le nombre total d'appels. Exemple de Code:

    @Test
public void testWithTimeoutFollowingCallsDoNotMatter() throws Exception {
    //the order until expected arg is specific
    verify(callback, timeout(5000)).call("firstExpectedArg");
    verify(callback, timeout(5000)).call("expectedArg");
    //no need to tell more, if additional calls come after the expected arg
    //verify(callback, timeout(5000)).call("randomArg");
}
  2. 11

    Ce n'est pas une super solution propre, mais vous pouvez le faire (XX est censé type de retour ici):

    final CountDownLatch latch = new CountDownLatch(1);

doReturn(new Answer<XX>()
    {
        @Override
        public XX answer(InvocationOnMock invocation)
        {
            latch.countDown();
            return someInstanceOfXX;
        }
    }
).when(myMock).myMethod("expectedArg");

    Ensuite, pour tester si la méthode est appelée, ne:

    try {
    assertTrue(latch.await(5L, TimeUnit.SECONDS));
} catch (InterruptedException e) {
    //Urgh... Failed. Deal with it and:
    Thread.currentThread.interrupt();
}