Batjocorirea obiectelor

3.1 Metoda doReturn().

Acum vine magia...

Să presupunem că ați creat un obiect simulat fals, dar aveți nevoie de el să funcționeze cumva. Când au fost apelate anumite metode, s-a făcut ceva important sau metodele au returnat un anumit rezultat. Ce să fac?

Biblioteca Mockito vă permite să adăugați comportamentul dorit unui obiect simulat.

Dacă doriți ca un obiect simulat să returneze un anumit rezultat atunci când este apelată o anumită metodă, atunci această „regulă” poate fi adăugată la obiect folosind codul:

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

Vedeți, la sfârșitul apelului de metodă, method name?de fapt nu există niciun apel aici. Metoda doReturn()returnează un proxy-obiect special cu ajutorul căruia monitorizează apelurile metodelor obiectului și, astfel, se scrie regula.

Din nou. Este o modalitate atât de inteligentă de a scrie o regulă pe care să o adăugați la un obiect simulat . Este nevoie de o anumită abilitate pentru a interpreta corect un astfel de cod în capul tău când îl vezi. Vine cu experienta.

Cred că este nevoie de un exemplu concret. Să creăm un obiect de clasă simulată ArrayListși să cerem metodei acestuia size()să returneze numărul 10. Codul complet va arăta astfel:

@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());
    }
}

Da, acest cod va funcționa, testul nu va eșua.

3.2 metoda când().

Există o altă modalitate de a adăuga o regulă de comportament la un obiect simulat - prin apelarea Mockito.when(). Arata cam asa:

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

Acesta este același mod de a scrie o regulă de comportament a obiectului simulat ca și cea anterioară. Comparaţie:

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

Aici se întâmplă exact același lucru - construirea unei noi reguli.

Adevărat, primul exemplu are două minusuri:

• apelul este foarte confuz.an object.method name()
• nu va funcționa dacă metoda methodname()revine void.

Ei bine, să scriem exemplul nostru preferat folosindMockito.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 Metoda doThrow().

Ne-am dat seama cum să facem ca o metodă de obiect simulat să returneze un rezultat specific. Cum pot face ca acesta să arunce o anumită excepție? Trimite-l la doReturn()?

Pentru a preveni revenirea metodei, și anume aruncarea unei excepții, trebuie să setați regula folosind doThrow().

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

Și apoi a doua opțiune:

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

Puțin așteptat, nu?

Ei bine, vezi tu, începi deja să înțelegi. Să o reparăm cu un exemplu:

@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
    }
}

Dacă trebuie să aruncați un anumit obiect excepție, atunci utilizați construcția formularului:

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

Doar treceți doThrow()un obiect excepție metodei și acesta va fi aruncat în timpul apelului de metodă.