Oggetti beffardi

3.1 Metodo doReturn()

Ora arriva la magia...

Supponiamo che tu abbia creato un finto oggetto fittizio, ma ne hai bisogno per funzionare in qualche modo. Quando sono stati chiamati determinati metodi, è stato fatto qualcosa di importante oi metodi hanno restituito un determinato risultato. Cosa fare?

La libreria Mockito ti consente di aggiungere il comportamento desiderato a un oggetto fittizio.

Se vuoi che un oggetto mock restituisca un certo risultato quando viene chiamato un certo metodo, allora questa "regola" può essere aggiunta all'oggetto usando il codice:

Mockito.doReturn(result).when(an object).method name();

Vedete, alla fine della chiamata al metodo, method name?in realtà non c'è nessuna chiamata in corso qui. Il metodo doReturn()restituisce uno speciale oggetto proxy con l'aiuto del quale monitora le chiamate dei metodi dell'oggetto e, quindi, viene scritta la regola.

Ancora. È solo un modo così intelligente per scrivere una regola da aggiungere a un finto oggetto . Ci vuole una certa abilità per interpretare correttamente tale codice nella tua testa quando lo vedi. Arriva con l'esperienza.

Penso che sia necessario un esempio concreto. Creiamo un oggetto classe mock ArrayListe chiediamo al suo metodo size()di restituire il numero 10. Il codice completo sarà simile a questo:

@ExtendWith(MockitoExtension.class)
class DoReturnTest {
    @Mock
    List mockList;

    @Test
    public void whenMockAnnotation () {
         //create a rule: return 10 when calling the size method
        Mockito.doReturn(10).when(mockList).size();

        //the method is called here and will return 10!!
        assertEquals(10, mockList.size());
    }
}

Sì, questo codice funzionerà, il test non fallirà.

3.2 metodo when()

C'è un altro modo per aggiungere una regola di comportamento a un oggetto fittizio, chiamando il metodo Mockito.when(). Sembra così:

Mockito.when(an object.method name()).thenReturn(result);

Questo è lo stesso modo di scrivere una regola di comportamento dell'oggetto fittizio della precedente. Confrontare:

Mockito.doReturn(result).when(an object).method name();

Qui accade esattamente la stessa cosa: la costruzione di una nuova regola.

È vero, il primo esempio ha due svantaggi:

• la chiamata è molto confusa.an object.method name()
• non funzionerà se il metodo methodname()restituisce void.

Bene, scriviamo il nostro esempio preferito usandoMockito.when()

@ExtendWith(MockitoExtension.class)
class WhenTest {
    @Mock
    List mockList;

    @Test
    public void whenMockAnnotation() {
        //create a rule: return 10 when calling the size method
        Mockito.when(mockList.size() ).thenReturn(10);

        //the method is called here and will return 10!!
        assertEquals(10, mockList.size());
    }
}

3.3 Metodo doThrow()

Abbiamo capito come fare in modo che un metodo oggetto fittizio restituisca un risultato specifico. Come posso fare in modo che generi un'eccezione specifica? Inviarlo a doReturn()?

Per impedire la restituzione del metodo, ovvero la generazione di un'eccezione, è necessario impostare la regola utilizzando il metodo doThrow().

Mockito.doThrow(exception.class).when(an object).method name();

E poi la seconda opzione:

Mockito.when(an object.method name()).thenThrow(exception.class);

Un po' scontato, vero?

Bene, vedi, stai già iniziando a capire. Risolviamo con un esempio:

@ExtendWith(MockitoExtension.class)
class DoThrowTest {
    @Mock
    List mockList;

    @Test
    public void whenMockAnnotation() {
        Mockito.when(mockList.size() ).thenThrow(IllegalStateException.class);
        mockList.size(); //an exception will be thrown here
    }
}

Se devi lanciare un oggetto eccezione specifico, usa la costruzione del modulo:

Mockito.doThrow(new Exception()).when(an object).method name();

Basta passare doThrow()un oggetto eccezione al metodo e verrà lanciato durante la chiamata al metodo.