java - examples - Usando Mockito con múltiples llamadas al mismo método con los mismos argumentos.

mockito examples in java

Question

¿Hay alguna manera de hacer que un método stub devuelva objetos diferentes en invocaciones posteriores? Me gustaría hacer esto para probar respuestas no determinadas de un ExecutorCompletionService . es decir, para probar que, independientemente del orden de devolución de los métodos, el resultado permanece constante.

El código que estoy buscando para probar se ve algo como esto.

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

Answer 1

Como se ha señalado anteriormente, casi todas las llamadas son posibles.

Para que puedas llamar

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

Más información en la Documenación de Mockito .

Answer 2

He implementado una clase MultipleAnswer que me ayuda a identificar diferentes respuestas en cada llamada. Aquí la pieza 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);
    }
}

Answer 3

Incluso puedes encadenar invocaciones de método doReturn() como esta

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

lindo no lo es :)

Answer 4

Puede hacerlo utilizando el método thenAnswer (cuando se encadena 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 el método equivalente, estático doAnswer :

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

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

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

Answer 5

Qué tal si

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

Puede poner tantos argumentos como desee en los corchetes de thenReturn, siempre que sean del tipo correcto. El primer valor se devolverá la primera vez que se llame al método, luego la segunda respuesta, y así sucesivamente. El último valor se devolverá repetidamente una vez que se hayan agotado todos los demás valores.

Answer 6

Se puede usar lo siguiente como un método común para devolver diferentes argumentos en diferentes llamadas a métodos. Lo único que debemos hacer es pasar una matriz con el orden en el que los objetos deben recuperarse en cada llamada.

@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); devolverá el objeto mock1 en la primera llamada, el objeto mock3 en la segunda llamada y el objeto mock2 en la tercera llamada. Se debe utilizar como when(something()).doAnswer(getAnswerForSubsequentCalls(mock1, mock3, mock2)); Esto es casi similar a when(something()).thenReturn(mock1, mock3, mock2);