Testcontainers for Java

https://java.testcontainers.org/
Admin
Testcontainers for Java is a Java library that supports JUnit tests, providing lightweight,...
Tokens:69,265
Snippets:807
Trust Score:9.9
Update:1 month ago
Show doc for...
Tokens:
Raw
### Start Datastore Emulator Container

Source: https://java.testcontainers.org/modules/gcloud

Instantiate a DatastoreEmulatorContainer with the specified Docker image. This is the initial setup before starting the emulator.

```java
DatastoreEmulatorContainer emulator = new DatastoreEmulatorContainer(
    DockerImageName.parse("gcr.io/google.com/cloudsdktool/google-cloud-cli:441.0.0-emulators")
);
```

--------------------------------

### Start Containers in Parallel

Source: https://java.testcontainers.org/features/advanced_options

Demonstrates how to start multiple Testcontainers containers concurrently using `Startables.deepStart(container1, container2, ...).join()`. This approach can significantly reduce the overall container startup time by leveraging parallel execution, which is beneficial for complex test setups.

```Java
Startables.deepStart(container1, container2, ...).join()
```

--------------------------------

### Start Milvus Container with External Etcd

Source: https://java.testcontainers.org/modules/milvus

This example demonstrates starting a Milvus container that depends on an external Etcd instance. Ensure Etcd is configured correctly before starting Milvus.

```java
Network network = Network.newNetwork();
GenericContainer<?> etcd = new GenericContainer<>("quay.io/coreos/etcd:v3.5.5")
    .withNetwork(network)
    .withNetworkAliases("etcd")
    .withCommand(
        "etcd",
        "-advertise-client-urls=http://127.0.0.1:2379",
        "-listen-client-urls=http://0.0.0.0:2379",
        "--data-dir=/etcd"
    )
    .withEnv("ETCD_AUTO_COMPACTION_MODE", "revision")
    .withEnv("ETCD_AUTO_COMPACTION_RETENTION", "1000")
    .withEnv("ETCD_QUOTA_BACKEND_BYTES", "4294967296")
    .withEnv("ETCD_SNAPSHOT_COUNT", "50000")
    .waitingFor(Wait.forLogMessage(".*ready to serve client requests.*", 1));
MilvusContainer milvus = new MilvusContainer("milvusdb/milvus:v2.3.9")
    .withNetwork(network)
    .withEtcdEndpoint("etcd:2379")
    .dependsOn(etcd)
```

--------------------------------

### Start PineconeLocalContainer Instance

Source: https://java.testcontainers.org/modules/pinecone

Instantiate a Pinecone container using the specified image. Ensure the image path is correct for your setup.

```java
PineconeLocalContainer container = new PineconeLocalContainer("ghcr.io/pinecone-io/pinecone-local:v0.7.0")
```

--------------------------------

### Start Firestore Emulator Container

Source: https://java.testcontainers.org/modules/gcloud

Instantiate a FirestoreEmulatorContainer with the specified Docker image. This is the initial setup before starting the emulator.

```java
FirestoreEmulatorContainer emulator = new FirestoreEmulatorContainer(
    DockerImageName.parse("gcr.io/google.com/cloudsdktool/google-cloud-cli:441.0.0-emulators")
);
```

--------------------------------

### Start MinIO Container

Source: https://java.testcontainers.org/modules/minio

Instantiate a MinIO container using the default image. This is the basic setup for using MinIO in tests.

```java
MinIOContainer container = new MinIOContainer("minio/minio:RELEASE.2023-09-04T19-57-37Z");
```

--------------------------------

### Example startup check output

Source: https://java.testcontainers.org/features/configuration

Displays the standard console output generated by Testcontainers during the initial environment validation phase.

```text
        ℹ︎ Checking the system...
        ✔ Docker version should be at least 1.6.0
        ✔ File should be mountable
        ✔ A port exposed by a docker container should be accessible
```

--------------------------------

### Start Milvus Container with Default Configuration

Source: https://java.testcontainers.org/modules/milvus

Use this snippet to quickly start a Milvus container with default settings. No external dependencies are required.

```java
MilvusContainer milvus = new MilvusContainer("milvusdb/milvus:v2.3.9")
```

--------------------------------

### Start and Use a Solr Container Instance

Source: https://java.testcontainers.org/modules/solr

Instantiate, start, and interact with a Solr container. Ensure to stop the container after use. Requires the Solr container to be running.

```java
// Create the solr container.
SolrContainer container = new SolrContainer(solrImage);

// Start the container. This step might take some time...
container.start();

// Do whatever you want with the client ...
SolrClient client = new Http2SolrClient.Builder(
    "http://" + container.getHost() + ":" + container.getSolrPort() + "/solr"
)
    .build();
SolrPingResponse response = client.ping("dummy");

// Stop the container.
container.stop();

```

--------------------------------

### Solace Container Setup with Simple Authentication

Source: https://java.testcontainers.org/modules/solace

Use this snippet to start a Solace container with basic username and password authentication. Ensure the Solace image and version are correctly specified.

```java
SolaceContainer solaceContainer = new SolaceContainer("solace/solace-pubsub-standard:10.25.0")
    .withCredentials("user", "pass")
    .withTopic(TOPIC.getName(), Service.SMF)
    .withVpn("test_vpn")
```

--------------------------------

### Copying files to a container before startup using MountableFile

Source: https://java.testcontainers.org/features/files

Demonstrates how to copy a classpath resource directory into a container before it starts using the MountableFile utility.

```java
GenericContainer<?> container = new GenericContainer<>(TestImages.TINY_IMAGE)
    .withCommand("sleep", "3000")
    .withCopyFileToContainer(
        MountableFile.forClasspathResource("/mappable-resource/"),
        directoryInContainer
    );
```

--------------------------------

### Start Neo4j Container

Source: https://java.testcontainers.org/modules/databases/neo4j

Basic usage to start a Neo4j container instance. Ensure the correct Neo4j version is specified.

```java
Neo4jContainer neo4j = new Neo4jContainer("neo4j:4.4")
```

--------------------------------

### Start OpenFGA Container Instance

Source: https://java.testcontainers.org/modules/openfga

Instantiate an OpenFGA container using the specified image. Ensure the image tag is correct for your needs.

```java
OpenFGAContainer openfga = new OpenFGAContainer("openfga/openfga:v1.4.3")
```

--------------------------------

### Start Default ActiveMQ Container

Source: https://java.testcontainers.org/modules/activemq

Use this to start a default ActiveMQ Classic container instance. Ensure the correct image tag is specified.

```java
ActiveMQContainer activemq = new ActiveMQContainer("apache/activemq:5.18.7")
```

--------------------------------

### Configure ScyllaDB Container with SSL

Source: https://java.testcontainers.org/modules/databases/scylladb

Start a ScyllaDB container with custom SSL configuration, mounting certificate and key files.

```java
ScyllaDBContainer scylladb = new ScyllaDBContainer("scylladb/scylla:6.2")
    .withConfigurationOverride("scylla-test-ssl")
    .withSsl(
        MountableFile.forClasspathResource("keys/scylla.cer.pem"),
        MountableFile.forClasspathResource("keys/scylla.key.pem"),
        MountableFile.forClasspathResource("keys/scylla.truststore")
    )
```

--------------------------------

### Start K3s Server with Testcontainers

Source: https://java.testcontainers.org/modules/k3s

Use K3sContainer to start a K3s server instance. Specify the Docker image name for the K3s distribution.

```java
K3sContainer k3s = new K3sContainer(DockerImageName.parse("rancher/k3s:v1.21.3-k3s1"))
    .withLogConsumer(new Slf4jLogConsumer(log))
```

--------------------------------

### Start MongoDBContainer

Source: https://java.testcontainers.org/modules/databases/mongodb

Start the MongoDB container to make it available for testing. Ensure the container is properly started before attempting to connect.

```java
mongoDBContainer.start();
```

--------------------------------

### Using a Solace Container Instance

Source: https://java.testcontainers.org/modules/solace

Retrieve connection details from a running Solace container to establish a session. This example shows how to get username, password, and origin for AMQP service.

```java
Session session = createSession(
    solaceContainer.getUsername(),
    solaceContainer.getPassword(),
    solaceContainer.getOrigin(Service.AMQP)
);
```

--------------------------------

### Start Default ChromaDB Container

Source: https://java.testcontainers.org/modules/chromadb

Instantiate a default ChromaDB container. Ensure the correct image version is specified.

```java
ChromaDBContainer chroma = new ChromaDBContainer("chromadb/chroma:0.4.23")
```

--------------------------------

### Start Pub/Sub Emulator Container

Source: https://java.testcontainers.org/modules/gcloud

Instantiate a Pub/Sub Emulator container using a specific Docker image. This is the initial step to bring up the emulator for testing.

```java
PubSubEmulatorContainer emulator = new PubSubEmulatorContainer(
    DockerImageName.parse("gcr.io/google.com/cloudsdktool/google-cloud-cli:441.0.0-emulators")
);
```

--------------------------------

### Start Default Qdrant Container

Source: https://java.testcontainers.org/modules/qdrant

Instantiate a Qdrant container using the default image and tag. Ensure the Qdrant container image is available.

```java
QdrantContainer qdrant = new QdrantContainer("qdrant/qdrant:v1.7.4")
```

--------------------------------

### Setup k6 Container

Source: https://java.testcontainers.org/modules/k6

Configure and initialize a k6 container instance. Use this to specify the k6 image, test script, script variables, and command-line options.

```java
K6Container container = new K6Container("grafana/k6:0.49.0")
    .withTestScript(MountableFile.forClasspathResource("scripts/test.js"))
    .withScriptVar("MY_SCRIPT_VAR", "are cool!")
    .withScriptVar("AN_UNUSED_VAR", "unused")
    .withCmdOptions("--quiet", "--no-usage-report")
```

--------------------------------

### Start LLDAP Container Instance

Source: https://java.testcontainers.org/modules/ldap

Instantiate an LLDAP container using the specified image. Ensure the image tag is correct for your needs.

```java
LLdapContainer lldap = new LLdapContainer("lldap/lldap:v0.6.1-alpine")
```

--------------------------------

### Basic Presto Container Setup

Source: https://java.testcontainers.org/modules/databases/presto

Initialize a Presto container for testing. This is useful for setting up a Presto instance to run tests against.

```java
public class SomeTest {

    @Rule
    public PrestoContainer presto = new PrestoContainer();

    @Test
    public void someTestMethod() {
        String url = presto.getJdbcUrl();

        ... create a connection and run test as normal

```

--------------------------------

### Initialize Database with Init Script from File

Source: https://java.testcontainers.org/modules/databases/jdbc

Load an initialization script from a file (relative to the project root) by prefixing the path with `file:`. This allows for easier management of SQL scripts used for database setup.

```sql
jdbc:tc:mysql:8.0.36:///databasename?TC_INITSCRIPT=file:src/main/resources/init_mysql.sql
```

--------------------------------

### Start BigQuery Emulator Container

Source: https://java.testcontainers.org/modules/gcloud

Instantiate a BigQueryEmulatorContainer with a specific Docker image. This is the initial step to use the BigQuery emulator in tests.

```java
BigQueryEmulatorContainer container = new BigQueryEmulatorContainer("ghcr.io/goccy/bigquery-emulator:0.4.3")
```

--------------------------------

### Start Azurite Container

Source: https://java.testcontainers.org/modules/azure

Initializes the Azurite storage emulator container with a specific image version.

```java
AzuriteContainer emulator = new AzuriteContainer("mcr.microsoft.com/azure-storage/azurite:3.33.0")
```

--------------------------------

### Start DB2 Container Instance

Source: https://java.testcontainers.org/modules/databases/db2

Instantiates a DB2 container with a specific image and accepts the EULA. Ensure the EULA is accepted either programmatically or by providing a license acceptance file.

```java
Db2Container db2 = new Db2Container("icr.io/db2_community/db2:11.5.8.0").acceptLicense()
```

--------------------------------

### Start Vault Container Instance

Source: https://java.testcontainers.org/modules/vault

Instantiates a Vault container with a specific image version, token, and initialization commands for secrets management.

```java
public static VaultContainer<?> vaultContainer = new VaultContainer<>("hashicorp/vault:1.13")
    .withVaultToken(VAULT_TOKEN)
    .withInitCommand(
        "secrets enable transit",
        "write -f transit/keys/my-key",
        "kv put secret/testing1 top_secret=password123",
        "kv put secret/testing2 secret_one=password1 secret_two=password2 secret_three=password3 secret_three=password3 secret_four=password4"
    );
```

--------------------------------

### Start CockroachDB Container Instance

Source: https://java.testcontainers.org/modules/databases/cockroachdb

Instantiate a CockroachDB container using the specified image. Ensure the image tag is appropriate for your needs.

```java
CockroachContainer cockroach = new CockroachContainer("cockroachdb/cockroach:v26.1.1")
```

--------------------------------

### Start Neo4j Container with Predefined Database

Source: https://java.testcontainers.org/modules/databases/neo4j

Load an existing Neo4j database (`graph.db`) into the container. This method is only compatible with Neo4j 3.5.x.

```java
Neo4jContainer neo4j = new Neo4jContainer("neo4j:3.5.30")
    .withDatabase(MountableFile.forClasspathResource("/test-graph.db"))
```

--------------------------------

### Start Ollama Container Instance

Source: https://java.testcontainers.org/modules/ollama

Instantiate an Ollama container using the specified image. Ensure the correct image tag is used.

```java
OllamaContainer ollama = new OllamaContainer("ollama/ollama:0.1.26")
```

--------------------------------

### Docker Compose config.json Example

Source: https://java.testcontainers.org/modules/docker_compose

An example of a Docker configuration file (`config.json`) that uses a credential store. When running Docker Compose in a container, this configuration might not work directly due to limitations accessing local credential stores like Keychain. Consider using `auths` directly or 'local compose' mode.

```json
{
  "auths" : {
    "https://index.docker.io/v1/" : {
    }
  },
  "credsStore" : "osxkeychain"
}
```

--------------------------------

### Start Azure CosmosDB Emulator container

Source: https://java.testcontainers.org/modules/azure

Initializes the CosmosDB emulator container using the official Microsoft Docker image.

```java
CosmosDBEmulatorContainer emulator = new CosmosDBEmulatorContainer(
    DockerImageName.parse("mcr.microsoft.com/cosmosdb/linux/azure-cosmos-emulator:latest")
);
```

--------------------------------

### Configure Minimum Duration Startup Strategy

Source: https://java.testcontainers.org/features/startup_and_waits

Demonstrates how to use MinimumDurationRunningStartupCheckStrategy to ensure a container remains running for a specified duration before being considered ready. This is useful for containers that perform initialization tasks after starting.

```java
public GenericContainer<?> bboxWithMinimumDuration = new GenericContainer<>(
    DockerImageName.parse("busybox:1.31.1")
)
    .withCommand("sh", "-c", String.format("sleep 5 && echo \"%s\"", HELLO_TESTCONTAINERS))
    .withStartupCheckStrategy(
        new MinimumDurationRunningStartupCheckStrategy(Duration.ofSeconds(1))
    );
```

--------------------------------

### Create QuestDB Container Instance

Source: https://java.testcontainers.org/modules/databases/questdb

Instantiate a QuestDB container using the specified image. This is the primary method for starting a QuestDB instance for testing.

```java
QuestDBContainer questDB = new QuestDBContainer("questdb/questdb:9.2.2")
```

--------------------------------

### Configure Basic Container Port Wait Strategy

Source: https://java.testcontainers.org/features/startup_and_waits

Demonstrates the default behavior of waiting for an exposed port to start listening. This is the simplest way to verify a container is ready for network communication.

```java
public GenericContainer nginx = new GenericContainer(DockerImageName.parse("nginx:1.27.0-alpine3.19-slim")) //
    .withExposedPorts(80);
```

--------------------------------

### Configure Pulsar with Environment Variables

Source: https://java.testcontainers.org/modules/pulsar

Set Pulsar configuration variables by prefixing them with PULSAR_PREFIX_. This example enables broker deduplication.

```java
PulsarContainer pulsar = new PulsarContainer(PULSAR_IMAGE)
    .withEnv("PULSAR_PREFIX_brokerDeduplicationEnabled", "true");
```

--------------------------------

### Start Bigtable Emulator Container

Source: https://java.testcontainers.org/modules/gcloud

Initialize a BigtableEmulatorContainer with the specified Docker image. This prepares the emulator for use in your integration tests.

```java
BigtableEmulatorContainer emulator = new BigtableEmulatorContainer(
    DockerImageName.parse("gcr.io/google.com/cloudsdktool/google-cloud-cli:441.0.0-emulators")
);
```

--------------------------------

### Start Typesense Container Instance

Source: https://java.testcontainers.org/modules/typesense

Instantiate a Typesense container using the TypesenseContainer class. Ensure you specify the desired Typesense image tag.

```java
TypesenseContainer typesense = new TypesenseContainer("typesense/typesense:27.1")
```

--------------------------------

### Container Startup Command

Source: https://java.testcontainers.org/features/commands

Override the default command executed when a container starts. This is useful for specifying custom configurations or entry points.

```APIDOC
## Override Container Startup Command

### Description
Allows you to specify a custom command to be executed when the container starts, overriding the default command defined in the Dockerfile.

### Method
`withCommand(String... command)`

### Endpoint
N/A (This is a configuration method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```java
public GenericContainer redisWithCustomPort = new GenericContainer(DockerImageName.parse("redis:6-alpine"))
    .withCommand("redis-server --port 7777");
```

### Response
N/A
```

--------------------------------

### Test with Datastore Emulator

Source: https://java.testcontainers.org/modules/gcloud

Start the Datastore emulator, configure Datastore client options to point to the emulator endpoint, and perform basic CRUD operations. Ensure to close the emulator after use.

```java
@Test
public void testSimple() {
    try (
        // creatingDatastoreEmulatorContainer {
        DatastoreEmulatorContainer emulator = new DatastoreEmulatorContainer(
            DockerImageName.parse("gcr.io/google.com/cloudsdktool/google-cloud-cli:441.0.0-emulators")
        );
        // }
    ) {
        emulator.start();
        DatastoreOptions options = DatastoreOptions
            .newBuilder()
            .setHost(emulator.getEmulatorEndpoint())
            .setCredentials(NoCredentials.getInstance())
            .setRetrySettings(ServiceOptions.getNoRetrySettings())
            .setProjectId(emulator.getProjectId())
            .build();
        Datastore datastore = options.getService();

        Key key = datastore.newKeyFactory().setKind("Task").newKey("sample");
        Entity entity = Entity.newBuilder(key).set("description", "my description").build();
        datastore.put(entity);

        assertThat(datastore.get(key).getString("description")).isEqualTo("my description");
    }
}
```

--------------------------------

### Container Dependencies

Source: https://java.testcontainers.org/features/startup_and_waits

Illustrates how to configure a container to depend on another container, ensuring the dependent container starts only after the prerequisite container is ready.

```APIDOC
## Depending on another container

### Description
Sometimes, a container relies on another container to be ready before it should start itself. An example of this might be a database that needs to be started before your application container can link to it. You can tell a container that it depends on another container by using the `dependsOn` method.

### Method
N/A (Code Example)

### Endpoint
N/A (Code Example)

### Parameters
N/A

### Request Example
N/A

### Response
N/A

### Code Example
```java
public GenericContainer<?> redis = new GenericContainer<>("redis:6-alpine").withExposedPorts(6379);

@Rule
public GenericContainer<?> nginx = new GenericContainer<>("nginx:1.27.0-alpine3.19-slim")
    .dependsOn(redis)
    .withExposedPorts(80);
```
```

--------------------------------

### Start Default Weaviate Container

Source: https://java.testcontainers.org/modules/weaviate

Instantiate a default Weaviate container using the specified image. Ensure the image name and tag are correct for your needs.

```java
WeaviateContainer weaviate = new WeaviateContainer("cr.weaviate.io/semitechnologies/weaviate:1.32.0")
```

--------------------------------

### Start Default Artemis Container

Source: https://java.testcontainers.org/modules/activemq

Instantiate a default ActiveMQ Artemis container. Specify the desired image tag for the Artemis version.

```java
ArtemisContainer artemis = new ArtemisContainer("apache/activemq-artemis:2.32.0-alpine")
```

--------------------------------

### Start Nginx Container with Custom Content

Source: https://java.testcontainers.org/modules/nginx

Demonstrates how to initialize an Nginx container and copy custom HTML content to the server's web root. It also sets up an HTTP wait strategy to ensure the server is ready.

```java
NginxContainer nginx = new NginxContainer(NGINX_IMAGE)
    .withCopyFileToContainer(MountableFile.forHostPath(tmpDirectory), "/usr/share/nginx/html")
    .waitingFor(new HttpWaitStrategy());
```

--------------------------------

### Initialize Database with Classpath Init Script

Source: https://java.testcontainers.org/modules/databases/jdbc

Configure Testcontainers to run an initialization script located on the classpath after the database container starts. This is useful for setting up database schemas or initial data.

```sql
jdbc:tc:mysql:8.0.36:///databasename?TC_INITSCRIPT=somepath/init_mysql.sql
```

--------------------------------

### Start HiveMQ Container with Specific Version

Source: https://java.testcontainers.org/modules/hivemq

Instantiates a HiveMQContainer using a specific Docker image and tag, allowing precise version control for testing.

```java
@Container
final HiveMQContainer hivemqSpecificVersion = new HiveMQContainer(DockerImageName.parse("hivemq/hivemq-ce:2024.3"));
```

--------------------------------

### Create Trino Container Instance

Source: https://java.testcontainers.org/modules/databases/trino

Instantiate a Trino container using the specified image. This is the primary method for starting a Trino instance for testing.

```java
TrinoContainer trino = new TrinoContainer("trinodb/trino:352")
```

--------------------------------

### Remove All Prepackaged Extensions

Source: https://java.testcontainers.org/modules/hivemq

Start a HiveMQ container without any of its default prepackaged extensions. This is useful for ensuring a clean environment or testing custom extension setups.

```java
@Container
final HiveMQContainer hivemqNoExtensions = new HiveMQContainer(
    DockerImageName.parse("hivemq/hivemq4").withTag("4.7.4")
)
    .withoutPrepackagedExtensions();

```

--------------------------------

### Create Static Content for Nginx

Source: https://java.testcontainers.org/modules/nginx

Shows how to create a temporary directory and an index.html file with 'Hello World!' content to be served by the Nginx container.

```java
// Create a temporary dir
File contentFolder = new File(tmpDirectory);
contentFolder.mkdir();
contentFolder.deleteOnExit();

// And "hello world" HTTP file
File indexFile = new File(contentFolder, "index.html");
indexFile.deleteOnExit();
@Cleanup
PrintStream printStream = new PrintStream(new FileOutputStream(indexFile));
printStream.println("<html><body>Hello World!</body></html>");
```

--------------------------------

### Pre-Testcontainers Redis Test

Source: https://java.testcontainers.org/quickstart/junit_5_quickstart

An example test for a Redis-backed cache that relies on a local Redis installation. This approach is prone to reliability issues and conflicts in parallel test execution.

```java
public class RedisBackedCacheIntTestStep0 {

    private RedisBackedCache underTest;

    @BeforeEach
    public void setUp() {
        // Assume that we have Redis running locally?
        underTest = new RedisBackedCache("localhost", 6379);
    }

    @Test
    public void testSimplePutAndGet() {
        underTest.put("test", "example");

        String retrieved = underTest.get("test");
        assertThat(retrieved).isEqualTo("example");
    }
}
```

--------------------------------

### Execute Commands in Running Container

Source: https://java.testcontainers.org/features/commands

Shows how to run commands inside a container using execInContainer, similar to docker exec. This example demonstrates creating a file and retrieving command output and exit codes.

```java
container.execInContainer("touch", "/somefile.txt");

Container.ExecResult lsResult = container.execInContainer("ls", "-al", "/");
String stdout = lsResult.getStdout();
int exitCode = lsResult.getExitCode();
assertThat(stdout).contains("somefile.txt");
assertThat(exitCode).isZero();
```

--------------------------------

### Start Grafana OTel LGTM Container Instance

Source: https://java.testcontainers.org/modules/grafana

Instantiate a Grafana OTel LGTM container from a Java application. Ensure the correct image tag is specified.

```java
LgtmStackContainer lgtm = new LgtmStackContainer("grafana/otel-lgtm:0.11.1")
```

--------------------------------

### Solace Container Setup with SSL

Source: https://java.testcontainers.org/modules/solace

Configure a Solace container for SSL connections by providing client certificates and a root CA. The `MountableFile` class is used to load resources from the classpath.

```java
SolaceContainer solaceContainer = new SolaceContainer("solace/solace-pubsub-standard:10.25.0")
    .withClientCert(
        MountableFile.forClasspathResource("solace.pem"),
        MountableFile.forClasspathResource("rootCA.crt")
    )
    .withTopic(TOPIC.getName(), Service.SMF_SSL)
```

--------------------------------

### Minimum Duration Startup Strategy

Source: https://java.testcontainers.org/features/startup_and_waits

Demonstrates how to use the MinimumDurationRunningStartupCheckStrategy to ensure a container is running for a specified minimum duration before considering it ready.

```APIDOC
## Minimum Duration Startup Strategy Example

### Description
Checks that the container is running and has been running for a defined minimum period of time.

### Method
N/A (Code Example)

### Endpoint
N/A (Code Example)

### Parameters
N/A

### Request Example
N/A

### Response
N/A

### Code Example
```java
public GenericContainer<?> bboxWithMinimumDuration = new GenericContainer<>(
    DockerImageName.parse("busybox:1.31.1")
)
    .withCommand("sh", "-c", String.format("sleep 5 && echo \"%s\"", HELLO_TESTCONTAINERS))
    .withStartupCheckStrategy(
        new MinimumDurationRunningStartupCheckStrategy(Duration.ofSeconds(1))
    );
```
```

--------------------------------

### ConsulContainer JUnit Test Example

Source: https://java.testcontainers.org/modules/consul

Demonstrates how to use ConsulContainer in JUnit tests to interact with Consul's Key-Value store via CLI, HTTP API, and a Java client. Ensure ConsulContainer is started before tests and stopped after.

```java
package org.testcontainers.consul;

import com.ecwid.consul.v1.ConsulClient;
import com.ecwid.consul.v1.Response;
import com.ecwid.consul.v1.kv.model.GetValue;
import io.restassured.RestAssured;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.testcontainers.containers.GenericContainer;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;

import static org.assertj.core.api.Assertions.assertThat;

class ConsulContainerTest {

    private static ConsulContainer consul = new ConsulContainer("hashicorp/consul:1.15")
        .withConsulCommand("kv put config/testing1 value123");

    @BeforeAll
    static void setup() {
        consul.start();
    }

    @AfterAll
    static void teardown() {
        consul.stop();
    }

    @Test
    void readFirstPropertyPathWithCli() throws IOException, InterruptedException {
        GenericContainer.ExecResult result = consul.execInContainer("consul", "kv", "get", "config/testing1");
        final String output = result.getStdout().replaceAll("\\r?\\n", "");
        assertThat(output).contains("value123");
    }

    @Test
    void readFirstSecretPathOverHttpApi() {
        io.restassured.response.Response response = RestAssured
            .given()
            .when()
            .get("http://" + getHostAndPort() + "/v1/kv/config/testing1")
            .andReturn();

        assertThat(response.body().jsonPath().getString("[0].Value"))
            .isEqualTo(Base64.getEncoder().encodeToString("value123".getBytes(StandardCharsets.UTF_8)));
    }

    @Test
    void writeAndReadMultipleValuesUsingClient() {
        final ConsulClient consulClient = new ConsulClient(consul.getHost(), consul.getFirstMappedPort());

        final Map<String, String> properties = new HashMap<>();
        properties.put("value", "world");
        properties.put("other_value", "another world");

        // Write operation
        properties.forEach((key, value) -> {
            Response<Boolean> writeResponse = consulClient.setKVValue(key, value);
            assertThat(writeResponse.getValue()).isTrue();
        });

        // Read operation
        properties.forEach((key, value) -> {
            Response<GetValue> readResponse = consulClient.getKVValue(key);
            assertThat(readResponse.getValue().getDecodedValue()).isEqualTo(value);
        });
    }

    private String getHostAndPort() {
        return consul.getHost() + ":" + consul.getMappedPort(8500);
    }
}

```

--------------------------------

### Define Container Dependencies

Source: https://java.testcontainers.org/features/startup_and_waits

Shows how to enforce startup order by declaring dependencies between containers. The dependsOn method ensures the target container starts only after the dependency container is ready.

```java
public GenericContainer<?> redis = new GenericContainer<>("redis:6-alpine").withExposedPorts(6379);

@Rule
public GenericContainer<?> nginx = new GenericContainer<>("nginx:1.27.0-alpine3.19-slim")
    .dependsOn(redis)
    .withExposedPorts(80);
```

--------------------------------

### Start MongoDBAtlasLocalContainer

Source: https://java.testcontainers.org/modules/databases/mongodb

Start the MongoDB Atlas Local container. This makes the database and its search capabilities available for your tests.

```java
atlasLocalContainer.start();
```

--------------------------------

### Test with Firestore Emulator

Source: https://java.testcontainers.org/modules/gcloud

Start the Firestore emulator, configure Firestore client options to point to the emulator endpoint, and perform basic document operations. Ensure to close the emulator after use.

```java
@Test
void testSimple() throws ExecutionException, InterruptedException {
    try (
        // emulatorContainer {
        FirestoreEmulatorContainer emulator = new FirestoreEmulatorContainer(
            DockerImageName.parse("gcr.io/google.com/cloudsdktool/google-cloud-cli:441.0.0-emulators")
        );
        // }
    ) {
        emulator.start();
        FirestoreOptions options = FirestoreOptions
            .getDefaultInstance()
            .toBuilder()
            .setHost(emulator.getEmulatorEndpoint())
            .setCredentials(NoCredentials.getInstance())
            .setProjectId("test-project")
            .build();
        Firestore firestore = options.getService();

        CollectionReference users = firestore.collection("users");
        DocumentReference docRef = users.document("alovelace");
        Map<String, Object> data = new HashMap<>();
        data.put("first", "Ada");
        data.put("last", "Lovelace");
        ApiFuture<WriteResult> result = docRef.set(data);
        result.get();

        ApiFuture<QuerySnapshot> query = users.get();
        QuerySnapshot querySnapshot = query.get();

        assertThat(querySnapshot.getDocuments().get(0).getData()).containsEntry("first", "Ada");
    }
}
```

--------------------------------

### Custom Startup Strategies

Source: https://java.testcontainers.org/features/startup_and_waits

Explains the possibility of creating custom `StartupCheckStrategy` subclasses or implementing `checkStartupState` for custom container startup verification.

```APIDOC
## Other startup strategies

### Description
If none of the provided startup strategies meet your requirements, you can create your own subclass of `StartupCheckStrategy` with an appropriate startup check mechanism in `waitUntilStartupSuccessful()`. Alternatively, you can leave it as is and just implement the `checkStartupState(DockerClient dockerClient, String containerId)` if you still want to check state periodically.

### Method
N/A (Conceptual)

### Endpoint
N/A (Conceptual)

### Parameters
N/A

### Request Example
N/A

### Response
N/A

### Code Example
N/A (Conceptual - requires custom implementation)
```

--------------------------------

### JDBC URL Examples for Various Databases

Source: https://java.testcontainers.org/modules/databases/jdbc

Examples of modified JDBC URLs for launching different database containers using Testcontainers. The format `jdbc:tc:<database>:<version>:///databasename` is used, where Testcontainers manages the container lifecycle.

```sql
jdbc:tc:clickhouse:18.10.3:///databasename
```

```sql
jdbc:tc:cockroach:v21.2.3:///databasename
```

```sql
jdbc:tc:cratedb:5.2.3:///databasename
```

```sql
jdbc:tc:db2:11.5.0.0a:///databasename
```

```sql
jdbc:tc:mariadb:10.3.39:///databasename
```

```sql
jdbc:tc:mysql:8.0.36:///databasename
```

```sql
jdbc:tc:sqlserver:2017-CU12:///databasename
```

```sql
jdbc:tc:oceanbasece:4.2.1-lts:///databasename
```

```sql
jdbc:tc:oracle:21-slim-faststart:///databasename
```

```sql
jdbc:tc:postgis:9.6-2.5:///databasename
```

```sql
jdbc:tc:postgresql:9.6.8:///databasename
```

```sql
jdbc:tc:questdb:6.5.3:///databasename
```

```sql
jdbc:tc:timescaledb:2.1.0-pg13:///databasename
```

```sql
jdbc:tc:pgvector:pg16:///databasename
```

```sql
jdbc:tc:tidb:v6.1.0:///databasename
```

```sql
jdbc:tc:timeplus:2.3.21:///databasename
```

```sql
jdbc:tc:trino:352://localhost/memory/default
```

```sql
jdbc:tc:yugabyte:2.14.4.0-b26:///databasename
```

--------------------------------

### Querying TPCH and Memory Catalogs

Source: https://java.testcontainers.org/modules/databases/presto

Example test demonstrating how to query both the 'tpch' and 'memory' catalogs. The 'tpch' catalog is read-only with standard schemas, while the 'memory' catalog allows for in-memory table creation.

```java
public class SomeTest {
    @Rule
    public PrestoContainer prestoSql = new PrestoContainer();

    @Test
    public void queryMemoryAndTpchConnectors() throws SQLException {
        try (Connection connection = prestoSql.createConnection();
             Statement statement = connection.createStatement()) {
            // Prepare data
            statement.execute("CREATE TABLE memory.default.table_with_array AS SELECT 1 id, ARRAY[1, 42, 2, 42, 4, 42] my_array");

            // Query Presto using newly created table and a builtin connector
            try (ResultSet resultSet = statement.executeQuery("" +
                "SELECT nationkey, element " +
                "FROM tpch.tiny.nation " +
                "JOIN memory.default.table_with_array twa ON nationkey = twa.id " +
                "LEFT JOIN UNNEST(my_array) a(element) ON true " +
                "ORDER BY element OFFSET 1 FETCH NEXT 3 ROWS WITH TIES ")) {
                List<Integer> actualElements = new ArrayList<>();
                while (resultSet.next()) {
                    actualElements.add(resultSet.getInt("element"));
                }
                Assert.assertEquals(Arrays.asList(2, 4, 42, 42, 42), actualElements);
            }
        }
    }
}

```

--------------------------------

### Enable Alternator in ScyllaDB Container

Source: https://java.testcontainers.org/modules/databases/scylladb

Start a ScyllaDB container with Alternator enabled.

```java
ScyllaDBContainer scylladb = new ScyllaDBContainer(SCYLLADB_IMAGE).withAlternator()
```

--------------------------------

### Configure GenericContainer with JibImage

Source: https://java.testcontainers.org/features/jib

Demonstrates how to initialize a GenericContainer using a JibImage instance. It includes setting an entrypoint via the Jib container builder and configuring a one-shot startup check strategy.

```java
GenericContainer<?> busybox = new GenericContainer<>(
    new JibImage(
        "busybox:1.35",
        jibContainerBuilder -> {
            return jibContainerBuilder.setEntrypoint("echo", "Hello World");
        }
    )
)
    .withStartupCheckStrategy(new OneShotStartupCheckStrategy().withTimeout(Duration.ofSeconds(3)));
```

--------------------------------

### Initialize SSL Context for CqlSession

Source: https://java.testcontainers.org/modules/databases/scylladb

Prepare SSL context, KeyStore, and TrustStore for secure CqlSession connections. Requires key and trust store files in the classpath.

```java
String testResourcesDir = getClass().getClassLoader().getResource("keys/").getPath();

KeyStore keyStore = KeyStore.getInstance("PKCS12");
keyStore.load(
    Files.newInputStream(Paths.get(testResourcesDir + "scylla.keystore")),
    "scylla".toCharArray()
);

KeyStore trustStore = KeyStore.getInstance("PKCS12");
trustStore.load(
    Files.newInputStream(Paths.get(testResourcesDir + "scylla.truststore")),
    "scylla".toCharArray()
);

KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(
    KeyManagerFactory.getDefaultAlgorithm()
);
keyManagerFactory.init(keyStore, "scylla".toCharArray());

TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(
    TrustManagerFactory.getDefaultAlgorithm()
);
trustManagerFactory.init(trustStore);

SSLContext sslContext = SSLContext.getInstance("TLS");
sslContext.init(keyManagerFactory.getKeyManagers(), trustManagerFactory.getTrustManagers(), null);
```

--------------------------------

### Configure Elasticsearch HttpClient

Source: https://java.testcontainers.org/modules/elasticsearch

Standard setup for connecting an Elasticsearch RestClient to a containerized instance.

```java
// Create the elasticsearch container.
try (ElasticsearchContainer container = new ElasticsearchContainer(ELASTICSEARCH_IMAGE)) {
    // Start the container. This step might take some time...
    container.start();

    // Do whatever you want with the rest client ...
    final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
    credentialsProvider.setCredentials(
        AuthScope.ANY,
        new UsernamePasswordCredentials(ELASTICSEARCH_USERNAME, ELASTICSEARCH_PASSWORD)
    );

    client =
        RestClient
            .builder(HttpHost.create(container.getHttpHostAddress()))
            .setHttpClientConfigCallback(httpClientBuilder -> {
                return httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
            })
            .build();

    Response response = client.performRequest(new Request("GET", "/_cluster/health"));

    ⋯

}
```

--------------------------------

### Configure One-Shot Startup Strategies

Source: https://java.testcontainers.org/features/startup_and_waits

Configures containers that perform a task and exit, using either a timeout-based or indefinite startup check strategy.

```java
public GenericContainer<?> bboxWithOneShot = new GenericContainer<>(DockerImageName.parse("busybox:1.31.1"))
    .withCommand(String.format("echo %s", HELLO_TESTCONTAINERS))
    .withStartupCheckStrategy(
        new OneShotStartupCheckStrategy().withTimeout(Duration.ofSeconds(3))
    );

public GenericContainer<?> bboxWithIndefiniteOneShot = new GenericContainer<>(
    DockerImageName.parse("busybox:1.31.1")
)
    .withCommand("sh", "-c", String.format("sleep 5 && echo \"%s\"", HELLO_TESTCONTAINERS))
    .withStartupCheckStrategy(
        new IndefiniteWaitOneShotStartupCheckStrategy()
    );
```

--------------------------------

### Configure Elasticsearch TransportClient

Source: https://java.testcontainers.org/modules/elasticsearch

Legacy setup for the deprecated TransportClient, requiring specific cluster name settings.

```java
// Create the elasticsearch container.
try (ElasticsearchContainer container = new ElasticsearchContainer(ELASTICSEARCH_IMAGE)) {
    // Start the container. This step might take some time...
    container.start();

    // Do whatever you want with the transport client
    TransportAddress transportAddress = new TransportAddress(container.getTcpHost());
    String expectedClusterName = "docker-cluster";
    Settings settings = Settings.builder().put("cluster.name", expectedClusterName).build();
    try (
        TransportClient transportClient = new PreBuiltTransportClient(settings)
            .addTransportAddress(transportAddress)
    ) {
        ClusterHealthResponse healths = transportClient.admin().cluster().prepareHealth().get();
        String clusterName = healths.getClusterName();

        ⋯

    }
}
```

--------------------------------

### Get Kafka Bootstrap Servers

Source: https://java.testcontainers.org/modules/kafka

Retrieve the bootstrap server location for connecting to the running Kafka broker.

```java
kafka.getBootstrapServers()
```

--------------------------------

### Create pgvector Container

Source: https://java.testcontainers.org/modules/databases/postgres

Use PostgreSQLContainer to start a container with the pgvector image. This allows for vector database capabilities.

```java
PostgreSQLContainer pgvector = new PostgreSQLContainer("pgvector/pgvector:pg16")
```

--------------------------------

### Create a Pulsar Container

Source: https://java.testcontainers.org/modules/pulsar

Instantiate a PulsarContainer with a specific image version. This is the basic setup for using Pulsar in tests.

```java
PulsarContainer pulsar = new PulsarContainer("apachepulsar/pulsar:3.0.0");
```

--------------------------------

### Create Docker Image from Dockerfile and Context Files (Java)

Source: https://java.testcontainers.org/features/creating_images

Demonstrates creating a Docker image using `ImageFromDockerfile` by providing files from strings and classpath resources. This is useful when the Dockerfile or its build context files are not directly available as physical files.

```java
GenericContainer container = new GenericContainer(
    new ImageFromDockerfile()
            .withFileFromString("folder/someFile.txt", "hello")
            .withFileFromClasspath("test.txt", "mappable-resource/test-resource.txt")
            .withFileFromClasspath("Dockerfile", "mappable-dockerfile/Dockerfile")
)
```

--------------------------------

### Managed Kibana and Elasticsearch Connection

Source: https://java.testcontainers.org/modules/elasticsearch

Demonstrates starting Kibana and Elasticsearch containers within the same shared network for automatic connectivity.

```java
// managedModeCanStartAndReachElasticsearchInSameExplicitNetwork {
try (
    Network network = Network.newNetwork();
    ElasticsearchContainer es = new ElasticsearchContainer(ES_IMAGE).withNetwork(network);
    KibanaContainer kibana = new KibanaContainer(es).withNetwork(network)
) {
    es.start();
    kibana.start();

    String status = getKibanaStatus(kibana);
    Assertions.assertThat(status).isEqualTo("available");
}
// }
```

--------------------------------

### Initialize Azure Service Bus Test Environment

Source: https://java.testcontainers.org/modules/azure

Java code to set up a network, SQL Server dependency, and the Service Bus emulator container.

```java
Network network = Network.newNetwork();
```

```java
MSSQLServerContainer mssqlServerContainer = new MSSQLServerContainer(
    "mcr.microsoft.com/mssql/server:2022-CU14-ubuntu-22.04"
)
    .acceptLicense()
    .withPassword("yourStrong(!)Password")
    .withCreateContainerCmdModifier(cmd -> {
        cmd.getHostConfig().withCapAdd(Capability.SYS_PTRACE);
    })
    .withNetwork(network);
```

```java
ServiceBusEmulatorContainer emulator = new ServiceBusEmulatorContainer(
    "mcr.microsoft.com/azure-messaging/servicebus-emulator:1.1.2"
)
    .acceptLicense()
    .withConfig(MountableFile.forClasspathResource("/service-bus-config.json"))
    .withNetwork(network)
    .withMsSqlServerContainer(mssqlServerContainer);
```

--------------------------------

### Provide Docker Build Context from Directory (Java)

Source: https://java.testcontainers.org/features/creating_images

Shows how to set the entire Docker build context from a specified directory using `withFileFromPath`. This method is equivalent to running `docker build` in that directory, allowing the Dockerfile and its associated files to be included in the build context.

```java
new ImageFromDockerfile()
    .withFileFromPath(".", RESOURCE_PATH))
```

--------------------------------

### Override MinIO Container Credentials

Source: https://java.testcontainers.org/modules/minio

Start a MinIO container and override the default username and password. Useful for specific testing scenarios.

```java
MinIOContainer container = new MinIOContainer("minio/minio:RELEASE.2023-09-04T19-57-37Z")
    .withUserName("testuser")
    .withPassword("testpassword");
```

--------------------------------

### Initialize Azure Event Hubs Test Environment

Source: https://java.testcontainers.org/modules/azure

Java code to set up a network, Azurite storage dependency, and the Event Hubs emulator container.

```java
Network network = Network.newNetwork();
```

```java
AzuriteContainer azuriteContainer = new AzuriteContainer("mcr.microsoft.com/azure-storage/azurite:3.33.0")
    .withNetwork(network);
```

```java
EventHubsEmulatorContainer emulator = new EventHubsEmulatorContainer(
    "mcr.microsoft.com/azure-messaging/eventhubs-emulator:2.0.1"
)
    .acceptLicense()
    .withNetwork(network)
    .withConfig(MountableFile.forClasspathResource("/eventhubs_config.json"))
    .withAzuriteContainer(azuriteContainer);
```

--------------------------------

### Create BigQuery Client

Source: https://java.testcontainers.org/modules/gcloud

Configure and build a BigQuery client to interact with the emulator. Ensure the emulator is running and accessible via the obtained endpoint and credentials.

```java
String url = container.getEmulatorHttpEndpoint();
BigQueryOptions options = BigQueryOptions
    .newBuilder()
    .setProjectId(container.getProjectId())
    .setHost(url)
    .setLocation(url)
    .setCredentials(NoCredentials.getInstance())
    .build();
BigQuery bigQuery = options.getService();
```

--------------------------------

### Configure Cassandra with Custom YAML and Init Script

Source: https://java.testcontainers.org/modules/databases/cassandra

Run a Cassandra container with a custom cassandra.yaml configuration and an initialization script. This is useful for setting up specific database states or authentication requirements.

```java
CassandraContainer cassandraContainer = new CassandraContainer(CASSANDRA_IMAGE)
    .withConfigurationOverride("cassandra-auth-required-configuration")
    .withInitScript("initial.cql")
```

--------------------------------

### Manual Container Lifecycle Management

Source: https://java.testcontainers.org/test_framework_integration/manual_lifecycle_control

Demonstrates how to use the try-with-resources pattern to automatically manage the lifecycle of a GenericContainer, ensuring it stops after use.

```java
try (GenericContainer container = new GenericContainer("imagename")) {
    container.start();
    // ... use the container
}
```

--------------------------------

### Create Redpanda Container

Source: https://java.testcontainers.org/modules/redpanda

Instantiate a Redpanda container using the official Docker image. This is the basic setup for using Redpanda in tests.

```java
RedpandaContainer container = new RedpandaContainer("docker.redpanda.com/redpandadata/redpanda:v23.1.2")
```

--------------------------------

### Create a ComposeContainer

Source: https://java.testcontainers.org/modules/docker_compose

Instantiate a `ComposeContainer` by providing the Docker image name and the path to your docker-compose.yml file. Use `withExposedService` to specify services that your tests will interact with.

```java
public ComposeContainer environment = new ComposeContainer(
    DockerImageName.parse("docker:25.0.5"),
    new File("src/test/resources/composev2/compose-test.yml")
)
    .withExposedService("redis-1", REDIS_PORT)
    .withExposedService("db-1", 3306);
```

--------------------------------

### Define MariaDB Container Instance

Source: https://java.testcontainers.org/modules/databases/mariadb

Instantiate a MariaDB container with a specific image version. This is the basic setup for using MariaDB with Testcontainers.

```java
MariaDBContainer mariadb = new MariaDBContainer("mariadb:10.3.39")
```

--------------------------------

### Get Redpanda Bootstrap Servers

Source: https://java.testcontainers.org/modules/redpanda

Retrieve the bootstrap server address for connecting to the Redpanda broker. This is essential for configuring Kafka clients.

```java
container.getBootstrapServers()
```

--------------------------------

### Running Startup Strategy

Source: https://java.testcontainers.org/features/startup_and_waits

The default startup strategy, which simply checks if the container has reached the running state and has not exited.

```APIDOC
## Running Startup Strategy

### Description
This is the default `StartupCheckStrategy`. It verifies that the container is in a running state and has not exited prematurely. The check is performed by inspecting the container's status.

### Method
N/A (Default behavior)

### Endpoint
N/A

### Parameters
N/A

### Request Example
```java
// Default behavior, no explicit configuration needed unless overriding
```

### Response
N/A

### Response Example
N/A
```

--------------------------------

### Get All Container Logs (Java)

Source: https://java.testcontainers.org/features/container_logs

Retrieves the entire log output from a container since its creation. Supports fetching stdout, stderr, or both.

```Java
final String logs = container.getLogs();
```

```Java
final String logs = container.getLogs(OutputFrame.OutputType.STDOUT);
```

```Java
final String logs = container.getLogs(OutputFrame.OutputType.STDERR);
```

--------------------------------

### Override Container Startup Command

Source: https://java.testcontainers.org/features/commands

Demonstrates how to use the withCommand method to override the default Dockerfile command. This is useful for passing custom arguments or flags to the container entrypoint.

```java
public GenericContainer redisWithCustomPort = new GenericContainer(DockerImageName.parse("redis:6-alpine"))
    .withCommand("redis-server --port 7777");
```
Tokens:
Raw