testcontainers 9.12.0 → 10.0.0-beta.5

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

@@ -1,45 +0,0 @@
-import { GenericContainer } from "../../generic-container/generic-container";
-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 beforeContainerStarted(): Promise<void>;
-    start(): Promise<StartedKafkaContainer>;
-    protected containerStarted(container: StartedTestContainer, inspectResult: InspectResult): Promise<void>;
-    private addPlaintextAndSecureListener;
-    private addPlaintextListener;
-    private updateAdvertisedListeners;
-    private createUser;
-}
-export declare class StartedKafkaContainer extends AbstractStartedContainer {
-    constructor(startedTestContainer: StartedTestContainer);
-}
-export {};

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

@@ -1,177 +0,0 @@
-"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.StartedKafkaContainer = exports.KafkaContainer = exports.KAFKA_IMAGE = void 0;
-const generic_container_1 = require("../../generic-container/generic-container");
-const uuid_1 = require("../../uuid");
-const abstract_started_container_1 = require("../abstract-started-container");
-const KAFKA_PORT = 9093;
-const KAFKA_BROKER_PORT = 9092;
-const DEFAULT_ZOOKEEPER_PORT = 2181;
-exports.KAFKA_IMAGE = "confluentinc/cp-kafka:7.2.2";
-class KafkaContainer extends generic_container_1.GenericContainer {
-    constructor(image = exports.KAFKA_IMAGE) {
-        super(image);
-        this.uuid = new uuid_1.RandomUuid();
-        this.isZooKeeperProvided = false;
-        this.withExposedPorts(KAFKA_PORT).withStartupTimeout(180000).withEnvironment({
-            KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: "BROKER:PLAINTEXT,PLAINTEXT:PLAINTEXT",
-            KAFKA_INTER_BROKER_LISTENER_NAME: "BROKER",
-            KAFKA_BROKER_ID: "1",
-            KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: "1",
-            KAFKA_OFFSETS_TOPIC_NUM_PARTITIONS: "1",
-            KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: "1",
-            KAFKA_LOG_FLUSH_INTERVAL_MESSAGES: "9223372036854775807",
-            KAFKA_GROUP_INITIAL_REBALANCE_DELAY_MS: "0",
-            KAFKA_CONFLUENT_SUPPORT_METRICS_ENABLE: "false",
-        });
-    }
-    withZooKeeper(host, port) {
-        this.isZooKeeperProvided = true;
-        this.zooKeeperHost = host;
-        this.zooKeeperPort = port;
-        return this;
-    }
-    withSaslSslListener(options) {
-        this.saslSslConfig = options;
-        return this;
-    }
-    beforeContainerStarted() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const network = this.networkMode && this.networkAliases.length > 0 ? this.networkAliases[0] : "localhost";
-            this.withEnvironment({ KAFKA_ADVERTISED_LISTENERS: `BROKER://${network}:${KAFKA_BROKER_PORT}` });
-            if (this.saslSslConfig) {
-                this.addPlaintextAndSecureListener(this.saslSslConfig);
-            }
-            else {
-                this.addPlaintextListener();
-            }
-            let command = "#!/bin/bash\n";
-            if (this.isZooKeeperProvided) {
-                this.withEnvironment({ KAFKA_ZOOKEEPER_CONNECT: `${this.zooKeeperHost}:${this.zooKeeperPort}` });
-            }
-            else {
-                this.zooKeeperHost = this.uuid.nextUuid();
-                this.zooKeeperPort = DEFAULT_ZOOKEEPER_PORT;
-                this.withExposedPorts(this.zooKeeperPort);
-                this.withEnvironment({ KAFKA_ZOOKEEPER_CONNECT: `localhost:${this.zooKeeperPort}` });
-                command += "echo 'clientPort=" + this.zooKeeperPort + "' > zookeeper.properties\n";
-                command += "echo 'dataDir=/var/lib/zookeeper/data' >> zookeeper.properties\n";
-                command += "echo 'dataLogDir=/var/lib/zookeeper/log' >> zookeeper.properties\n";
-                command += "zookeeper-server-start zookeeper.properties &\n";
-            }
-            command += "echo '' > /etc/confluent/docker/ensure \n";
-            command += "/etc/confluent/docker/run \n";
-            this.withCommand(["sh", "-c", command]);
-        });
-    }
-    start() {
-        const _super = Object.create(null, {
-            start: { get: () => super.start }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            return new StartedKafkaContainer(yield _super.start.call(this));
-        });
-    }
-    containerStarted(container, inspectResult) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.updateAdvertisedListeners(container, inspectResult);
-            if (this.saslSslConfig) {
-                yield this.createUser(container, this.saslSslConfig.sasl);
-            }
-        });
-    }
-    addPlaintextAndSecureListener({ port, sasl, keystore, truststore }) {
-        this.withEnvironment({
-            KAFKA_LISTENERS: `SECURE://0.0.0.0:${port},PLAINTEXT://0.0.0.0:${KAFKA_PORT},BROKER://0.0.0.0:${KAFKA_BROKER_PORT}`,
-            KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: "BROKER:PLAINTEXT,PLAINTEXT:PLAINTEXT,SECURE:SASL_SSL",
-            KAFKA_SSL_PROTOCOL: "TLSv1.2",
-            KAFKA_SSL_KEYSTORE_LOCATION: "/etc/kafka/secrets/server.keystore.pfx",
-            KAFKA_SSL_KEYSTORE_PASSWORD: keystore.passphrase,
-            KAFKA_SSL_KEYSTORE_TYPE: "PKCS12",
-            KAFKA_SASL_ENABLED_MECHANISMS: sasl.mechanism,
-            [`KAFKA_LISTENER_NAME_SECURE_${sasl.mechanism}_SASL_JAAS_CONFIG`]: "org.apache.kafka.common.security.scram.ScramLoginModule required;",
-        })
-            .withCopyContentToContainer([{ content: keystore.content, target: "/etc/kafka/secrets/server.keystore.pfx" }])
-            .withExposedPorts(KAFKA_PORT, port);
-        if (truststore) {
-            this.withCopyContentToContainer([
-                { content: truststore.content, target: "/etc/kafka/secrets/server.truststore.pfx" },
-            ]).withEnvironment({
-                KAFKA_SSL_TRUSTSTORE_LOCATION: "/etc/kafka/secrets/server.truststore.pfx",
-                KAFKA_SSL_TRUSTSTORE_PASSWORD: truststore.passphrase,
-                KAFKA_SSL_TRUSTSTORE_TYPE: "PKCS12",
-            });
-        }
-    }
-    addPlaintextListener() {
-        this.withEnvironment({
-            KAFKA_LISTENERS: `PLAINTEXT://0.0.0.0:${KAFKA_PORT},BROKER://0.0.0.0:${KAFKA_BROKER_PORT}`,
-        }).withExposedPorts(KAFKA_PORT);
-    }
-    updateAdvertisedListeners(container, inspectResult) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const brokerAdvertisedListener = `BROKER://${inspectResult.hostname}:${KAFKA_BROKER_PORT}`;
-            let bootstrapServers = `PLAINTEXT://${container.getHost()}:${container.getMappedPort(KAFKA_PORT)}`;
-            if (this.saslSslConfig) {
-                if (this.networkMode) {
-                    bootstrapServers = `${bootstrapServers},SECURE://${inspectResult.hostname}:${this.saslSslConfig.port}`;
-                }
-                else {
-                    bootstrapServers = `${bootstrapServers},SECURE://${container.getHost()}:${container.getMappedPort(this.saslSslConfig.port)}`;
-                }
-            }
-            const { output, exitCode } = yield container.exec([
-                "kafka-configs",
-                "--alter",
-                "--bootstrap-server",
-                brokerAdvertisedListener,
-                "--entity-type",
-                "brokers",
-                "--entity-name",
-                this.opts.environment["KAFKA_BROKER_ID"],
-                "--add-config",
-                `advertised.listeners=[${bootstrapServers},${brokerAdvertisedListener}]`,
-            ]);
-            if (exitCode !== 0) {
-                throw new Error(`Kafka container configuration failed with exit code ${exitCode}: ${output}`);
-            }
-        });
-    }
-    createUser(container, { user: { name, password }, mechanism }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { output, exitCode } = yield container.exec([
-                "kafka-configs",
-                "--alter",
-                // At the time of writing kafka-configs displays a warning stating that the 'zookeeper' flag is deprecated in favor of 'bootstrap-server'.
-                // Unfortunately, 'bootstrap-server' can only be used to set quotas and not to create a user.
-                "--zookeeper",
-                this.opts.environment["KAFKA_ZOOKEEPER_CONNECT"],
-                "--entity-type",
-                "users",
-                "--entity-name",
-                `${name}`,
-                "--add-config",
-                `${mechanism}=[password=${password}]`,
-            ]);
-            if (exitCode !== 0) {
-                throw new Error(`Kafka container configuration failed with exit code ${exitCode}: ${output}`);
-            }
-        });
-    }
-}
-exports.KafkaContainer = KafkaContainer;
-class StartedKafkaContainer extends abstract_started_container_1.AbstractStartedContainer {
-    constructor(startedTestContainer) {
-        super(startedTestContainer);
-    }
-}
-exports.StartedKafkaContainer = StartedKafkaContainer;

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

@@ -1,19 +0,0 @@
-import { GenericContainer } from "../../generic-container/generic-container";
-import { AbstractStartedContainer } from "../abstract-started-container";
-import { StartedTestContainer } from "../../test-container";
-export declare class MongoDBContainer extends GenericContainer {
-    private readonly dockerImageName;
-    constructor(image?: string);
-    start(): Promise<StartedMongoDBContainer>;
-    protected containerStarted(startedTestContainer: StartedTestContainer): Promise<void>;
-    private initReplicaSet;
-    private executeMongoEvalCommand;
-    private buildMongoEvalCommand;
-    private getMongoCmdBasedOnImageTag;
-    private checkMongoNodeExitCode;
-    private buildMongoWaitCommand;
-}
-export declare class StartedMongoDBContainer extends AbstractStartedContainer {
-    constructor(startedTestContainer: StartedTestContainer);
-    getConnectionString(): string;
-}

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

@@ -1,85 +0,0 @@
-"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.StartedMongoDBContainer = exports.MongoDBContainer = void 0;
-const generic_container_1 = require("../../generic-container/generic-container");
-const abstract_started_container_1 = require("../abstract-started-container");
-const wait_1 = require("../../wait-strategy/wait");
-const docker_image_name_1 = require("../../docker-image-name");
-const MONGODB_PORT = 27017;
-class MongoDBContainer extends generic_container_1.GenericContainer {
-    constructor(image = "mongo:4.0.1") {
-        super(image);
-        this.dockerImageName = docker_image_name_1.DockerImageName.fromString(this.image);
-    }
-    start() {
-        const _super = Object.create(null, {
-            start: { get: () => super.start }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            this.withExposedPorts(MONGODB_PORT)
-                .withCommand(["--replSet", "rs0"])
-                .withWaitStrategy(wait_1.Wait.forLogMessage(/.*waiting for connections.*/i))
-                .withStartupTimeout(120000);
-            return new StartedMongoDBContainer(yield _super.start.call(this));
-        });
-    }
-    containerStarted(startedTestContainer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.initReplicaSet(startedTestContainer);
-        });
-    }
-    initReplicaSet(startedTestContainer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.executeMongoEvalCommand(startedTestContainer, "rs.initiate();");
-            yield this.executeMongoEvalCommand(startedTestContainer, this.buildMongoWaitCommand());
-        });
-    }
-    executeMongoEvalCommand(startedTestContainer, command) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const execResult = yield startedTestContainer.exec(this.buildMongoEvalCommand(command));
-            this.checkMongoNodeExitCode(execResult);
-        });
-    }
-    buildMongoEvalCommand(command) {
-        return [this.getMongoCmdBasedOnImageTag(), "--eval", command];
-    }
-    getMongoCmdBasedOnImageTag() {
-        return parseInt(this.dockerImageName.tag[0]) >= 5 ? "mongosh" : "mongo";
-    }
-    checkMongoNodeExitCode(execResult) {
-        const { exitCode, output } = execResult;
-        if (execResult.exitCode !== 0) {
-            throw new Error(`Error running mongo command. Exit code ${exitCode}: ${output}`);
-        }
-    }
-    buildMongoWaitCommand() {
-        return `
-    var attempt = 0;
-    while(db.runCommand({isMaster: 1}).ismaster==false) {
-      if (attempt > 60) {
-        quit(1);
-      }
-      print(attempt); sleep(100); attempt++; 
-    }
-    `;
-    }
-}
-exports.MongoDBContainer = MongoDBContainer;
-class StartedMongoDBContainer extends abstract_started_container_1.AbstractStartedContainer {
-    constructor(startedTestContainer) {
-        super(startedTestContainer);
-    }
-    getConnectionString() {
-        return `mongodb://${this.getHost()}:${this.getMappedPort(MONGODB_PORT)}`;
-    }
-}
-exports.StartedMongoDBContainer = StartedMongoDBContainer;

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

@@ -1,30 +0,0 @@
-import { GenericContainer } from "../../generic-container/generic-container";
-import { StartedTestContainer } from "../../test-container";
-import { AbstractStartedContainer } from "../abstract-started-container";
-export declare class MySqlContainer extends GenericContainer {
-    private database;
-    private username;
-    private userPassword;
-    private rootPassword;
-    constructor(image?: string);
-    withDatabase(database: string): this;
-    withUsername(username: string): this;
-    withRootPassword(rootPassword: string): this;
-    withUserPassword(userPassword: string): this;
-    start(): Promise<StartedMySqlContainer>;
-}
-export declare class StartedMySqlContainer extends AbstractStartedContainer {
-    private readonly database;
-    private readonly username;
-    private readonly userPassword;
-    private readonly rootPassword;
-    private readonly port;
-    constructor(startedTestContainer: StartedTestContainer, database: string, username: string, userPassword: string, rootPassword: string);
-    getPort(): number;
-    getDatabase(): string;
-    getUsername(): string;
-    getUserPassword(): string;
-    getRootPassword(): string;
-    getConnectionUri(isRoot?: boolean): string;
-    executeQuery(query: string, additionalFlags?: string[]): Promise<string>;
-}

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

@@ -1,111 +0,0 @@
-"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.StartedMySqlContainer = exports.MySqlContainer = void 0;
-const generic_container_1 = require("../../generic-container/generic-container");
-const abstract_started_container_1 = require("../abstract-started-container");
-const MYSQL_PORT = 3306;
-class MySqlContainer extends generic_container_1.GenericContainer {
-    constructor(image = "mysql:8.0.31") {
-        super(image);
-        this.database = "test";
-        this.username = "test";
-        this.userPassword = "test";
-        this.rootPassword = "test";
-    }
-    withDatabase(database) {
-        this.database = database;
-        return this;
-    }
-    withUsername(username) {
-        this.username = username;
-        return this;
-    }
-    withRootPassword(rootPassword) {
-        this.rootPassword = rootPassword;
-        return this;
-    }
-    withUserPassword(userPassword) {
-        this.userPassword = userPassword;
-        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.opts.exposedPorts : [MYSQL_PORT]))
-                .withEnvironment({
-                MYSQL_DATABASE: this.database,
-                MYSQL_ROOT_PASSWORD: this.rootPassword,
-                MYSQL_USER: this.username,
-                MYSQL_PASSWORD: this.userPassword,
-            })
-                .withStartupTimeout(120000);
-            return new StartedMySqlContainer(yield _super.start.call(this), this.database, this.username, this.userPassword, this.rootPassword);
-        });
-    }
-}
-exports.MySqlContainer = MySqlContainer;
-class StartedMySqlContainer extends abstract_started_container_1.AbstractStartedContainer {
-    constructor(startedTestContainer, database, username, userPassword, rootPassword) {
-        super(startedTestContainer);
-        this.database = database;
-        this.username = username;
-        this.userPassword = userPassword;
-        this.rootPassword = rootPassword;
-        this.port = startedTestContainer.getMappedPort(3306);
-    }
-    getPort() {
-        return this.port;
-    }
-    getDatabase() {
-        return this.database;
-    }
-    getUsername() {
-        return this.username;
-    }
-    getUserPassword() {
-        return this.userPassword;
-    }
-    getRootPassword() {
-        return this.rootPassword;
-    }
-    getConnectionUri(isRoot = false) {
-        const url = new URL("", "mysql://");
-        url.hostname = this.getHost();
-        url.port = this.getPort().toString();
-        url.pathname = this.getDatabase();
-        url.username = isRoot ? "root" : this.getUsername();
-        url.password = isRoot ? this.getRootPassword() : this.getUserPassword();
-        return url.toString();
-    }
-    executeQuery(query, additionalFlags = []) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const result = yield this.startedTestContainer.exec([
-                "mysql",
-                "-h",
-                "127.0.0.1",
-                "-u",
-                this.username,
-                `-p${this.userPassword}`,
-                "-e",
-                `${query};`,
-                ...additionalFlags,
-            ]);
-            if (result.exitCode !== 0) {
-                throw new Error(`executeQuery failed with exit code ${result.exitCode} for query: ${query}`);
-            }
-            return result.output;
-        });
-    }
-}
-exports.StartedMySqlContainer = StartedMySqlContainer;

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

@@ -1,55 +0,0 @@
-import { GenericContainer } from "../../generic-container/generic-container";
-import { StartedTestContainer } from "../../test-container";
-import { AbstractStartedContainer } from "../abstract-started-container";
-export declare class NatsContainer extends GenericContainer {
-    private args;
-    constructor(image?: string);
-    withUsername(user: string): this;
-    withPass(pass: string): this;
-    withArg(name: string, value: string): this;
-    private static ensureDashInFrontOfArgumentName;
-    start(): Promise<StartedNatsContainer>;
-    private getUser;
-    private getPass;
-}
-export declare class StartedNatsContainer extends AbstractStartedContainer {
-    readonly username: string;
-    readonly password: string;
-    private readonly connectionOptions;
-    constructor(startedTestContainer: StartedTestContainer, username: string, password: string);
-    getConnectionOptions(): NatsConnectionOptions;
-}
-export interface NatsConnectionOptions {
-    debug?: boolean;
-    maxPingOut?: number;
-    maxReconnectAttempts?: number;
-    name?: string;
-    noEcho?: boolean;
-    noRandomize?: boolean;
-    pass?: string;
-    pedantic?: boolean;
-    pingInterval?: number;
-    port?: number;
-    reconnect?: boolean;
-    reconnectDelayHandler?: () => number;
-    reconnectJitter?: number;
-    reconnectJitterTLS?: number;
-    reconnectTimeWait?: number;
-    servers?: Array<string> | string;
-    timeout?: number;
-    tls?: NatsTlsOptions;
-    token?: string;
-    user?: string;
-    verbose?: boolean;
-    waitOnFirstConnect?: boolean;
-    ignoreClusterUpdates?: boolean;
-    inboxPrefix?: string;
-}
-export interface NatsTlsOptions {
-    certFile?: string;
-    cert?: string;
-    caFile?: string;
-    ca?: string;
-    keyFile?: string;
-    key?: string;
-}

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

@@ -1,99 +0,0 @@
-"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.StartedNatsContainer = exports.NatsContainer = void 0;
-const generic_container_1 = require("../../generic-container/generic-container");
-const abstract_started_container_1 = require("../abstract-started-container");
-const wait_1 = require("../../wait-strategy/wait");
-const CLIENT_PORT = 4222;
-const ROUTING_PORT_FOR_CLUSTERING = 6222;
-const HTTP_MANAGEMENT_PORT = 8222;
-const USER_ARGUMENT_KEY = "--user";
-const PASS_ARGUMENT_KEY = "--pass";
-class NatsContainer extends generic_container_1.GenericContainer {
-    constructor(image = "nats:2.8.4-alpine") {
-        super(image);
-        this.args = {};
-        this.args[USER_ARGUMENT_KEY] = "test";
-        this.args[PASS_ARGUMENT_KEY] = "test";
-    }
-    withUsername(user) {
-        this.args[USER_ARGUMENT_KEY] = user;
-        return this;
-    }
-    withPass(pass) {
-        this.args[PASS_ARGUMENT_KEY] = pass;
-        return this;
-    }
-    withArg(name, value) {
-        name = NatsContainer.ensureDashInFrontOfArgumentName(name);
-        this.args[name] = value;
-        return this;
-    }
-    static ensureDashInFrontOfArgumentName(name) {
-        if (name.startsWith("--") || name.startsWith("-")) {
-            return name;
-        }
-        if (name.length == 1) {
-            return "-" + name;
-        }
-        else {
-            return "--" + name;
-        }
-    }
-    start() {
-        const _super = Object.create(null, {
-            start: { get: () => super.start }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            function buildCmdsFromArgs(args) {
-                const result = [];
-                result.push("nats-server");
-                for (const argsKey in args) {
-                    result.push(argsKey);
-                    result.push(args[argsKey]);
-                }
-                return result;
-            }
-            this.withCommand(buildCmdsFromArgs(this.args))
-                .withExposedPorts(...(this.hasExposedPorts
-                ? this.opts.exposedPorts
-                : [CLIENT_PORT, ROUTING_PORT_FOR_CLUSTERING, HTTP_MANAGEMENT_PORT]))
-                .withWaitStrategy(wait_1.Wait.forLogMessage(/.*Server is ready.*/))
-                .withStartupTimeout(120000);
-            return new StartedNatsContainer(yield _super.start.call(this), this.getUser(), this.getPass());
-        });
-    }
-    getUser() {
-        return this.args[USER_ARGUMENT_KEY];
-    }
-    getPass() {
-        return this.args[PASS_ARGUMENT_KEY];
-    }
-}
-exports.NatsContainer = NatsContainer;
-class StartedNatsContainer extends abstract_started_container_1.AbstractStartedContainer {
-    constructor(startedTestContainer, username, password) {
-        super(startedTestContainer);
-        this.username = username;
-        this.password = password;
-        const port = startedTestContainer.getMappedPort(CLIENT_PORT);
-        this.connectionOptions = {
-            servers: `${this.startedTestContainer.getHost()}:${port}`,
-            user: this.username,
-            pass: this.password,
-        };
-    }
-    getConnectionOptions() {
-        return this.connectionOptions;
-    }
-}
-exports.StartedNatsContainer = StartedNatsContainer;

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

@@ -1,23 +0,0 @@
-import { GenericContainer } from "../..";
-import { StartedTestContainer } from "../../test-container";
-import { AbstractStartedContainer } from "../abstract-started-container";
-export declare class Neo4jContainer extends GenericContainer {
-    private password;
-    private apoc;
-    private ttl?;
-    constructor(image?: string);
-    withPassword(password: string): this;
-    withApoc(): this;
-    withTtl(schedule?: number): this;
-    start(): Promise<StartedNeo4jContainer>;
-}
-export declare class StartedNeo4jContainer extends AbstractStartedContainer {
-    private readonly password;
-    private readonly boltPort;
-    private readonly httpPort;
-    constructor(startedTestContainer: StartedTestContainer, password: string);
-    getBoltUri(): string;
-    getHttpUri(): string;
-    getPassword(): string;
-    getUsername(): string;
-}