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?

nbpeth
fonte
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.

Tom
fonte
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