Mockito: diferencia entre doReturn () y when ()

Actualmente estoy en el proceso de usar Mockito para simular mis objetos de capa de servicio en una aplicación Spring MVC en la que quiero probar mis métodos de controlador. Sin embargo, como he estado leyendo sobre los detalles de Mockito, he encontrado que los métodos doReturn(...).when(...)son equivalentes a when(...).thenReturn(...). Entonces, mi pregunta es ¿cuál es el punto de tener dos métodos que hacen lo mismo o cuál es la sutil diferencia entre doReturn(...).when(...)y when(...).thenReturn(...)?

Cualquier ayuda sería apreciada.

Las dos sintaxis para el apilamiento son aproximadamente equivalentes. Sin embargo, siempre se puede usar doReturn/whenpara tropezar; pero hay casos en los que no puedes usar when/thenReturn. Stubbing métodos vacíos es uno de esos. Otros incluyen el uso con espías Mockito y tropezar con el mismo método más de una vez.

Una cosa que when/thenReturnle da, que doReturn/whenno lo hace, es la verificación de tipo del valor que está devolviendo, en el momento de la compilación. Sin embargo, creo que esto casi no tiene valor: si tiene el tipo incorrecto, lo descubrirá tan pronto como ejecute su prueba.

Recomiendo encarecidamente solo usar doReturn/when. No tiene sentido aprender dos sintaxis cuando una lo hará.

Es posible que desee consultar mi respuesta en Forming Mockito "gramáticas" , una respuesta más detallada a una pregunta muy relacionada.

Ambos enfoques se comportan de manera diferente si usa un objeto espiado (anotado con @Spy) en lugar de un simulacro (anotado con @Mock):

• when(...) thenReturn(...) realiza una llamada de método real justo antes de que se devuelva el valor especificado. Entonces, si el método llamado arroja una Excepción, debe lidiar con ella / burlarse, etc. Por supuesto, aún obtiene su resultado (lo que define thenReturn(...))

• doReturn(...) when(...) no llama al método en absoluto .

Ejemplo:

public class MyClass {
     protected String methodToBeTested() {
           return anotherMethodInClass();
     }

     protected String anotherMethodInClass() {
          throw new NullPointerException();
     }
}

Prueba:

@Spy
private MyClass myClass;

// ...

// would work fine
doReturn("test").when(myClass).anotherMethodInClass();

// would throw a NullPointerException
when(myClass.anotherMethodInClass()).thenReturn("test");

Mockito javadoc parece decir por qué usar en doReturn()lugar de when() Use doReturn () en esas raras ocasiones en las que no puedes usar Mockito.when (Object).

Tenga en cuenta que Mockito.when (Object) siempre se recomienda para el apilamiento porque es seguro para el tipo de argumento y más legible (especialmente cuando se topan llamadas consecutivas).

Estas son esas raras ocasiones en que doReturn () es útil:

1. Cuando espiar objetos reales y llamar métodos reales a un espía trae efectos secundarios

List list = new LinkedList(); List spy = spy(list);

// Imposible: el método real se llama así que spy.get (0) arroja IndexOutOfBoundsException (la lista aún está vacía)

when(spy.get(0)).thenReturn("foo");

// Tienes que usar doReturn () para stubbing: doReturn("foo").when(spy).get(0);

2. Anulación de una excepción anterior:

when(mock.foo()).thenThrow(new RuntimeException());

// Imposible: el método foo () con excepción se llama así que se lanza RuntimeException. when(mock.foo()).thenReturn("bar");

// Tienes que usar doReturn () para stubbing:

doReturn("bar").when(mock).foo(); Los escenarios anteriores muestran una compensación de la elegante sintaxis de Mockito. Sin embargo, tenga en cuenta que los escenarios son muy raros. El espionaje debe ser esporádico y anular las excepciones es muy raro. Sin mencionar que, en general, anular el apisonamiento es un posible olor a código que señala demasiado apisonamiento.

Continuando con esta respuesta , existe otra diferencia de que si desea que su método devuelva diferentes valores, por ejemplo, cuando se llama por primera vez, se llama por segunda vez, etc., puede pasar valores, por ejemplo ...

PowerMockito.doReturn(false, false, true).when(SomeClass.class, "SomeMethod", Matchers.any(SomeClass.class));

Por lo tanto, devolverá falso cuando se llame al método en el mismo caso de prueba y luego devolverá falso nuevamente y, por último, verdadero.

La última alternativa se usa para métodos en simulacros que regresan void.

Eche un vistazo, por ejemplo, aquí: Cómo hacer métodos simulados para anular con mockito