Avsløre spesifikk atferd i objekter

5.1 Verify()-metoden

I tillegg til å lage virtuelle objekter, dukker det ofte opp en annen interessant oppgave - å sørge for at klassen som testes kaller de riktige metodene til de riktige objektene. Dessuten ringte han det nødvendige antall ganger, med riktige parametere og lignende.

For dette har Mockito også litt magi - en familie av metoder Mockito.verify(…). Den generelle regelen som spesifiserer metodeanropskontroll 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 metodekallet verify()setter vi regelen om at mockitoListmetoden med parameteren 10 skal kalles på objektet get().

5.2 Verify()-metoden med kontroll av antall anrop

Noen ganger er det mer komplekse verifiseringsscenarier. For eksempel må du sjekke ikke bare det faktum at metoden ble kalt, men for eksempel at den ble kalt 3 ganger. Eller det ble kalt fra deg i en syklus og burde derfor ha blitt kalt N ganger.

Vi vil ikke spørre om dette kan gjøres, vi vil umiddelbart spørre: hvordan skrive ned en slik regel? Og igjen, Mockito svikter oss ikke. Regelen kan spesifiseres som:

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

Viktig! Mengde er ikke en type int, men et spesielt objekt som kan definere ulike mønstre. Husker du de forskjellige versjonene av metoden any()? Det er det samme her - det er spesielle metoder som du kan sette forskjellige scenarier med:

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å kreve at det, bortsett fra de spesifiserte metodepåkallelsene, ikke gjøres andre referanser til objektet . Det er en regel for dette:

Mockito.verifyNoMoreInteractions(an object);

5.3 Metode anropsordre

De tidligere reglene regulerte ikke rekkefølgen på ringemetoder på noen måte. Regelen må bare oppfylles og det er det. Men det er situasjoner hvor rekkefølgen på metodekall er viktig, og Mockito har en løsning for dette også.

En streng rekkefølge av metodekall kan spesifiseres ved hjelp av et spesielt objekt InOrder. Først må du lage den:

InOrder inOrder = Mockito.inOrder(an object);

Og legg deretter til regler ved å kalle 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 Sjekke unntak i Mockito

At det er kastet unntak sjekkes litt annerledes. For å gjøre dette, bruk metoden assertThrows(). Det generelle formatet for en slik sjekk er:

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

Ikke noe komplisert.

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