Java verifica chamadas nulas de método n vezes com Mockito


140

Estou tentando verificar se um método (nulo) está sendo chamado dentro de um DAO - estou usando um ponto de confirmação que envia uma lista de resultados até esse ponto, redefine a lista e continua. Digamos que eu tenha 4 itens na lista e eu tenho um ponto de confirmação 1, eu esperaria que o método "send" fosse chamado 4 vezes. Posso verificar se o método é chamado uma vez escrevendo

Mockito.verify(mock).send()

passa .. mas quero verificar o número de vezes que foi chamado. Eu pensaria que

Mockito.verify(mock.send(), times(4))

seria suficiente, mas diz que os parâmetros não estão corretos para verificação.

Aliás, se eu mudar Mockito.verify(mock).send()para Mockito.verify(mock.send())ou Mockito.verify((mock).send())receber o mesmo erro. Pensamentos sobre isso?


10
Tente Mockito.verify(mock, times(4)).send(). Gostaria de saber por que você "moveu" a send()chamada do verifymétodo dentro do método. Você já tinha a sintaxe correta.
Tom


Observe também que, se você não se importa quantas vezes algo é chamado, você pode escreververify(mock, atLeastOnce()).send();
Dawood ibn Kareem

Obrigado, está correto. O que eu achei confuso foi que Mockito.verify(mock).send()passou, mas encapsulá-lo causou um erro, que nada muda. no entanto, é uma vitória!
Nbpeth

Respostas:


237

O método necessário é o Mockito # Verifique :

public static <T> T verify(T mock,
                           VerificationMode mode)

mocké o seu objeto simulado e modeé o VerificationModeque descreve como a simulação deve ser verificada. Os modos possíveis são :

verify(mock, times(5)).someMethod("was called five times");
verify(mock, never()).someMethod("was never called");
verify(mock, atLeastOnce()).someMethod("was called at least once");
verify(mock, atLeast(2)).someMethod("was called at least twice");
verify(mock, atMost(3)).someMethod("was called at most 3 times");
verify(mock, atLeast(0)).someMethod("was called any number of times"); // useful with captors
verify(mock, only()).someMethod("no other method has been called on the mock");

Você precisará destas importações estáticas da Mockitoclasse para usar o verifymétodo e estes modos de verificação:

import static org.mockito.Mockito.atLeast;
import static org.mockito.Mockito.atLeastOnce;
import static org.mockito.Mockito.atMost;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.only;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;

Portanto, no seu caso, a sintaxe correta será:

Mockito.verify(mock, times(4)).send()

Isso verifica se o método sendfoi chamado 4 vezes no objeto simulado. Ele falhará se for chamado menos ou mais de 4 vezes.


Se você quiser apenas verificar se o método foi chamado uma vez, não será necessário passar a VerificationMode. Um simples

verify(mock).someMethod("was called once");

seria o suficiente. Ele usa internamente verify(mock, times(1)).someMethod("was called once");.


É possível ter várias chamadas de verificação no mesmo simulador para obter uma verificação "entre". Mockito não suporta algo assim verify(mock, between(4,6)).someMethod("was called between 4 and 6 times");, mas podemos escrever

verify(mock, atLeast(4)).someMethod("was called at least four times ...");
verify(mock, atMost(6)).someMethod("... and not more than six times");

em vez disso, para obter o mesmo comportamento. Os limites estão incluídos , portanto o caso de teste fica verde quando o método foi chamado 4, 5 ou 6 vezes.


1
Para quem procura descobrir onde VerificationModeestão os métodos (para importação estática ou referência explícita), eles estão org.mockito.internal.verification.VerificationModeFactory.
Steve Chambers

verify(mock, atLeast(0)).someMethod("was called any number of times");foi útil ignorar uma verificação de chamada
tj-recess

2
existe algo parecido verify(between(m,n))que verifica o número de chamadas entre m e n?
Nishant 20/03/19

2
@nishant Não, o Mockito não parece apoiar isso, mas você pode ligar verifypara momentos com atLeast(M)e atMost(n)obter o mesmo comportamento. Eu editei a resposta para explicar isso.
Tom

@KevinWelker Você está certo, removi as informações sobre VerificationModeFactory. Ainda está disponível na versão mais recente, mas concordo que classes internas não devem ser usadas.
Tom
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.