Você Programador sabe como usar Mockito com Java? essa ferramenta é uma poderosa estrutura de teste em Java, desenvolvida para simplificar e facilitar a criação de simulações (mocks) de objetos em testes unitários. Ela permite simular o comportamento de classes ou interfaces, criando objetos fictícios que se comportam de maneira controlada durante os testes.
Utilizado principalmente em testes unitários, o Mockito ajuda a isolar o código em teste, permitindo que você se concentre na unidade específica de funcionalidade sem depender de outras partes do sistema.
Ao criar mocks de dependências externas, como classes ou serviços, é possível simular seus comportamentos e resultados esperados, sem a necessidade de executar o código real dessas dependências.
O que são Testes de Integração?
Os testes de integração são uma parte essencial do processo de garantia de qualidade no desenvolvimento de software. Eles se concentram na verificação da interação entre diferentes componentes, módulos ou sistemas dentro de uma aplicação.
Enquanto os testes unitários se concentram em verificar partes isoladas do código, os testes de integração avaliam como essas partes funcionam em conjunto.
Esses testes são projetados para identificar problemas que podem surgir quando unidades individuais são combinadas para formar um sistema completo. Eles garantem que as diferentes partes do software se comuniquem e cooperem adequadamente, trocando informações e realizando suas funções de maneira integrada.
Os testes de integração podem ser conduzidos em diferentes níveis de integração, como integração de componentes (verificando a interação entre módulos), integração de sistemas (avaliando como subsistemas ou sistemas completos se comunicam) e integração do usuário (testando a interação com o usuário final).
Exemplo de um Teste de Integração com Java e Mockito
Primeiro, vamos adicionar as dependências em nosso projeto com Spring Boot no arquivo pom.xml, para então dar inicio ao nosso exemplo de testes de integração :
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>2.5.5</version>
</dependency>
<!-- Spring Boot Starter Test for testing -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<version>2.5.5</version>
<scope>test</scope>
</dependency>
<!-- Mockito for mocking -->
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
<version>3.12.4</version>
<scope>test</scope>
</dependency>
</dependencies>Agora que já temos nossas dependências necessárias para darmos continuidade em nosso exemplo, vamos criar uma classe controller chamada ExemploController:
package br.com.virandoprogramador.controller
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/api")
public class ExemploController {
@GetMapping("/mensagem")
public ResponseEntity<String> obterMensagem() {
String mensagem = "Olá esse é um post do Virando Programdor!";
return ResponseEntity.ok(mensagem);
}
@PostMapping("/mensagem")
public ResponseEntity<String> criarMensagem(@RequestBody String novaMensagem) {
return ResponseEntity.ok("Mensagem criada com sucesso: " + novaMensagem);
}
}Esta classe RestController possui dois endpoints: um para obter uma mensagem e outro para criar uma nova mensagem.
Agora, vamos criar uma classe de teste de integração usando Mockito:
package br.com.virandoprogramador.test
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
@ExtendWith({SpringExtension.class, MockitoExtension.class})
@WebMvcTest(ExemploController.class)
@AutoConfigureMockMvc
public class ExemploControllerIntegrationTest {
@Autowired
private MockMvc mockMvc;
@Test
public void testObterMensagem() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get("/api/mensagem")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(MockMvcResultMatchers.content().string("Olá esse é um post do Virando Programdor!"));
}
@Test
public void testCriarMensagem() throws Exception {
String novaMensagem = "Nova mensagem de teste";
mockMvc.perform(MockMvcRequestBuilders.post("/api/mensagem")
.content(novaMensagem)
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(MockMvcResultMatchers.content().string("Mensagem criada com sucesso: " + novaMensagem));
}
}Neste exemplo de teste de integração com Mockito, estamos testando os endpoints da classe RestController. O primeiro teste verifica se a mensagem retornada é “Olá esse é um post do Virando Programdor!” ao chamar o endpoint GET /api/mensagem. O segundo teste verifica se a criação de uma nova mensagem usando o endpoint POST /api/mensagem retorna a mensagem correta.
A anotação @WebMvcTest é uma anotação fornecida pelo Spring Boot para testes específicos de MVC (Model-View-Controller) em uma aplicação. Ela é usada para testar controladores (@Controller), sem iniciar a aplicação completa, focando apenas na camada web da aplicação.
Ao utilizar @WebMvcTest, o Spring Boot carrega apenas o contexto do controlador que está sendo testado, não iniciando outros componentes, como bancos de dados, serviços, entre outros. Isso ajuda a tornar os testes mais focados e rápidos, pois reduz a inicialização do contexto da aplicação.
Essa anotação é tipicamente usada em conjunto com outras anotações como @MockMvc, que cria um ambiente simulado para testar as requisições HTTP para os endpoints do controlador.
O que é um Mock Java?
Em Java, um “mock” é um objeto simulado que replica o comportamento de um objeto real em um ambiente de teste. Os mocks são frequentemente utilizados em testes unitários e de integração para isolar o código que está sendo testado.
Esses objetos mockados são criados para imitar o comportamento de objetos reais, permitindo simular interações específicas, respostas e comportamentos desejados durante a execução dos testes.
Eles são usados para substituir partes do sistema que podem ter dependências externas, como serviços externos, bases de dados ou componentes que não são ideais para serem executados durante testes.
Geralmente, as bibliotecas de mocking em Java, como Mockito, EasyMock e PowerMock, oferecem maneiras de criar, configurar e verificar comportamentos em mocks.
Ao definir expectativas específicas e comportamentos para métodos chamados nesses mocks, é possível simular cenários diferentes e testar como o código reage a essas situações simuladas.
Quando usar Mock?
Bom, separei 5 situações onde faz todo sentido utilizarmos Mocks em nosso cenários de testes:
- Isolamento de dependências externas: Quando você precisa testar um componente ou classe que depende de recursos externos, como bases de dados, serviços web, APIs externas ou sistemas legados, é útil substituir essas dependências por mocks. Isso evita a necessidade de acesso real a esses recursos externos durante os testes, tornando os testes mais rápidos, previsíveis e independentes do ambiente.
- Controle sobre o comportamento: Utilizar mocks permite simular diferentes comportamentos ou respostas das dependências durante o teste, possibilitando testar cenários específicos, como falhas de conexão, respostas inesperadas ou exceções que podem ser difíceis de reproduzir com componentes reais.
- Testes unitários e isolamento de unidades: Ao realizar testes unitários, é importante isolar a unidade de código que está sendo testada. Usar mocks para substituir outras partes do sistema ajuda a garantir que apenas o componente específico seja testado, sem depender do funcionamento correto de outras partes do sistema.
- Melhoria na velocidade dos testes: Evitar acessos a recursos externos reais, como bancos de dados ou serviços web, reduz o tempo necessário para execução dos testes. Mocks oferecem respostas imediatas e previsíveis, agilizando o processo de teste.
- Cenários difíceis de reproduzir: Situações complexas ou difíceis de serem reproduzidas, como erros de rede, condições de erro em serviços externos ou respostas inesperadas, podem ser simuladas facilmente com o uso de mocks.
Conclusão sobre Como usar Mockito com Java
O Mockito é uma biblioteca de mocking para Java amplamente utilizada no desenvolvimento de testes unitários e de integração. Sua principal função é criar objetos simulados, chamados de mocks, que reproduzem o comportamento de componentes reais do sistema durante os testes.
Esses mocks são criados facilmente através de métodos estáticos da classe Mockito, permitindo simular o comportamento de classes e interfaces. A configuração do comportamento desses mocks é bastante flexível, permitindo especificar retornos de métodos, lançar exceções, verificar interações e personalizar comportamentos conforme necessário para os testes.
Para concluir, o Mockito integra-se facilmente com frameworks de teste populares, como JUnit, TestNG e Spring Test, tornando-se uma escolha comum para a criação e configuração de mocks em diferentes ambientes de teste.
