Avslöja specifikt beteende i objekt

5.1 Metoden verify().

Förutom att skapa virtuella objekt uppstår ofta en annan intressant uppgift - att se till att klassen som testas anropar rätt metoder för rätt objekt. Dessutom ringde han det erforderliga antalet gånger, med rätt parametrar och liknande.

För detta har Mockito också en del magi - en familj av metoder Mockito.verify(…). Den allmänna regeln som specificerar metodanropskontroll är:

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

Exempel:

@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 metodanropet verify()sätter vi regeln att mockitoListmetoden med parametern 10 ska anropas på objektet get().

5.2 Metoden verify() med kontroll av antalet samtal

Ibland finns det mer komplexa verifieringsscenarier. Till exempel måste du kontrollera inte bara det faktum att metoden anropades, utan till exempel att den anropades 3 gånger. Eller så kallades det från dig i en cykel och borde därför ha hetat N gånger.

Vi kommer inte att fråga om detta kan göras, vi kommer omedelbart att fråga: hur man skriver ner en sådan regel? Och återigen, Mockito sviker oss inte. Regeln kan specificeras som:

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

Viktig! Kvantitet är inte en typ int, utan ett speciellt objekt som kan definiera olika mönster. Kommer du ihåg de olika versionerna av metoden any()? Det är samma sak här - det finns speciella metoder med vilka du kan ställa in olika scenarier:

Exempel:

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 också kräva att, förutom de angivna metodanropen, inga andra referenser till objektet görs . Det finns en regel för detta:

Mockito.verifyNoMoreInteractions(an object);

5.3 Metod för anropsorder

De tidigare reglerna reglerade inte ordningen för anropsmetoder på något sätt. Regeln måste bara uppfyllas och det är det. Men det finns situationer när ordningen på metodanrop är viktig, och Mockito har en lösning för detta också.

En strikt ordning av metodanrop kan anges med ett speciellt objekt InOrder. Först måste du skapa den:

InOrder inOrder = Mockito.inOrder(an object);

Och lägg sedan till regler genom att anropa metoder verify().

Exempel:

    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 Kontrollera undantag i Mockito

Att undantag har slängts kontrolleras lite annorlunda. För att göra detta, använd metoden assertThrows(). Det allmänna formatet för en sådan kontroll är:

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

Inget komplicerat.

Exempel:

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