¿Cómo verificar que se llame a un método de un objeto no simulado?

Parece que mockito solo verifica si se llama a un método de un objeto simulado y el objeto simulado siempre tiene algo como doReturn().when(mock object)

Pero, ¿puedo crear un objeto simulado y definir doReturn().when(mock object) y luego verificar que se llame a un método de otro objeto?

Esto es lo que quiero hacer: defino un entorno simulado y devuelvo una respuesta pase lo que pase. Pero luego quiero verificar diferentes métodos de otroObj se llama en diferentes casos.

¿Como hacer eso?

public class BaseClass {
    private Environment mockEnvironment;
    @Test
    public void testcase () {
     setMockitoEnvironment(); 
     response = foo(mockEnvironment, argument1);
     verify(anotherObj).codePath1(...);
     response = foo(mockEnvironment, argument2);
     verify(anotherObj).codePath2(...);
   }
}

//this method successfully return a response with any input 
//because I do not care how response is eventually generated, 
//I only care whether code path reaches createResponse() via 
//code path 1 or code path 2.
private void setMockitoEnvironment() {
    mockEnvironment = mock(Environment.class);
    doReturn (response).when(mockEnvironment).createResponse(for any input);
}
private Response foo(...) {
    ... 
    return createResponse(...);
}

Puedes usar un Mockito Spy para esto. Si configura anotherObjcomo espía, puede verificar las llamadas a métodos en ese objeto. En su ejemplo, debe asegurarse de que la llamada a fooutilice el espía en lugar de una implementación normal de anotherObj. El espía está configurado de esta manera:

AnotherClass anotherObjSpy = Mockito.spy(new AnotherClass());
// do stuff -- e.g. anotherObjSpy.foo(...);
verify(anotherObjSpy).codePath1(...);

Anote el objeto no simulado con una @Spyanotación y luego verifique verify(). Mira esto