testcontainers 9.2.0 → 9.3.0

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

@@ -0,0 +1,172 @@
+"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;
+    }
+    preStart() {
+        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));
+        });
+    }
+    postStart(container, inspectResult, boundPorts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.updateAdvertisedListeners(container, inspectResult, boundPorts);
+            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, boundPorts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const brokerAdvertisedListener = `BROKER://${inspectResult.hostname}:${KAFKA_BROKER_PORT}`;
+            let bootstrapServers = `PLAINTEXT://${container.getHost()}:${boundPorts.getBinding(KAFKA_PORT)}`;
+            if (this.saslSslConfig) {
+                bootstrapServers = `${bootstrapServers},SECURE://${container.getHost()}:${boundPorts.getBinding(this.saslSslConfig.port)}`;
+            }
+            const { output, exitCode } = yield container.exec([
+                "kafka-configs",
+                "--alter",
+                "--bootstrap-server",
+                brokerAdvertisedListener,
+                "--entity-type",
+                "brokers",
+                "--entity-name",
+                this.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.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

@@ -0,0 +1,19 @@
+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 postStart(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

@@ -0,0 +1,85 @@
+"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");
+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));
+        });
+    }
+    postStart(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

@@ -0,0 +1,29 @@
+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;
+    executeQuery(query: string, additionalFlags?: string[]): Promise<string>;
+}

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

@@ -0,0 +1,102 @@
+"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.ports : [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;
+    }
+    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

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,97 @@
+"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");
+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-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.ports : [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

@@ -0,0 +1,23 @@
+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;
+}

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

@@ -0,0 +1,82 @@
+"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.StartedNeo4jContainer = exports.Neo4jContainer = void 0;
+const __1 = require("../..");
+const abstract_started_container_1 = require("../abstract-started-container");
+const BOLT_PORT = 7687;
+const HTTP_PORT = 7474;
+const USERNAME = "neo4j";
+class Neo4jContainer extends __1.GenericContainer {
+    constructor(image = "neo4j:4.4.12") {
+        super(image);
+        this.password = "test";
+        this.apoc = false;
+    }
+    withPassword(password) {
+        this.password = password;
+        return this;
+    }
+    withApoc() {
+        this.apoc = true;
+        return this;
+    }
+    withTtl(schedule = 5) {
+        this.ttl = schedule;
+        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 : [BOLT_PORT, HTTP_PORT]))
+                .withWaitStrategy(__1.Wait.forLogMessage("Started."))
+                .withEnvironment({ NEO4J_AUTH: `${USERNAME}/${this.password}` })
+                .withStartupTimeout(120000);
+            if (this.apoc) {
+                this.withEnvironment({
+                    NEO4JLABS_PLUGINS: '["apoc"]',
+                    NEO4J_dbms_security_procedures_unrestricted: "apoc.*",
+                });
+            }
+            if (this.ttl) {
+                this.withEnvironment({
+                    NEO4J_apoc_ttl_enabled: "true",
+                    NEO4J_apoc_ttl_schedule: this.ttl.toString(),
+                });
+            }
+            return new StartedNeo4jContainer(yield _super.start.call(this), this.password);
+        });
+    }
+}
+exports.Neo4jContainer = Neo4jContainer;
+class StartedNeo4jContainer extends abstract_started_container_1.AbstractStartedContainer {
+    constructor(startedTestContainer, password) {
+        super(startedTestContainer);
+        this.password = password;
+        this.boltPort = this.startedTestContainer.getMappedPort(BOLT_PORT);
+        this.httpPort = this.startedTestContainer.getMappedPort(HTTP_PORT);
+    }
+    getBoltUri() {
+        return `bolt://${this.getHost()}:${this.boltPort}/`;
+    }
+    getHttpUri() {
+        return `http://${this.getHost()}:${this.httpPort}/`;
+    }
+    getPassword() {
+        return this.password;
+    }
+    getUsername() {
+        return USERNAME;
+    }
+}
+exports.StartedNeo4jContainer = StartedNeo4jContainer;