Verwenden von Mockito mit mehreren Aufrufen derselben Methode mit denselben Argumenten

Gibt es eine Möglichkeit, dass eine Stubbed-Methode bei nachfolgenden Aufrufen unterschiedliche Objekte zurückgibt? Ich möchte dies tun, um unbestimmte Antworten von einem zu testen ExecutorCompletionService. dh um zu testen, dass unabhängig von der Rückgabereihenfolge der Methoden das Ergebnis konstant bleibt.

Der Code, den ich testen möchte, sieht ungefähr so ​​aus.

// 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 (...) { }        
}

Sie können dies mit der folgenden thenAnswerMethode tun (beim Verketten mit when):

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

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

        return 2;
    }
});

Oder verwenden Sie die entsprechende statische doAnswerMethode:

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

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

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

Wie wäre es mit

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

Sie können so viele Argumente in die Klammern von thenReturn setzen, wie Sie möchten, vorausgesetzt, sie haben alle den richtigen Typ. Der erste Wert wird beim ersten Aufruf der Methode zurückgegeben, dann die zweite Antwort usw. Der letzte Wert wird wiederholt zurückgegeben, sobald alle anderen Werte aufgebraucht sind.

Wie bereits erwähnt, sind fast alle Anrufe verkettbar.

Sie könnten also anrufen

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

Weitere Informationen in Mockitos Dokumentation .

Sie können sogar doReturn()Methodenaufrufe wie diese verketten

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

süß ist es nicht :)

Ich habe eine MultipleAnswerKlasse implementiert , die mir hilft, bei jedem Anruf unterschiedliche Antworten zu finden. Hier der Code:

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

Das Folgende kann als gemeinsame Methode verwendet werden, um verschiedene Argumente bei verschiedenen Methodenaufrufen zurückzugeben. Wir müssen nur ein Array mit der Reihenfolge übergeben, in der Objekte bei jedem Aufruf abgerufen werden sollen.

@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);gibt beim ersten Aufruf das Objekt mock1, beim zweiten Aufruf das Objekt mock3 und beim dritten Aufruf das Objekt mock2 zurück. Sollte wie when(something()).doAnswer(getAnswerForSubsequentCalls(mock1, mock3, mock2)); folgt verwendet werden. Dies ist fast ähnlich zuwhen(something()).thenReturn(mock1, mock3, mock2);

Im Zusammenhang mit der Antwort von @ [Igor Nikolaev] vor 8 Jahren Answerkann die Verwendung von a mithilfe eines in Java 8 verfügbaren Lambda-Ausdrucks etwas vereinfacht werden .

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

oder einfacher:

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

BDD-Stil:

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

doReturn (Wert1, Wert2, Wert3) .when (Methodenaufruf)