A estrutura Mockito fornece uma variedade de métodos, como mock(), verify(), when(), etc., usados ​​para testar aplicativos Java. O uso desses métodos predefinidos torna o teste muito fácil.

A breve descrição dos métodos Mockito é fornecida abaixo:

diferença entre árvore binária e árvore de pesquisa binária

Método mockito mock()

É usado para criar objetos simulados de uma determinada classe ou interface. Mockito contém cinco zombar() métodos com argumentos diferentes. Quando não atribuímos nada aos mocks, eles retornarão valores padrão. Todos os cinco métodos executam a mesma função de zombar dos objetos.

A seguir estão os métodos mock() com parâmetros diferentes:

Método mock() com classe:É usado para criar objetos simulados de uma classe concreta ou interface. Leva uma classe ou um nome de interface como parâmetro.
Sintaxe: mock(Classe classToMock)Método mock() com resposta:É usado para criar objetos simulados de uma classe ou interface com um procedimento específico. É um método simulado avançado, que pode ser usado ao trabalhar com sistemas legados. Leva Answer como parâmetro junto com o nome da classe ou interface. A resposta é uma enumeração de respostas simuladas pré-configuradas.
Sintaxe: mock (classe classToMock, resposta padrãoAnswer)Método mock() com MockSettings:É usado para criar objetos simulados com algumas configurações não padrão. Leva MockSettings como um parâmetro de configuração adicional junto com a classe ou nome da interface. MockSettings permite a criação de objetos simulados com configurações adicionais.
Sintaxe: mock(Classe classToMock, MockSettings mockSettings)Método mock() com ReturnValues:Permite a criação de objetos simulados de uma determinada classe ou interface. Agora, ele está obsoleto, pois ReturnValues ​​foi substituído por Answer.
Sintaxe: mock(Classe classToMock, ReturnValues ​​returnValues)Método mock() com String:É usado para criar objetos simulados especificando os nomes simulados. Na depuração, nomear objetos simulados pode ser útil, ao passo que é uma má escolha usar códigos grandes e complexos.
Sintaxe: mock (classe classToMock, nome da string)

O trecho de código a seguir mostra como usar zombar() método:

 ToDoService doService = mock(ToDoService.class); 

Método Mockito quando()

Ele permite métodos de stub. Deve ser usado quando queremos simular para retornar valores específicos quando métodos específicos são chamados. Em termos simples, ' Quando o método XYZ() é chamado, então retorne ABC. É usado principalmente quando há alguma condição para executar.

Sintaxe: quando(T métodoChamada)

O trecho de código a seguir mostra como usar o método when():

 when(mock.someCode ()).thenReturn(5); 

No código acima, entãoReturn() é usado principalmente com quando() método.

Método Mockito de verificação()

O verificar() método é usado para verificar se alguns métodos especificados são chamados ou não. Em termos simples, valida um determinado comportamento que aconteceu uma vez em um teste. É usado na parte inferior do código de teste para garantir que os métodos definidos sejam chamados.

A estrutura Mockito monitora todas as chamadas de método com seus parâmetros para zombar de objetos. Após a simulação, podemos verificar se as condições definidas foram atendidas ou não usando o método verify(). Este tipo de teste às vezes é conhecido como testes comportamentais. Ele verifica se um método é chamado com os parâmetros corretos, em vez de verificar o resultado de uma chamada de método.

O método verify() também é usado para testar o número de invocações. Portanto, podemos testar o número exato de invocações usando o método vezes, método pelo menos uma vez, e no máximo método para um método simulado.

Existem dois tipos de métodos verify() disponíveis na classe Mockito, que são fornecidos abaixo:

método verificar():Ele verifica que determinado comportamento aconteceu uma vez.
Sintaxe: verificar (T simulado)Método verify() com VerificationMode:Verifica se algum comportamento aconteceu pelo menos uma vez, número exato de vezes ou nunca.
Sintaxe: verificar(T mock, modo VerificationMode)

Método espião Mockito()

Mockito fornece um método para simular parcialmente um objeto, que é conhecido como espião método. Ao usar o método spy, existe um objeto real, e espiões ou stubs são criados a partir desse objeto real. Se não fizermos stub de um método usando spy, ele chamará o comportamento real do método. A principal função do método spy() é substituir os métodos específicos do objeto real. Uma das funções do método spy() é verificar a invocação de um determinado método.

Existem dois tipos de métodos spy() disponíveis na classe Mockito:

método espião():Cria um espião do objeto real. O método espião chama os métodos reais, a menos que sejam stubados. Devemos usar os espiões reais com cuidado e ocasionalmente, por exemplo, ao lidar com o código legado.
Sintaxe: espião (objeto T)Método spy() com classe:Ele cria um objeto espião baseado na classe em vez de um objeto. O método spy(T object) é particularmente útil para espionar classes abstratas porque elas não podem ser instanciadas.
Sintaxe: espião(Classe classToSpy)

O trecho de código a seguir mostra como usar o método spy():

 List spyArrayList = spy(ArrayList.class); 

Método Mockito reset()

O método Mockito reset() é usado para redefinir os mocks. É usado principalmente para trabalhar com simulações injetadas em contêiner. Normalmente, o método reset() resulta em um código longo e testes ruins. É melhor criar novos mocks em vez de usar o método reset(). É por isso que o método reset() raramente é usado em testes.

A assinatura do método reset() é:

comandos sqlddl

 public static void reset(T ... mocks) { MOCKITO_CORE.reset(mocks); } 

Método Mockito verifyNoMoreInteractions()

É usado para verificar se qualquer uma das simulações fornecidas tem alguma interação não verificada. Podemos usar este método depois de verificar todos os mocks, para ter certeza de que nada mais foi invocado nos mocks. Ele também detecta as invocações não verificadas que ocorrem antes do método de teste, por exemplo, em setup(), método @Before ou no construtor. É um método opcional e não precisamos usá-lo em todos os testes.

A assinatura do método verifyNoMoreInteractions() é:

 public static void verifyNoMoreInteractions(Object... mocks) { MOCKITO_CORE.verifyNoMoreInteractions(mocks); } 

Método Mockito verifyZeroInteractions()

Ele verifica se nenhuma interação ocorreu nas simulações fornecidas. Ele também detecta as invocações que ocorreram antes do método de teste, por exemplo, no método setup(), @Before ou no construtor.

A assinatura do método verifyZeroInteractions() é:

 public static void verifyZeroInteractions(Object... mocks) { MOCKITO_CORE.verifyNoMoreInteractions(mocks); } 

Método Mockito doThrow()

É usado para fazer stub de um método void para lançar uma exceção. Ele cria uma nova instância de exceção para cada invocação de método. Existem dois tipos de métodos doThrow() disponíveis na classe Mockito com parâmetros diferentes, conforme mostrado abaixo:

Método doThrow() com Throwable:Este método é usado quando queremos fazer stub de um método void com uma exceção. Sintaxe: doThrow(laçável paraBeThrown)
A assinatura do método doThrow() é:

 public static Stubber doThrow(Throwable toBeThrown) { return MOCKITO_CORE.doAnswer(new ThrowsException(toBeThrown)); } 

Método doThrow() com classe:Este método é usado quando queremos fazer stub de um método void para lançar uma exceção de uma classe especificada.
Sintaxe: doThrow(Classe toBeThrown)
A assinatura do método doThrow() é:

 public static Stubber doThrow(Class toBeThrown) { return MOCKITO_CORE.doAnswer(new ThrowsExceptionClass(toBeThrown)); } 

Método Mockito doCallRealMethod()

É usado quando queremos chamar a implementação real de um método. Em outras palavras, é usado para criar simulações parciais de um objeto. É usado em situações raras, como para chamar métodos reais. É semelhante ao método spy() e a única diferença é que resulta em código complexo.

A assinatura do método doCallRealMethod() é:

 public static Stubber doCallRealMethod() { return MOCKITO_CORE.doAnswer(new CallsRealMethods()); } 

Método Mockito doAnswer()

É usado quando queremos fazer stub de um método void com um tipo de resposta genérico. A assinatura do método doAnswer() é:

 public static Stubber doAnswer(Answer answer) { return MOCKITO_CORE.doAnswer(answer); } 

Método Mockito doNothing()

É usado para definir métodos void para não fazer nada. O método doNothing() é usado em situações raras. Por padrão, os métodos void em instâncias simuladas não fazem nada, ou seja, nenhuma tarefa é executada.

A assinatura do método doNothing() é:

 public static Stubber doNothing() { return MOCKITO_CORE.doAnswer(new DoesNothing()); } 

Método Mockito doReturn()

É usado nas raras ocasiões em que não podemos usar Mockito.when(object). O método Mockito.when(object) é sempre sugerido para stubbing porque é seguro para o tipo de argumento e mais legível em comparação com o método doReturn().

A assinatura do método doReturn() é:

 public static Stubber doReturn(Object toBeReturned) { return MOCKITO_CORE.doAnswer(new Returns(toBeReturned)); } 

Método Mockito inOrder()

É utilizado para criar objetos que permitem a verificação de mocks em uma ordem específica. A verificação feita em ordem é mais flexível, pois não precisamos verificar todas as interações. Precisamos verificar apenas as interações que estão interessadas em testar (em ordem). Também podemos usar o método inOrder() para criar um objeto inOrder passando simulações que são relevantes para a verificação do pedido.

A assinatura do método Mockito.inOrder() é:

 public static InOrder inOrder(Object... mocks) { return MOCKITO_CORE.inOrder(mocks); } 

Método Mockito ignoreStubs()

É usado para ignorar os métodos stub de determinadas simulações para verificação. É útil com métodos verifyNoMoreInteractions() ou verificação inOrder(). Também ajuda a evitar verificação redundante de chamadas interrompidas.

A assinatura do método ignoreStubs() é:

 public static Object[] ignoreStubs(Object... mocks) { return MOCKITO_CORE.ignoreStubs(mocks); } 

Método Mockito times()

É usado para verificar o número exato de invocações de métodos, o que significa que declara quantas vezes um método é invocado. A assinatura do método times() é:

 public static VerificationMode times(int wantedNumberOfInvocations) { return VerificationModeFactory.times(wantedNumberOfInvocations); } 

Método Mockito nunca()

É utilizado para verificar se a interação não aconteceu. A assinatura do método never() é:

 public static VerificationMode never() { return times(0); } 

Método Mockito atLeastOnce()

É usado para verificar a invocação pelo menos uma vez, o que significa que o método deve ser invocado pelo menos uma vez.

A assinatura do método atLeastOnce() é:

 public static VerificationMode atLeastOnce() { return VerificationModeFactory.atLeastOnce(); } 

Método Mockito atLeast()

É usado para verificar a invocação pelo menos x número de vezes. Por exemplo, dado atLeast(3) significa que o método será invocado no mínimo três vezes.

anexando string em java

A assinatura do método atLeast() é:

 public static VerificationMode atLeast(int minNumberOfInvocations) { return VerificationModeFactory.atLeast(minNumberOfInvocations); } 

Método Mockito atMost()

É usado para verificar a invocação no máximo x número de vezes. Por exemplo, dado atMost(3) significa que o método será invocado no máximo três vezes.

A assinatura do método atMost() é:

 public static VerificationMode atMost(int maxNumberOfInvocations) { return VerificationModeFactory.atMost(maxNumberOfInvocations); } 

Método de chamadas Mockito()

Permite uma verificação não gananciosa em ordem. Só pode ser usado com o método de verificação inOrder(). Por exemplo, inOrder.verify(mock, calls(3)).xyzMethod('...');

A assinatura do método calls() é:

 public static VerificationMode calls( int wantedNumberOfInvocations ){ return VerificationModeFactory.calls( wantedNumberOfInvocations ); } 

Método apenas Mockito()

Ele verifica se o método fornecido foi o único método invocado. A assinatura do método only() é:

lista java para array

 public static VerificationMode only() { return VerificationModeFactory.only(); } 

Método de tempo limite do Mockito()

Permite que o Mockito execute a verificação com tempo limite. Ele instrui uma verificação a aguardar um período específico de tempo por uma interação específica, em vez de falhar imediatamente. Pode ser útil para testes em situações existentes.

O método timeout() difere do método after(), pois o método after() espera o período completo, a menos que o resultado final seja declarado, enquanto o método timeout() irá parar assim que a verificação for aprovada. Raramente é usado em testes.

A assinatura do método timeout() é:

 public static VerificationWithTimeout timeout(long millis) { return new Timeout(millis, VerificationModeFactory.times(1)); } 

Método Mockito after()

Ele permite que o Mockito verifique durante um determinado período de tempo. Já discutimos que o método after() difere do método timeout().

A assinatura do método after() é:

 public static VerificationAfterDelay after(long millis) { return new After(millis, VerificationModeFactory.times(1)); } 

Método Mockito validarMockitoUsage()

É usado para validar explicitamente o estado da estrutura para detectar o uso inválido da estrutura Mockito. É um recurso opcional do Mockito porque valida o uso o tempo todo. Tanto o executor integrado (MockitoJUnitRunner) quanto a regra (MockitoRule) chamam o método activateMockitoUsage() após cada método de teste.

A assinatura do método validMockitoUsage() é:

 public static void validateMockitoUsage() { MOCKITO_CORE.validateMockitoUsage(); } 

Método Mockito withSettings()

É usado para criar simulações com configurações adicionais de simulação. Deve ser usado ocasionalmente em testes. Em vez de usar o método withSettings(), crie testes simples usando simulações simples. As principais razões para usar o MockSettings são

• Usando MockSetting, podemos adicionar facilmente outras configurações simuladas quando necessário.
• Ele combina diferentes configurações simuladas sem bagunçar o código.

A assinatura do método withSettings() é:

 public static MockSettings withSettings() { return new MockSettingsImpl().defaultAnswer(RETURNS_DEFAULTS); }