Mockito - Differenza tra Doreturn () e quando ()

Question

Attualmente sono in procinto di utilizzare Mockito per deridere i miei oggetti a livello di servizio in un'applicazione MVC Spring in cui voglio testare i miei metodi controller. Tuttavia, come ho letto sui dettagli di Mockito, ho scoperto che i metodi doReturn(...).when(...) è equivalente a when(...).thenReturn(...). Quindi, la mia domanda è qual è il punto di avere due metodi che fanno la stessa cosa o qual è la sottile differenza tra doReturn(...).when(...) e when(...).thenReturn(...)?

Qualsiasi aiuto sarebbe apprezzato.

Answer 1

Le due sintassi per lo stopbing sono approssimativamente equivalenti. Tuttavia, puoi sempre uso doReturn/when per lo stopbing; Ma ci sono casi in cui tu Non posso uso when/thenReturn. I metodi di vuoto di Stubing sono uno di questi. Altri includono l'uso con le spie mockito e lo stoping lo stesso metodo più di una volta.

Una cosa che when/thenReturn ti dà, quello doReturn/when Non è, è il controllo del valore del valore che stai restituendo, al momento della compilazione. Tuttavia, credo che questo abbia quasi nessun valore: se hai sbagliato il tipo, lo scoprirai non appena esegui il test.

Consiglio vivamente solo di usare doReturn/when. Non ha senso imparare due sintassi quando si fa.

Potresti voler fare riferimento alla mia risposta a Formare "grammatiche" di mockito - Una risposta più dettagliata a una domanda molto strettamente correlata.

Answer 2

Entrambi gli approcci si comportano in modo diverso se si utilizza un oggetto spia (annotato con @Spy) invece di un finto (annotato con @Mock):

• when(...) thenReturn(...) fa un vero metodo chiamata Poco prima che verrà restituito il valore specificato. Quindi, se il metodo chiamato lancia un'eccezione devi affrontarlo / deridere ecc. Naturalmente ottieni ancora il tuo risultato (cosa definisci thenReturn(...))

• doReturn(...) when(...) non chiama affatto il metodo.

Esempio:

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

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

Test:

@Spy
private MyClass myClass;

// ...

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

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

Answer 3

Il mockito javadoc sembra dire perché usare doReturn() invece di when()Usa Doreturn () in quelle rare occasioni in cui non è possibile usare mockito.When (oggetto).

Fai attenzione a quel mockito.When (oggetto) è sempre raccomandato per lo stopbing perché è un tipo di argomento-sicuro e più leggibile (specialmente quando si torreggia le chiamate consecutive).

Ecco quelle rare occasioni in cui Doreturn () è utile:

1. Quando spiaggio di oggetti reali e chiamano metodi reali su una spia porta effetti collaterali

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

// Impossible: il metodo reale è chiamato So Spy.get (0) lancia indexOutOfBoundSexception (l'elenco è ancora vuoto)

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

// Devi usare Doreturn () per lo stoping: doReturn("foo").when(spy).get(0);

2. Prepara una precedente eliminazione delle eccezioni:

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

// Impossible: il metodo FOO () di Exception-Stubbhed è chiamato So RuntimeException. when(mock.foo()).thenReturn("bar");

// Devi usare Doreturn () per lo stoping:

doReturn("bar").when(mock).foo(); Gli scenari sopra mostra un compromesso dell'elegante sintassi di Mockito. Si noti che gli scenari sono molto rari, però. Lo spionaggio dovrebbe essere sporadico e il ribaltamento delle eccezioni prevalente è molto raro. Per non parlare del fatto che in generale il superamento dello stuzzichino è un potenziale odore di codice che indica troppo lobding.

Answer 4

Continuando questa risposta, C'è un'altra differenza che se si desidera che il tuo metodo restituisca valori diversi, ad esempio quando si chiama per la prima volta, la seconda volta, allora puoi passare i valori, quindi ad esempio ...

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

Quindi restituirà falso quando il metodo viene chiamato nello stesso caso di test e quindi restituirà di nuovo falso e infine vero.

Answer 5

Quest'ultima alternativa viene utilizzata per i metodi su simulazioni che ritornano void.

Si prega di dare un'occhiata, ad esempio, qui:Come fare i metodi finti per annullare il mockito