Testing Mastery: JUnit, Mockito & Integration Tests · Lección

Bases de datos embebidas para pruebas

Configure y utilice bases de datos en memoria o embebidas para realizar pruebas de integración rápidas y aisladas.

Bases de datos embebidas para pruebas es una lección gratuita de Testing Mastery: JUnit, Mockito & Integration Tests en CoddyKit. Esta es la lección 3 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 Testing Mastery: JUnit, Mockito & Integration Tests, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Testing Mastery: JUnit, Mockito & Integration Tests incluye 4 lecciones en total.

Partes de esta lección aún no han sido traducidas y se muestran en inglés.

Embedded DBs for Tests

When writing integration tests for Spring Boot applications, especially those interacting with a database, you need a database instance for your tests to run against.

Embedded databases provide a lightweight, in-memory solution that's perfect for this scenario.

Why Use Embedded DBs?

Embedded databases offer several key benefits for testing:

Isolation: Each test run gets a clean, fresh database, preventing side effects.
Speed: Being in-memory, they are incredibly fast, reducing test execution time.
Simplicity: No need for external database servers or complex setup.
Repeatability: Tests are consistent because they always start with the same data state.

H2 & HSQLDB Options

Two popular choices for embedded databases in Java applications are H2 Database and HSQLDB.

H2: A fast, open-source, JDBC-compliant in-memory database. It's widely used with Spring Boot.
HSQLDB: Another lightweight, relational database written in Java.

We'll focus on H2 as it's a common default in Spring Boot.

Adding H2 Dependency

To use H2 in your Spring Boot project, you typically add it as a test scope dependency in your pom.xml (for Maven) or build.gradle (for Gradle).

This ensures it's only available during testing.

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

Spring Boot Auto-Config

One of Spring Boot's magic tricks is auto-configuration. When it detects H2 on the classpath during tests, it automatically configures an in-memory H2 database for you.

You often don't need to specify a database URL in application.properties for tests, making setup trivial!

User Entity & Repository

Let's consider a simple User entity and a UserRepository. We want to test if our repository correctly saves and retrieves users.

These are standard JPA components.

// User.java
package com.coddykit.demo;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;

    public User() {}
    public User(String name, String email) {
        this.name = name;
        this.email = email;
    }

    // Getters and Setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

// UserRepository.java
package com.coddykit.demo;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    User findByName(String name);
}

@DataJpaTest with H2

Spring Boot provides @DataJpaTest specifically for testing JPA components. It auto-configures an in-memory database (like H2 if present) and an EntityManager.

It also rolls back transactions after each test, ensuring a clean state.

UserRepository Test Example

Here's how you might write an integration test for our UserRepository using H2 and @DataJpaTest:

package com.coddykit.demo;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager;
import static org.assertj.core.api.Assertions.assertThat;

@DataJpaTest
class UserRepositoryTest {

    @Autowired
    private TestEntityManager entityManager;

    @Autowired
    private UserRepository userRepository;

    @Test
    void whenFindByName_thenReturnUser() {
        // given
        User alice = new User("Alice", "alice@example.com");
        entityManager.persist(alice);
        entityManager.flush();

        // when
        User found = userRepository.findByName(alice.getName());

        // then
        assertThat(found.getName()).isEqualTo(alice.getName());
        assertThat(found.getEmail()).isEqualTo(alice.getEmail());
    }

    @Test
    void whenInvalidName_thenReturnNull() {
        // when
        User found = userRepository.findByName("InvalidName");

        // then
        assertThat(found).isNull();
    }
}

Schema & Data Initialization

For more complex scenarios, you might need to pre-populate your in-memory database with a schema or initial data.

Place schema.sql in src/test/resources for DDL (Data Definition Language).
Place data.sql in src/test/resources for DML (Data Manipulation Language).

Spring Boot will automatically pick these up for your tests.

Quick Check

Which of the following is NOT a primary benefit of using an embedded database like H2 for Spring Boot integration tests?

Recap & Next Steps

We've explored how embedded databases like H2 are invaluable for fast and isolated Spring Boot integration tests.

They offer speed, isolation, and simplicity.
Spring Boot auto-configures them with minimal effort.
@DataJpaTest simplifies testing JPA repositories with these databases.
You can initialize schemas and data using schema.sql and data.sql.

Next, you might explore testing RESTful APIs with MockMvc!

Preguntas frecuentes

¿La lección «Bases de datos embebidas para pruebas» es gratis?

Sí — el texto completo de «Bases de datos embebidas para pruebas» 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 Testing Mastery: JUnit, Mockito & Integration Tests, actualiza a CoddyKit PRO. El curso de Testing Mastery: JUnit, Mockito & Integration Tests incluye 4 lecciones en total.

¿Qué aprenderé en «Bases de datos embebidas para pruebas»?

Configure y utilice bases de datos en memoria o embebidas para realizar pruebas de integración rápidas y aisladas. Practicas Testing Mastery: JUnit, Mockito & Integration Tests 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 Testing Mastery: JUnit, Mockito & Integration Tests?

No se requiere experiencia previa. Testing Mastery: JUnit, Mockito & Integration Tests 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 3 de 4.

¿Cuánto tiempo toma la lección «Bases de datos embebidas para pruebas»?

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 Testing Mastery: JUnit, Mockito & Integration Tests?

Sí. Cada lección de Testing Mastery: JUnit, Mockito & Integration Tests 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

Framework de contexto de pruebas de Spring
Pruebas de API RESTful
Bases de datos embebidas para pruebas
Pruebas de la capa web con @WebMvcTest y MockMvc

← Volver a Testing Mastery: JUnit, Mockito & Integration Tests