Como utiliza Junit, Mockito e Spring

Nesse artigo vamos falar sobre Junit, mockito e Spring, Vamos começar explicando um pouco sobre o que é o JUnit e o Mockito e depois mostrar como usá-los juntos para testar um Endpoint Spring que depende de uma classe interna.

O que é JUnit?

JUnit é uma estrutura de teste de unidade para a linguagem de programação Java. Ele fornece uma maneira fácil de escrever testes automatizados para garantir que o código funcione corretamente. Os testes JUnit são escritos como métodos de teste em uma classe de teste e são executados automaticamente pelo JUnit Runner. Os testes podem ser executados dentro do IDE ou por meio de ferramentas de build como Maven ou Gradle.

O que é Mockito?

Mockito é uma biblioteca de simulação (mocking) para Java que permite criar objetos simulados para testar o comportamento de outras classes. Ele fornece uma maneira fácil de criar objetos falsos para simular o comportamento de uma classe real em um ambiente de teste. Isso permite que você isole seu código de dependências externas e execute testes mais confiáveis.

Configurando o ambiente

Antes de começarmos a escrever testes, é importante configurar o ambiente de desenvolvimento. Para este exemplo, precisamos das seguintes dependências no arquivo build.gradle:

testImplementation 'org.springframework.boot:spring-boot-starter-test'
testImplementation 'org.mockito:mockito-core:3.12.4'

Escrevendo testes com JUnit e Mockito

Agora que temos nosso ambiente configurado, podemos começar a escrever testes usando JUnit e Mockito. Vamos começar com um exemplo simples de um endpoint Spring que retorna uma lista de usuários.

Para este exemplo, suponha que temos uma entidade chamada Produto e um repository chamado ProdutoRepository que implementa o acesso a um banco de dados para realizar operações CRUD em produtos. Além disso, temos um controller chamado ProdutoController que possui um endpoint para buscar todos os produtos no banco de dados.

@Entity
public class Produto {
    @Id
    private Long id;
    private String nome;
    private double preco;
    // getters e setters
}

@Repository
public interface ProdutoRepository extends JpaRepository<Produto, Long> {
}

@RestController
@RequestMapping("/produtos")
public class ProdutoController {

    @Autowired
    private ProdutoRepository produtoRepository;

    @GetMapping
    public List<Produto> getProdutos() {
        return produtoRepository.findAll();
    }
}

Agora vamos escrever um teste JUnit para o endpoint getProdutos. Vamos mockar o ProdutoRepository para garantir que o endpoint está retornando todos os produtos corretamente.

@RunWith(MockitoJUnitRunner.class)
public class ProdutoControllerTest {

    @InjectMocks
    private ProdutoController produtoController;

    @Mock
    private ProdutoRepository produtoRepository;

    @Test
    public void testGetProdutos() {
        // Criação de produtos simulados
        List<Produto> produtos = new ArrayList<>();
        produtos.add(new Produto(1L, "Produto 1", 10.0));
        produtos.add(new Produto(2L, "Produto 2", 20.0));

        // Configurando o comportamento simulado do produtoRepository
        Mockito.when(produtoRepository.findAll()).thenReturn(produtos);

        // Chamada do endpoint
        List<Produto> result = produtoController.getProdutos();

        // Verificando se todos os produtos foram retornados corretamente
        Assert.assertEquals(produtos.size(), result.size());
        Assert.assertEquals(produtos.get(0), result.get(0));
        Assert.assertEquals(produtos.get(1), result.get(1));
    }
}

Explicando o que acontece neste teste:

1. A anotação @RunWith(MockitoJUnitRunner.class) configura o JUnit para usar o Mockito como framework de mocking.
2. A anotação @InjectMocks cria uma instância do ProdutoController e injeta o mock do ProdutoRepository nele.
3. A anotação @Mock cria um mock da classe ProdutoRepository.
4. No método testGetProdutos, criamos uma lista de produtos simulados e configuramos o comportamento simulado do ProdutoRepository usando o método when do Mockito. O método thenReturn indica que, quando o método findAll do ProdutoRepository for chamado, ele deve retornar a lista de produtos simulados.
5. Então, chamamos o endpoint getProdutos do ProdutoController e armazenamos o resultado em uma variável.
6. Finalmente, verificamos se todos os produtos foram retornados corretamente usando o método assertEquals do JUnit.

Com esse teste, podemos garantir que o endpoint getProdutos retorna todos os produtos do banco de dados corretamente. Se a implementação do endpoint for alterada no futuro e não retornar mais todos os produtos corretamente, esse teste falhará e saberemos que precisamos corrigir o código.

Conclusão

JUnit e Mockito são ferramentas poderosas para escrever testes automatizados em Java. Usando essas ferramentas em conjunto, podemos simular o comportamento de outras classes e garantir que nosso código funcione corretamente em diferentes cenários. Espero que este artigo tenha sido útil e que você possa usar essas técnicas em seus próprios projetos Spring.