Como testar as interfaces do mapeador Spring Boot MyBatis com Spring Tester? -Blog

Testar as interfaces do mapeador Spring Boot MyBatis é uma etapa crucial para garantir a confiabilidade e funcionalidade do seu aplicativo. Como fornecedor do Spring Tester, entendo a importância dos testes completos e os desafios que os desenvolvedores enfrentam quando se trata de testar as interfaces do mapeador MyBatis. Nesta postagem do blog, compartilharei algumas práticas e técnicas recomendadas sobre como testar com eficácia as interfaces do mapeador Spring Boot MyBatis usando Spring Tester.

Compreendendo as interfaces do mapeador MyBatis

MyBatis é uma estrutura de persistência popular que simplifica o acesso ao banco de dados em aplicativos Java. As interfaces mapeadoras MyBatis são interfaces Java que definem métodos SQL para operações de banco de dados. Essas interfaces são usadas para interagir com o banco de dados sem a necessidade de escrever código padrão para operações JDBC.

Ao testar as interfaces do mapeador MyBatis, precisamos garantir que as consultas SQL definidas nessas interfaces estejam corretas e retornem os resultados esperados. Spring Tester fornece uma maneira conveniente de testar essas interfaces em um contexto de aplicativo Spring Boot.

Configurando o ambiente de teste

Antes de começarmos os testes, precisamos configurar o ambiente de teste. Primeiro, certifique-se de ter as seguintes dependências em seupom.xmlse você estiver usando Maven:

<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter-test</artifactId> <scope>teste</scope> </dependency>

Essas dependências fornecem os utilitários de teste necessários para Spring Boot e MyBatis.

Escrevendo um teste simples para uma interface MyBatis Mapper

Vamos supor que temos uma interface simples de mapeador MyBatis chamadaUserMapperque possui um método para encontrar um usuário por ID:

importar org.apache.ibatis.annotations.Mapper; importar org.apache.ibatis.annotations.Select; @Mapper interface pública UserMapper { @Select("SELECT * FROM users WHERE id = #{id}") Usuário findUserById(int id); }

Para testar esta interface mapeadora, podemos escrever uma classe de teste usando Spring Tester. Aqui está um exemplo:

importar org.junit.jupiter.api.Test; importar org.springframework.beans.factory.annotation.Autowired; importar org.springframework.boot.test.context.SpringBootTest; importar estático org.junit.jupiter.api.Assertions.assertNotNull; @SpringBootTest public class UserMapperTest { @Autowired private UserMapper userMapper; @Test public void testFindUserById() { Usuário usuário = userMapper.findUserById(1); assertNotNull(usuário); } }

Nesta classe de teste, usamos o@SpringBootTestanotação para carregar o contexto do aplicativo Spring Boot. Em seguida, ligamos automaticamente oUserMapperinterface e escreva um método de teste para chamar oFindurbymétodo. Usamos JUnit 5assertNotNullasserção para garantir que o usuário retornado não seja nulo.

Testando com um banco de dados de teste

Em um cenário real, não queremos usar o banco de dados de produção para testes. Podemos usar um banco de dados na memória como H2 para teste. Adicione a seguinte dependência ao seupom.xml:

<dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <scope>teste</scope> </dependency>

Em seguida, configure o banco de dados de teste em seuteste-aplicativo.propertiesarquivo:

spring.datasource.url=jdbc:h2:mem:testdb spring.datasource.driverClassName=org.h2.Driver spring.datasource.username=sa spring.datasource.password=senha spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

Agora, ao executar os testes, o Spring Boot usará o banco de dados H2 na memória em vez do banco de dados de produção.

Testando consultas e transações complexas

Às vezes, as interfaces do mapeador MyBatis podem ter consultas ou transações complexas. Por exemplo, uma interface mapeadora pode ter um método para inserir um usuário e então atualizar outro registro relacionado na mesma transação.

Vamos supor que temos umUserMappercom um método para inserir um usuário:

Lab Colloid Mill Machine

importar org.apache.ibatis.annotations.Insert; importar org.apache.ibatis.annotations.Options; @Mapper interface pública UserMapper { @Insert("INSERT INTO usuários (nome, e-mail) VALUES (#{nome}, #{email})") @Options(useGeneratedKeys = true, keyProperty = "id") int insertUser(Usuário usuário); }

Para testar este método, podemos escrever um teste da seguinte forma:

importar org.junit.jupiter.api.Test; importar org.springframework.beans.factory.annotation.Autowired; importar org.springframework.boot.test.context.SpringBootTest; importar org.springframework.transaction.annotation.Transactional; importar estático org.junit.jupiter.api.Assertions.assertTrue; @SpringBootTest @Transactional public class UserMapperInsertTest { @Autowired private UserMapper userMapper; @Test public void testInsertUser() { Usuário usuário = new Usuário(); user.setName("John Doe"); user.setEmail("johndoe@example.com"); int resultado = userMapper.insertUser(usuário); assertTrue(resultado > 0); } }

O@Transacionala anotação garante que o teste seja executado dentro de uma transação e que as alterações feitas durante o teste sejam revertidas após a conclusão do teste.

Usando simulação para dependências externas

Em alguns casos, a interface do mapeador MyBatis pode depender de serviços ou componentes externos. Por exemplo, um método mapeador pode chamar uma API externa para validar alguns dados antes de executar uma operação de banco de dados. Nesses casos, podemos usar zombaria para isolar a interface do mapeador dessas dependências externas.

Podemos usar o Mockito, que é uma estrutura de simulação popular no ecossistema Java. Adicione a seguinte dependência ao seupom.xml:

<dependency> <groupId>org.mockito</groupId> <artifactId>mockito-core</artifactId> <scope>teste</scope> </dependency>

Aqui está um exemplo de como usar o Mockito para simular um serviço externo em um teste de mapeador:

importar org.junit.jupiter.api.Test; importar org.mockito.Mockito; importar org.springframework.beans.factory.annotation.Autowired; importar org.springframework.boot.test.context.SpringBootTest; importar org.springframework.boot.test.mock.mockito.MockBean; importar static org.junit.jupiter.api.Assertions.assertEquals; @SpringBootTest public class UserMapperWithMockTest { @Autowired private UserMapper userMapper; @MockBean private ExternalService externalService; @Test public void testMapperWithMock() { Mockito.when(externalService.validateData(Mockito.any())).thenReturn(true); Usuário usuário = userMapper.findUserById(1); assertEquals("Nome esperado", user.getName()); } }

Produtos Relacionados

Como fornecedor de Spring Tester, também oferecemos uma variedade de equipamentos de laboratório de alta qualidade. Você pode estar interessado em nossoBomba de vácuo de circulação vertical de água,Máquina de moinho colóide de laboratório, eReator de vidro revestido 20L. Esses produtos são projetados para atender às necessidades de diversas pesquisas científicas e aplicações industriais.

Conclusão

Testar as interfaces do mapeador Spring Boot MyBatis é essencial para garantir a qualidade e confiabilidade de sua aplicação. Usando o Spring Tester, podemos escrever facilmente testes para essas interfaces em um contexto de aplicativo Spring Boot. Podemos usar bancos de dados na memória para testar, lidar com transações e usar simulação para isolar dependências externas.

Se você estiver interessado em nossos produtos Spring Tester ou em qualquer equipamento de laboratório relacionado, entre em contato conosco para futuras aquisições e negociações. Temos o compromisso de fornecer a você as melhores soluções para suas necessidades de testes e pesquisas.

Referências

Documentação de inicialização Spring
Documentação MyBatis
Documentação do JUnit 5
Documentação do Mockito