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 mockitoList
o 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:
Método | Descrição | |
---|---|---|
1 | nunca() | O método nunca deve ser chamado |
2 | vezes(n) | n vezes |
3 | pelo menos(n) | n ou mais vezes |
4 | pelo menos uma vez() | 1 ou mais vezes |
5 | no máximo(n) | n ou menos vezes |
6 | apenas() | Deve haver apenas uma chamada e apenas para este método |
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());
}
}
GO TO FULL VERSION