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.
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.
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
- Testes parametrizados com @CsvSource e @MethodSource
- Mockito avançado: capturadores de argumentos e spies
- Fatias de teste do Spring Boot: @WebMvcTest e @DataJpaTest
- Testcontainers: testes de integração com banco de dados real