Testcontainers for Node.js

https://node.testcontainers.org
Admin
Testcontainers is a library that provides lightweight, throwaway instances of common databases,...
Tokens:72,099
Snippets:769
Trust Score:9.9
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Install mockserver-client

Source: https://node.testcontainers.org/modules/mockserver

Installs the mockserver-client library used in the examples.

```bash
npm install mockserver-client
```

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

### Install toxiproxy-node-client

Source: https://node.testcontainers.org/modules/toxiproxy

Install the toxiproxy-node-client library used in the examples.

```bash
npm install toxiproxy-node-client

```

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

### Install mysql2

Source: https://node.testcontainers.org/modules/mysql

Installs the mysql2 client library used in the examples.

```bash
npm install mysql2
```

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

### Install cassandra-driver

Source: https://node.testcontainers.org/modules/cassandra

Install the cassandra-driver client library used in the examples.

```bash
npm install cassandra-driver

```

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

### Install redis client

Source: https://node.testcontainers.org/modules/redis

Install the redis client library used in the examples.

```bash
npm install redis
```

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

### Install oracledb

Source: https://node.testcontainers.org/modules/oraclefree

Install the oracledb library used in the examples.

```bash
npm install oracledb
```

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

### Install @kubernetes/client-node

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

Installs the Kubernetes client library used in the examples.

```bash
npm install @kubernetes/client-node

```

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

### Install chromadb

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

Installs the chromadb client library used in the examples.

```bash
npm install chromadb

```

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

### Install minio client library

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

Installs the MinIO client library used in the examples.

```bash
npm install minio

```

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

### Install @kurrent/kurrentdb-client

Source: https://node.testcontainers.org/modules/kurrentdb

Install the KurrentDB client library used in the examples.

```bash
npm install @kurrent/kurrentdb-client
```

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

### Install etcd3 client

Source: https://node.testcontainers.org/modules/etcd

Install the etcd3 client library used in the examples.

```bash
npm install etcd3

```

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

### Install @opensearch-project/opensearch

Source: https://node.testcontainers.org/modules/opensearch

Install the official OpenSearch client library used in the examples.

```bash
npm install @opensearch-project/opensearch

```

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

### Install mqtt client library

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

Install the mqtt client library used in the examples.

```bash
npm install mqtt
```

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

### Install mongoose

Source: https://node.testcontainers.org/modules/mongodb

Install the mongoose library used in the MongoDB examples.

```bash
npm install mongoose
```

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

### Install @confluentinc/kafka-javascript for Kafka 8.x examples

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

Installs the Kafka JavaScript client library used in the Kafka 8.x examples.

```bash
npm install @confluentinc/kafka-javascript
```

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

### Install @clickhouse/client

Source: https://node.testcontainers.org/modules/clickhouse

Install the ClickHouse client library used in the examples.

```bash
npm install @clickhouse/client
```

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

### Install @chroma-core/default-embed

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

Installs the @chroma-core/default-embed library used in the examples.

```bash
npm install @chroma-core/default-embed

```

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

### Install node-vault

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

Install the node-vault client library used in the examples.

```bash
npm install node-vault
```

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

### Install mariadb client library

Source: https://node.testcontainers.org/modules/mariadb

Install the mariadb client library used in the examples.

```bash
npm install mariadb

```

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

### Install @google-cloud/datastore

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

Install the Datastore client library required for the Datastore example.

```bash
npm install @google-cloud/datastore
```

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

### Install @azure/storage-queue

Source: https://node.testcontainers.org/modules/azurite

Install the Azure Storage Queue client library used in the queue example.

```bash
npm install @azure/storage-queue
```

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

### Install @qdrant/js-client-rest

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

Install the Qdrant JavaScript client library used in the examples.

```bash
npm install @qdrant/js-client-rest
```

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

### Install @azure/service-bus

Source: https://node.testcontainers.org/modules/azureservicebus

Install the Azure Service Bus client library used in the examples.

```bash
npm install @azure/service-bus
```

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

### Install @google-cloud/storage

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

Install the Storage client library required for the Cloud Storage example.

```bash
npm install @google-cloud/storage
```

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

### Install weaviate-ts-client

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

Install the Weaviate TypeScript client library used in the examples.

```bash
npm install weaviate-ts-client
```

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

### Install @azure/cosmos

Source: https://node.testcontainers.org/modules/cosmosdb

Install the Azure Cosmos DB client library used in the examples.

```bash
npm install @azure/cosmos

```

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

### Install arangojs

Source: https://node.testcontainers.org/modules/arangodb

Install the arangojs client library used in the examples.

```bash
npm install arangojs
```

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

### Install nano

Source: https://node.testcontainers.org/modules/couchdb

Install the nano library, used in the examples to interact with CouchDB.

```bash
npm install nano
```

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

### Install @google-cloud/firestore

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

Install the Firestore client library required for the Firestore example.

```bash
npm install @google-cloud/firestore
```

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

### Install @elastic/elasticsearch

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

Install the official Elasticsearch client library used in the examples.

```bash
npm install @elastic/elasticsearch
```

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

### Install couchbase client

Source: https://node.testcontainers.org/modules/couchbase

Install the Couchbase Node.js client library used in the examples.

```bash
npm install couchbase
```

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

### Install amqplib and types

Source: https://node.testcontainers.org/modules/rabbitmq

Install the amqplib client library and its TypeScript type definitions for the examples.

```bash
npm install amqplib
npm install @types/amqplib --save-dev

```

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

### Install @google-cloud/bigquery

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

Installs the @google-cloud/bigquery library, required for the BigQuery emulator examples.

```bash
npm install @google-cloud/bigquery
```

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

### Install @azure/storage-blob

Source: https://node.testcontainers.org/modules/azurite

Install the Azure Storage Blob client library used in the blob examples.

```bash
npm install @azure/storage-blob
```

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

### Install @google-cloud/pubsub

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

Install the PubSub client library required for the Cloud PubSub example.

```bash
npm install @google-cloud/pubsub
```

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

### Install @azure/data-tables

Source: https://node.testcontainers.org/modules/azurite

Install the Azure Data Tables client library used in the table example.

```bash
npm install @azure/data-tables
```

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

### Install @google-cloud/spanner

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

Install the Spanner client library required for the Cloud Spanner examples.

```bash
npm install @google-cloud/spanner
```

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

### Install @aws-sdk/client-s3

Source: https://node.testcontainers.org/modules/localstack

Install the AWS SDK for JavaScript S3 client, used in the examples.

```bash
npm install @aws-sdk/client-s3
```

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

### Install neo4j-driver

Source: https://node.testcontainers.org/modules/neo4j

Install the official Neo4j JavaScript driver, required for the examples.

```bash
npm install neo4j-driver
```

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

### Cloud PubSub Emulator Example

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

Starts a PubSub emulator container, connects using the PubSub client, and verifies topic creation. Substitute IMAGE with a container registry image.

```typescript
await using container = await new PubSubEmulatorContainer(IMAGE).start();

const pubSub = new PubSub({
  projectId: "test-project",
  apiEndpoint: container.getEmulatorEndpoint(),
});

const [createdTopic] = await pubSub.createTopic("test-topic");

expect(createdTopic.name).toContain("test-topic");
```

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

### Cloud Storage Emulator Example

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

Starts a Cloud Storage emulator container, connects using the Storage client, and verifies bucket creation. Substitute IMAGE with a container registry image.

```typescript
await using container = await new CloudStorageEmulatorContainer(IMAGE).start();

const storage = new Storage({
  projectId: "test-project",
  apiEndpoint: container.getExternalUrl(),
});

await storage.createBucket("test-bucket");
const [buckets] = await storage.getBuckets();

expect(buckets[0].name).toBe("test-bucket");
```

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

### Datastore Emulator Example

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

Starts a Datastore emulator container, connects using the Datastore client, and verifies a save/get operation. Substitute IMAGE with a container registry image.

```typescript
await using container = await new DatastoreEmulatorContainer(IMAGE).start();

const datastore = new Datastore({
  projectId: "test-project",
  apiEndpoint: container.getEmulatorEndpoint(),
});

const key = datastore.key(["test-kind", "123"]);
const data = { message: "Hello, Datastore!" };
await datastore.save({ key, data });
const [entity] = await datastore.get(key);

expect(entity).toEqual({ message: "Hello, Datastore!", [Datastore.KEY]: key });
```

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

### Start WeaviateContainer with modules

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

Start a Weaviate container with specific modules enabled via environment variables. The example verifies that the server version and each enabled module are defined.

```typescript
const enableModules = [
  "backup-filesystem",
  "text2vec-openai",
  "text2vec-cohere",
  "text2vec-huggingface",
  "generative-openai",
];
const environment: Environment = {
  ENABLE_MODULES: enableModules.join(","),
  BACKUP_FILESYSTEM_PATH: "/tmp/backups",
};

await using container = await new WeaviateContainer(IMAGE).withEnvironment(environment).start();

const client = weaviate.client({
  scheme: "http",
  host: container.getHttpHostAddress(),
});

const res = await client.misc.metaGetter().do();
expect(res.version).toBeDefined();
expect(res.modules).toBeDefined();
enableModules.forEach((module) => expect(res.modules[module]).toBeDefined());
```

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

### Install @influxdata/influxdb-client

Source: https://node.testcontainers.org/modules/influxdb

Installs the official InfluxDB client library used in the InfluxDB 2.x example.

```bash
npm install @influxdata/influxdb-client
```

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

### Install pg and @types/pg

Source: https://node.testcontainers.org/modules/cockroachdb

Install the pg client library and its TypeScript types for use with the CockroachDB examples.

```bash
npm install pg
npm install @types/pg --save-dev

```

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

### Install mssql and @types/mssql

Source: https://node.testcontainers.org/modules/mssqlserver

Installs the mssql client library and its TypeScript type definitions for use in the examples.

```bash
npm install mssql
npm install @types/mssql --save-dev

```

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

### Firestore Emulator Example

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

Starts a Firestore emulator container, connects using the Firestore client, and verifies a document write/read. Substitute IMAGE with a container registry image.

```typescript
await using container = await new FirestoreEmulatorContainer(IMAGE).start();

const app = initializeApp({ projectId: "test-project" }, `test-app-${randomUuid()}`);
const firestore = getFirestore(app);
firestore.settings({
  host: container.getEmulatorEndpoint(),
  ssl: false,
});

const collection = "test-collection";
const document = "test-doc";
const docRef = firestore.collection(collection).doc(document);
await docRef.set({ message: "Hello, Firestore!" });
const snapshot = await docRef.get();

expect(snapshot.data()).toEqual({ message: "Hello, Firestore!" });
```

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

### Start container with an entrypoint

Source: https://node.testcontainers.org/features/containers

Starts a container with a custom entrypoint.

```javascript
const container = await new GenericContainer("alpine")
  .withEntrypoint(["cat"])
  .start();

```

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

### Start container with labels

Source: https://node.testcontainers.org/features/containers

Starts a container with custom labels.

```javascript
const container = await new GenericContainer("alpine")
  .withLabels({ label: "value" })
  .start();

```

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

### Install @testcontainers/valkey

Source: https://node.testcontainers.org/modules/valkey

Install the Testcontainers Valkey module as a development dependency.

```bash
npm install @testcontainers/valkey --save-dev

```

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

### Install @nats-io/jetstream

Source: https://node.testcontainers.org/modules/nats

Installs the NATS JetStream library, required for JetStream examples.

```bash
npm install @nats-io/jetstream

```

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

### Install @nats-io/transport-node

Source: https://node.testcontainers.org/modules/nats

Installs the NATS transport library for Node.js, required for the examples.

```bash
npm install @nats-io/transport-node

```

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

### Get a database connection string

Source: https://node.testcontainers.org/modules/mongodb

Starts a MongoDBAtlasLocalContainer and gets a database connection string.

```typescript
await using container = await new MongoDBAtlasLocalContainer(IMAGE).start();
```

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

### Start Qdrant with config file

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

Starts a Qdrant container with a custom configuration file and connects using a hardcoded API key.

```typescript
await using container = await new QdrantContainer(IMAGE)
  .withConfigFile(path.resolve(__dirname, "test_config.yaml"))
  .start();

const client = new QdrantClient({ url: `http://${container.getRestHostAddress()}`, apiKey: "SOME_TEST_KEY" });
```

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

### Start container with bind mounts

Source: https://node.testcontainers.org/features/containers

Starts a container with bind mounts. Not recommended because bind mounts are not portable and do not work with Docker in Docker or remote Docker agents. Prefer copying files/directories/content into the container instead.

```javascript
const container = await new GenericContainer("alpine")
  .withBindMounts([{
    source: "/local/file.txt",
    target:"/remote/file.txt"
  }, {
    source: "/local/dir",
    target:"/remote/dir",
    mode: "ro"
  }])
  .start();

```

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

### Start MinIO container with custom credentials

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

Starts a MinIO container with custom credentials, creates a bucket, and verifies its existence.

```javascript
await using container = await new MinioContainer(IMAGE)
  .withUsername("AzureDiamond")
  .withPassword("hunter2!")
  .start();

const client = new minio.Client({
  endPoint: container.getHost(),
  port: container.getPort(),
  useSSL: false,
  accessKey: "AzureDiamond",
  secretKey: "hunter2!",
});

await client.makeBucket("test-bucket");

const bucketExits = await client.bucketExists("test-bucket");
expect(bucketExits).toBeTruthy();

```

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

### Start Qdrant with API key

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

Starts a Qdrant container with a generated API key and connects using that key.

```typescript
const apiKey = crypto.randomUUID();

await using container = await new QdrantContainer(IMAGE).withApiKey(apiKey).start();

const client = new QdrantClient({ url: `http://${container.getRestHostAddress()}`, apiKey });
```

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

### Start container with environment variables

Source: https://node.testcontainers.org/features/containers

Starts a container with environment variables set.

```javascript
const container = await new GenericContainer("alpine")
  .withEnvironment({ ENV: "VALUE" })
  .start();

```

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

### Start a pod with K3sContainer

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

Starts a K3s container, creates a pod named 'helloworld' in the default namespace, and waits up to 60 seconds for it to become Ready and Running.

```typescript
await using container = await new K3sContainer(IMAGE).start();

const kubeConfig = new k8s.KubeConfig();
kubeConfig.loadFromString(container.getKubeConfig());

const pod = {
  metadata: {
    name: "helloworld",
  },
  spec: {
    containers: [
      {
        name: "helloworld",
        image: "testcontainers/helloworld:1.1.0",
        ports: [
          {
            containerPort: 8080,
          },
        ],
        readinessProbe: {
          tcpSocket: {
            port: 8080,
          },
        },
      },
    ],
  },
};

const client = kubeConfig.makeApiClient(k8s.CoreV1Api);
await client.createNamespacedPod({ namespace: "default", body: pod });

await vi.waitFor(async () => {
  const { status } = await client.readNamespacedPodStatus({ namespace: "default", name: "helloworld" });

  return (
    status?.phase === "Running" &&
    status?.conditions?.some((cond) => cond.type === "Ready" && cond.status === "True")
  );
}, 60_000);

```

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

### Global setup with RedisContainer and Vitest

Source: https://node.testcontainers.org/quickstart/global-setup

Sets up a single Redis container globally for reuse across tests. The setup function starts the container and provides its connection URL via project.provide, while teardown stops it. The vitest.config.js registers the setup file as globalSetup.

```javascript
import { RedisContainer } from "@testcontainers/redis";

let redisContainer;

export async function setup(project) {
  redisContainer = await new RedisContainer("redis:8").start();
  project.provide("redisUrl", redisContainer.getConnectionUrl());
}

export async function teardown() {
  await redisContainer?.stop();
}

```

```javascript
import { defineConfig } from "vitest/config";

export default defineConfig({
  test: {
    globalSetup: "./setup.js",
  },
});

```

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

### Set/get a value with RedisContainer

Source: https://node.testcontainers.org/modules/redis

Start a Redis container, connect a client, set and get a value, and verify the result.

```typescript
await using container = await new RedisContainer(IMAGE).start();

const client = createClient({ url: container.getConnectionUrl() });
await client.connect();

await client.set("key", "val");
expect(await client.get("key")).toBe("val");

client.destroy();
```

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

### Set/get a value with ValkeyContainer

Source: https://node.testcontainers.org/modules/valkey

Start a Valkey container, connect with the redis client, set and get a value, and verify the result.

```typescript
await using container = await new ValkeyContainer(IMAGE).start();

const client = createClient({ url: container.getConnectionUrl() });
await client.connect();

await client.set("key", "val");
expect(await client.get("key")).toBe("val");

client.destroy();

```

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

### Start a Docker Compose environment with containerRuntimeClient.compose.up

Source: https://node.testcontainers.org/features/advanced

Starts a Docker Compose environment using the container runtime client. The up method takes a configuration object (shown as { ... }).

```typescript
const environment = await containerRuntimeClient.compose.up({ ... })
```

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

### Connect to WeaviateContainer

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

Start a Weaviate container and connect to it using the Weaviate client. The example verifies that the server version is defined.

```typescript
await using container = await new WeaviateContainer(IMAGE).start();

const client = weaviate.client({
  scheme: "http",
  host: container.getHttpHostAddress(),
});

const res = await client.misc.metaGetter().do();
expect(res.version).toBeDefined();
```

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

### Use Redis Stack JSON commands

Source: https://node.testcontainers.org/modules/redis

Start a Redis Stack container and use the JSON module to set and get a JSON value.

```typescript
await using container = await new RedisContainer(REDISSTACK_IMAGE).withPassword("testPassword").start();

const client = createClient({ url: container.getConnectionUrl() });
await client.connect();

await client.json.set("key", "$", { name: "test" });
const result = await client.json.get("key");
expect(result).toEqual({ name: "test" });

client.destroy();
```

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

### Start a network with containerRuntimeClient.network.create

Source: https://node.testcontainers.org/features/advanced

Creates a network using the container runtime client. The create method takes a configuration object (shown as { ... }).

```typescript
const network = await containerRuntimeClient.network.create({ ... })
```

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

### Create a custom container by extending GenericContainer

Source: https://node.testcontainers.org/features/containers

Creates a custom container by extending GenericContainer and AbstractStartedContainer. Overrides the start method to return a custom started container type and adds custom methods. The example imports the necessary types and demonstrates the full class definitions.

```typescript
import {
  GenericContainer,
  TestContainer,
  StartedTestContainer,
  AbstractStartedContainer
} from "testcontainers";

class CustomContainer extends GenericContainer {
  constructor() {
    super("alpine");
  }

  public withCustomMethod(): this {
    // ...
    return this;
  }

  public override async start(): Promise<StartedCustomContainer> {
    return new StartedCustomContainer(await super.start());
  }
}

class StartedCustomContainer extends AbstractStartedContainer {
  constructor(startedTestContainer: StartedTestContainer) {
    super(startedTestContainer);
  }

  public withCustomMethod(): void {
    // ...
  }
}

const customContainer: TestContainer = new CustomContainer();
const startedCustomContainer: StartedTestContainer = await customContainer.start();

```

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

### Start a Docker Compose environment

Source: https://node.testcontainers.org/features/compose

Creates and starts a Docker Compose environment using the testcontainers library. Requires the path to the build context and the compose file name.

```javascript
const { DockerComposeEnvironment } = require("testcontainers");

const composeFilePath = "/path/to/build-context";
const composeFile = "docker-compose.yml";

const environment = await new DockerComposeEnvironment(composeFilePath, composeFile).up();

```

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

### Get a connection string with MongoDBAtlasLocalContainer

Source: https://node.testcontainers.org/modules/mongodb

Shows three ways to start a MongoDBAtlasLocalContainer: without credentials, with credentials, and with custom credentials. The ellipsis (⋯) indicates omitted code.

```typescript
await using container = await new MongoDBAtlasLocalContainer(IMAGE).start();

⋯

await using container = await new MongoDBAtlasLocalContainer(IMAGE).start();

⋯

await using container = await new MongoDBAtlasLocalContainer(IMAGE)
  .withUsername("customUsername")
  .withPassword("customPassword")
  .start();
```

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

### Test Redis container with RedisContainer module

Source: https://node.testcontainers.org/quickstart/usage

Uses the RedisContainer module to start a Redis container and connect using the provided connection URL, simplifying the test setup.

```typescript
import { createClient, RedisClientType } from "redis";
import { RedisContainer, StartedRedisContainer } from "@testcontainers/redis";

describe("Redis", () => {
  let container: StartedRedisContainer;
  let redisClient: RedisClientType;

  beforeAll(async () => {
    container = await new RedisContainer("redis:8").start();
    redisClient = createClient({ url: container.getConnectionUrl() });
    await redisClient.connect();
  });

  afterAll(async () => {
    await redisClient.disconnect();
    await container.stop();
  });

  it("works", async () => {
    await redisClient.set("key", "val");
    expect(await redisClient.get("key")).toBe("val");
  });
});

```

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

### With credentials

Source: https://node.testcontainers.org/modules/clickhouse

Starts a ClickHouse container with custom username and password, then creates a client using those credentials.

```typescript
await using container = await new ClickHouseContainer(IMAGE)
  .withUsername("customUsername")
  .withPassword("customPassword")
  .start();

const client = createClient({
  url: container.getHttpUrl(),
  username: container.getUsername(),
  password: container.getPassword(),
});
```

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

### Set startup timeout with withStartupTimeout

Source: https://node.testcontainers.org/features/wait-strategies

Configures the startup timeout for all wait strategies. The example sets it to 120 seconds (120_000 milliseconds).

```javascript
const { GenericContainer } = require("testcontainers");

const container = await new GenericContainer("alpine")
  .withStartupTimeout(120_000) // 120 seconds
  .start();

```

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

### Build and start a Docker image with GenericContainer.fromDockerfile

Source: https://node.testcontainers.org/features/images

Builds a Docker image from a Dockerfile and starts a container from it. The image is built with a randomly generated name and deleted on exit by default.

```javascript
const { GenericContainer } = require("testcontainers");

const container = await GenericContainer
  .fromDockerfile("/path/to/build-context")
  .build();

const startedContainer = await container.start();

```

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

### Build a Docker image for a specific platform (withPlatform)

Source: https://node.testcontainers.org/features/images

Builds a Docker image for a specific platform using withPlatform(). The example uses "linux/amd64".

```javascript
const container = await GenericContainer
  .fromDockerfile("/path/to/build-context")
  .withPlatform("linux/amd64")
  .build();

```

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

### Start Kafka with SASL/SSL listener and verify message with KafkaJS

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

Starts a Kafka container with SASL/SSL listener (port 9096) using the specified keystore/truststore, then verifies message production/consumption with SSL and SASL credentials. The helper function is provided to complete the setup, using the default port 9093 when additionalKafkaConfig does not override brokers.

```typescript
const saslConfig: SaslSslListenerOptions = {
  port: 9096,
  sasl: {
    mechanism: "SCRAM-SHA-512",
    user: {
      name: "app-user",
      password: "userPassword",
    },
  },
  keystore: {
    content: fs.readFileSync(path.resolve(certificatesDir, "kafka.server.keystore.pfx")),
    passphrase: "serverKeystorePassword",
  },
  truststore: {
    content: fs.readFileSync(path.resolve(certificatesDir, "kafka.server.truststore.pfx")),
    passphrase: "serverTruststorePassword",
  },
};

await using container = await new KafkaContainer(IMAGE).withSaslSslListener(saslConfig).start();

await assertMessageProducedAndConsumed(
  container,
  {
    brokers: [`${container.getHost()}:${container.getMappedPort(9096)}`],
    ssl: true,
    sasl: {
      mechanism: "scram-sha-512",
      username: "app-user",
      password: "userPassword",
    },
  },
  {
    "ssl.ca.location": path.resolve(certificatesDir, "kafka.client.truststore.pem"),
  }
);
```

```typescript
export async function assertMessageProducedAndConsumed(
  container: StartedKafkaContainer,
  additionalKafkaConfig: Partial<KafkaJS.KafkaConfig> = {},
  additionalGlobalConfig: Partial<GlobalConfig> = {}
) {
  const brokers = [`${container.getHost()}:${container.getMappedPort(9093)}`];
  const kafka = new KafkaJS.Kafka({
    kafkaJS: {
      logLevel: KafkaJS.logLevel.ERROR,
      brokers,
      ...additionalKafkaConfig,
    },
    ...additionalGlobalConfig,
  });

  const producer = kafka.producer();
  await producer.connect();
  const consumer = kafka.consumer({ kafkaJS: { groupId: "test-group", fromBeginning: true } });
  await consumer.connect();

  await producer.send({ topic: "test-topic", messages: [{ value: "test message" }] });
  await consumer.subscribe({ topic: "test-topic" });

  const consumedMessage = await new Promise((resolve) =>
    consumer.run({
      eachMessage: async ({ message }) => resolve(message.value?.toString()),
    })
  );
  expect(consumedMessage).toBe("test message");

  await consumer.disconnect();
  await producer.disconnect();
}

```

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

### Mock HTTP request with MockserverContainer

Source: https://node.testcontainers.org/modules/mockserver

Starts a Mockserver container, mocks a GET /foo response returning "bar" with status 200, and verifies the response via superagent.

```typescript
await using container = await new MockserverContainer(IMAGE).start();

const client = mockServerClient(container.getHost(), container.getMockserverPort());
await client.mockAnyResponse({
  httpRequest: {
    method: "GET",
    path: "/foo",
  },
  httpResponse: {
    body: {
      string: "bar",
    },
    statusCode: 200,
  },
});

const response = await superagent.get(`${container.getUrl()}/foo`);

expect(response.statusCode).toBe(200);
expect(response.text).toBe("bar");
```

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

### Start Neo4j with plugins

Source: https://node.testcontainers.org/modules/neo4j

Starts a Neo4j container with APOC Extended and Graph Data Science plugins, then verifies APOC monitor methods reflect node creation.

```javascript
await using container = await new Neo4jContainer(IMAGE)
  .withPlugins([Neo4jPlugin.APOC_EXTENDED, Neo4jPlugin.GRAPH_DATA_SCIENCE])
  .withStartupTimeout(120_000)
  .start();

const driver = neo4j.driver(
  container.getBoltUri(),
  neo4j.auth.basic(container.getUsername(), container.getPassword())
);

const session = driver.session();

// Monitor methods are only available in extended Apoc.
const result = await session.run("CALL apoc.monitor.ids()");
expect(result.records[0].get("nodeIds")).toEqual({ high: 0, low: 0 });

// Insert one node.
await session.run("CREATE (a:Person {name: $name}) RETURN a", { name: "Some dude" });

// Monitor result should reflect increase in data.
const result2 = await session.run("CALL apoc.monitor.ids()");
expect(result2.records[0].get("nodeIds")).toEqual({ high: 0, low: 1 });

await session.close();
await driver.close();
```

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

### Stream logs from a specific time with logs({ since })

Source: https://node.testcontainers.org/features/containers

Specifies a UNIX timestamp (in seconds) from which logs should start. The example calculates a timestamp 10 seconds ago and passes it as the 'since' option.

```javascript
const msInSec = 1000;
const tenSecondsAgoMs = new Date().getTime() - 10 * msInSec;
const since = tenSecondsAgoMs / msInSec;

(await container.logs({ since }))
  .on("data", line => console.log(line))

```

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

### With credentials

Source: https://node.testcontainers.org/modules/cassandra

Starts a Cassandra container with custom username and password, then connects using those credentials.

```typescript
const username = "testUser";
const password = "testPassword";

await using container = await new CassandraContainer(IMAGE).withUsername(username).withPassword(password).start();

const client = new Client({
  contactPoints: [container.getContactPoint()],
  localDataCenter: container.getDatacenter(),
  credentials: { username, password },
  keyspace: "system",
});

```

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

### Mock HTTPS request with MockserverContainer

Source: https://node.testcontainers.org/modules/mockserver

Starts a Mockserver container, mocks a GET /foo response, and verifies it over HTTPS using the secure URL and disabling TLS certificate validation because MockServer uses a self-signed certificate.

```typescript
await using container = await new MockserverContainer(IMAGE).start();

const client = mockServerClient(container.getHost(), container.getMockserverPort());
await client.mockAnyResponse({
  httpRequest: {
    method: "GET",
    path: "/foo",
  },
  httpResponse: {
    body: {
      string: "bar",
    },
    statusCode: 200,
  },
});

const secureUrl = container.getSecureUrl();
const response = await superagent.get(`${secureUrl}/foo`).disableTLSCerts();

expect(response.statusCode).toBe(200);
expect(response.text).toBe("bar");
```

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

### Run CLI init commands at startup

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

Starts a Vault container with init commands to enable a transit secrets engine and create a key, then verifies the key exists.

```javascript
await using container = await new VaultContainer(IMAGE)
  .withVaultToken(VAULT_TOKEN)
  .withInitCommands("secrets enable transit", "write -f transit/keys/my-key")
  .start();

const result = await container.exec(["vault", "read", "-format=json", "transit/keys/my-key"]);

expect(result.exitCode).toBe(0);
expect(result.output).toContain("my-key");
```

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

### Produce/consume a message with NatsContainer

Source: https://node.testcontainers.org/modules/nats

Starts a NATS container, connects, subscribes to a subject, publishes a message, and verifies the received payload. Uses the TextEncoder/TextDecoder for encoding and decoding. The example uses the `expect` assertion from a test framework.

```typescript
const SUBJECT = "HELLO";
const PAYLOAD = "WORLD";
const TE = new TextEncoder();
const TD = new TextDecoder();

await using container = await new NatsContainer(IMAGE).start();
const nc = await connect(container.getConnectionOptions());

const sub = nc.subscribe(SUBJECT);

(async () => {
  for await (const m of sub) {
    const actual = TD.decode(m.data);
    expect(actual).toEqual(PAYLOAD);
  }
})().then();

nc.publish(SUBJECT, TE.encode(PAYLOAD));

await nc.drain();
await nc.close();

```

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

### Execute a query with CouchbaseContainer

Source: https://node.testcontainers.org/modules/couchbase

Starts a Couchbase container with a bucket, connects using the container's credentials, and performs a key-value upsert and get operation. Requires the `couchbase` client library and a chosen image from the container registry.

```typescript
const bucketDefinition = new BucketDefinition("mybucket");
await using container = await new CouchbaseContainer(image).withBucket(bucketDefinition).start();

const cluster = await couchbase.Cluster.connect(container.getConnectionString(), {
  username: container.getUsername(),
  password: container.getPassword(),
});

const bucket = cluster.bucket(bucketDefinition.getName());
await bucket.waitUntilReady(10_000, {
  serviceTypes: [couchbase.ServiceType.KeyValue],
});

const coll = bucket.defaultCollection();
await coll.upsert("testdoc", { foo: "bar" });
const result = await coll.get("testdoc");

expect(result.content).toEqual({ foo: "bar" });

await cluster.close();
```

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

### Start container with SSL and verify SSL connection

Source: https://node.testcontainers.org/modules/postgresql

Starts a PostgreSQL container with SSL certificates using withSSLCert() and connects with SSL enabled. Note: withSSL()/withSSLCert() expect existing certificate/key files; they do not generate key material.

```typescript
await using container = await new PostgreSqlContainer(IMAGE)
  .withSSLCert(SSL_CA_CERT, SSL_SERVER_CERT, SSL_SERVER_KEY)
  .start();

const client = new Client({
  host: container.getHost(),
  port: container.getPort(),
  database: container.getDatabase(),
  user: container.getUsername(),
  password: container.getPassword(),
  ssl: {
    rejectUnauthorized: false,
  },
});
await client.connect();

const result = await client.query("SELECT ssl FROM pg_stat_ssl WHERE pid = pg_backend_pid()");
expect(result.rows[0]).toEqual({ ssl: true });

await client.end();

```

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

### Reuse a running container with withReuse()

Source: https://node.testcontainers.org/features/containers

Enables container reuse with withReuse() so that Testcontainers does not start a new container if one with the same configuration is already running. The example creates two containers with identical configuration and asserts they share the same ID.

```typescript
const container1 = await new GenericContainer("alpine")
  .withCommand(["sleep", "infinity"])
  .withReuse()
  .start();

const container2 = await new GenericContainer("alpine")
  .withCommand(["sleep", "infinity"])
  .withReuse()
  .start();

expect(container1.getId()).toBe(container2.getId());

```
Tokens:
Raw