0Pricing
Java Academy · Lección

Testcontainers: pruebas de integración con una base de datos real

Inicie PostgreSQL en Docker con Testcontainers y ejecute pruebas de integración contra una base de datos real.

Testcontainers: pruebas de integración con una base de datos real es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

¿Por qué Testcontainers?

Las bases de datos en memoria H2 no admiten funciones específicas de PostgreSQL, como JSON, la búsqueda de texto completo u ON CONFLICT. Testcontainers inicia contenedores Docker reales durante las pruebas y proporciona una base de datos idéntica a la de producción.

Añadir la dependencia de Testcontainers

Añada el BOM de Testcontainers y el módulo de PostgreSQL al archivo de compilación. Spring Boot 3.1 y versiones posteriores incluyen una versión gestionada de 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 y @Container

Anote la clase de prueba con @Testcontainers y declare el contenedor como un campo estático @Container. JUnit 5 lo inicia y detiene automáticamente.

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

Configurar DataSource desde el contenedor

Utilice @DynamicPropertySource para inyectar el puerto dinámico y las credenciales del contenedor en la configuración de DataSource de 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

Spring Boot 3.1+ configura automáticamente el DataSource a partir de un bean @Container de Testcontainers anotado con @ServiceConnection, sin necesidad de @DynamicPropertySource.

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

Patrón de contenedor singleton

Iniciar un contenedor por clase de prueba es lento. Comparta un contenedor entre todas las pruebas mediante un campo estático con Startables.deepStart() o una clase base abstracta.

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);
    }
}

Pruebas de funcionalidades específicas de PostgreSQL

Con Testcontainers puede probar columnas JSON, operadores JSONB, búsqueda de texto completo y ON CONFLICT DO UPDATE, algo imposible con H2.

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

Varios contenedores: Compose

Utilice DockerComposeContainer para ejecutar una pila completa (Postgres + Redis + Kafka) en pruebas de integración que requieran varios servicios.

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

Ryuk: limpieza automática

Testcontainers utiliza un contenedor Ryuk para detener y eliminar automáticamente los contenedores cuando termina la JVM, incluso si falla una prueba, lo que evita fugas de contenedores.

<code>@SpringBootTest</code> con Testcontainers

Utilice @SpringBootTest en lugar de @DataJpaTest para probar la pila completa de la aplicación (controladores, servicios y repositorios) con un contenedor real de Postgres.

@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());
    }
}

Caché de imágenes de contenedor

Testcontainers almacena en caché localmente las imágenes de Docker descargadas. Descargue las imágenes en CI antes de ejecutar las pruebas (docker pull postgres:16-alpine) para evitar el coste de descarga durante la ejecución.

Comprobación rápida

¿Qué anotación conecta automáticamente un contenedor de Testcontainers con el DataSource de Spring en Spring Boot 3.1+?

Resumen

Testcontainers ejecuta contenedores Docker reales para las pruebas de integración. Utilice @Container + @DynamicPropertySource o @ServiceConnection (Boot 3.1+). Comparta los contenedores entre las pruebas mediante el patrón singleton. Pruebe funcionalidades específicas de PostgreSQL que son imposibles con H2.

Preguntas frecuentes

¿La lección «Testcontainers: pruebas de integración con una base de datos real» es gratis?

Sí — el texto completo de «Testcontainers: pruebas de integración con una base de datos real» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Testcontainers: pruebas de integración con una base de datos real»?

Inicie PostgreSQL en Docker con Testcontainers y ejecute pruebas de integración contra una base de datos real. Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Testcontainers: pruebas de integración con una base de datos real»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Pruebas parametrizadas con @CsvSource y @MethodSource
  2. Mockito avanzado: capturadores de argumentos y spies
  3. Slices de prueba de Spring Boot: @WebMvcTest y @DataJpaTest
  4. Testcontainers: pruebas de integración con una base de datos real
← Volver a Java Academy