Resolving Issues with Quarkus Tests, Test Containers, and Liquibase Integration

Ensuring Proper Integration Between Liquibase and TestContainers in Quarkus

Backend solution using Quarkus with TestContainers to manage PostgreSQL and Liquibase migrations. This script resolves container misalignment issues.

import org.testcontainers.containers.PostgreSQLContainer;
import org.testcontainers.utility.DockerImageName;
import java.util.HashMap;
import java.util.Map;
public class PostgreSQLTestResource implements QuarkusTestResourceLifecycleManager {
    private static PostgreSQLContainer<?> postgreSQLContainer;
    @Override
    public Map<String, String> start() {
        postgreSQLContainer = new PostgreSQLContainer<>(DockerImageName.parse("postgres:alpine"))
            .withDatabaseName("test")
            .withUsername("postgres")
            .withPassword("password")
            .withReuse(true);
        postgreSQLContainer.start();
        Map<String, String> config = new HashMap<>();
        config.put("quarkus.datasource.jdbc.url", postgreSQLContainer.getJdbcUrl());
        config.put("quarkus.datasource.username", postgreSQLContainer.getUsername());
        config.put("quarkus.datasource.password", postgreSQLContainer.getPassword());
        return config;
    }
    @Override
    public void stop() {
        if (postgreSQLContainer != null) {
            postgreSQLContainer.stop();
        }
    }
}

Validating Application-Liquibase Integration Using Unit Tests

A modular and reusable Quarkus test example that verifies the database connection and migration script execution.

import org.junit.jupiter.api.Test;
import io.quarkus.test.junit.QuarkusTest;
import io.quarkus.test.junit.TestProfile;
@QuarkusTest
@TestProfile(TestProfileResolver.class)
public class XServiceTest {
    @Inject
    XTypeVersionService xTypeVersionService;
    @Test
    public void getXTypeVersion() {
        List<XTypeVersionEntity> entities = xTypeVersionService.get();
        assertFalse(entities.isEmpty(), "The entity list should not be empty.");
    }
}

Ensuring Configuration Consistency Across Test Profiles

Custom test profile configuration to guarantee alignment between Liquibase and application containers.

public class TestProfileResolver implements QuarkusTestProfile {
    @Override
    public String getConfigProfile() {
        return "test";
    }
    @Override
    public Map<String, String> getConfigOverrides() {
        return Map.of("quarkus.config.locations", "src/test/resources/application.yaml");
    }
}

Front-End Simulation for Data Validation

Dynamic front-end code snippet to ensure data from database integration is correctly displayed.

fetch('/api/xTypeVersion')
    .then(response => response.json())
    .then(data => {
        const list = document.getElementById('entity-list');
        data.forEach(entity => {
            const item = document.createElement('li');
            item.textContent = entity.name;
            list.appendChild(item);
        });
    })
    .catch(error => console.error('Error fetching data:', error));

Unit Tests for Backend and Front-End Consistency

Example test scripts to validate both backend logic and front-end integration with test data.

import org.junit.jupiter.api.Test;
public class FrontEndValidationTest {
    @Test
    public void fetchData() {
        given().when().get("/api/xTypeVersion")
            .then().statusCode(200)
            .body("size()", greaterThan(0));
    }
}

FAQs About Quarkus, TestContainers, and Liquibase Integration

1. What is the role of TestContainers in integration tests?
2. TestContainers helps manage isolated database instances during testing, ensuring consistent environments.
3. Why do I need the withReuse(true) command?
4. The withReuse(true) command allows you to reuse the same container across multiple tests, saving resources and setup time.
5. What is the purpose of the TC_INITSCRIPT property?
6. The TC_INITSCRIPT property specifies an initialization SQL script to seed the database at container startup.
7. How do I ensure Liquibase migrations are applied correctly?
8. By configuring the quarkus.liquibase.jdbc.url property, you can ensure Liquibase uses the same database container as the application.
9. What log levels should I use for debugging?
10. Set TRACE or DEBUG levels for Liquibase and TestContainers to monitor database operations and migrations.
11. How can I test API responses with seeded data?
12. Use tools like RestAssured to send requests to endpoints and verify the data returned matches the test data.
13. What does the @QuarkusTestResource annotation do?
14. The @QuarkusTestResource annotation registers a custom lifecycle manager for external dependencies like databases.
15. Why do I need a custom TestProfileResolver?
16. It ensures the correct configurations are loaded for test execution, aligning environment variables and resources.
17. How can I detect if multiple containers are being created?
18. Check your Docker Desktop or monitor the console logs for duplicate container instances and their respective ports.
19. What is the best way to clean up test resources?
20. Override the stop method in your lifecycle manager to stop and remove the container after tests complete.

Key Takeaways for Resolving Testing Conflicts

Integration testing with Quarkus, Liquibase, and TestContainers requires careful setup to ensure migrations and database interactions align. By customizing your test resource manager and using a unified configuration, you can eliminate conflicts between the containers used by Liquibase and your application.

These steps help streamline your testing process, making it easier to debug and validate your tests. Remember to use detailed logs, such as enabling TRACE for Liquibase, to monitor the behavior of your tests and resolve discrepancies early. With this approach, you can confidently build scalable and maintainable tests. 🐛