Ujawnianie określonych zachowań obiektów

5.1 Metoda weryfikuj().

Oprócz tworzenia obiektów wirtualnych często pojawia się inne ciekawe zadanie – upewnienie się, że testowana klasa wywołuje właściwe metody właściwych obiektów. Co więcej, sprawdził wymaganą liczbę razy, z poprawnymi parametrami i tym podobne.

Do tego Mockito ma też trochę magii – rodzinę metod Mockito.verify(…). Ogólna zasada określająca sprawdzanie wywołań metod to:

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

Przykład:

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

Podczas wywołania metody verify()ustalamy regułę, że na obiekcie mockitoListpowinna zostać wywołana metoda z parametrem 10 get().

5.2 Metoda valid() ze sprawdzaniem ilości wywołań

Czasami istnieją bardziej złożone scenariusze weryfikacji. Na przykład musisz sprawdzić nie tylko fakt, że metoda została wywołana, ale na przykład, że została wywołana 3 razy. Lub został wywołany od ciebie w cyklu i dlatego powinien był zostać wywołany N razy.

Nie zapytamy, czy da się to zrobić, od razu zapytamy: jak spisać taką regułę? I znowu Mockito nas nie zawodzi. Regułę można określić jako:

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

Ważny! Ilość nie jest typem int, ale specjalnym obiektem, który może definiować różne wzorce. Czy pamiętasz różne wersje tej metody any()? Tutaj jest tak samo - istnieją specjalne metody, za pomocą których można ustawić różne scenariusze:

Przykład:

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

Możesz również wymagać, aby poza określonymi wywołaniami metod nie były wykonywane żadne inne odwołania do obiektu . Jest na to reguła:

Mockito.verifyNoMoreInteractions(an object);

5.3 Kolejność wywoływania metod

Poprzednie zasady w żaden sposób nie regulowały kolejności wywoływania metod. Reguła musi być po prostu spełniona i tyle. Ale są sytuacje, w których kolejność wywołań metod jest ważna, a Mockito również ma na to rozwiązanie.

Ścisłą kolejność wywołań metod można określić za pomocą specjalnego obiektu InOrder. Najpierw musisz go utworzyć:

InOrder inOrder = Mockito.inOrder(an object);

A następnie dodaj do niego reguły, wywołując metody verify().

Przykład:

    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 Sprawdzanie wyjątków w Mockito

Fakt, że wyjątki zostały zgłoszone, jest sprawdzany nieco inaczej. Aby to zrobić, użyj metody assertThrows(). Ogólny format takiego czeku to:

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

Nic skomplikowanego.

Przykład:

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