testcontainers 9.2.0 → 9.3.0

package/dist/src/http-wait-strategy.js

@@ -0,0 +1,113 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpWaitStrategy = void 0;
+const wait_strategy_1 = require("./wait-strategy");
+const retry_strategy_1 = require("./retry-strategy");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const https_1 = __importDefault(require("https"));
+class HttpWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
+    constructor(path, port) {
+        super();
+        this.protocol = "http";
+        this.method = "GET";
+        this.headers = {};
+        this.predicates = [];
+        this._allowInsecure = false;
+        this.readTimeout = 1000;
+        this.path = path;
+        this.port = port;
+    }
+    forStatusCode(statusCode) {
+        this.predicates.push((response) => __awaiter(this, void 0, void 0, function* () { return response.status === statusCode; }));
+        return this;
+    }
+    forStatusCodeMatching(predicate) {
+        this.predicates.push((response) => __awaiter(this, void 0, void 0, function* () { return predicate(response.status); }));
+        return this;
+    }
+    forResponsePredicate(predicate) {
+        this.predicates.push((response) => __awaiter(this, void 0, void 0, function* () { return predicate(yield response.text()); }));
+        return this;
+    }
+    withMethod(method) {
+        this.method = method;
+        return this;
+    }
+    withHeaders(headers) {
+        this.headers = Object.assign(Object.assign({}, this.headers), headers);
+        return this;
+    }
+    withBasicCredentials(username, password) {
+        const base64Encoded = Buffer.from(`${username}:${password}`).toString("base64");
+        this.headers = Object.assign(Object.assign({}, this.headers), { Authorization: `Basic ${base64Encoded}` });
+        return this;
+    }
+    withReadTimeout(readTimeout) {
+        this.readTimeout = readTimeout;
+        return this;
+    }
+    usingTls() {
+        this.protocol = "https";
+        return this;
+    }
+    allowInsecure() {
+        this._allowInsecure = true;
+        return this;
+    }
+    waitUntilReady(container, host, boundPorts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield new retry_strategy_1.IntervalRetryStrategy(this.readTimeout).retryUntil(() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const url = `${this.protocol}://${host}:${boundPorts.getBinding(this.port)}${this.path}`;
+                    return yield (0, node_fetch_1.default)(url, {
+                        method: this.method,
+                        timeout: this.readTimeout,
+                        headers: this.headers,
+                        agent: this.getAgent(),
+                    });
+                }
+                catch (_a) {
+                    return undefined;
+                }
+            }), (response) => __awaiter(this, void 0, void 0, function* () {
+                if (response === undefined) {
+                    return false;
+                }
+                else if (!this.predicates.length) {
+                    return response.ok;
+                }
+                else {
+                    for (const predicate of this.predicates) {
+                        const result = yield predicate(response);
+                        if (!result) {
+                            return false;
+                        }
+                    }
+                    return true;
+                }
+            }), () => {
+                throw new Error(`URL ${this.path} not accessible after ${this.startupTimeout}ms for ${container.id}`);
+            }, this.startupTimeout);
+        });
+    }
+    getAgent() {
+        if (this._allowInsecure) {
+            return new https_1.default.Agent({
+                rejectUnauthorized: false,
+            });
+        }
+    }
+}
+exports.HttpWaitStrategy = HttpWaitStrategy;

package/dist/src/images.d.ts

@@ -0,0 +1,2 @@
+export declare const REAPER_IMAGE: string;
+export declare const SSHD_IMAGE: string;

package/dist/src/images.js

@@ -0,0 +1,6 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SSHD_IMAGE = exports.REAPER_IMAGE = void 0;
+exports.REAPER_IMAGE = (_a = process.env["RYUK_CONTAINER_IMAGE"]) !== null && _a !== void 0 ? _a : "testcontainers/ryuk:0.3.4";
+exports.SSHD_IMAGE = (_b = process.env["SSHD_CONTAINER_IMAGE"]) !== null && _b !== void 0 ? _b : "testcontainers/sshd:1.1.0";

package/dist/src/index.d.ts

@@ -0,0 +1,21 @@
+export { TestContainer, StartedTestContainer, StoppedTestContainer } from "./test-container";
+export { GenericContainer } from "./generic-container/generic-container";
+export { GenericContainerBuilder } from "./generic-container/generic-container-builder";
+export { TestContainers } from "./test-containers";
+export { DockerComposeEnvironment } from "./docker-compose-environment/docker-compose-environment";
+export { StartedDockerComposeEnvironment } from "./docker-compose-environment/started-docker-compose-environment";
+export { StoppedDockerComposeEnvironment } from "./docker-compose-environment/stopped-docker-compose-environment";
+export { DownedDockerComposeEnvironment } from "./docker-compose-environment/downed-docker-compose-environment";
+export { Network, StartedNetwork, StoppedNetwork } from "./network";
+export { Wait } from "./wait";
+export { StartupCheckStrategy, StartupStatus } from "./startup-check-strategy";
+export { PullPolicy, DefaultPullPolicy, AlwaysPullPolicy } from "./pull-policy";
+export { AbstractStartedContainer } from "./modules/abstract-started-container";
+export { PostgreSqlContainer, StartedPostgreSqlContainer } from "./modules/postgresql/postgresql-container";
+export { KafkaContainer, StartedKafkaContainer } from "./modules/kafka/kafka-container";
+export { Neo4jContainer, StartedNeo4jContainer } from "./modules/neo4j/neo4j-container";
+export { ArangoDBContainer, StartedArangoContainer } from "./modules/arangodb/arangodb-container";
+export { ElasticsearchContainer, StartedElasticsearchContainer } from "./modules/elasticsearch/elasticsearch-container";
+export { MySqlContainer, StartedMySqlContainer } from "./modules/mysql/mysql-container";
+export { NatsContainer, StartedNatsContainer, NatsConnectionOptions, NatsTlsOptions, } from "./modules/nats/nats-container";
+export { MongoDBContainer, StartedMongoDBContainer } from "./modules/mongodb/mongodb-container";

package/dist/src/index.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StartedMongoDBContainer = exports.MongoDBContainer = exports.StartedNatsContainer = exports.NatsContainer = exports.StartedMySqlContainer = exports.MySqlContainer = exports.StartedElasticsearchContainer = exports.ElasticsearchContainer = exports.StartedArangoContainer = exports.ArangoDBContainer = exports.StartedNeo4jContainer = exports.Neo4jContainer = exports.StartedKafkaContainer = exports.KafkaContainer = exports.StartedPostgreSqlContainer = exports.PostgreSqlContainer = exports.AbstractStartedContainer = exports.AlwaysPullPolicy = exports.DefaultPullPolicy = exports.StartupCheckStrategy = exports.Wait = exports.StoppedNetwork = exports.StartedNetwork = exports.Network = exports.DownedDockerComposeEnvironment = exports.StoppedDockerComposeEnvironment = exports.StartedDockerComposeEnvironment = exports.DockerComposeEnvironment = exports.TestContainers = exports.GenericContainerBuilder = exports.GenericContainer = void 0;
+var generic_container_1 = require("./generic-container/generic-container");
+Object.defineProperty(exports, "GenericContainer", { enumerable: true, get: function () { return generic_container_1.GenericContainer; } });
+var generic_container_builder_1 = require("./generic-container/generic-container-builder");
+Object.defineProperty(exports, "GenericContainerBuilder", { enumerable: true, get: function () { return generic_container_builder_1.GenericContainerBuilder; } });
+var test_containers_1 = require("./test-containers");
+Object.defineProperty(exports, "TestContainers", { enumerable: true, get: function () { return test_containers_1.TestContainers; } });
+var docker_compose_environment_1 = require("./docker-compose-environment/docker-compose-environment");
+Object.defineProperty(exports, "DockerComposeEnvironment", { enumerable: true, get: function () { return docker_compose_environment_1.DockerComposeEnvironment; } });
+var started_docker_compose_environment_1 = require("./docker-compose-environment/started-docker-compose-environment");
+Object.defineProperty(exports, "StartedDockerComposeEnvironment", { enumerable: true, get: function () { return started_docker_compose_environment_1.StartedDockerComposeEnvironment; } });
+var stopped_docker_compose_environment_1 = require("./docker-compose-environment/stopped-docker-compose-environment");
+Object.defineProperty(exports, "StoppedDockerComposeEnvironment", { enumerable: true, get: function () { return stopped_docker_compose_environment_1.StoppedDockerComposeEnvironment; } });
+var downed_docker_compose_environment_1 = require("./docker-compose-environment/downed-docker-compose-environment");
+Object.defineProperty(exports, "DownedDockerComposeEnvironment", { enumerable: true, get: function () { return downed_docker_compose_environment_1.DownedDockerComposeEnvironment; } });
+var network_1 = require("./network");
+Object.defineProperty(exports, "Network", { enumerable: true, get: function () { return network_1.Network; } });
+Object.defineProperty(exports, "StartedNetwork", { enumerable: true, get: function () { return network_1.StartedNetwork; } });
+Object.defineProperty(exports, "StoppedNetwork", { enumerable: true, get: function () { return network_1.StoppedNetwork; } });
+var wait_1 = require("./wait");
+Object.defineProperty(exports, "Wait", { enumerable: true, get: function () { return wait_1.Wait; } });
+var startup_check_strategy_1 = require("./startup-check-strategy");
+Object.defineProperty(exports, "StartupCheckStrategy", { enumerable: true, get: function () { return startup_check_strategy_1.StartupCheckStrategy; } });
+var pull_policy_1 = require("./pull-policy");
+Object.defineProperty(exports, "DefaultPullPolicy", { enumerable: true, get: function () { return pull_policy_1.DefaultPullPolicy; } });
+Object.defineProperty(exports, "AlwaysPullPolicy", { enumerable: true, get: function () { return pull_policy_1.AlwaysPullPolicy; } });
+var abstract_started_container_1 = require("./modules/abstract-started-container");
+Object.defineProperty(exports, "AbstractStartedContainer", { enumerable: true, get: function () { return abstract_started_container_1.AbstractStartedContainer; } });
+var postgresql_container_1 = require("./modules/postgresql/postgresql-container");
+Object.defineProperty(exports, "PostgreSqlContainer", { enumerable: true, get: function () { return postgresql_container_1.PostgreSqlContainer; } });
+Object.defineProperty(exports, "StartedPostgreSqlContainer", { enumerable: true, get: function () { return postgresql_container_1.StartedPostgreSqlContainer; } });
+var kafka_container_1 = require("./modules/kafka/kafka-container");
+Object.defineProperty(exports, "KafkaContainer", { enumerable: true, get: function () { return kafka_container_1.KafkaContainer; } });
+Object.defineProperty(exports, "StartedKafkaContainer", { enumerable: true, get: function () { return kafka_container_1.StartedKafkaContainer; } });
+var neo4j_container_1 = require("./modules/neo4j/neo4j-container");
+Object.defineProperty(exports, "Neo4jContainer", { enumerable: true, get: function () { return neo4j_container_1.Neo4jContainer; } });
+Object.defineProperty(exports, "StartedNeo4jContainer", { enumerable: true, get: function () { return neo4j_container_1.StartedNeo4jContainer; } });
+var arangodb_container_1 = require("./modules/arangodb/arangodb-container");
+Object.defineProperty(exports, "ArangoDBContainer", { enumerable: true, get: function () { return arangodb_container_1.ArangoDBContainer; } });
+Object.defineProperty(exports, "StartedArangoContainer", { enumerable: true, get: function () { return arangodb_container_1.StartedArangoContainer; } });
+var elasticsearch_container_1 = require("./modules/elasticsearch/elasticsearch-container");
+Object.defineProperty(exports, "ElasticsearchContainer", { enumerable: true, get: function () { return elasticsearch_container_1.ElasticsearchContainer; } });
+Object.defineProperty(exports, "StartedElasticsearchContainer", { enumerable: true, get: function () { return elasticsearch_container_1.StartedElasticsearchContainer; } });
+var mysql_container_1 = require("./modules/mysql/mysql-container");
+Object.defineProperty(exports, "MySqlContainer", { enumerable: true, get: function () { return mysql_container_1.MySqlContainer; } });
+Object.defineProperty(exports, "StartedMySqlContainer", { enumerable: true, get: function () { return mysql_container_1.StartedMySqlContainer; } });
+var nats_container_1 = require("./modules/nats/nats-container");
+Object.defineProperty(exports, "NatsContainer", { enumerable: true, get: function () { return nats_container_1.NatsContainer; } });
+Object.defineProperty(exports, "StartedNatsContainer", { enumerable: true, get: function () { return nats_container_1.StartedNatsContainer; } });
+var mongodb_container_1 = require("./modules/mongodb/mongodb-container");
+Object.defineProperty(exports, "MongoDBContainer", { enumerable: true, get: function () { return mongodb_container_1.MongoDBContainer; } });
+Object.defineProperty(exports, "StartedMongoDBContainer", { enumerable: true, get: function () { return mongodb_container_1.StartedMongoDBContainer; } });

package/dist/src/labels.d.ts

@@ -0,0 +1,5 @@
+export declare const LABEL_TESTCONTAINERS = "org.testcontainers";
+export declare const LABEL_TESTCONTAINERS_LANG = "org.testcontainers.lang";
+export declare const LABEL_TESTCONTAINERS_VERSION = "org.testcontainers.version";
+export declare const LABEL_TESTCONTAINERS_SESSION_ID = "org.testcontainers.session-id";
+export declare const LABEL_TESTCONTAINERS_CONTAINER_HASH = "org.testcontainers.container-hash";

package/dist/src/labels.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LABEL_TESTCONTAINERS_CONTAINER_HASH = exports.LABEL_TESTCONTAINERS_SESSION_ID = exports.LABEL_TESTCONTAINERS_VERSION = exports.LABEL_TESTCONTAINERS_LANG = exports.LABEL_TESTCONTAINERS = void 0;
+exports.LABEL_TESTCONTAINERS = "org.testcontainers";
+exports.LABEL_TESTCONTAINERS_LANG = "org.testcontainers.lang";
+exports.LABEL_TESTCONTAINERS_VERSION = "org.testcontainers.version";
+exports.LABEL_TESTCONTAINERS_SESSION_ID = "org.testcontainers.session-id";
+exports.LABEL_TESTCONTAINERS_CONTAINER_HASH = "org.testcontainers.container-hash";

package/dist/src/logger.d.ts

@@ -0,0 +1,36 @@
+type Message = string;
+export interface Logger {
+    enabled(): boolean;
+    trace(message: Message): void;
+    debug(message: Message): void;
+    info(message: Message): void;
+    warn(message: Message): void;
+    error(message: Message): void;
+}
+declare class DebugLogger implements Logger {
+    private readonly logger;
+    constructor(namespace: string);
+    enabled(): boolean;
+    trace(message: Message): void;
+    debug(message: Message): void;
+    info(message: Message): void;
+    warn(message: Message): void;
+    error(message: Message): void;
+}
+export declare class FakeLogger implements Logger {
+    readonly traceLogs: Message[];
+    readonly debugLogs: Message[];
+    readonly infoLogs: Message[];
+    readonly warnLogs: Message[];
+    readonly errorLogs: Message[];
+    enabled(): boolean;
+    trace(message: Message): void;
+    debug(message: Message): void;
+    info(message: Message): void;
+    warn(message: Message): void;
+    error(message: Message): void;
+}
+export declare const log: DebugLogger;
+export declare const containerLog: DebugLogger;
+export declare const execLog: DebugLogger;
+export {};

package/dist/src/logger.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execLog = exports.containerLog = exports.log = exports.FakeLogger = void 0;
+const debug_1 = __importDefault(require("debug"));
+class DebugLogger {
+    constructor(namespace) {
+        this.logger = (0, debug_1.default)(namespace);
+    }
+    enabled() {
+        return this.logger.enabled;
+    }
+    trace(message) {
+        this.logger(`TRACE ${message}`);
+    }
+    debug(message) {
+        this.logger(`DEBUG ${message}`);
+    }
+    info(message) {
+        this.logger(`INFO  ${message}`);
+    }
+    warn(message) {
+        this.logger(`WARN  ${message}`);
+    }
+    error(message) {
+        this.logger(`ERROR ${message}`);
+    }
+}
+class FakeLogger {
+    constructor() {
+        this.traceLogs = [];
+        this.debugLogs = [];
+        this.infoLogs = [];
+        this.warnLogs = [];
+        this.errorLogs = [];
+    }
+    enabled() {
+        return true;
+    }
+    trace(message) {
+        this.traceLogs.push(message);
+    }
+    debug(message) {
+        this.debugLogs.push(message);
+    }
+    info(message) {
+        this.infoLogs.push(message);
+    }
+    warn(message) {
+        this.warnLogs.push(message);
+    }
+    error(message) {
+        this.errorLogs.push(message);
+    }
+}
+exports.FakeLogger = FakeLogger;
+exports.log = new DebugLogger("testcontainers");
+exports.containerLog = new DebugLogger("testcontainers:containers");
+exports.execLog = new DebugLogger("testcontainers:exec");

package/dist/src/modules/abstract-started-container.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+import { RestartOptions, StartedTestContainer, StopOptions, StoppedTestContainer } from "../test-container";
+import { ExecResult, Labels } from "../docker/types";
+import { Readable } from "stream";
+export declare class AbstractStartedContainer implements StartedTestContainer {
+    protected readonly startedTestContainer: StartedTestContainer;
+    constructor(startedTestContainer: StartedTestContainer);
+    stop(options?: Partial<StopOptions>): Promise<StoppedTestContainer>;
+    restart(options?: Partial<RestartOptions>): Promise<void>;
+    getHost(): string;
+    getFirstMappedPort(): number;
+    getMappedPort(port: number): number;
+    getName(): string;
+    getLabels(): Labels;
+    getId(): string;
+    getNetworkNames(): string[];
+    getNetworkId(networkName: string): string;
+    getIpAddress(networkName: string): string;
+    exec(command: string[]): Promise<ExecResult>;
+    logs(): Promise<Readable>;
+}

package/dist/src/modules/abstract-started-container.js

@@ -0,0 +1,59 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractStartedContainer = void 0;
+class AbstractStartedContainer {
+    constructor(startedTestContainer) {
+        this.startedTestContainer = startedTestContainer;
+    }
+    stop(options) {
+        return this.startedTestContainer.stop(options);
+    }
+    restart(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.startedTestContainer.restart(options);
+        });
+    }
+    getHost() {
+        return this.startedTestContainer.getHost();
+    }
+    getFirstMappedPort() {
+        return this.startedTestContainer.getFirstMappedPort();
+    }
+    getMappedPort(port) {
+        return this.startedTestContainer.getMappedPort(port);
+    }
+    getName() {
+        return this.startedTestContainer.getName();
+    }
+    getLabels() {
+        return this.startedTestContainer.getLabels();
+    }
+    getId() {
+        return this.startedTestContainer.getId();
+    }
+    getNetworkNames() {
+        return this.startedTestContainer.getNetworkNames();
+    }
+    getNetworkId(networkName) {
+        return this.startedTestContainer.getNetworkId(networkName);
+    }
+    getIpAddress(networkName) {
+        return this.startedTestContainer.getIpAddress(networkName);
+    }
+    exec(command) {
+        return this.startedTestContainer.exec(command);
+    }
+    logs() {
+        return this.startedTestContainer.logs();
+    }
+}
+exports.AbstractStartedContainer = AbstractStartedContainer;

package/dist/src/modules/arangodb/arangodb-container.d.ts

@@ -0,0 +1,19 @@
+import { GenericContainer } from "../..";
+import { StartedTestContainer } from "../../test-container";
+import { AbstractStartedContainer } from "../abstract-started-container";
+export declare class ArangoDBContainer extends GenericContainer {
+    private password;
+    constructor(image?: string, password?: string);
+    withPassword(password: string): this;
+    start(): Promise<StartedArangoContainer>;
+}
+export declare class StartedArangoContainer extends AbstractStartedContainer {
+    private readonly password;
+    private readonly host;
+    private readonly port;
+    constructor(startedTestContainer: StartedTestContainer, password: string);
+    getTcpUrl(): string;
+    getHttpUrl(): string;
+    getPassword(): string;
+    getUsername(): string;
+}

package/dist/src/modules/arangodb/arangodb-container.js

@@ -0,0 +1,60 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StartedArangoContainer = exports.ArangoDBContainer = void 0;
+const __1 = require("../..");
+const abstract_started_container_1 = require("../abstract-started-container");
+const ARANGODB_PORT = 8529;
+const USERNAME = "root";
+class ArangoDBContainer extends __1.GenericContainer {
+    constructor(image = "arangodb:3.10.0", password = "test") {
+        super(image);
+        this.password = password;
+    }
+    withPassword(password) {
+        this.password = password;
+        return this;
+    }
+    start() {
+        const _super = Object.create(null, {
+            start: { get: () => super.start }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            this.withExposedPorts(...(this.hasExposedPorts ? this.ports : [ARANGODB_PORT]))
+                .withWaitStrategy(__1.Wait.forLogMessage("Have fun!"))
+                .withEnvironment({ ARANGO_ROOT_PASSWORD: this.password })
+                .withStartupTimeout(120000);
+            return new StartedArangoContainer(yield _super.start.call(this), this.password);
+        });
+    }
+}
+exports.ArangoDBContainer = ArangoDBContainer;
+class StartedArangoContainer extends abstract_started_container_1.AbstractStartedContainer {
+    constructor(startedTestContainer, password) {
+        super(startedTestContainer);
+        this.password = password;
+        this.host = this.startedTestContainer.getHost();
+        this.port = this.startedTestContainer.getMappedPort(ARANGODB_PORT);
+    }
+    getTcpUrl() {
+        return `tcp://${this.host}:${this.port}/`;
+    }
+    getHttpUrl() {
+        return `http://${this.host}:${this.port}/`;
+    }
+    getPassword() {
+        return this.password;
+    }
+    getUsername() {
+        return USERNAME;
+    }
+}
+exports.StartedArangoContainer = StartedArangoContainer;

package/dist/src/modules/elasticsearch/elasticsearch-container.d.ts

@@ -0,0 +1,12 @@
+import { GenericContainer, StartedTestContainer } from "../..";
+import { AbstractStartedContainer } from "../abstract-started-container";
+export declare class ElasticsearchContainer extends GenericContainer {
+    constructor(image?: string);
+    start(): Promise<StartedElasticsearchContainer>;
+}
+export declare class StartedElasticsearchContainer extends AbstractStartedContainer {
+    readonly startedTestContainer: StartedTestContainer;
+    private readonly httpPort;
+    constructor(startedTestContainer: StartedTestContainer);
+    getHttpUrl(): string;
+}

package/dist/src/modules/elasticsearch/elasticsearch-container.js

@@ -0,0 +1,43 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StartedElasticsearchContainer = exports.ElasticsearchContainer = void 0;
+const __1 = require("../..");
+const abstract_started_container_1 = require("../abstract-started-container");
+const ELASTIC_SEARCH_HTTP_PORT = 9200;
+class ElasticsearchContainer extends __1.GenericContainer {
+    constructor(image = "elasticsearch:7.17.7") {
+        super(image);
+    }
+    start() {
+        const _super = Object.create(null, {
+            start: { get: () => super.start }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            this.withExposedPorts(...(this.hasExposedPorts ? this.ports : [ELASTIC_SEARCH_HTTP_PORT]))
+                .withEnvironment({ "discovery.type": "single-node" })
+                .withStartupTimeout(120000);
+            return new StartedElasticsearchContainer(yield _super.start.call(this));
+        });
+    }
+}
+exports.ElasticsearchContainer = ElasticsearchContainer;
+class StartedElasticsearchContainer extends abstract_started_container_1.AbstractStartedContainer {
+    constructor(startedTestContainer) {
+        super(startedTestContainer);
+        this.startedTestContainer = startedTestContainer;
+        this.httpPort = this.getMappedPort(ELASTIC_SEARCH_HTTP_PORT);
+    }
+    getHttpUrl() {
+        return `http://${this.getHost()}:${this.httpPort}`;
+    }
+}
+exports.StartedElasticsearchContainer = StartedElasticsearchContainer;

package/dist/src/modules/kafka/kafka-container.d.ts

@@ -0,0 +1,46 @@
+import { GenericContainer } from "../../generic-container/generic-container";
+import { BoundPorts } from "../../bound-ports";
+import { StartedTestContainer } from "../..";
+import { AbstractStartedContainer } from "../abstract-started-container";
+import { InspectResult } from "../../docker/functions/container/inspect-container";
+import { Content } from "../../docker/types";
+export declare const KAFKA_IMAGE = "confluentinc/cp-kafka:7.2.2";
+interface SaslSslListenerOptions {
+    sasl: SaslOptions;
+    port: number;
+    keystore: PKCS12CertificateStore;
+    truststore?: PKCS12CertificateStore;
+}
+interface SaslOptions {
+    mechanism: "SCRAM-SHA-256" | "SCRAM-SHA-512";
+    user: User;
+}
+interface User {
+    name: string;
+    password: string;
+}
+interface PKCS12CertificateStore {
+    content: Content;
+    passphrase: string;
+}
+export declare class KafkaContainer extends GenericContainer {
+    private readonly uuid;
+    private isZooKeeperProvided;
+    private zooKeeperHost?;
+    private zooKeeperPort?;
+    private saslSslConfig?;
+    constructor(image?: string);
+    withZooKeeper(host: string, port: number): this;
+    withSaslSslListener(options: SaslSslListenerOptions): this;
+    protected preStart(): Promise<void>;
+    start(): Promise<StartedKafkaContainer>;
+    protected postStart(container: StartedTestContainer, inspectResult: InspectResult, boundPorts: BoundPorts): Promise<void>;
+    private addPlaintextAndSecureListener;
+    private addPlaintextListener;
+    private updateAdvertisedListeners;
+    private createUser;
+}
+export declare class StartedKafkaContainer extends AbstractStartedContainer {
+    constructor(startedTestContainer: StartedTestContainer);
+}
+export {};