Revelando Comportamento Específico em Objetos

5.1 O método Verify()

Além de criar objetos virtuais, muitas vezes surge outra tarefa interessante - garantir que a classe em teste chame os métodos corretos dos objetos corretos. Além disso, ele ligou o número necessário de vezes, com os parâmetros corretos e afins.

Para isso, o Mockito também tem um pouco de mágica - uma família de métodos Mockito.verify(…). A regra geral que especifica a verificação de chamada de método é:

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

Exemplo:

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

Durante a chamada do método, verify()definimos a regra de que mockitoListo método com o parâmetro 10 deve ser chamado no objeto get().

5.2 O método Verify() com verificação do número de chamadas

Às vezes, há cenários de verificação mais complexos. Por exemplo, você precisa verificar não apenas se o método foi chamado, mas, por exemplo, se foi chamado 3 vezes. Ou foi chamado de você em um ciclo e, portanto, deveria ter sido chamado N vezes.

Não vamos perguntar se isso pode ser feito, vamos perguntar imediatamente: como escrever tal regra? E, novamente, Mockito não nos decepciona. A regra pode ser especificada como:

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

Importante! A quantidade não é um tipo int, mas um objeto especial que pode definir vários padrões. Você se lembra das diferentes versões do método any()? É o mesmo aqui - existem métodos especiais com os quais você pode definir vários cenários:

Exemplo:

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

Você também pode exigir que, além das chamadas de método especificadas, nenhuma outra referência ao objeto seja feita . Existe uma regra para isso:

Mockito.verifyNoMoreInteractions(an object);

5.3 Ordem de chamada do método

As regras anteriores não regulavam a ordem dos métodos de chamada de forma alguma. A regra só tem que ser cumprida e pronto. Mas há situações em que a ordem das chamadas de método é importante, e o Mockito também tem uma solução para isso.

Uma ordem estrita de chamadas de método pode ser especificada usando um objeto especial InOrder. Primeiro você precisa criá-lo:

InOrder inOrder = Mockito.inOrder(an object);

E, em seguida, adicione regras a ele chamando métodos verify().

Exemplo:

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 Verificando exceções no Mockito

O fato de que exceções foram lançadas é verificado de forma um pouco diferente. Para fazer isso, use o método assertThrows(). O formato geral para tal verificação é:

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

Nada complicado.

Exemplo:

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