repository·main·Indexed 11 days ago
https://github.com/testcontainers/testcontainers-javaA Java library that enables developers to run lightweight, throwaway instances of common databases, Selenium web browsers, or any other Docker-compatible software during JUnit tests to ensure a consistent, isolated environment for integration testing.
Testcontainers provides database support for DAO unit tests and end-to-end integration tests. Use it in the following scenarios:
Note that while Testcontainers offers higher fidelity than H2, it is less performant. It is recommended to use mocks for higher-level components and limit the number of tests that interact directly with the database.
Testcontainers provides direct integrations with several open-source testing frameworks. Instead of manually managing container lifecycles within your test code, you can use these specialized extensions to integrate container management directly into the framework's lifecycle (e.g., as part of property-based testing or specialized test runners).
Supported integrations include:
jqwik-testcontainers for property-based testing integration.kotest-extensions-testcontainers for Kotest-specific extensions.TDK-Testcontainers integration for Synthesized data workflows.Testcontainers Infrastructure (TCI) Framework for infrastructure-level integration.DynamoDbClient to interact with it, making it suitable for testing applications designed for Amazon DynamoDB.When connecting to ScyllaDB via a CqlSession, you can use different connection strategies provided by the container instance:
The JUnit 5 integration uses the @Testcontainers annotation on a test class to enable the extension. The extension scans for fields annotated with @Container and manages their lifecycle automatically by calling their Startable interface methods.
@Nested test classes because nested classes must be non-static and cannot contain static fields.@Testcontainers
class MyTest {
@Container
static GenericContainer<?> sharedContainer = new GenericContainer<>("redis:latest"); // Shared across all methods
@Container
GenericContainer<?> restartedContainer = new GenericContainer<>("postgres:latest"); // Restarted for every method
@Test
void testOne() {
// ...
}
}@Rule or @ClassRule in JUnit 4. This pattern is typically used to share a single container instance across multiple test classes to improve performance by reducing the overhead of starting and stopping containers.When no pre-existing Docker image is available, or when you need to customize a base image for specific tests, you can use ImageFromDockerfile to build a temporary image from a Dockerfile.
To use it, pass an instance of ImageFromDockerfile as a constructor parameter to GenericContainer. Testcontainers will execute a docker build to create the image before starting the container.
GenericContainer container = new GenericContainer(
new ImageFromDockerfile()
// configuration here
);The MySQL module handles the root user password as follows:
root user defaults to the password test.root user as well.When choosing an API for Docker Compose support:
ComposeContainer: Supports Compose V2. This is the recommended approach.DockerComposeContainer: Utilizes Compose V1, which is deprecated by Docker.The APIs are similar, and most usage patterns apply to both.
Before creating a new module, evaluate if it provides enough value to be maintained as a first-class Testcontainers module. A new module is appropriate if it meets these criteria:
GenericContainer snippet by:If the contribution does not meet these, consider publishing a code snippet, contributing an example to the repository, or publishing your own third-party library instead.
To prevent classpath conflicts with your application or test code, Testcontainers 'shades' (relocates) certain implementation-detail dependencies.
JUnit, docker-java-{api,transport}, JNA, and visible-assertions are part of the public API and are NOT shaded.docker-java-core, Guava, and OkHttp are shaded and relocated under the org.testcontainers.shaded package to avoid version conflicts.