¿Cómo decirle a un objeto simulado Mockito que devuelva algo diferente la próxima vez que se llame?

Por lo tanto, estoy creando un objeto simulado como una variable estática en el nivel de la clase de esta manera ... En una prueba, quiero Foo.someMethod()devolver un cierto valor, mientras que en otra prueba, quiero que devuelva un valor diferente. El problema que tengo es que parece que necesito reconstruir los simulacros para que esto funcione correctamente. Me gustaría evitar reconstruir los simulacros y usar los mismos objetos en cada prueba.

class TestClass {

    private static Foo mockFoo;

    @BeforeClass
    public static void setUp() {
        mockFoo = mock(Foo.class);
    }

    @Test
    public void test1() {
        when(mockFoo.someMethod()).thenReturn(0);

        TestObject testObj = new TestObject(mockFoo);

        testObj.bar(); // calls mockFoo.someMethod(), receiving 0 as the value

    }

    @Test
    public void test2() {
        when(mockFoo.someMethod()).thenReturn(1);

        TestObject testObj = new TestObject(mockFoo);

        testObj.bar(); // calls mockFoo.someMethod(), STILL receiving 0 as the value, instead of expected 1.

    }

}

En la segunda prueba, sigo recibiendo 0 como valor cuando se llama a testObj.bar () ... ¿Cuál es la mejor manera de resolver esto? Tenga en cuenta que sé que podría usar un simulacro diferente Fooen cada prueba, sin embargo, tengo que encadenar varias solicitudes mockFoo, lo que significa que tendría que encadenar en cada prueba.

En primer lugar, no hagas que el simulacro sea estático. Que sea un campo privado. Simplemente ponga su clase de configuración en el @Beforeno @BeforeClass. Se puede ejecutar un montón, pero es barato.

En segundo lugar, la forma en que lo tiene ahora es la forma correcta de obtener un simulacro para devolver algo diferente dependiendo de la prueba.

También puede Stub Llamadas consecutivas (# 10 en 2.8.9 api). En este caso, usaría múltiples llamadas de devolución o una llamada de devolución con múltiples parámetros (varargs).

import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import org.junit.Before;
import org.junit.Test;

public class TestClass {

    private Foo mockFoo;

    @Before
    public void setup() {
        setupFoo();
    }

    @Test
    public void testFoo() {
        TestObject testObj = new TestObject(mockFoo);

        assertEquals(0, testObj.bar());
        assertEquals(1, testObj.bar());
        assertEquals(-1, testObj.bar());
        assertEquals(-1, testObj.bar());
    }

    private void setupFoo() {
        mockFoo = mock(Foo.class);

        when(mockFoo.someMethod())
            .thenReturn(0)
            .thenReturn(1)
            .thenReturn(-1); //any subsequent call will return -1

        // Or a bit shorter with varargs:
        when(mockFoo.someMethod())
            .thenReturn(0, 1, -1); //any subsequent call will return -1
    }
}

Para todos los que buscan devolver algo y luego otra excepción de lanzamiento de llamada:

    when(mockFoo.someMethod())
            .thenReturn(obj1)
            .thenReturn(obj2)
            .thenThrow(new RuntimeException("Fail"));

o

    when(mockFoo.someMethod())
            .thenReturn(obj1, obj2)
            .thenThrow(new RuntimeException("Fail"));

O, incluso más limpio:

when(mockFoo.someMethod()).thenReturn(obj1, obj2);

Para cualquier persona que use spy () y doReturn () en lugar del método when ():

lo que necesita para devolver un objeto diferente en diferentes llamadas es esto:

doReturn(obj1).doReturn(obj2).when(this.spyFoo).someMethod();

.

Para simulacros clásicos:

when(this.mockFoo.someMethod()).thenReturn(obj1, obj2);

o con una excepción lanzada:

when(mockFoo.someMethod())
        .thenReturn(obj1)
        .thenThrow(new IllegalArgumentException())
        .thenReturn(obj2, obj3);