Eu pesquisei sobre isso, mas não encontrei nada relevante. Eu tenho algo parecido com isto:
Object obj = getObject();
Mockeable mock= Mockito.mock(Mockeable.class);
Mockito.when(mock.mymethod(obj )).thenReturn(null);
Testeable testableObj = new Testeable();
testableObj.setMockeable(mock);
command.runtestmethod();
Agora, quero verificar se mymethod(Object o)
, que é chamado por dentro runtestmethod()
, foi chamado com o Objeto o
, não com nenhum outro. Mas sempre passo no teste, seja lá o que colocar na verificação, por exemplo, com:
Mockito.verify(mock.mymethod(Mockito.eq(obj)));
ou
Mockito.verify(mock.mymethod(Mockito.eq(null)));
ou
Mockito.verify(mock.mymethod(Mockito.eq("something_else")));
Eu sempre passo no teste. Como posso realizar essa verificação (se possível)?
Obrigado.
java
unit-testing
junit
mockito
manolowar
fonte
fonte
Você está tentando fazer a igualdade lógica utilizando o método .equals do objeto? Você pode fazer isso utilizando o correspondente argThat incluído no Mockito
Em seguida, você pode implementar seu próprio comparador de argumentos que será diferido para cada objeto .equals method
Agora, usando seu código, você pode atualizá-lo para ler ...
Se você está apenas buscando igualdade EXATA (mesmo objeto na memória), basta
Isso verificará que foi chamado uma vez.
fonte
ReflectionEquals
classe para esse fim.verify(mock).mymethod(obj);
não verifica a igualdade EXATA (mesmo objeto na memória). Em vez disso, usa os objetos equals-method que poderiam ter sido substituídos.ArgumentMatcher
para ser menos detalhado.verify()
chama oequals()
método / do argumento de entrada / , em vez doequals()
método / do objeto / gravado . isso é irrelevante, a menos que você esteja tentando confirmar que o sujeito do teste retorna uma instância específica do objeto, e o sujeito retorna o que deveria ser um decorador transparente dessa instância. Osverify
argumentosequals()
não sabiam do decorador; enquanto o decoradorequals()
seria reescrito para tolerar o original. Nesse caso, seu teste falhará falsamente.eq
matcher se não usar outros matchers..verify(mock)
. Agora você está iniciando a verificação do resultado da chamada de método, sem verificar nada (não fazendo uma chamada de método). Portanto, todos os testes estão passando.Seu código deve se parecer com:
fonte
argThat
mais lambdaé assim que você pode falhar na verificação do argumento:
Onde
argThat
mais afirmao teste acima "dirá"
Expected: lambda$... Was: YourClass.toSting...
. Você pode obter uma causa mais específica da falha se usar declarações no lambda:MAS: APENAS FUNCIONA COM 1 CHAMADA DE MÉTODO. Se o método verificado chamar mais de 2 vezes, o mockito passa todas as combinações chamadas para cada verificador. Portanto, o mockito espera que seu verificador retorne silenciosamente
true
para um dos argumentos definidos efalse
(sem nenhuma exceção de asserção) para outras chamadas válidas. Essa expectativa não é um problema para uma chamada de método - ela deve retornar apenas uma vez verdadeira.Agora o teste diz:
Expected: Obj.description to contain 'KEY'. Was: 'Actual description'
. NOTA: Eu useiassertJ
afirmações, mas cabe a você qual estrutura de afirmação usar.argThat
com vários argumentos.Se você usar
argThat
, todos os argumentos deverão ser fornecidos com correspondências. Por exemplo:Onde:
eq
matchera maneira mais fácil de verificar se o argumento é igual:
argumento direto
se a comparação por ref for aceitável, continue com:
A causa da falha pergunta original era o lugar errado das paranthes:
verify(mock.mymethod...
. Isso estava errado. O direito seria:verify(mock).*
fonte
Eu usei o Mockito.verify dessa maneira
fonte
Você verificou o método equals para a classe ridicularizável? Se este retornar sempre verdadeiro ou você testar a mesma instância na mesma instância e o método equal não for sobrescrito (e, portanto, apenas verificar as referências), ele retornará verdadeiro.
fonte
O outro método é usar o método org.mockito.internal.matchers.Equals.Equals em vez de redefinir um:
fonte
Você já tentou com o mesmo matcher ()? Como em:
Eu tive o mesmo problema. Eu tentei com o eq () e o refEq (), mas sempre tive falsos positivos. Quando usei o mesmo combinador (), o teste falhou quando os argumentos eram instâncias diferentes e passou quando os argumentos eram a mesma instância.
fonte
Você também pode usar TypeSafeDiagnosingMatcher
Em seguida, verifique essa chamada:
fonte