testcontainers 8.16.0 → 9.0.0

package/dist/docker-compose-environment/docker-compose-environment.d.ts

@@ -1,6 +1,6 @@
 import { WaitStrategy } from "../wait-strategy";
 import { Uuid } from "../uuid";
-import { EnvKey, EnvValue } from "../docker/types";
+import { Environment } from "../docker/types";
 import { StartedDockerComposeEnvironment } from "./started-docker-compose-environment";
 export declare class DockerComposeEnvironment {
     private readonly composeFilePath;
@@ -8,15 +8,15 @@ export declare class DockerComposeEnvironment {
     private projectName;
     private build;
     private recreate;
-    private envFile;
+    private environmentFile;
     private profiles;
-    private env;
+    private environment;
     private waitStrategy;
     private startupTimeout;
     constructor(composeFilePath: string, composeFiles: string | string[], uuid?: Uuid);
     withBuild(): this;
-    withEnv(key: EnvKey, value: EnvValue): this;
-    withEnvFile(envFile: string): this;
+    withEnvironment(environment: Environment): this;
+    withEnvironmentFile(environmentFile: string): this;
     withProfiles(...profiles: string[]): this;
     withNoRecreate(): this;
     withWaitStrategy(containerName: string, waitStrategy: WaitStrategy): this;

package/dist/docker-compose-environment/docker-compose-environment.js

@@ -30,9 +30,9 @@ class DockerComposeEnvironment {
     constructor(composeFilePath, composeFiles, uuid = new uuid_1.RandomUuid()) {
         this.build = false;
         this.recreate = true;
-        this.envFile = "";
+        this.environmentFile = "";
         this.profiles = [];
-        this.env = {};
+        this.environment = {};
         this.waitStrategy = {};
         this.startupTimeout = 60000;
         this.composeFilePath = composeFilePath;
@@ -43,16 +43,16 @@ class DockerComposeEnvironment {
         this.build = true;
         return this;
     }
-    withEnv(key, value) {
-        this.env[key] = value;
+    withEnvironment(environment) {
+        this.environment = Object.assign(Object.assign({}, this.environment), environment);
         return this;
     }
-    withEnvFile(envFile) {
-        this.envFile = envFile;
+    withEnvironmentFile(environmentFile) {
+        this.environmentFile = environmentFile;
         return this;
     }
     withProfiles(...profiles) {
-        this.profiles = profiles;
+        this.profiles = [...this.profiles, ...profiles];
         return this;
     }
     withNoRecreate() {
@@ -85,11 +85,11 @@ class DockerComposeEnvironment {
                 commandOptions.push("--no-recreate");
             }
             const composeOptions = [];
-            if (this.envFile) {
-                composeOptions.push("--env-file", this.envFile);
+            if (this.environmentFile) {
+                composeOptions.push("--env-file", this.environmentFile);
             }
             this.profiles.forEach((profile) => composeOptions.push("--profile", profile));
-            yield (0, docker_compose_up_1.dockerComposeUp)(Object.assign(Object.assign({}, options), { commandOptions, composeOptions, env: this.env }), services);
+            yield (0, docker_compose_up_1.dockerComposeUp)(Object.assign(Object.assign({}, options), { commandOptions, composeOptions, environment: this.environment }), services);
             const startedContainers = (yield (0, list_containers_1.listContainers)()).filter((container) => container.Labels["com.docker.compose.project"] === this.projectName);
             const startedContainerNames = startedContainers.reduce((containerNames, startedContainer) => [
                 ...containerNames,
@@ -125,7 +125,7 @@ class DockerComposeEnvironment {
                 return Object.assign(Object.assign({}, map), { [containerName]: startedGenericContainer });
             }, {});
             logger_1.log.info(`DockerCompose environment started: ${Object.keys(startedGenericContainers).join(", ")}`);
-            return new started_docker_compose_environment_1.StartedDockerComposeEnvironment(startedGenericContainers, Object.assign(Object.assign({}, options), { composeOptions, env: this.env }));
+            return new started_docker_compose_environment_1.StartedDockerComposeEnvironment(startedGenericContainers, Object.assign(Object.assign({}, options), { composeOptions, environment: this.environment }));
         });
     }
     waitForContainer(container, containerName, boundPorts) {

package/dist/generic-container/generic-container-builder.d.ts

@@ -1,4 +1,4 @@
-import { BuildContext } from "../docker/types";
+import { BuildArgs } from "../docker/types";
 import { PullPolicy } from "../pull-policy";
 import { Uuid } from "../uuid";
 import { GenericContainer } from "./generic-container";
@@ -9,8 +9,8 @@ export declare class GenericContainerBuilder {
     private buildArgs;
     private pullPolicy;
     private cache;
-    constructor(context: BuildContext, dockerfileName: string, uuid?: Uuid);
-    withBuildArg(key: string, value: string): GenericContainerBuilder;
+    constructor(context: string, dockerfileName: string, uuid?: Uuid);
+    withBuildArgs(buildArgs: BuildArgs): GenericContainerBuilder;
     withPullPolicy(pullPolicy: PullPolicy): this;
     withCache(cache: boolean): this;
     build(image?: string): Promise<GenericContainer>;

package/dist/generic-container/generic-container-builder.js

@@ -34,8 +34,8 @@ class GenericContainerBuilder {
         this.pullPolicy = new pull_policy_1.DefaultPullPolicy();
         this.cache = true;
     }
-    withBuildArg(key, value) {
-        this.buildArgs[key] = value;
+    withBuildArgs(buildArgs) {
+        this.buildArgs = buildArgs;
         return this;
     }
     withPullPolicy(pullPolicy) {

package/dist/generic-container/generic-container.d.ts

@@ -1,26 +1,25 @@
-/// <reference types="node" />
 import archiver from "archiver";
 import { BoundPorts } from "../bound-ports";
 import { PortWithOptionalBinding } from "../port";
 import { PullPolicy } from "../pull-policy";
 import { StartedTestContainer, TestContainer } from "../test-container";
 import { WaitStrategy } from "../wait-strategy";
-import { Readable } from "stream";
-import { BindMode, BindMount, BuildContext, Command, ContainerName, Dir, Env, EnvKey, EnvValue, ExtraHost, HealthCheck, NetworkMode, TmpFs, Labels, Ulimits } from "../docker/types";
+import { BindMount, ContentToCopy, Environment, ExtraHost, FileToCopy, HealthCheck, Labels, TmpFs, Ulimits } from "../docker/types";
 import { InspectResult } from "../docker/functions/container/inspect-container";
 import { GenericContainerBuilder } from "./generic-container-builder";
+import { StartedNetwork } from "../network";
 export declare class GenericContainer implements TestContainer {
     readonly image: string;
-    static fromDockerfile(context: BuildContext, dockerfileName?: string): GenericContainerBuilder;
+    static fromDockerfile(context: string, dockerfileName?: string): GenericContainerBuilder;
     private readonly imageName;
-    protected env: Env;
-    protected networkMode?: NetworkMode;
+    protected environment: Environment;
+    protected networkMode?: string;
     protected networkAliases: string[];
     protected ports: PortWithOptionalBinding[];
-    protected cmd: Command[];
+    protected command: string[];
     protected entrypoint?: string[];
     protected bindMounts: BindMount[];
-    protected name?: ContainerName;
+    protected name?: string;
     protected labels: Labels;
     protected tmpFs: TmpFs;
     protected healthCheck?: HealthCheck;
@@ -44,21 +43,21 @@ export declare class GenericContainer implements TestContainer {
     private startContainer;
     protected postStart?(container: StartedTestContainer, inspectResult: InspectResult, boundPorts: BoundPorts): Promise<void>;
     protected get hasExposedPorts(): boolean;
-    withCmd(cmd: Command[]): this;
+    withCommand(command: string[]): this;
     withEntrypoint(entrypoint: string[]): this;
-    withName(name: ContainerName): this;
+    withName(name: string): this;
     withLabels(labels: Labels): this;
-    withEnv(key: EnvKey, value: EnvValue): this;
+    withEnvironment(environment: Environment): this;
     withTmpFs(tmpFs: TmpFs): this;
     withUlimits(ulimits: Ulimits): this;
     withAddedCapabilities(...capabilities: string[]): this;
     withDroppedCapabilities(...capabilities: string[]): this;
-    withNetworkMode(networkMode: NetworkMode): this;
+    withNetwork(network: StartedNetwork): this;
+    withNetworkMode(networkMode: string): this;
     withNetworkAliases(...networkAliases: string[]): this;
-    withExtraHosts(...extraHosts: ExtraHost[]): this;
+    withExtraHosts(extraHosts: ExtraHost[]): this;
     withExposedPorts(...ports: PortWithOptionalBinding[]): this;
-    protected addExposedPorts(...ports: PortWithOptionalBinding[]): this;
-    withBindMount(source: Dir, target: Dir, bindMode?: BindMode): this;
+    withBindMounts(bindMounts: BindMount[]): this;
     withHealthCheck(healthCheck: HealthCheck): this;
     withStartupTimeout(startupTimeout: number): this;
     withWaitStrategy(waitStrategy: WaitStrategy): this;
@@ -68,8 +67,8 @@ export declare class GenericContainer implements TestContainer {
     withReuse(): this;
     withPullPolicy(pullPolicy: PullPolicy): this;
     withIpcMode(ipcMode: string): this;
-    withCopyFileToContainer(sourcePath: string, containerPath: string): this;
-    withCopyContentToContainer(content: string | Buffer | Readable, containerPath: string): this;
+    withCopyFilesToContainer(filesToCopy: FileToCopy[]): this;
+    withCopyContentToContainer(contentsToCopy: ContentToCopy[]): this;
     protected getTarToCopy(): archiver.Archiver;
     private waitForContainer;
     private getWaitStrategy;

package/dist/generic-container/generic-container.js

@@ -41,10 +41,10 @@ const labels_1 = require("../labels");
 class GenericContainer {
     constructor(image) {
         this.image = image;
-        this.env = {};
+        this.environment = {};
         this.networkAliases = [];
         this.ports = [];
-        this.cmd = [];
+        this.command = [];
         this.bindMounts = [];
         this.labels = {};
         this.tmpFs = {};
@@ -78,8 +78,8 @@ class GenericContainer {
             }
             const createContainerOptions = {
                 imageName: this.imageName,
-                env: this.env,
-                cmd: this.cmd,
+                environment: this.environment,
+                command: this.command,
                 entrypoint: this.entrypoint,
                 bindMounts: this.bindMounts,
                 tmpFs: this.tmpFs,
@@ -170,8 +170,8 @@ class GenericContainer {
     get hasExposedPorts() {
         return this.ports.length !== 0;
     }
-    withCmd(cmd) {
-        this.cmd = cmd;
+    withCommand(command) {
+        this.command = command;
         return this;
     }
     withEntrypoint(entrypoint) {
@@ -183,27 +183,33 @@ class GenericContainer {
         return this;
     }
     withLabels(labels) {
-        this.labels = Object.assign({}, labels);
+        this.labels = Object.assign(Object.assign({}, this.labels), labels);
         return this;
     }
-    withEnv(key, value) {
-        this.env[key] = value;
+    withEnvironment(environment) {
+        this.environment = Object.assign(Object.assign({}, this.environment), environment);
         return this;
     }
     withTmpFs(tmpFs) {
-        this.tmpFs = tmpFs;
+        this.tmpFs = Object.assign(Object.assign({}, this.tmpFs), tmpFs);
         return this;
     }
     withUlimits(ulimits) {
-        this.ulimits = ulimits;
+        this.ulimits = Object.assign(Object.assign({}, this.ulimits), ulimits);
         return this;
     }
     withAddedCapabilities(...capabilities) {
-        this.addedCapabilities = capabilities;
+        var _a;
+        this.addedCapabilities = [...((_a = this.addedCapabilities) !== null && _a !== void 0 ? _a : []), ...capabilities];
         return this;
     }
     withDroppedCapabilities(...capabilities) {
-        this.droppedCapabilities = capabilities;
+        var _a;
+        this.droppedCapabilities = [...((_a = this.droppedCapabilities) !== null && _a !== void 0 ? _a : []), ...capabilities];
+        return this;
+    }
+    withNetwork(network) {
+        this.networkMode = network.getName();
         return this;
     }
     withNetworkMode(networkMode) {
@@ -211,23 +217,19 @@ class GenericContainer {
         return this;
     }
     withNetworkAliases(...networkAliases) {
-        this.networkAliases = networkAliases;
+        this.networkAliases = [...this.networkAliases, ...networkAliases];
         return this;
     }
-    withExtraHosts(...extraHosts) {
-        this.extraHosts.push(...extraHosts);
+    withExtraHosts(extraHosts) {
+        this.extraHosts = [...this.extraHosts, ...extraHosts];
         return this;
     }
     withExposedPorts(...ports) {
-        this.ports = ports;
-        return this;
-    }
-    addExposedPorts(...ports) {
-        this.ports.push(...ports);
+        this.ports = [...this.ports, ...ports];
         return this;
     }
-    withBindMount(source, target, bindMode = "rw") {
-        this.bindMounts.push({ source, target, bindMode });
+    withBindMounts(bindMounts) {
+        this.bindMounts = bindMounts.map((bindMount) => (Object.assign({ mode: "rw" }, bindMount)));
         return this;
     }
     withHealthCheck(healthCheck) {
@@ -266,12 +268,14 @@ class GenericContainer {
         this.ipcMode = ipcMode;
         return this;
     }
-    withCopyFileToContainer(sourcePath, containerPath) {
-        this.getTarToCopy().file(sourcePath, { name: containerPath });
+    withCopyFilesToContainer(filesToCopy) {
+        const tar = this.getTarToCopy();
+        filesToCopy.forEach(({ source, target }) => tar.file(source, { name: target }));
         return this;
     }
-    withCopyContentToContainer(content, containerPath) {
-        this.getTarToCopy().append(content, { name: containerPath });
+    withCopyContentToContainer(contentsToCopy) {
+        const tar = this.getTarToCopy();
+        contentsToCopy.forEach(({ content, target }) => tar.append(content, { name: target }));
         return this;
     }
     getTarToCopy() {

package/dist/generic-container/started-generic-container.d.ts

@@ -1,10 +1,9 @@
 /// <reference types="node" />
 import { RestartOptions, StartedTestContainer, StopOptions, ExecOptions, StoppedTestContainer } from "../test-container";
 import Dockerode from "dockerode";
-import { Command, ContainerName, ExecResult, Host, Id as ContainerId, Labels } from "../docker/types";
+import { ExecResult, Labels } from "../docker/types";
 import { InspectResult } from "../docker/functions/container/inspect-container";
 import { BoundPorts } from "../bound-ports";
-import { Port } from "../port";
 import { Readable } from "stream";
 import { WaitStrategy } from "../wait-strategy";
 export declare class StartedGenericContainer implements StartedTestContainer {
@@ -14,19 +13,19 @@ export declare class StartedGenericContainer implements StartedTestContainer {
     private boundPorts;
     private readonly name;
     private readonly waitStrategy;
-    constructor(container: Dockerode.Container, host: Host, inspectResult: InspectResult, boundPorts: BoundPorts, name: ContainerName, waitStrategy: WaitStrategy);
+    constructor(container: Dockerode.Container, host: string, inspectResult: InspectResult, boundPorts: BoundPorts, name: string, waitStrategy: WaitStrategy);
     stop(options?: Partial<StopOptions>): Promise<StoppedTestContainer>;
     restart(options?: Partial<RestartOptions>): Promise<void>;
     private stopContainer;
     private waitForContainer;
-    getHost(): Host;
-    getMappedPort(port: Port): Port;
-    getId(): ContainerId;
-    getName(): ContainerName;
+    getHost(): string;
+    getMappedPort(port: number): number;
+    getId(): string;
+    getName(): string;
     getLabels(): Labels;
     getNetworkNames(): string[];
     getNetworkId(networkName: string): string;
     getIpAddress(networkName: string): string;
-    exec(command: Command[], options?: Partial<ExecOptions>): Promise<ExecResult>;
+    exec(command: string[], options?: Partial<ExecOptions>): Promise<ExecResult>;
     logs(): Promise<Readable>;
 }

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

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

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

@@ -16,7 +16,7 @@ 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.7.13", password = new uuid_1.RandomUuid().nextUuid()) {
+    constructor(image = "arangodb:3.10.0", password = new uuid_1.RandomUuid().nextUuid()) {
         super(image);
         this.password = password;
     }
@@ -31,7 +31,7 @@ class ArangoDBContainer extends __1.GenericContainer {
         return __awaiter(this, void 0, void 0, function* () {
             this.withExposedPorts(...(this.hasExposedPorts ? this.ports : [ARANGODB_PORT]))
                 .withWaitStrategy(__1.Wait.forLogMessage("Have fun!"))
-                .withEnv("ARANGO_ROOT_PASSWORD", this.password)
+                .withEnvironment({ ARANGO_ROOT_PASSWORD: this.password })
                 .withStartupTimeout(120000);
             return new StartedArangoContainer(yield _super.start.call(this), this.password);
         });

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

@@ -14,7 +14,7 @@ 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 = "docker.elastic.co/elasticsearch/elasticsearch:7.9.2") {
+    constructor(image = "elasticsearch:7.17.7") {
         super(image);
     }
     start() {
@@ -23,7 +23,7 @@ class ElasticsearchContainer extends __1.GenericContainer {
         });
         return __awaiter(this, void 0, void 0, function* () {
             this.withExposedPorts(...(this.hasExposedPorts ? this.ports : [ELASTIC_SEARCH_HTTP_PORT]))
-                .withEnv("discovery.type", "single-node")
+                .withEnvironment({ "discovery.type": "single-node" })
                 .withStartupTimeout(120000);
             return new StartedElasticsearchContainer(yield _super.start.call(this));
         });

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

@@ -1,11 +1,10 @@
 import { GenericContainer } from "../../generic-container/generic-container";
 import { BoundPorts } from "../../bound-ports";
-import { Port } from "../../port";
 import { StartedTestContainer } from "../..";
 import { AbstractStartedContainer } from "../abstract-started-container";
-import { Host } from "../../docker/types";
 import { InspectResult } from "../../docker/functions/container/inspect-container";
-export declare const KAFKA_IMAGE = "confluentinc/cp-kafka:5.5.4";
+import { Content } from "../../docker/types";
+export declare const KAFKA_IMAGE = "confluentinc/cp-kafka:7.2.2";
 interface SaslSslListenerOptions {
     sasl: SaslOptions;
     port: number;
@@ -21,7 +20,7 @@ interface User {
     password: string;
 }
 interface PKCS12CertificateStore {
-    content: Parameters<GenericContainer["withCopyContentToContainer"]>[0];
+    content: Content;
     passphrase: string;
 }
 export declare class KafkaContainer extends GenericContainer {
@@ -31,7 +30,7 @@ export declare class KafkaContainer extends GenericContainer {
     private zooKeeperPort?;
     private saslSslConfig?;
     constructor(image?: string);
-    withZooKeeper(host: Host, port: Port): this;
+    withZooKeeper(host: string, port: number): this;
     withSaslSslListener(options: SaslSslListenerOptions): this;
     protected preStart(): Promise<void>;
     start(): Promise<StartedKafkaContainer>;

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

@@ -16,23 +16,23 @@ 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:5.5.4";
+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)
-            .withEnv("KAFKA_LISTENER_SECURITY_PROTOCOL_MAP", "BROKER:PLAINTEXT,PLAINTEXT:PLAINTEXT")
-            .withEnv("KAFKA_INTER_BROKER_LISTENER_NAME", "BROKER")
-            .withEnv("KAFKA_BROKER_ID", "1")
-            .withEnv("KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR", "1")
-            .withEnv("KAFKA_OFFSETS_TOPIC_NUM_PARTITIONS", "1")
-            .withEnv("KAFKA_TRANSACTION_STATE_LOG_MIN_ISR", "1")
-            .withEnv("KAFKA_LOG_FLUSH_INTERVAL_MESSAGES", "9223372036854775807")
-            .withEnv("KAFKA_GROUP_INITIAL_REBALANCE_DELAY_MS", "0")
-            .withEnv("KAFKA_CONFLUENT_SUPPORT_METRICS_ENABLE", "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;
@@ -47,7 +47,7 @@ class KafkaContainer extends generic_container_1.GenericContainer {
     preStart() {
         return __awaiter(this, void 0, void 0, function* () {
             const network = this.networkMode && this.networkAliases.length > 0 ? this.networkAliases[0] : "localhost";
-            this.withEnv("KAFKA_ADVERTISED_LISTENERS", `BROKER://${network}:${KAFKA_BROKER_PORT}`);
+            this.withEnvironment({ KAFKA_ADVERTISED_LISTENERS: `BROKER://${network}:${KAFKA_BROKER_PORT}` });
             if (this.saslSslConfig) {
                 this.addPlaintextAndSecureListener(this.saslSslConfig);
             }
@@ -56,13 +56,13 @@ class KafkaContainer extends generic_container_1.GenericContainer {
             }
             let command = "#!/bin/bash\n";
             if (this.isZooKeeperProvided) {
-                this.withEnv("KAFKA_ZOOKEEPER_CONNECT", `${this.zooKeeperHost}:${this.zooKeeperPort}`);
+                this.withEnvironment({ KAFKA_ZOOKEEPER_CONNECT: `${this.zooKeeperHost}:${this.zooKeeperPort}` });
             }
             else {
                 this.zooKeeperHost = this.uuid.nextUuid();
                 this.zooKeeperPort = DEFAULT_ZOOKEEPER_PORT;
-                this.addExposedPorts(this.zooKeeperPort);
-                this.withEnv("KAFKA_ZOOKEEPER_CONNECT", `localhost:${this.zooKeeperPort}`);
+                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";
@@ -70,7 +70,7 @@ class KafkaContainer extends generic_container_1.GenericContainer {
             }
             command += "echo '' > /etc/confluent/docker/ensure \n";
             command += "/etc/confluent/docker/run \n";
-            this.withCmd(["sh", "-c", command]);
+            this.withCommand(["sh", "-c", command]);
         });
     }
     start() {
@@ -90,25 +90,32 @@ class KafkaContainer extends generic_container_1.GenericContainer {
         });
     }
     addPlaintextAndSecureListener({ port, sasl, keystore, truststore }) {
-        this.withEnv("KAFKA_LISTENERS", `SECURE://0.0.0.0:${port},PLAINTEXT://0.0.0.0:${KAFKA_PORT},BROKER://0.0.0.0:${KAFKA_BROKER_PORT}`)
-            .withEnv("KAFKA_LISTENER_SECURITY_PROTOCOL_MAP", "BROKER:PLAINTEXT,PLAINTEXT:PLAINTEXT,SECURE:SASL_SSL")
-            .withEnv("KAFKA_SSL_PROTOCOL", "TLSv1.2")
-            .withCopyContentToContainer(keystore.content, "/etc/kafka/secrets/server.keystore.pfx")
-            .withEnv("KAFKA_SSL_KEYSTORE_LOCATION", "/etc/kafka/secrets/server.keystore.pfx")
-            .withEnv("KAFKA_SSL_KEYSTORE_PASSWORD", keystore.passphrase)
-            .withEnv("KAFKA_SSL_KEYSTORE_TYPE", "PKCS12")
-            .withEnv("KAFKA_SASL_ENABLED_MECHANISMS", sasl.mechanism)
-            .withEnv(`KAFKA_LISTENER_NAME_SECURE_${sasl.mechanism}_SASL_JAAS_CONFIG`, "org.apache.kafka.common.security.scram.ScramLoginModule required;")
-            .addExposedPorts(KAFKA_PORT, port);
+        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(truststore.content, "/etc/kafka/secrets/server.truststore.pfx")
-                .withEnv("KAFKA_SSL_TRUSTSTORE_LOCATION", "/etc/kafka/secrets/server.truststore.pfx")
-                .withEnv("KAFKA_SSL_TRUSTSTORE_PASSWORD", truststore.passphrase)
-                .withEnv("KAFKA_SSL_TRUSTSTORE_TYPE", "PKCS12");
+            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.withEnv("KAFKA_LISTENERS", `PLAINTEXT://0.0.0.0:${KAFKA_PORT},BROKER://0.0.0.0:${KAFKA_BROKER_PORT}`).addExposedPorts(KAFKA_PORT);
+        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* () {
@@ -125,7 +132,7 @@ class KafkaContainer extends generic_container_1.GenericContainer {
                 "--entity-type",
                 "brokers",
                 "--entity-name",
-                this.env["KAFKA_BROKER_ID"],
+                this.environment["KAFKA_BROKER_ID"],
                 "--add-config",
                 `advertised.listeners=[${bootstrapServers},${brokerAdvertisedListener}]`,
             ]);
@@ -142,7 +149,7 @@ class KafkaContainer extends generic_container_1.GenericContainer {
                 // 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.env["KAFKA_ZOOKEEPER_CONNECT"],
+                this.environment["KAFKA_ZOOKEEPER_CONNECT"],
                 "--entity-type",
                 "users",
                 "--entity-name",

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

@@ -26,7 +26,7 @@ class MongoDBContainer extends generic_container_1.GenericContainer {
         });
         return __awaiter(this, void 0, void 0, function* () {
             this.withExposedPorts(MONGODB_PORT)
-                .withCmd(["--replSet", "rs0"])
+                .withCommand(["--replSet", "rs0"])
                 .withWaitStrategy(wait_1.Wait.forLogMessage(new RegExp(".*waiting for connections.*", "i")))
                 .withStartupTimeout(120000);
             return new StartedMongoDBContainer(yield _super.start.call(this));

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

@@ -1,7 +1,6 @@
 import { GenericContainer } from "../../generic-container/generic-container";
 import { StartedTestContainer } from "../../test-container";
 import { AbstractStartedContainer } from "../abstract-started-container";
-import { Port } from "../../port";
 export declare class MySqlContainer extends GenericContainer {
     private database;
     private username;
@@ -21,7 +20,7 @@ export declare class StartedMySqlContainer extends AbstractStartedContainer {
     private readonly rootPassword;
     private readonly port;
     constructor(startedTestContainer: StartedTestContainer, database: string, username: string, userPassword: string, rootPassword: string);
-    getPort(): Port;
+    getPort(): number;
     getDatabase(): string;
     getUsername(): string;
     getUserPassword(): string;