Usando o Mockito com várias chamadas para o mesmo método com os mesmos argumentos

Existe uma maneira de um método stubbed retornar objetos diferentes nas invocações subseqüentes? Eu gostaria de fazer isso para testar respostas não determinadas de um ExecutorCompletionService. isto é, para testar se, independentemente da ordem de retorno dos métodos, o resultado permanece constante.

O código que estou procurando testar é mais ou menos assim.

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

Você pode fazer isso usando o thenAnswermétodo (ao encadear com when):

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

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

        return 2;
    }
});

Ou usando o doAnswermétodo estático equivalente :

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

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

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

E se

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

Você pode colocar quantos argumentos quiser entre colchetes do Return, desde que sejam do tipo correto. O primeiro valor será retornado na primeira vez em que o método for chamado, na segunda resposta e assim por diante. O último valor será retornado repetidamente quando todos os outros valores forem usados.

Como apontado anteriormente, quase todas as chamadas são encadeadas.

Então você poderia ligar

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

Mais informações em Documenation de Mockito .

Você pode até encadear doReturn()invocações de métodos como esta

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

fofo não é :)

Eu implementei uma MultipleAnswerclasse que me ajuda a esboçar respostas diferentes em cada chamada. Aqui o trecho de código:

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

A seguir, pode ser usado como um método comum para retornar argumentos diferentes em diferentes chamadas de método. A única coisa que precisamos fazer é passar uma matriz com a ordem na qual os objetos devem ser recuperados em cada chamada.

@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);retornará o objeto mock1 na primeira chamada, o objeto mock3 na segunda chamada e o objeto mock2 na terceira chamada. Deve ser usado como when(something()).doAnswer(getAnswerForSubsequentCalls(mock1, mock3, mock2)); Este é quase semelhante aowhen(something()).thenReturn(mock1, mock3, mock2);

Relacionadas com @ [Igor Nikolaev] resposta 's a partir de 8 anos atrás, usando um Answerpode ser simplificado um pouco usando uma expressão lambda disponível em Java 8.

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

ou mais simplesmente:

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

Estilo BDD:

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

doReturn (valor1, valor2, valor3) .when (chamada de método)