Dezvăluirea comportamentului specific în obiecte

5.1 Metoda verify().

Pe lângă crearea de obiecte virtuale, apare adesea o altă sarcină interesantă - să vă asigurați că clasa supusă testului apelează metodele corecte ale obiectelor potrivite. Mai mult, a sunat de numărul necesar de ori, cu parametrii corecti și altele asemenea.

Pentru aceasta, Mockito are și ceva magie - o familie de metode Mockito.verify(…). Regula generală care specifică verificarea apelului de metodă este:

Mockito.verify(an object).method name(parameter);

Exemplu:

@ExtendWith(MockitoExtension.class)
class VerifyTest {
    @Mock
    List<String> mockList;

    @Test
    public void whenMockAnnotation() {
        //method call
        String name = mockList.get(10);

        // check if the method was called
        Mockito.verify(mockList).get(10);
    }
}

În timpul apelului de metodă, verify()setăm regula ca mockitoListmetoda cu parametrul 10 să fie apelată pe obiect get().

5.2 Metoda verify() cu verificarea numărului de apeluri

Uneori există scenarii de verificare mai complexe. De exemplu, trebuie să verificați nu doar faptul că metoda a fost apelată, ci, de exemplu, că a fost apelată de 3 ori. Sau a fost numit de la tine într-un ciclu și, prin urmare, ar fi trebuit să fie numit de N ori.

Nu vom întreba dacă acest lucru se poate face, ne vom întreba imediat: cum să scrieți o astfel de regulă? Și din nou, Mockito nu ne dezamăgește. Regula poate fi specificată astfel:

Mockito.verify(an object,quantity).method name(parameter);

Important! Cantitatea nu este un tip int, ci un obiect special care poate defini diferite modele. Vă amintiți diferitele versiuni ale metodei any()? La fel este și aici - există metode speciale cu care puteți seta diverse scenarii:

Exemplu:

String name1 = mockList.get(1);  //method call
String name2 = mockList.get(2);  //method call
String name3 = mockList.get(3);  //method call

//check that the get() method was called 3 times
Mockito.verify(mockList, times(3)).get(anyInt());

De asemenea, puteți solicita ca, în afară de invocările de metodă specificate, să nu fie făcute alte referințe la obiect . Există o regulă pentru asta:

Mockito.verifyNoMoreInteractions(an object);

5.3 Metoda comenzii apelului

Regulile anterioare nu reglementau în niciun fel ordinea metodelor de apelare. Regula trebuie doar îndeplinită și atât. Dar există situații în care ordinea apelurilor de metodă este importantă, iar Mockito are o soluție și pentru asta.

O ordine strictă a apelurilor de metodă poate fi specificată folosind un obiect special InOrder. Mai întâi trebuie să-l creați:

InOrder inOrder = Mockito.inOrder(an object);

Și apoi adăugați reguli prin apelarea metodelor verify().

Exemplu:

    List<String> mockedList = mock(MyList.class);
    mockedList.size();
    mockedList.add("a parameter");
    mockedList.clear();
 
    InOrder inOrder = Mockito.inOrder(mockedList);
    inOrder.verify(mockedList).size();
    inOrder.verify(mockedList).add("a parameter");
    inOrder.verify(mockedList).clear();

5.4 Verificarea excepțiilor în Mockito

Faptul că au fost aruncate excepții este verificat puțin diferit. Pentru a face acest lucru, utilizați metoda assertThrows(). Formatul general pentru o astfel de verificare este:

Assertions.assertThrows(exception.class, () -> an object.methodname());

Nimic complicat.

Exemplu:

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

    @Test
    public void whenMockAnnotation() {
        //set the behavior of the method (needed for demonstration purposes only)
        Mockito.when(mockList.size()).thenThrow(IllegalStateException.class);

        //check if an IllegalStateException will be thrown when calling the size method
        assertThrows(IllegalStateException.class, () -> mockList.size());
    }
}