Mockito - Diferencia entre doreturn () y When ()

Question

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 descubierto que los métodos doReturn(...).when(...) es equivalente 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.

Answer 1

Las dos sintaxis para los trozos son aproximadamente equivalentes. Sin embargo, puedes siempre usar doReturn/when por trozos; Pero hay casos en los que tu no poder usar when/thenReturn. Los métodos de vacío de trozo son uno de estos. Otros incluyen el uso con Spies Mockito y retirar el mismo método más de una vez.

Una cosa que when/thenReturn te da que doReturn/when No lo hace, es comprobación de tipo del valor que está devolviendo, en el momento de la compilación. Sin embargo, creo que esto es casi sin 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 uno lo hará.

Es posible que desee consultar mi respuesta en Formando Mockito "Gramáticas" - Una respuesta más detallada a una pregunta muy relacionada.

Answer 2

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(...) Hace una llamada de método real Justo antes de que se devuelva el valor especificado. Entonces, si el método llamado lanza una excepción, debe lidiar con él / burlarse, etc. Por supuesto, aún obtiene su resultado (lo que define en thenReturn(...))

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

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");

Answer 3

El Mockito Javadoc parece decir por qué usar doReturn() en vez de when()Use doreturn () en esas raras ocasiones en las que no puede usar Mockito. Cuando (objeto).

Tenga cuidado de que Mockito.When (Object) siempre se recomienda para retirarlo porque es de tipo argumento seguro y más legible (especialmente al retirar las llamadas consecutivas).

Aquí están esas raras ocasiones en que Doreturn () es útil:

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

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

// imposible: el método real se llama SO 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 parada de excepción anterior:

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

// imposible: el método foo () de excepción se llama para 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. Tenga en cuenta que los escenarios son muy raros. El espionaje debe ser esporádico y anular la parada de excepción es muy raro. Sin mencionar que, en general, anular el rastrojo es un olor a código potencial que señala demasiado.

Answer 4

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

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

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

Answer 5

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

Por favor, eche un vistazo, por ejemplo, aquí:Cómo hacer simulacros a los métodos nulo con maCkito