Testes de Integração com TestContainers e RestAssured - Felipe-builder/rest-conexa-challenger GitHub Wiki

Testes de Integração com TestContainers e RestAssured

Este documento descreve como implementar e executar testes de integração usando TestContainers para configurar um contêiner MySQL e RestAssured para realizar requisições HTTP.

Dependências Maven

Adicione as seguintes dependências ao seu arquivo pom.xml:

<dependencies>
    <!-- TestContainers -->
    <dependency>
        <groupId>org.testcontainers</groupId>
        <artifactId>mysql</artifactId>
        <version>1.17.6</version>
        <scope>test</scope>
    </dependency>
    <!-- RestAssured -->
    <dependency>
        <groupId>io.rest-assured</groupId>
        <artifactId>rest-assured</artifactId>
        <version>4.5.1</version>
        <scope>test</scope>
        <exclusions>
            <exclusion>
                <groupId>org.codehaus.groovy</groupId>
                <artifactId>groovy-xml</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

Configuração do MySQL e Spring Boot

O arquivo src/test/resources/application.yml contém as configurações para o contêiner MySQL e o Spring Boot durante os testes de integração. Certifique-se de ajustar as informações conforme necessário.

# application.yml

server:
  port: 8888
spring:
  application:
    name: rest-conexa-challenger-test
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/rest-conexa-challenger-test?useTimezone=true&serverTimezone=UTC&useSSL=false
    username: root
    password: admin123
  jpa:
    open-in-view: false
    show-sql: false
    hibernate:
      ddl-auto: update
    properties:
      hibernate:
        dialect: org.hibernate.dialect.MySQLDialect
  flyway:
    url: jdbc:mysql://localhost:3306/
    schemas: rest-conexa-challenger-test
    user: root
    password: admin123
    locations: classpath:db/migration
springdoc:
  pathsToMatch: /api/v1/**
  swagger-ui:
    use-root-path: true

Configuração dos Testes

O seguinte código mostra como configurar os testes de integração utilizando TestContainers e RestAssured.

Configuração Inicial

// TestConfigs.java

package com.felipe.configs;

public class TestConfigs {

    public static final int SERVER_PORT = 8888;
}

Teste de Integração Swagger

// SwaggerIntegrationTest.java

package com.felipe.integrationtests.swagger;

import static io.restassured.RestAssured.given;
import static org.junit.Assert.assertTrue;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import com.felipe.configs.TestConfigs;
import com.felipe.integrationtests.testcontainers.AbstractIntegrationTest;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
public class SwaggerIntegrationTest extends AbstractIntegrationTest {

    @Test
    public void shouldDisplaySwaggerUiPage() {
        var content = given()
                .basePath("/swagger-ui/index.html")
                .port(TestConfigs.SERVER_PORT)
                .when()
                .get()
                .then()
                .statusCode(200)
                .extract()
                .body()
                .asString();

        assertTrue(content.contains("Swagger UI"));
    }
}

Configuração do TestContainers

// AbstractIntegrationTest.java

package com.felipe.integrationtests.testcontainers;

import java.util.Map;
import java.util.stream.Stream;

import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.MapPropertySource;
import org.springframework.test.context.ContextConfiguration;
import org.testcontainers.containers.MySQLContainer;
import org.testcontainers.lifecycle.Startables;

@ContextConfiguration(initializers = AbstractIntegrationTest.Initializer.class)
public class AbstractIntegrationTest {

    static public class Initializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
        static MySQLContainer<?> mysql = new MySQLContainer<>("mysql:8.0");

        private static void startContainers() {
            Startables.deepStart(Stream.of(mysql)).join();
        }

        private Map<String, String> createConnectionConfiguration() {
            return Map.of(
                    "spring.datasource.url", mysql.getJdbcUrl(),
                    "spring.datasource.username", mysql.getUsername(),
                    "spring.datasource.password", mysql.getPassword()
            );
        }

        @SuppressWarnings({"rawtypes", "unchecked"})
        @Override
        public void initialize(ConfigurableApplicationContext applicationContext) {
            startContainers();
            ConfigurableEnvironment environment = applicationContext.getEnvironment();
            MapPropertySource testcontainers = new MapPropertySource(
                    "testcontainers",
                    (Map) createConnectionConfiguration());
            environment.getPropertySources().addFirst(testcontainers);
        }
    }
}

Esse documento fornece uma visão geral das dependências, configurações e códigos necessários para implementar testes de integração usando TestContainers e RestAssured no seu projeto. Certifique-se de personalizar as configurações conforme necessário para atender aos requisitos específicos do seu aplicativo.

Essa estrutura de documentação fornece uma visão geral clara dos passos necessários para configurar e executar testes de integração usando TestContainers e RestAssured no seu projeto Spring Boot. Certifique-se de personalizar os exemplos e as configurações conforme necessário para se adequar à sua aplicação.

⚠️ **GitHub.com Fallback** ⚠️