Testcontainers Python

https://testcontainers-python.readthedocs.io
Admin
Testcontainers Python facilitates the use of Docker containers for functional and integration...
Tokens:22,063
Snippets:218
Trust Score:8.3
Update:3 months ago
Show doc for...
Tokens:
Raw
### Initialize and connect to MilvusContainer

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/milvus/README.html

Demonstrates starting a Milvus container and verifying the connection URL.

```python
>>> from testcontainers.milvus import MilvusContainer
>>> with MilvusContainer("milvusdb/milvus:v2.4.4") as milvus_container:
...     milvus_container.get_exposed_port(milvus_container.port) in milvus_container.get_connection_url()
True
```

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

### Initialize local development environment

Source: https://testcontainers-python.readthedocs.io/en/latest/_sources/index.rst.txt

Uses make to install dependencies via Poetry for local development.

```bash
make install
```

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

### Initialize and connect to CockroachDB

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/cockroachdb/README.html

Demonstrates starting a CockroachDB container and creating a SQLAlchemy engine using the connection URL.

```python
>>> import sqlalchemy
>>> from testcontainers.cockroachdb import CockroachDBContainer

>>> with CockroachDBContainer('cockroachdb/cockroach:v24.1.1') as crdb:
...     engine = sqlalchemy.create_engine(crdb.get_connection_url())
...     with engine.begin() as connection:
...         result = connection.execute(sqlalchemy.text("select version()"))
...         version, = result.fetchone()
```

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

### Initialize and use K3SContainer

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/k3s/README.html

Demonstrates how to start a K3S container and interact with it using the official Kubernetes Python client.

```python
>>> import yaml
>>> from testcontainers.k3s import K3SContainer
>>> from kubernetes import client, config

>>> with K3SContainer() as k3s:
...     config.load_kube_config_from_dict(yaml.safe_load(k3s.config_yaml()))
...     pod = client.CoreV1Api().list_pod_for_all_namespaces(limit=1)
...     assert len(pod.items) > 0, "Unable to get running nodes from k3s cluster"
```

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

### Start Weaviate container with default settings

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/weaviate/README.html

Initializes and starts a Weaviate container using default image settings.

```python
>>> from testcontainers.weaviate import WeaviateContainer

>>> with WeaviateContainer() as container:
...     with container.get_client() as client:
...         client.is_live()
True
```

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

### Initialize CosmosDB MongoDB Emulator

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/cosmosdb/README.html

Demonstrates starting a CosmosDB MongoDB emulator container and accessing connection details.

```python
>>> from testcontainers.cosmosdb import CosmosDBMongoEndpointContainer

>>> with CosmosDBMongoEndpointContainer(mongodb_version="4.0") as emulator:
...   print(f"Point your MongoDB client at {emulator.host}:{emulator.port} using key {emulator.key}")
...   print(f"and eiher disable TLS server auth or trust the server's self signed cert (emulator.server_certificate_pem)")
```

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

### Create and run a container with DockerContainer and DockerImage

Source: https://testcontainers-python.readthedocs.io/en/latest/_sources/core/README.rst.txt

Builds a Docker image from a local path and starts a container, waiting for specific logs to appear.

```python
>>> from testcontainers.core.container import DockerContainer
>>> from testcontainers.core.waiting_utils import wait_for_logs
>>> from testcontainers.core.image import DockerImage

>>> with DockerImage(path="./core/tests/image_fixtures/sample/", tag="test-sample:latest") as image:
...     with DockerContainer(str(image)) as container:
...         delay = wait_for_logs(container, "Test Sample Image")
```

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

### Initialize CosmosDB NoSQL Emulator

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/cosmosdb/README.html

Demonstrates starting a CosmosDB NoSQL emulator container and interacting with it using the provided client or Azure SDK.

```python
>>> from testcontainers.cosmosdb import CosmosDBNoSQLEndpointContainer
>>> with CosmosDBNoSQLEndpointContainer() as emulator:
...   db = emulator.insecure_sync_client().create_database_if_not_exists("test")
```

```python
>>> from testcontainers.cosmosdb import CosmosDBNoSQLEndpointContainer
>>> from azure.cosmos import CosmosClient

>>> with CosmosDBNoSQLEndpointContainer() as emulator:
...   client = CosmosClient(url=emulator.url, credential=emulator.key, connection_verify=False)
...   db = client.create_database_if_not_exists("test")
```

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

### Initialize Azurite Container and Blob Service Client

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/azurite/README.html

Demonstrates how to start an Azurite container and retrieve a connection string to initialize a BlobServiceClient.

```python
>>> from testcontainers.azurite import AzuriteContainer
>>> from azure.storage.blob import BlobServiceClient

>>> with AzuriteContainer() as azurite_container:
...   connection_string = azurite_container.get_connection_string()
...   client = BlobServiceClient.from_connection_string(
...        connection_string,
...        api_version="2019-12-12"
...   )
```

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

### Install Testcontainers via pip

Source: https://testcontainers-python.readthedocs.io/en/latest/index.html

Install the core package or specific modules using extras.

```bash
pip install testcontainers[postgres]
```

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

### Initialize and use MongoDbContainer

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/mongodb/README.html

Demonstrates starting a MongoDB container and performing basic CRUD operations using the PyMongo client.

```python
>>> from testcontainers.mongodb import MongoDbContainer

>>> with MongoDbContainer("mongo:7.0.7") as mongo:
...    db = mongo.get_connection_client().test
...    # Insert a database entry
...    result = db.restaurants.insert_one(
...        {
...            "name": "Vella",
...            "cuisine": "Italian",
...            "restaurant_id": "123456"
...        }
...    )
...    # Find the restaurant document
...    result = db.restaurants.find_one({"name": "Vella"})
...    result["restaurant_id"]
'123456'
```

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

### Initialize MinioContainer and perform object operations

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/minio/README.html

Demonstrates spinning up a Minio container, creating a bucket, and performing basic put and get operations on objects.

```python
>>> import io
>>> from testcontainers.minio import MinioContainer

>>> with MinioContainer() as minio:
...   client = minio.get_client()
...   client.make_bucket("test")
...   test_content = b"Hello World"
...   write_result = client.put_object(
...       "test",
...       "testfile.txt",
...       io.BytesIO(test_content),
...       length=len(test_content),
...   )
...   retrieved_content = client.get_object("test", "testfile.txt").data
```

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

### Start Weaviate container with custom settings

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/weaviate/README.html

Configures the Weaviate container with specific environment variables for modules and query limits.

```python
>>> from testcontainers.weaviate import WeaviateContainer

>>> with WeaviateContainer(
...     env_vars={
...         "ENABLE_MODULES": "backup-filesystem,text2vec-openai",
...         "BACKUP_FILESYSTEM_PATH": "/tmp/backups",
...         "QUERY_DEFAULTS_LIMIT": 100,
...     }
... ) as container:
...     with container.get_client() as client:
...         client.is_live()
True
```

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

### Run Mailpit Container

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/mailpit/README.html

Spin up a Mailpit container and interact with it using smtplib. The simple example allows login with any credentials.

```python
>>> import smtplib

>>> from testcontainers.mailpit import MailpitContainer

>>> with MailpitContainer() as mailpit_container:
...     host_ip = mailpit_container.get_container_host_ip()
...     host_port = mailpit_container.get_exposed_smtp_port()
...     server = smtplib.SMTP(
...         mailpit_container.get_container_host_ip(),
...         mailpit_container.get_exposed_smtp_port(),
...     )
...     code, _ = server.login("any", "auth")
...     assert code == 235  # authentication successful
...     # use server.sendmail(...) to send emails
```

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

### Initialize and connect to a Db2 container

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/db2/README.html

Uses the Db2Container class to start a container and create a SQLAlchemy engine for database interaction.

```python
>>> import sqlalchemy
>>> from testcontainers.db2 import Db2Container

>>> with Db2Container("icr.io/db2_community/db2:latest") as db2:
...    engine = sqlalchemy.create_engine(db2.get_connection_url())
...    with engine.begin() as connection:
...        result = connection.execute(sqlalchemy.text("select service_level from sysibmadm.env_inst_info"))
```

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

### PostgresContainer

Source: https://testcontainers-python.readthedocs.io/en/latest/_sources/modules/postgres/README.rst.txt

The PostgresContainer class provides a way to spin up a PostgreSQL database instance for testing. It handles the lifecycle of the container, including starting and stopping the database service.

```APIDOC
## class PostgresContainer

### Description
Represents a PostgreSQL container that can be used in tests. It automatically manages the container lifecycle and provides connection details.

### Usage
```python
from testcontainers.postgres import PostgresContainer

with PostgresContainer("postgres:latest") as postgres:
    url = postgres.get_connection_url()
```
```

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

### Initialize a Generic Server Container

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/generic/README.html

Demonstrates creating a container from a custom image and verifying connectivity using httpx.

```python
>>> import httpx
>>> from testcontainers.generic import ServerContainer
>>> from testcontainers.core.waiting_utils import wait_for_logs
>>> from testcontainers.core.image import DockerImage

>>> with DockerImage(path="./modules/generic/tests/samples/python_server", tag="test-srv:latest") as image:
...     with ServerContainer(port=9000, image=image) as srv:
...         url = srv._create_connection_url()
...         response = httpx.get(f"{url}", timeout=5)
...         assert response.status_code == 200, "Response status code is not 200"
...         delay = wait_for_logs(srv, "GET / HTTP/1.1")
```

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

### Initialize and use QdrantContainer

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/qdrant/README.html

Demonstrates how to instantiate the Qdrant container and retrieve a client to interact with the database.

```python
>>> from testcontainers.qdrant import QdrantContainer

>>> with QdrantContainer() as qdrant:
...     client = qdrant.get_client()
...     client.get_collections()
CollectionsResponse(collections=[])
```

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

### Initialize and use RedisContainer

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/redis/README.html

Demonstrates how to instantiate a Redis container and retrieve a client instance using a context manager.

```python
>>> from testcontainers.redis import RedisContainer

>>> with RedisContainer() as redis_container:
...     redis_client = redis_container.get_client()
```

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

### Initialize and use MosquittoContainer

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/mqtt/README.html

Demonstrates how to instantiate the Mosquitto broker and retrieve an MQTT client within a context manager.

```python
>>> from testcontainers.mqtt import MosquittoContainer

>>> with MosquittoContainer() as mosquitto_broker:
...     mqtt_client = mosquitto_broker.get_client()
```

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

### Initialize and connect to CassandraContainer

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/cassandra/README.html

Demonstrates how to instantiate a Cassandra container and connect to it using the official Cassandra driver.

```python
>>> from testcontainers.cassandra import CassandraContainer
>>> from cassandra.cluster import Cluster, DCAwareRoundRobinPolicy

>>> with CassandraContainer("cassandra:4.1.4") as cassandra, Cluster(
...    cassandra.get_contact_points(),
...    load_balancing_policy=DCAwareRoundRobinPolicy(cassandra.get_local_datacenter()),
... ) as cluster:
...    session = cluster.connect()
...    result = session.execute("SELECT release_version FROM system.local;")
...    result.one().release_version
'4.1.4'
```

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

### Spin up a Docker container

Source: https://testcontainers-python.readthedocs.io/en/latest/core/README.html

Demonstrates initializing a container and waiting for specific log output.

```python
>>> from testcontainers.core.container import DockerContainer
>>> from testcontainers.core.waiting_utils import wait_for_logs

>>> with DockerContainer("hello-world") as container:
...    delay = wait_for_logs(container, "Hello from Docker!")
```

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

### Initialize and connect to a SQL Server container

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/mssql/README.html

Demonstrates how to instantiate a SQL Server container and create a SQLAlchemy engine for database operations.

```python
>>> import sqlalchemy
>>> from testcontainers.mssql import SqlServerContainer

>>> with SqlServerContainer("mcr.microsoft.com/mssql/server:2022-CU12-ubuntu-22.04") as mssql:
...    engine = sqlalchemy.create_engine(mssql.get_connection_url())
...    with engine.begin() as connection:
...        result = connection.execute(sqlalchemy.text("select @@VERSION"))
```

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

### Initialize RedpandaContainer

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/kafka/README.html

Demonstrates basic usage of the Redpanda container.

```python
>>> from testcontainers.kafka import RedpandaContainer

>>> with RedpandaContainer() as redpanda:
...    connection = redpanda.get_bootstrap_server()
```

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

### Initialize and connect to ScyllaDB

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/scylla/README.html

Uses the ScyllaContainer context manager to spin up a database instance and execute a CQL command.

```python
>>> from testcontainers.scylla import ScyllaContainer

>>> with ScyllaContainer() as scylla:
...    cluster = scylla.get_cluster()
...    with cluster.connect() as session:
...        result = session.execute(
...            "CREATE KEYSPACE keyspace1 WITH replication "
...            "= {'class': 'SimpleStrategy', 'replication_factor': '1'};")
```

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

### testcontainers.mssql.SqlServerContainer

Source: https://testcontainers-python.readthedocs.io/en/latest/_sources/modules/mssql/README.rst.txt

The SqlServerContainer class allows users to instantiate and manage a Microsoft SQL Server container. It provides methods to start, stop, and retrieve connection details for the SQL Server instance.

```APIDOC
## class SqlServerContainer

### Description
Represents a Microsoft SQL Server container. This class is used to manage the lifecycle of a SQL Server instance during test execution.

### Usage
```python
from testcontainers.mssql import SqlServerContainer

with SqlServerContainer("mcr.microsoft.com/mssql/server:2022-latest") as mssql:
    # Use the container
    connection_url = mssql.get_connection_url()
```
```

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

### Connect to ClickHouse Container

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/clickhouse/README.html

Demonstrates initializing a ClickHouse container and executing a query using the clickhouse-driver.

```python
>>> import clickhouse_driver
>>> from testcontainers.clickhouse import ClickHouseContainer

>>> with ClickHouseContainer("clickhouse/clickhouse-server:21.8") as clickhouse:
...     client = clickhouse_driver.Client.from_url(clickhouse.get_connection_url())
...     client.execute("select 'working'")
[('working',)]
```

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

### Initialize and connect to OracleDbContainer

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/oracle-free/README.html

Demonstrates how to instantiate the Oracle container and establish a connection using SQLAlchemy.

```python
>>> import sys, pytest
>>> if sys.platform.startswith('win') or sys.platform == 'darwin':
...     pytest.skip("linux only test")

>>> import sqlalchemy
>>> from testcontainers.oracle import OracleDbContainer

>>> with OracleDbContainer() as oracle:
...     engine = sqlalchemy.create_engine(oracle.get_connection_url())
...     with engine.begin() as connection:
...         result = connection.execute(sqlalchemy.text("SELECT 1 FROM dual"))
...         result.fetchall()
[(1,)]
```

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

### Initialize Datastore Emulator

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/google/README.html

Uses the DatastoreContainer to spin up an emulator and retrieve a client instance automatically.

```python
>>> from testcontainers.google import DatastoreContainer

>>> config = DatastoreContainer()
>>> with config as datastore:
...    datastore_client = datastore.get_datastore_client()
```

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

### Basic Ollama Container Usage

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/ollama/README.html

Demonstrates initializing the Ollama container and listing available models.

```python
>>> from testcontainers.ollama import OllamaContainer
>>> with OllamaContainer() as ollama:
...     ollama.list_models()
[]
```

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

### Instantiate and test NewSubModuleContainer

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/test_module_import/README.html

Demonstrates using a Docker image to initialize the container and verify its connection and capabilities.

```python
>>> import httpx
>>> from testcontainers.core.image import DockerImage
>>> from testcontainers.test_module_import import NewSubModuleContainer

>>> with DockerImage(path="./modules/generic/tests/samples/python_server", tag="test-new-mod:latest") as image:
...     with NewSubModuleContainer(port=9000, image=image) as new_mod:
...         url = new_mod._create_connection_url()
...         response = httpx.get(f"{url}", timeout=5)
...         assert response.status_code == 200, "Response status code is not 200"
...         assert new_mod.additional_capability() == "NewSubModuleContainer"
```

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

### Initialize MemcachedContainer

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/memcached/README.html

Demonstrates how to instantiate and retrieve connection details for a Memcached container.

```python
>>> from testcontainers.memcached import MemcachedContainer

>>> with MemcachedContainer() as memcached_container:
...    host, port = memcached_container.get_host_and_port()
```

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

### Initialize and authenticate with VaultContainer

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/vault/README.html

Demonstrates how to instantiate a Vault container, retrieve the connection URL, and authenticate using the hvac client.

```python
>>> from testcontainers.vault import VaultContainer
>>> import hvac

>>> with VaultContainer("hashicorp/vault:1.16.1") as vault_container:
...     connection_url = vault_container.get_connection_url()
...     client = hvac.Client(url=connection_url, token=vault_container.root_token)
...     assert client.is_authenticated()
...     # use root client to perform desired actions, e.g.
...     policies = client.sys.list_acl_policies()
```

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

### MinioContainer.__init__

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/minio/README.html

Initializes a new Minio container instance with configurable image, port, and credentials.

```APIDOC
## MinioContainer(image='minio/minio:RELEASE.2022-12-02T19-19-22Z', port=9000, access_key='minioadmin', secret_key='minioadmin', **kwargs)

### Description
Initializes the Minio container. Users can specify the image, port, and credentials for the Minio instance.

### Parameters
- **image** (str) - Optional - The Docker image to use for the container.
- **port** (int) - Optional - The port to expose for the Minio service.
- **access_key** (str) - Optional - The access key for Minio authentication.
- **secret_key** (str) - Optional - The secret key for Minio authentication.
```

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

### Initialize and use LocalStackContainer

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/localstack/README.html

Demonstrates how to instantiate the LocalStack container and retrieve an AWS service client.

```python
>>> from testcontainers.localstack import LocalStackContainer

>>> with LocalStackContainer(image="localstack/localstack:2.0.1") as localstack:
...     dynamo_client = localstack.get_client("dynamodb")
...     tables = dynamo_client.list_tables()
>>> tables
{'TableNames': [], ...}
```

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

### Run an AWS Lambda container

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/aws/README.html

Demonstrates how to initialize an AWS Lambda container using a custom Docker image and send a request to it.

```python
>>> from testcontainers.aws import AWSLambdaContainer
>>> from testcontainers.core.waiting_utils import wait_for_logs
>>> from testcontainers.core.image import DockerImage

>>> with DockerImage(path="./modules/aws/tests/lambda_sample", tag="test-lambda:latest") as image:
...     with AWSLambdaContainer(image=image, port=8080) as func:
...         response = func.send_request(data={'payload': 'some data'})
...         assert response.status_code == 200
...         assert "Hello from AWS Lambda using Python" in response.json()
...         delay = wait_for_logs(func, "START RequestId:")
```

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

### Initialize PubSub Emulator

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/google/README.html

Uses the PubSubContainer to spin up an emulator and create a topic using the provided client methods.

```python
>>> from testcontainers.google import PubSubContainer

>>> config = PubSubContainer()
>>> with config as pubsub:
...    publisher = pubsub.get_publisher_client()
...    topic_path = publisher.topic_path(pubsub.project, "my-topic")
...    topic = publisher.create_topic(name=topic_path)
```

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

### Initialize and query Neo4jContainer

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/neo4j/README.html

Demonstrates how to instantiate the container and execute a Cypher query using the Neo4j driver.

```python
>>> from testcontainers.neo4j import Neo4jContainer

>>> with Neo4jContainer() as neo4j, \
...         neo4j.get_driver() as driver, \
...         driver.session() as session:
...     result = session.run("MATCH (n) RETURN n LIMIT 1")
...     record = result.single()
```

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

### Spin up an ArangoDB container

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/arangodb/README.html

Demonstrates initializing an ArangoDB container and connecting to it using the arangoclient library.

```python
>>> from testcontainers.arangodb import ArangoDbContainer
>>> from arango import ArangoClient

>>> with ArangoDbContainer("arangodb:3.11.8") as arango:
...    client = ArangoClient(hosts=arango.get_connection_url())
...
...    # Connect
...    sys_db = client.db(username="root", password="passwd")
...
...    # Create a new database named "test".
...    sys_db.create_database("test")
True
```

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

### CockroachDBContainer.__init__

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/cockroachdb/README.html

Initializes a new CockroachDB database container instance.

```APIDOC
## CockroachDBContainer(image, username, password, dbname, dialect, **kwargs)

### Description
Initializes a CockroachDB database container. You can specify the image version, credentials, database name, and dialect.

### Parameters
- **image** (str) - Optional - The Docker image to use (default: 'cockroachdb/cockroach:v24.1.1')
- **username** (str) - Optional - Database username
- **password** (str) - Optional - Database password
- **dbname** (str) - Optional - Database name
- **dialect** (str) - Optional - SQLAlchemy dialect (default: 'cockroachdb+psycopg2')
- **kwargs** - Optional - Additional keyword arguments for the container
```

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

### Initialize Selenium Browser Container

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/selenium/README.html

Demonstrates how to instantiate and use a Chrome browser container with the BrowserWebDriverContainer class.

```python
>>> from testcontainers.selenium import BrowserWebDriverContainer
>>> from selenium.webdriver import DesiredCapabilities

>>> with BrowserWebDriverContainer(DesiredCapabilities.CHROME) as chrome:
...    webdriver = chrome.get_driver()
```

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

### Initialize KafkaContainer

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/kafka/README.html

Demonstrates standard Kafka container usage and KRaft protocol configuration.

```python
>>> from testcontainers.kafka import KafkaContainer

>>> with KafkaContainer() as kafka:
...    connection = kafka.get_bootstrap_server()

# Using KRaft protocol
>>> with KafkaContainer().with_kraft() as kafka:
...    connection = kafka.get_bootstrap_server()
```

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

### Initialize and use ChromaContainer

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/chroma/README.html

Spins up a ChromaDB container, retrieves configuration, and creates a collection using the Chroma Python client.

```python
>>> import chromadb
>>> from testcontainers.chroma import ChromaContainer

>>> with ChromaContainer() as chroma:
...   config = chroma.get_config()
...   client = chromadb.HttpClient(host=config["host"], port=config["port"])
...   col = client.get_or_create_collection("test")
...   col.name
'test'
```

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

### MySqlContainer.__init__

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/mysql/README.html

Initializes a new MySQL database container instance with specified configuration parameters.

```APIDOC
## MySqlContainer Constructor

### Description
Initializes a MySQL database container. You can specify the image, credentials, database name, and port.

### Parameters
- **image** (str) - Optional - The Docker image to use (default: 'mysql:latest')
- **dialect** (str) - Optional - The SQLAlchemy dialect to use
- **username** (str) - Optional - Database username
- **root_password** (str) - Optional - Root password for the database
- **password** (str) - Optional - User password for the database
- **dbname** (str) - Optional - Initial database name
- **port** (int) - Optional - Port to expose (default: 3306)
- **seed** (str) - Optional - Path to a SQL file to be loaded on initialization
```

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

### Define SFTP users with SFTPUser

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/sftp/README.html

Demonstrates creating users with passwords or keypairs and verifying their properties.

```python
>>> from testcontainers.sftp import SFTPUser

>>> users = [
...     SFTPUser("jane", password="secret"),
...     SFTPUser.with_keypair("ron", folders=["stuff"]),
... ]

>>> for user in users:
...     print(user.name, user.folders[0])
...
jane upload
ron stuff

>>> assert users[0].password == "secret"

>>> assert users[1].public_key is not None

>>> assert users[1].public_key.decode().startswith("ssh-rsa ")

>>> assert users[1].private_key is not None

>>> assert users[1].private_key.decode().startswith("-----BEGIN RSA PRIVATE KEY-----")
```

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

### OpenSearchContainer.__init__

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/opensearch/README.html

Initializes a new OpenSearch container instance.

```APIDOC
## OpenSearchContainer(image='opensearchproject/opensearch:2.4.0', port=9200, security_enabled=False, initial_admin_password='admin', **kwargs)

### Description
Initializes an OpenSearch container instance with specified image, port, and security settings.

### Parameters
- **image** (str) - Optional - The Docker image to use (default: 'opensearchproject/opensearch:2.4.0')
- **port** (int) - Optional - The port to expose (default: 9200)
- **security_enabled** (bool) - Optional - Whether security is enabled (default: False)
- **initial_admin_password** (str) - Optional - The initial admin password (default: 'admin')
```

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

### Interact with OpenSearch Container

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/opensearch/README.html

Demonstrates creating an index, adding a document, refreshing the index, and performing a search using the OpenSearch Python client.

```python
>>> from testcontainers.opensearch import OpenSearchContainer

>>> with OpenSearchContainer() as opensearch:
...   client = opensearch.get_client()
...   creation_result = client.index(index="test", body={"test": "test"})
...   refresh_result = client.indices.refresh(index="test")
...   search_result = client.search(index="test", body={"query": {"match_all": {}}})
```

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

### Build a Docker image

Source: https://testcontainers-python.readthedocs.io/en/latest/core/README.html

Builds a Docker image from a specified path and retrieves logs.

```python
>>> from testcontainers.core.image import DockerImage

>>> with DockerImage(path="./core/tests/image_fixtures/sample/", tag="test-image") as image:
...    logs = image.get_logs()
```

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

### RabbitMqContainer.__init__

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/rabbitmq/README.html

Initializes a new RabbitMQ container instance with optional configuration for image, port, credentials, and virtual host.

```APIDOC
## RabbitMqContainer(image='rabbitmq:latest', port=None, username=None, password=None, vhost=None, **kwargs)

### Description
Initializes a RabbitMQ container for testing. This class manages the lifecycle of a RabbitMQ broker instance.

### Parameters
- **image** (str) - Optional - The Docker image to use (default: 'rabbitmq:latest')
- **port** (int) - Optional - The port to expose
- **username** (str) - Optional - RabbitMQ username
- **password** (str) - Optional - RabbitMQ password
- **vhost** (str) - Optional - RabbitMQ virtual host
```

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

### Initialize and connect to RabbitMQ container

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/rabbitmq/README.html

Uses the RabbitMqContainer to spin up a broker and establishes a connection using the pika library.

```python
>>> import pika
>>> from testcontainers.rabbitmq import RabbitMqContainer

>>> with RabbitMqContainer("rabbitmq:3.9.10") as rabbitmq:
...    connection = pika.BlockingConnection(rabbitmq.get_connection_params())
...    channel = connection.channel()
```

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

### Connect to MySQL Container with SQLAlchemy

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/mysql/README.html

Demonstrates spinning up a MySQL container and establishing a connection using a SQLAlchemy engine.

```python
>>> import sqlalchemy
>>> from testcontainers.mysql import MySqlContainer

>>> with MySqlContainer("mysql:5.7.17", dialect="pymysql") as mysql:
...     engine = sqlalchemy.create_engine(mysql.get_connection_url())
...     with engine.begin() as connection:
...         result = connection.execute(sqlalchemy.text("select version()"))
...         version, = result.fetchone()
```

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

### Initialize and query an Elasticsearch container

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/elasticsearch/README.html

Demonstrates how to instantiate an Elasticsearch container with specific memory limits and retrieve the version number via a URL request.

```python
>>> import json
>>> import urllib
>>> from testcontainers.elasticsearch import ElasticSearchContainer

>>> with ElasticSearchContainer(f'elasticsearch:8.3.3', mem_limit='3G') as es:
...    resp = urllib.request.urlopen(es.get_url())
...    json.loads(resp.read().decode())['version']['number']
'8.3.3'
```

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

### Run a FastAPI application in a generic container

Source: https://testcontainers-python.readthedocs.io/en/latest/_sources/modules/generic/README.rst.txt

Demonstrates initializing a FastAPI server using ServerContainer and waiting for specific logs before executing tests.

```python
>>> from testcontainers.generic import ServerContainer
>>> from testcontainers.core.waiting_utils import wait_for_logs

>>> with DockerImage(path="./modules/generic/tests/samples/fastapi", tag="fastapi-test:latest") as image:
...     with ServerContainer(port=80, image=image) as fastapi_server:
...         delay = wait_for_logs(fastapi_server, "Uvicorn running on http://0.0.0.0:80")
...         fastapi_server.get_api_url = lambda: fastapi_server._create_connection_url() + "/api/v1/"
...         client = fastapi_server.get_client()
...         response = client.get("/")
...         assert response.status_code == 200
...         assert response.json() == {"Status": "Working"}
```

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

### NginxContainer Constructor

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/nginx/README.html

Initializes a new Nginx container instance with a specified image and port.

```APIDOC
## NginxContainer(image: str = 'nginx:latest', port: int = 80, **kwargs)

### Description
Initializes an Nginx container instance. This class allows for the configuration of the Nginx image and the port to be exposed.

### Parameters
- **image** (str) - Optional - The Docker image to use for the container. Defaults to 'nginx:latest'.
- **port** (int) - Optional - The port to expose on the container. Defaults to 80.
- **kwargs** (dict) - Optional - Additional keyword arguments passed to the base container class.
```

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

### PostgresContainer(image, port, username, password, dbname, driver, **kwargs)

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/postgres/README.html

Initializes a new PostgreSQL container instance. Users can specify the image, port, credentials, database name, and the driver used for connection URLs.

```APIDOC
## PostgresContainer

### Description
Initializes a PostgreSQL database container. This class allows for easy setup of a Postgres instance for testing purposes.

### Constructor Parameters
- **image** (str) - Optional - The Docker image to use (default: 'postgres:latest').
- **port** (int) - Optional - The port to expose (default: 5432).
- **username** (str) - Optional - Database username.
- **password** (str) - Optional - Database password.
- **dbname** (str) - Optional - Database name.
- **driver** (str) - Optional - The database driver to use in the connection URL (default: 'psycopg2'). Pass None to get a URL without a driver.

### Methods
- **get_connection_url()** - Returns the connection URL for the database container.
```

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

### Project folder structure

Source: https://testcontainers-python.readthedocs.io/en/latest/_sources/index.rst.txt

Displays the directory layout for implicit namespace packages in the project.

```bash
  modules
  # One folder per feature.
  [feature name]
      # Folder without __init__.py for implicit namespace packages.
      testcontainers
          # Implementation as namespace package with __init__.py.
          [feature name]
              __init__.py
              # Other files for this
              ...
      # Tests for the feature.
      tests
          test_[some_aspect_for_the_feature].py
          ...
      # README for this feature.
      README.rst
```

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

### MilvusContainer(image: str = 'milvusdb/milvus:latest', port: int = 19530, **kwargs)

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/milvus/README.html

Initializes a new Milvus database container instance. Users can specify a custom image and port.

```APIDOC
## MilvusContainer

### Description
Initializes a Milvus database container. This class allows for the lifecycle management of a Milvus instance within a test environment.

### Parameters
- **image** (str) - Optional - The Docker image to use for the Milvus container. Defaults to 'milvusdb/milvus:latest'.
- **port** (int) - Optional - The port to expose for the Milvus service. Defaults to 19530.
- **kwargs** - Optional - Additional keyword arguments passed to the underlying container implementation.

### Usage Example
```python
from testcontainers.milvus import MilvusContainer
with MilvusContainer("milvusdb/milvus:v2.4.4") as milvus_container:
    # Access container properties
    port = milvus_container.get_exposed_port(milvus_container.port)
    url = milvus_container.get_connection_url()
```
```

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

### ClickHouseContainer(image, port, username, password, dbname, **kwargs)

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/clickhouse/README.html

Initializes a new ClickHouse database container instance.

```APIDOC
## ClickHouseContainer

### Description
Initializes a ClickHouse database container. This class allows for the configuration of the container image, port, and database credentials.

### Parameters
- **image** (str) - Optional - The Docker image to use (default: 'clickhouse/clickhouse-server:latest')
- **port** (int) - Optional - The port to expose (default: 9000)
- **username** (str) - Optional - Database username
- **password** (str) - Optional - Database password
- **dbname** (str) - Optional - Database name

### Usage Example
```python
from testcontainers.clickhouse import ClickHouseContainer

with ClickHouseContainer("clickhouse/clickhouse-server:21.8") as clickhouse:
    url = clickhouse.get_connection_url()
    # Use the connection URL with a driver like clickhouse-driver
```
```

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

### RedisContainer(image='redis:latest', port=6379, password=None, **kwargs)

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/redis/README.html

Initializes a new Redis container instance. Users can specify the image, port, and password for the Redis instance.

```APIDOC
## RedisContainer

### Description
Initializes and manages a Redis container for testing. This class allows for easy setup and teardown of Redis instances.

### Constructor
`RedisContainer(image: str = 'redis:latest', port: int = 6379, password: str | None = None, **kwargs)`

### Parameters
- **image** (str) - Optional - The Docker image to use for the Redis container. Defaults to 'redis:latest'.
- **port** (int) - Optional - The port to expose on the container. Defaults to 6379.
- **password** (str | None) - Optional - The password for the Redis instance.
- **kwargs** - Optional - Additional keyword arguments passed to the base container class.

### Methods
- **get_client()** - Returns a Redis client instance connected to the container.
```

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

### KeycloakContainer Constructor

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/keycloak/README.html

Initializes a new Keycloak container instance with configurable image, credentials, and ports.

```APIDOC
## KeycloakContainer

### Description
Initializes a Keycloak container for testing. This class allows configuring the Keycloak image, admin credentials, and network ports.

### Constructor Signature
`KeycloakContainer(image='quay.io/keycloak/keycloak:latest', username=None, password=None, port=8080, management_port=9000, cmd='start-dev')`

### Parameters
- **image** (str) - Optional - The Docker image to use (default: 'quay.io/keycloak/keycloak:latest')
- **username** (str) - Optional - Admin username for Keycloak
- **password** (str) - Optional - Admin password for Keycloak
- **port** (int) - Optional - The port to expose for Keycloak (default: 8080)
- **management_port** (int) - Optional - The management port (default: 9000)
- **cmd** (str) - Optional - The command to run on startup (default: 'start-dev')
```

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

### Db2Container(image, username, password, port, dbname, dialect, **kwargs)

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/db2/README.html

Initializes an IBM Db2 database container instance.

```APIDOC
## Db2Container

### Description
Initializes and manages an IBM Db2 database container.

### Parameters
- **image** (str) - Optional - Docker image to use (default: 'icr.io/db2_community/db2:latest')
- **username** (str) - Optional - Database username (default: 'db2inst1')
- **password** (str) - Optional - Database password
- **port** (int) - Optional - Database port (default: 50000)
- **dbname** (str) - Optional - Database name (default: 'testdb')
- **dialect** (str) - Optional - SQLAlchemy dialect (default: 'db2+ibm_db')

### Methods
- **get_connection_url()** - Returns the SQLAlchemy connection URL for the container.
```

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

### TrinoContainer Constructor

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/trino/README.html

Initializes a new Trino container instance with configurable image, user, and port settings.

```APIDOC
## TrinoContainer

### Description
Initializes a Trino container for testing. This class allows users to define the Docker image, the user context, and the port for the Trino service.

### Constructor Signature
`TrinoContainer(image='trinodb/trino:latest', user='test', port=8080, **kwargs)`

### Parameters
- **image** (str) - Optional - The Docker image to use for the container. Defaults to 'trinodb/trino:latest'.
- **user** (str) - Optional - The user context for the Trino instance. Defaults to 'test'.
- **port** (int) - Optional - The port on which the Trino service listens. Defaults to 8080.
- **kwargs** (dict) - Optional - Additional keyword arguments passed to the base container class.
```

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

### Fetch cloud provider registry passwords

Source: https://testcontainers-python.readthedocs.io/en/latest/_sources/index.rst.txt

Commands to retrieve authentication tokens from ECR, GCP, and Azure.

```bash
ECR_PASSWORD = $(aws ecr get-login-password --region eu-west-1)
GCP_PASSWORD = $(gcloud auth print-access-token)
AZURE_PASSWORD = $(az acr login --name <registry-name> --expose-token --output tsv)
```

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

### WeaviateContainer(image, env_vars)

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/weaviate/README.html

Initializes a new Weaviate container instance. Users can specify a custom Docker image and pass environment variables to configure the Weaviate instance.

```APIDOC
## WeaviateContainer(image, env_vars)

### Description
Initializes a Weaviate vector database container. This class is used to manage the lifecycle of a Weaviate instance during tests.

### Parameters
- **image** (str) - Optional - Docker image to use with Weaviate container. Defaults to 'semitechnologies/weaviate:1.24.5'.
- **env_vars** (dict[str, str]) - Optional - Additional environment variables to include with the container, such as ENABLE_MODULES or QUERY_DEFAULTS_LIMIT.

### Usage Example
```python
from testcontainers.weaviate import WeaviateContainer

with WeaviateContainer(env_vars={"ENABLE_MODULES": "text2vec-openai"}) as container:
    with container.get_client() as client:
        client.is_live()
```
```

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

### Usage of NatsContainer

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/nats/README.html

Demonstrates initializing a NATS container and performing basic publish/subscribe operations using the nats-py client.

```python
>>> import asyncio
>>> from nats import connect as nats_connect
>>> from testcontainers.nats import NatsContainer

>>> async def test_doctest_usage():
...     with NatsContainer() as nats_container:
...         client = await nats_connect(nats_container.nats_uri())
...         sub_tc = await client.subscribe("tc")
...         await client.publish("tc", b"Test-Containers")
...         next_message = await sub_tc.next_msg(timeout=5.0)
...         await client.close()
...     return next_message.data
>>> asyncio.run(test_doctest_usage())
b'Test-Containers'
```

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

### ServerContainer(port: int, image: str | DockerImage)

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/generic/README.html

Initializes a container for a generic server based on a custom image. Users can specify the port to be exposed and the Docker image to use.

```APIDOC
## ServerContainer(port, image)

### Description
Creates a container for a generic server using a custom Docker image. This class is designed to facilitate testing of custom server applications within a containerized environment.

### Parameters
- **port** (int) - Required - The port to be exposed on the container.
- **image** (str | DockerImage) - Required - The Docker image to be used for the container.

### Usage Example
```python
from testcontainers.generic import ServerContainer
from testcontainers.core.image import DockerImage

with DockerImage(path="./path/to/image", tag="my-app:latest") as image:
    with ServerContainer(port=8080, image=image) as srv:
        url = srv._create_connection_url()
        # Perform tests against the container
```
```

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

### MinioContainer.get_client

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/minio/README.html

Retrieves a client instance for the Minio Python API.

```APIDOC
## get_client()

### Description
Returns a client object that can be used to interact with the Minio instance using the Minio Python API.
```

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

### Connect to Postgres with SQLAlchemy

Source: https://testcontainers-python.readthedocs.io/en/latest/_sources/index.rst.txt

Uses the PostgresContainer to spin up a database and connects using SQLAlchemy.

```python
>>> from testcontainers.postgres import PostgresContainer
>>> import sqlalchemy

>>> with PostgresContainer("postgres:16") as postgres:
...     psql_url = postgres.get_connection_url()
...     engine = sqlalchemy.create_engine(psql_url)
...     with engine.begin() as connection:
...         version, = connection.execute(sqlalchemy.text("SELECT version()")).fetchone()
>>> version
'PostgreSQL 16...'
```

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

### QdrantContainer

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/qdrant/README.html

Initializes a Qdrant vector database container. Users can specify the image, ports, API key, and configuration file path.

```APIDOC
## QdrantContainer

### Description
Initializes a Qdrant vector database container instance.

### Constructor
`QdrantContainer(image='qdrant/qdrant:v1.8.3', rest_port=6333, grpc_port=6334, api_key=None, config_file_path=None, **kwargs)`

### Parameters
- **image** (str) - Optional - The Docker image to use for the container.
- **rest_port** (int) - Optional - The REST API port.
- **grpc_port** (int) - Optional - The gRPC port.
- **api_key** (str) - Optional - API key for authentication.
- **config_file_path** (Path) - Optional - Path to a custom configuration file.

### Usage Example
```python
from testcontainers.qdrant import QdrantContainer

with QdrantContainer() as qdrant:
    client = qdrant.get_client()
    client.get_collections()
```
```

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

### MosquittoContainer(image='eclipse-mosquitto:latest', **kwargs)

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/mqtt/README.html

Initializes a new Mosquitto MQTT broker container. This class inherits from DockerContainer and provides a convenient way to manage the broker lifecycle.

```APIDOC
## MosquittoContainer

### Description
Specialization of DockerContainer for the Mosquitto MQTT broker. This allows for the programmatic management of an MQTT broker instance within a test environment.

### Constructor
`MosquittoContainer(image: str = 'eclipse-mosquitto:latest', **kwargs)`

### Parameters
- **image** (str) - Optional - The Docker image to use for the container. Defaults to 'eclipse-mosquitto:latest'.
- **kwargs** (dict) - Optional - Additional keyword arguments passed to the base DockerContainer class.

### Usage Example
```python
from testcontainers.mqtt import MosquittoContainer

with MosquittoContainer() as mosquitto_broker:
    mqtt_client = mosquitto_broker.get_client()
```
```

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

### Connect to SFTPContainer with basic authentication

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/sftp/README.html

Uses paramiko to connect to an SFTP container using the default basic credentials.

```python
>>> import paramiko

>>> from testcontainers.sftp import SFTPContainer

>>> with SFTPContainer() as sftp_container:
...     host_ip = sftp_container.get_container_host_ip()
...     host_port = sftp_container.get_exposed_sftp_port()
...     ssh = paramiko.SSHClient()
...     ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
...     ssh.connect(host_ip, host_port, "basic", "password")
...     # ssh.get(...)
...     # ssh.listdir()
...     # ssh.chdir("upload")
...     # ssh.put(...)
```

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

### MongoDbContainer

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/mongodb/README.html

Initializes a MongoDB container instance. Users can specify the image, port, credentials, and database name.

```APIDOC
## class MongoDbContainer(image='mongo:latest', port=27017, username=None, password=None, dbname=None, **kwargs)

### Description
Initializes a MongoDB container for testing. This class manages the lifecycle of a MongoDB container instance.

### Parameters
- **image** (str) - Optional - The Docker image to use (default: 'mongo:latest')
- **port** (int) - Optional - The port to expose (default: 27017)
- **username** (str) - Optional - Database username
- **password** (str) - Optional - Database password
- **dbname** (str) - Optional - Initial database name

### Usage Example
```python
from testcontainers.mongodb import MongoDbContainer

with MongoDbContainer("mongo:7.0.7") as mongo:
    db = mongo.get_connection_client().test
    # Perform database operations
```
```

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

### Configure DOCKER_AUTH_CONFIG environment variable

Source: https://testcontainers-python.readthedocs.io/en/latest/_sources/index.rst.txt

Sets the authentication configuration for a private Docker registry using a JSON string.

```bash
DOCKER_AUTH_CONFIG='{"auths": {"https://myregistry.com": {"auth": "dXNlcm5hbWU6cGFzc3dvcmQ="}}}'
```

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

### ElasticSearchContainer(image, port, **kwargs)

Source: https://testcontainers-python.readthedocs.io/en/latest/modules/elasticsearch/README.html

Initializes an Elasticsearch container instance. Users can specify the image version and additional container configuration parameters.

```APIDOC
## ElasticSearchContainer

### Description
Initializes and manages an Elasticsearch container instance for testing.

### Constructor
`ElasticSearchContainer(image: str = 'elasticsearch', port: int = 9200, **kwargs)`

### Parameters
- **image** (str) - Optional - The Docker image to use for the container. Defaults to 'elasticsearch'.
- **port** (int) - Optional - The port to expose. Defaults to 9200.
- **kwargs** - Optional - Additional keyword arguments passed to the underlying container configuration.

### Methods
- **get_url()** - Returns the connection URL for the running Elasticsearch container.
```
Tokens:
Raw