Utilizzo di Mockito con più chiamate allo stesso metodo con gli stessi argomenti

C'è un modo per fare in modo che un metodo stubbing restituisca oggetti diversi nelle invocazioni successive? Mi piacerebbe fare questo per testare risposte non determinate da un ExecutorCompletionService. cioè per verificare che indipendentemente dall'ordine di ritorno dei metodi, il risultato rimane costante.

Il codice che sto cercando di testare assomiglia a questo.

// Create an completion service so we can group these tasks together
ExecutorCompletionService<T> completionService =
        new ExecutorCompletionService<T>(service);

// Add all these tasks to the completion service
for (Callable<T> t : ts)
    completionService.submit(request);

// As an when each call finished, add it to the response set.
for (int i = 0; i < calls.size(); i ++) {
    try {
        T t = completionService.take().get();
        // do some stuff that I want to test
    } catch (...) { }        
}

Puoi farlo usando il thenAnswermetodo (durante il concatenamento con when):

when(someMock.someMethod()).thenAnswer(new Answer() {
    private int count = 0;

    public Object answer(InvocationOnMock invocation) {
        if (count++ == 1)
            return 1;

        return 2;
    }
});

O usando il doAnswermetodo statico equivalente :

doAnswer(new Answer() {
    private int count = 0;

    public Object answer(InvocationOnMock invocation) {
        if (count++ == 1)
            return 1;

        return 2;
    }
}).when(someMock).someMethod();

Che ne dite di

when( method-call ).thenReturn( value1, value2, value3 );

Puoi inserire tutti gli argomenti che desideri tra parentesi di Ritorno, a condizione che siano tutti del tipo corretto. Il primo valore verrà restituito la prima volta che viene chiamato il metodo, quindi la seconda risposta e così via. L'ultimo valore verrà restituito ripetutamente una volta esauriti tutti gli altri valori.

Come precedentemente sottolineato, quasi tutte le chiamate sono concatenabili.

Quindi potresti chiamare

when(mock.method()).thenReturn(foo).thenReturn(bar).thenThrow(new Exception("test"));

//OR if you're mocking a void method and/or using spy instead of mock

doReturn(foo).doReturn(bar).doThrow(new Exception("Test").when(mock).method();

Maggiori informazioni nella documentazione di Mockito .

Puoi persino concatenare doReturn()invocazioni di metodi come questo

doReturn(null).doReturn(anotherInstance).when(mock).method();

carino non è vero :)

Ho implementato una MultipleAnswerclasse che mi aiuta a stub risposte diverse in ogni chiamata. Ecco il pezzo di codice:

private final class MultipleAnswer<T> implements Answer<T> {

    private final ArrayList<Answer<T>> mAnswers;

    MultipleAnswer(Answer<T>... answer) {
        mAnswers = new ArrayList<>();
        mAnswers.addAll(Arrays.asList(answer));
    }

    @Override
    public T answer(InvocationOnMock invocation) throws Throwable {
        return mAnswers.remove(0).answer(invocation);
    }
}

Di seguito può essere utilizzato come metodo comune per restituire argomenti diversi su chiamate a metodi diversi. L'unica cosa che dobbiamo fare è che dobbiamo passare un array con l'ordine in cui gli oggetti dovrebbero essere recuperati in ogni chiamata.

@SafeVarargs
public static <Mock> Answer<Mock> getAnswerForSubsequentCalls(final Mock... mockArr) {
    return new Answer<Mock>() {
       private int count=0, size=mockArr.length;
       public Mock answer(InvocationOnMock invocation) throws throwable {
           Mock mock = null;
           for(; count<size && mock==null; count++){
                mock = mockArr[count];
           }

           return mock;    
       } 
    }
}

Ex. getAnswerForSubsequentCalls(mock1, mock3, mock2);restituirà l'oggetto mock1 alla prima chiamata, l'oggetto mock3 alla seconda chiamata e l'oggetto mock2 alla terza chiamata. Dovrebbe essere usato come when(something()).doAnswer(getAnswerForSubsequentCalls(mock1, mock3, mock2)); Questo è quasi simile awhen(something()).thenReturn(mock1, mock3, mock2);

Relativo alla risposta di [[Igor Nikolaev] di 8 anni fa, l'uso di un Answerpuò essere in qualche modo semplificato usando un'espressione lambda disponibile in Java 8.

when(someMock.someMethod()).thenAnswer(invocation -> {
    doStuff();
    return;
});

o più semplicemente:

when(someMock.someMethod()).thenAnswer(invocation -> doStuff());

Stile BDD:

import static org.mockito.BDDMockito.*;
...
    @Test
    void submit() {
        given(yourMock.yourMethod()).willReturn(1, 2, 3);

doReturn (value1, value2, value3) .when (metodo-call)