Java Academy · Aula

Testcontainers: testes de integração com banco de dados real

Inicie o PostgreSQL no Docker com Testcontainers e execute testes de integração contra um banco de dados real.

Aula 4 de 413 etapas

Testcontainers: testes de integração com banco de dados real é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Por que usar Testcontainers?

Bancos de dados H2 em memória não oferecem suporte a recursos específicos do PostgreSQL (JSON, pesquisa de texto completo, ON CONFLICT). O Testcontainers inicia contêineres Docker reais durante os testes, proporcionando um banco de dados idêntico ao de produção.

Adicionando a dependência do Testcontainers

Adicione o BOM do Testcontainers e o módulo PostgreSQL ao arquivo de compilação. O Spring Boot 3.1+ inclui uma versão gerenciada do Testcontainers.

// build.gradle:
testImplementation "org.testcontainers:junit-jupiter"
testImplementation "org.testcontainers:postgresql"
// Optionally use Spring Boot Testcontainers support:
testImplementation "org.springframework.boot:spring-boot-testcontainers"

@Testcontainers e @Container

Anote a classe de teste com @Testcontainers e declare o contêiner como um campo estático @Container. O JUnit 5 inicia e encerra o contêiner automaticamente.

@Testcontainers
@DataJpaTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
class UserRepositoryIntegrationTest {
    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:16-alpine")
        .withDatabaseName("testdb")
        .withUsername("test")
        .withPassword("test");
}

Configurando o DataSource a partir do contêiner

Use @DynamicPropertySource para injetar a porta dinâmica e as credenciais do contêiner na configuração do DataSource do Spring.

@DynamicPropertySource
static void configureProperties(DynamicPropertyRegistry registry) {
    registry.add("spring.datasource.url",      postgres::getJdbcUrl);
    registry.add("spring.datasource.username", postgres::getUsername);
    registry.add("spring.datasource.password", postgres::getPassword);
}

Spring Boot 3.1 ServiceConnection

O Spring Boot 3.1+ configura automaticamente o DataSource a partir de um bean do Testcontainers anotado com @Container e @ServiceConnection — não é necessário utilizar @DynamicPropertySource.

@Bean
@ServiceConnection
static PostgreSQLContainer<?> postgresContainer() {
    return new PostgreSQLContainer<>("postgres:16-alpine");
}

Padrão de contêiner único

Iniciar um contêiner para cada classe de teste é lento. Compartilhe um único contêiner entre todos os testes usando um campo estático com Startables.deepStart() ou uma classe base abstrata.

abstract class AbstractIntegrationTest {
    @Container
    static final PostgreSQLContainer<?> POSTGRES =
        new PostgreSQLContainer<>("postgres:16-alpine").withReuse(true);
    static { POSTGRES.start(); }
    @DynamicPropertySource
    static void props(DynamicPropertyRegistry r) {
        r.add("spring.datasource.url",      POSTGRES::getJdbcUrl);
        r.add("spring.datasource.username", POSTGRES::getUsername);
        r.add("spring.datasource.password", POSTGRES::getPassword);
    }
}

Testando recursos específicos do PostgreSQL

Com o Testcontainers, você pode testar colunas JSON, operadores JSONB, pesquisa de texto completo e ON CONFLICT DO UPDATE — recursos impossíveis com o H2.

@Test
void jsonb_search_works() {
    // Insert row with JSONB column, then query
    List<Event> logins = repo.findByType("login");
    assertEquals(1, logins.size());
}

Vários contêineres: Compose

Utilize DockerComposeContainer para executar uma pilha completa (Postgres + Redis + Kafka) em testes de integração que exigem vários serviços.

@Container
static DockerComposeContainer<?> compose = new DockerComposeContainer<>(
    new File("src/test/resources/docker-compose.yml"))
    .withExposedService("postgres", 5432)
    .withExposedService("redis", 6379);

Ryuk: limpeza automática

O Testcontainers utiliza um contêiner Ryuk para interromper e remover contêineres automaticamente quando a JVM é encerrada — mesmo quando um teste falha, evitando o acúmulo de contêineres.

@SpringBootTest com Testcontainers

Utilize @SpringBootTest em vez de @DataJpaTest para testar toda a pilha da aplicação (controladores, serviços e repositórios) com um contêiner Postgres real.

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@Testcontainers
class FullIntegrationTest extends AbstractIntegrationTest {
    @LocalServerPort int port;
    @Autowired TestRestTemplate rest;
    @Test
    void end_to_end_user_creation() {
        ResponseEntity<UserDto> r = rest.postForEntity("/api/users", createReq(), UserDto.class);
        assertEquals(HttpStatus.CREATED, r.getStatusCode());
    }
}

Armazenamento em cache de imagens de contêiner

O Testcontainers armazena localmente em cache as imagens Docker baixadas. Baixe as imagens no CI antes da execução dos testes (docker pull postgres:16-alpine) para evitar o custo do download durante a execução.

Verificação rápida

Qual anotação conecta automaticamente um contêiner do Testcontainers ao DataSource do Spring no Spring Boot 3.1+?

Recapitulação

O Testcontainers executa contêineres Docker reais para testes de integração. Utilize @Container + @DynamicPropertySource ou @ServiceConnection (Boot 3.1+). Compartilhe contêineres entre os testes usando o padrão de contêiner único. Teste recursos específicos do PostgreSQL que são impossíveis com o H2.

Grátis para começar

Aprenda Java com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos
104
Aulas
374

Perguntas Frequentes

A aula “Testcontainers: testes de integração com banco de dados real” é grátis?

Sim — o texto completo de “Testcontainers: testes de integração com banco de dados real” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Testcontainers: testes de integração com banco de dados real”?

Inicie o PostgreSQL no Docker com Testcontainers e execute testes de integração contra um banco de dados real. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Testcontainers: testes de integração com banco de dados real”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Testes parametrizados com @CsvSource e @MethodSource
  2. Mockito avançado: capturadores de argumentos e spies
  3. Fatias de teste do Spring Boot: @WebMvcTest e @DataJpaTest
  4. Testcontainers: testes de integração com banco de dados real
← Voltar para Java Academy