Como dizer a um objeto simulado do Mockito para retornar algo diferente da próxima vez que for chamado?

Então, eu estou criando um objeto simulado como uma variável estática no nível da classe ... Assim, em um teste, quero Foo.someMethod()retornar um determinado valor, enquanto em outro teste, quero que ele retorne um valor diferente. O problema que estou tendo é que parece que preciso reconstruir as zombarias para que isso funcione corretamente. Gostaria de evitar a reconstrução das zombarias e apenas usar os mesmos objetos em cada teste.

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.

    }

}

No segundo teste, ainda estou recebendo 0 como o valor quando testObj.bar () é chamado ... Qual é a melhor maneira de resolver isso? Observe que eu sei que eu poderia usar uma simulação diferente Fooem cada teste; no entanto, eu tenho que encadear várias solicitações mockFoo, o que significa que eu teria que fazer o encadeamento em cada teste.

Antes de tudo, não torne a simulação estática. Torne-o um campo privado. Basta colocar sua classe setUp no @Beforenot @BeforeClass. Pode ser um monte, mas é barato.

Em segundo lugar, o jeito que você tem agora é a maneira correta de fazer com que uma simulação retorne algo diferente, dependendo do teste.

Você também pode Stub de chamadas consecutivas (nº 10 em 2.8.9 api). Nesse caso, você usaria várias chamadas thenReturn ou uma chamada thenReturn com vários 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 que procuram retornar algo e depois para outra chamada, lance a exceção:

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

ou

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

Ou ainda mais limpo:

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

Para qualquer pessoa que use o spy () e o doReturn () em vez do método when ():

o que você precisa para retornar objetos diferentes em chamadas diferentes é o seguinte:

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

.

Para zombarias clássicas:

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

ou com uma exceção sendo lançada:

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