Início / coding / Perguntas / 79554436
Accepted
Kate
Asked: 2025-04-04 12:04:44 +0800 CST

Tentando adicionar stubs em um loop e obtendo uma exceção Mockito: Uso incorreto da API detectado aqui

  • 772

Estou usando o Mockito para criar testes unitários para Java, mas encontrei um problema estranho

Digamos que eu tenha um ObjectUnderTestcom um mainMethode uma dependência Dependencysimulada, com um método mockedMethod:

class ObjectUnderTest {
    private Dependency dependency;

    public mainMethod() {
        // some logic...
        // now calling the `mockedMethod` with some retry config
        // this is pseudocode but you get it
        retryOn(RETRY_TIMES, SOME_INTERVAL,
          () -> dependency.mockedMethod("mockedValue") != null, // do this each retry and returns when dependency returns non-null
          () -> new SomeException("kaboom") // throw some exception after retry exhausted
        );
        // some other logic...
    }
}


class MyTestClass {
    // say Dependency has a method 
    // public ReturnValueDep mockedMethod(String)
    private Dependency mockedDep;

    private ObjectUnderTest testObj;

    @BeforeEach
    public void setUp() {
        // set up mocks...
        this.testObj = new ObjectUnderTest(mockedDep, // other params...
        );
    }

    @Test
    public void thisTestFailed() {
        final OngoingStubbing<ReturnValueDep> stubbing = lenient().when(mockedDep.mockedMethod(eq("mockedValue")));
        IntStream.rangeClosed(0, RETRY_TIMES).forEach((int i) -> stubbing.thenReturn(null));
        stubbing.thenReturn(SOME_NON_NULL_VALUE);

        assertThrows(SomeException.class, () -> testObj.mainMethod());
    }
}

No entanto, estou recebendo um erro do Mockito como este:

=> org.mockito.exceptions.base.MockitoException: 
     [java] Incorrect use of API detected here:
     [java] -> at xxxxxx (redacted)
     [java] You probably stored a reference to OngoingStubbing returned by when() and called stubbing methods like thenReturn() on this reference more than once.
     [java] Examples of correct usage:
     [java]     when(mock.isOk()).thenReturn(true).thenReturn(false).thenThrow(exception);
     [java]     when(mock.isOk()).thenReturn(true, false).thenThrow(exception);

Alguma ideia de por que isso não é permitido? Isso é tão estranho.

Adicionar lenient()a ele não resolve o erro. Parece que não pode ser contornado.

java

2 respostas

  1. Best Answer

    A mensagem de erro é bem clara sobre o problema: você não pode chamar .thenReturna mesma OngoingStubbinginstância várias vezes. Então isso é proibido:

    final OngoingStubbing<ReturnValueDep> stubbing = when(mockedDep.mockedMethod("mockedValue"));
stubbing.thenReturn(null);
stubbing.thenReturn(null);
stubbing.thenReturn(SOME_NON_NULL_VALUE);

    Cada .thenReturnchamada retorna uma nova OngoingStubbinginstância, que você pode usar para encadear as chamadas stub. Isso funciona sem problemas:

    final OngoingStubbing<ReturnValueDep> stubbing = when(mockedDep.mockedMethod("mockedValue"));
stubbing.thenReturn(null)
        .thenReturn(null)
        .thenReturn(SOME_NON_NULL_VALUE);

    Com um loop simples e uma variável não final, isso é trivial de escrever – basta reatribuir a stubbingvariável:

    OngoingStubbing<ReturnValueDep> stubbing = .when(mockedDep.mockedMethod("mockedValue"));
for (int i = 0; i <= RETRY_TIMES; ++i) {
  stubbing = stubbing.thenReturn(null);
}
stubbing.thenReturn(SOME_NON_NULL_VALUE);

    Se você precisar usar um fluxo, os redutores serão úteis:

    OngoingStubbing<ReturnValueDep> stubbing = when(mockedDep.mockedMethod(eq("mockedValue")));
IntStream.rangeClosed(0, RETRY_TIMES)
    .reduce(
        when(mockedDep.mockedMethod("mockedValue")),
        (stubbing, i) -> stubbing.thenReturn(null))
    .thenReturn(SOME_NON_NULL_VALUE);
    • 1

  2. Parece que você já tem uma solução na descrição do erro: você não deve manter uma referência a um objeto simulado e aplicar thenRteturnem um loop. Em vez disso, você deve aplicar multiple thenReturna uma when()cláusula ou aplicar thenReturnuma vez, mas com múltiplos argumentos.

    Aqui está um exemplo:

    class ObjectUnderTest {
    private static final int RETRY_TIMES = 5;
    private Dependency dependency;

    public ObjectUnderTest(Dependency dependency) {
        this.dependency = dependency;
    }

    public void mainMethod() {
        for (int i = 0; i < RETRY_TIMES; i++) {
            System.out.println(String.format("Retry %s, result: %s", i, dependency.mockedMethod("mockedValue")));
        }
    }
}

class Dependency {
    public Integer mockedMethod(String arg) {
        return null;
    }
}


class MyTestClass {
    private Dependency mockedDep = mock(Dependency.class);

    private ObjectUnderTest testObj = new ObjectUnderTest(mockedDep);

    @Test
    public void thisTestFailed() {
        // one `thenReturn` with multiple values
        when(mockedDep.mockedMethod("mockedValue")).thenReturn(null, null, null, null, 1);
        testObj.mainMethod();

        // multiple `thenReturn` with different values. In such case you could check complex scenario, for example with throwing exceptions(not even for the last method call, maybe for testing exception handling and retries). 
        when(mockedDep.mockedMethod("mockedValue"))
                .thenReturn(null)
                .thenReturn(null)
                .thenReturn(null)
                .thenReturn(null)
                .thenThrow(RuntimeException.class);
        testObj.mainMethod();
    }
}
    • 0

relate perguntas