Afsløring af specifik adfærd i objekter

5.1 Verify() metoden

Udover at skabe virtuelle objekter, opstår der ofte en anden interessant opgave - at sikre, at klassen under test kalder de rigtige metoder til de rigtige objekter. Desuden ringede han det nødvendige antal gange med de korrekte parametre og lignende.

Til dette har Mockito også noget magi - en familie af metoder Mockito.verify(…). Den generelle regel, der specificerer metodekaldskontrol er:

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

Eksempel:

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

Under metodekaldet verify()sætter vi reglen om, at mockitoListmetoden med parameteren 10 skal kaldes på objektet get().

5.2 Verify()-metoden med kontrol af antallet af opkald

Nogle gange er der mere komplekse verifikationsscenarier. For eksempel skal du ikke bare kontrollere, at metoden blev kaldt, men for eksempel at den blev kaldt 3 gange. Eller det blev kaldt fra dig i en cyklus og burde derfor have heddet N gange.

Vi vil ikke spørge, om dette kan lade sig gøre, vi vil straks spørge: hvordan skriver man en sådan regel ned? Og igen, Mockito svigter os ikke. Reglen kan specificeres som:

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

Vigtig! Kvantitet er ikke en type int, men et særligt objekt, der kan definere forskellige mønstre. Kan du huske de forskellige versioner af metoden any()? Det er det samme her - der er specielle metoder, hvormed du kan indstille forskellige scenarier:

Eksempel:

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

Du kan også kræve, at der, bortset fra de angivne metodekald, ikke foretages andre referencer til objektet . Der er en regel for dette:

Mockito.verifyNoMoreInteractions(an object);

5.3 Metode kaldeordre

De tidligere regler regulerede ikke rækkefølgen af ​​opkaldsmetoder på nogen måde. Reglen skal bare opfyldes, og det er det. Men der er situationer, hvor rækkefølgen af ​​metodekald er vigtig, og Mockito har også en løsning på dette.

En streng rækkefølge af metodekald kan angives ved hjælp af et specielt objekt InOrder. Først skal du oprette det:

InOrder inOrder = Mockito.inOrder(an object);

Og føj derefter regler til det ved at kalde metoder verify().

Eksempel:

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 Kontrol af undtagelser i Mockito

At der er smidt undtagelser, tjekkes lidt anderledes. For at gøre dette skal du bruge metoden assertThrows(). Det generelle format for en sådan kontrol er:

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

Intet kompliceret.

Eksempel:

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