testcontainers 9.3.0 → 9.5.0

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

@@ -20,7 +20,6 @@ const logger_1 = require("../logger");
 const pull_policy_1 = require("../pull-policy");
 const reaper_1 = require("../reaper");
 const docker_image_name_1 = require("../docker-image-name");
-const wait_strategy_1 = require("../wait-strategy");
 const port_forwarder_1 = require("../port-forwarder");
 const pull_image_1 = require("../docker/functions/image/pull-image");
 const create_container_1 = require("../docker/functions/container/create-container");
@@ -36,6 +35,8 @@ const hash_1 = require("../hash");
 const get_container_1 = require("../docker/functions/container/get-container");
 const labels_1 = require("../labels");
 const wait_for_container_1 = require("../wait-for-container");
+const create_container_options_1 = require("./create-container-options");
+const default_wait_strategy_1 = require("../wait-strategy/default-wait-strategy");
 const reusableContainerCreationLock = new async_lock_1.default();
 class GenericContainer {
     static fromDockerfile(context, dockerfileName = "Dockerfile") {
@@ -43,66 +44,41 @@ class GenericContainer {
     }
     constructor(image) {
         this.image = image;
-        this.environment = {};
-        this.networkAliases = [];
-        this.ports = [];
-        this.command = [];
-        this.bindMounts = [];
-        this.labels = {};
-        this.tmpFs = {};
         this.startupTimeout = 60000;
-        this.useDefaultLogDriver = false;
-        this.privilegedMode = false;
+        this.networkAliases = [];
         this.pullPolicy = new pull_policy_1.DefaultPullPolicy();
-        this.reuse = false;
-        this.extraHosts = [];
-        this.imageName = docker_image_name_1.DockerImageName.fromString(image);
+        const imageName = docker_image_name_1.DockerImageName.fromString(image);
+        this.opts = (0, create_container_options_1.initCreateContainerOptions)(imageName, imageName.isReaper());
     }
     start() {
         return __awaiter(this, void 0, void 0, function* () {
             const { dockerode, indexServerAddress } = yield (0, docker_client_1.dockerClient)();
             yield (0, pull_image_1.pullImage)(dockerode, indexServerAddress, {
-                imageName: this.imageName,
+                imageName: this.opts.imageName,
                 force: this.pullPolicy.shouldPull(),
             });
-            if (!this.reuse && !this.imageName.isReaper()) {
+            if (!this.opts.reusable && !this.opts.imageName.isReaper()) {
                 yield reaper_1.ReaperInstance.getInstance();
             }
-            if (this.preStart) {
+            if (this.beforeContainerStarted) {
+                yield this.beforeContainerStarted();
+            }
+            else if (this.preStart) {
                 yield this.preStart();
             }
-            if (!this.imageName.isHelperContainer() && port_forwarder_1.PortForwarderInstance.isRunning()) {
+            if (!this.opts.imageName.isHelperContainer() && port_forwarder_1.PortForwarderInstance.isRunning()) {
                 const portForwarder = yield port_forwarder_1.PortForwarderInstance.getInstance();
-                this.extraHosts.push({ host: "host.testcontainers.internal", ipAddress: portForwarder.getIpAddress() });
+                this.opts.extraHosts.push({ host: "host.testcontainers.internal", ipAddress: portForwarder.getIpAddress() });
             }
-            const createContainerOptions = {
-                imageName: this.imageName,
-                environment: this.environment,
-                command: this.command,
-                entrypoint: this.entrypoint,
-                bindMounts: this.bindMounts,
-                tmpFs: this.tmpFs,
-                exposedPorts: this.ports,
-                name: this.name,
-                labels: this.labels,
-                reusable: this.reuse,
-                networkMode: this.networkAliases.length > 0 ? undefined : this.networkMode,
-                healthCheck: this.healthCheck,
-                useDefaultLogDriver: this.useDefaultLogDriver,
-                privilegedMode: this.privilegedMode,
-                autoRemove: this.imageName.isReaper(),
-                extraHosts: this.extraHosts,
-                ipcMode: this.ipcMode,
-                ulimits: this.ulimits,
-                addedCapabilities: this.addedCapabilities,
-                droppedCapabilities: this.droppedCapabilities,
-                user: this.user,
-                workingDir: this.workingDir,
-                resourcesQuota: this.resourcesQuota,
-            };
-            if (this.reuse) {
-                const containerHash = (0, hash_1.hash)(JSON.stringify(createContainerOptions));
-                createContainerOptions.labels = Object.assign(Object.assign({}, createContainerOptions.labels), { [labels_1.LABEL_TESTCONTAINERS_CONTAINER_HASH]: containerHash });
+            if (this.networkAliases.length > 0) {
+                this.opts.networkMode = undefined;
+            }
+            else {
+                this.opts.networkMode = this.networkMode;
+            }
+            if (this.opts.reusable) {
+                const containerHash = (0, hash_1.hash)(JSON.stringify(this.opts));
+                this.opts.labels = Object.assign(Object.assign({}, this.opts.labels), { [labels_1.LABEL_TESTCONTAINERS_CONTAINER_HASH]: containerHash });
                 logger_1.log.debug(`Container reuse has been enabled, hash: ${containerHash}`);
                 // We might have several async processes try to create a reusable container
                 // at once, to avoid possibly creating too many of these, use a lock
@@ -115,31 +91,41 @@ class GenericContainer {
                     }
                     else {
                         logger_1.log.debug("No container found to reuse");
-                        return this.startContainer(createContainerOptions);
+                        return this.startContainer(this.opts);
                     }
                 }));
             }
             else {
-                return this.startContainer(createContainerOptions);
+                return this.startContainer(this.opts);
             }
         });
     }
-    reuseContainer(startedContainer) {
+    reuseContainer(container) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const { host, hostIps } = yield (0, docker_client_1.dockerClient)();
-            const inspectResult = yield (0, inspect_container_1.inspectContainer)(startedContainer);
-            const boundPorts = bound_ports_1.BoundPorts.fromInspectResult(hostIps, inspectResult).filter(this.ports);
-            const waitStrategy = ((_a = this.waitStrategy) !== null && _a !== void 0 ? _a : (0, wait_strategy_1.defaultWaitStrategy)(host, startedContainer)).withStartupTimeout(this.startupTimeout);
-            yield (0, wait_for_container_1.waitForContainer)(startedContainer, waitStrategy, host, boundPorts);
-            return new started_generic_container_1.StartedGenericContainer(startedContainer, host, inspectResult, boundPorts, inspectResult.name, waitStrategy);
+            const inspectResult = yield (0, inspect_container_1.inspectContainer)(container);
+            const boundPorts = bound_ports_1.BoundPorts.fromInspectResult(hostIps, inspectResult).filter(this.opts.exposedPorts);
+            const waitStrategy = ((_a = this.waitStrategy) !== null && _a !== void 0 ? _a : (0, default_wait_strategy_1.defaultWaitStrategy)(host, container)).withStartupTimeout(this.startupTimeout);
+            if (this.containerStarting) {
+                yield this.containerStarting(inspectResult, true);
+            }
+            yield (0, wait_for_container_1.waitForContainer)(container, waitStrategy, host, boundPorts);
+            const startedContainer = new started_generic_container_1.StartedGenericContainer(container, host, inspectResult, boundPorts, inspectResult.name, waitStrategy);
+            if (this.containerStarted) {
+                yield this.containerStarted(startedContainer, inspectResult, true);
+            }
+            else if (this.postStart) {
+                yield this.postStart(startedContainer, inspectResult, boundPorts);
+            }
+            return startedContainer;
         });
     }
     startContainer(createContainerOptions) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const container = yield (0, create_container_1.createContainer)(createContainerOptions);
-            if (!this.imageName.isHelperContainer() && port_forwarder_1.PortForwarderInstance.isRunning()) {
+            if (!this.opts.imageName.isHelperContainer() && port_forwarder_1.PortForwarderInstance.isRunning()) {
                 const portForwarder = yield port_forwarder_1.PortForwarderInstance.getInstance();
                 const portForwarderNetworkId = portForwarder.getNetworkId();
                 const excludedNetworks = [portForwarderNetworkId, "none", "host"];
@@ -162,62 +148,73 @@ class GenericContainer {
                 this.tarToCopy.finalize();
                 yield (0, put_container_archive_1.putContainerArchive)({ container, stream: this.tarToCopy, containerPath: "/" });
             }
-            logger_1.log.info(`Starting container ${this.imageName} with ID: ${container.id}`);
+            logger_1.log.info(`Starting container ${this.opts.imageName} with ID: ${container.id}`);
+            if (this.containerCreated) {
+                yield this.containerCreated(container.id);
+            }
             yield (0, start_container_1.startContainer)(container);
             const { host, hostIps } = yield (0, docker_client_1.dockerClient)();
             const inspectResult = yield (0, inspect_container_1.inspectContainer)(container);
-            const boundPorts = bound_ports_1.BoundPorts.fromInspectResult(hostIps, inspectResult).filter(this.ports);
-            const waitStrategy = ((_a = this.waitStrategy) !== null && _a !== void 0 ? _a : (0, wait_strategy_1.defaultWaitStrategy)(host, container)).withStartupTimeout(this.startupTimeout);
-            (yield (0, container_logs_1.containerLogs)(container))
-                .on("data", (data) => logger_1.containerLog.trace(`${container.id}: ${data.trim()}`))
-                .on("err", (data) => logger_1.containerLog.error(`${container.id}: ${data.trim()}`));
+            const boundPorts = bound_ports_1.BoundPorts.fromInspectResult(hostIps, inspectResult).filter(this.opts.exposedPorts);
+            const waitStrategy = ((_a = this.waitStrategy) !== null && _a !== void 0 ? _a : (0, default_wait_strategy_1.defaultWaitStrategy)(host, container)).withStartupTimeout(this.startupTimeout);
+            if (logger_1.containerLog.enabled()) {
+                (yield (0, container_logs_1.containerLogs)(container))
+                    .on("data", (data) => logger_1.containerLog.trace(`${container.id}: ${data.trim()}`))
+                    .on("err", (data) => logger_1.containerLog.error(`${container.id}: ${data.trim()}`));
+            }
+            if (this.containerStarting) {
+                yield this.containerStarting(inspectResult, false);
+            }
             yield (0, wait_for_container_1.waitForContainer)(container, waitStrategy, host, boundPorts);
             const startedContainer = new started_generic_container_1.StartedGenericContainer(container, host, inspectResult, boundPorts, inspectResult.name, waitStrategy);
-            if (this.postStart) {
+            if (this.containerStarted) {
+                yield this.containerStarted(startedContainer, inspectResult, false);
+            }
+            else if (this.postStart) {
                 yield this.postStart(startedContainer, inspectResult, boundPorts);
             }
             return startedContainer;
         });
     }
     get hasExposedPorts() {
-        return this.ports.length !== 0;
+        return this.opts.exposedPorts.length !== 0;
     }
     withCommand(command) {
-        this.command = command;
+        this.opts.command = command;
         return this;
     }
     withEntrypoint(entrypoint) {
-        this.entrypoint = entrypoint;
+        this.opts.entrypoint = entrypoint;
         return this;
     }
     withName(name) {
-        this.name = name;
+        this.opts.name = name;
         return this;
     }
     withLabels(labels) {
-        this.labels = Object.assign(Object.assign({}, this.labels), labels);
+        this.opts.labels = Object.assign(Object.assign({}, this.opts.labels), labels);
         return this;
     }
     withEnvironment(environment) {
-        this.environment = Object.assign(Object.assign({}, this.environment), environment);
+        this.opts.environment = Object.assign(Object.assign({}, this.opts.environment), environment);
         return this;
     }
     withTmpFs(tmpFs) {
-        this.tmpFs = Object.assign(Object.assign({}, this.tmpFs), tmpFs);
+        this.opts.tmpFs = Object.assign(Object.assign({}, this.opts.tmpFs), tmpFs);
         return this;
     }
     withUlimits(ulimits) {
-        this.ulimits = Object.assign(Object.assign({}, this.ulimits), ulimits);
+        this.opts.ulimits = Object.assign(Object.assign({}, this.opts.ulimits), ulimits);
         return this;
     }
     withAddedCapabilities(...capabilities) {
         var _a;
-        this.addedCapabilities = [...((_a = this.addedCapabilities) !== null && _a !== void 0 ? _a : []), ...capabilities];
+        this.opts.addedCapabilities = [...((_a = this.opts.addedCapabilities) !== null && _a !== void 0 ? _a : []), ...capabilities];
         return this;
     }
     withDroppedCapabilities(...capabilities) {
         var _a;
-        this.droppedCapabilities = [...((_a = this.droppedCapabilities) !== null && _a !== void 0 ? _a : []), ...capabilities];
+        this.opts.droppedCapabilities = [...((_a = this.opts.droppedCapabilities) !== null && _a !== void 0 ? _a : []), ...capabilities];
         return this;
     }
     withNetwork(network) {
@@ -233,19 +230,19 @@ class GenericContainer {
         return this;
     }
     withExtraHosts(extraHosts) {
-        this.extraHosts = [...this.extraHosts, ...extraHosts];
+        this.opts.extraHosts = [...this.opts.extraHosts, ...extraHosts];
         return this;
     }
     withExposedPorts(...ports) {
-        this.ports = [...this.ports, ...ports];
+        this.opts.exposedPorts = [...this.opts.exposedPorts, ...ports];
         return this;
     }
     withBindMounts(bindMounts) {
-        this.bindMounts = bindMounts.map((bindMount) => (Object.assign({ mode: "rw" }, bindMount)));
+        this.opts.bindMounts = bindMounts.map((bindMount) => (Object.assign({ mode: "rw" }, bindMount)));
         return this;
     }
     withHealthCheck(healthCheck) {
-        this.healthCheck = healthCheck;
+        this.opts.healthCheck = healthCheck;
         return this;
     }
     withStartupTimeout(startupTimeoutMs) {
@@ -257,19 +254,19 @@ class GenericContainer {
         return this;
     }
     withDefaultLogDriver() {
-        this.useDefaultLogDriver = true;
+        this.opts.useDefaultLogDriver = true;
         return this;
     }
     withPrivilegedMode() {
-        this.privilegedMode = true;
+        this.opts.privilegedMode = true;
         return this;
     }
     withUser(user) {
-        this.user = user;
+        this.opts.user = user;
         return this;
     }
     withReuse() {
-        this.reuse = true;
+        this.opts.reusable = true;
         return this;
     }
     withPullPolicy(pullPolicy) {
@@ -277,7 +274,7 @@ class GenericContainer {
         return this;
     }
     withIpcMode(ipcMode) {
-        this.ipcMode = ipcMode;
+        this.opts.ipcMode = ipcMode;
         return this;
     }
     withCopyFilesToContainer(filesToCopy) {
@@ -297,7 +294,7 @@ class GenericContainer {
         return this.tarToCopy;
     }
     withWorkingDir(workingDir) {
-        this.workingDir = workingDir;
+        this.opts.workingDir = workingDir;
         return this;
     }
     withResourcesQuota({ memory, cpu }) {
@@ -305,7 +302,7 @@ class GenericContainer {
         // see Memory, NanoCpus parameters
         const ram = memory !== undefined ? memory * Math.pow(1024, 3) : undefined;
         const cpuQuota = cpu !== undefined ? cpu * Math.pow(10, 9) : undefined;
-        this.resourcesQuota = { memory: ram, cpu: cpuQuota };
+        this.opts.resourcesQuota = { memory: ram, cpu: cpuQuota };
         return this;
     }
 }

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

@@ -1,11 +1,11 @@
 /// <reference types="node" />
-import { ExecOptions, RestartOptions, StartedTestContainer, StopOptions, StoppedTestContainer } from "../test-container";
+import { RestartOptions, StartedTestContainer, StopOptions, StoppedTestContainer } from "../test-container";
 import Dockerode from "dockerode";
 import { ExecResult, Labels } from "../docker/types";
 import { InspectResult } from "../docker/functions/container/inspect-container";
 import { BoundPorts } from "../bound-ports";
 import { Readable } from "stream";
-import { WaitStrategy } from "../wait-strategy";
+import { WaitStrategy } from "../wait-strategy/wait-strategy";
 export declare class StartedGenericContainer implements StartedTestContainer {
     private readonly container;
     private readonly host;
@@ -14,7 +14,9 @@ export declare class StartedGenericContainer implements StartedTestContainer {
     private readonly name;
     private readonly waitStrategy;
     constructor(container: Dockerode.Container, host: string, inspectResult: InspectResult, boundPorts: BoundPorts, name: string, waitStrategy: WaitStrategy);
+    protected containerIsStopping?(): Promise<void>;
     stop(options?: Partial<StopOptions>): Promise<StoppedTestContainer>;
+    protected containerIsStopped?(): Promise<void>;
     restart(options?: Partial<RestartOptions>): Promise<void>;
     private stopContainer;
     getHost(): string;
@@ -26,6 +28,6 @@ export declare class StartedGenericContainer implements StartedTestContainer {
     getNetworkNames(): string[];
     getNetworkId(networkName: string): string;
     getIpAddress(networkName: string): string;
-    exec(command: string[], options?: Partial<ExecOptions>): Promise<ExecResult>;
+    exec(command: string[]): Promise<ExecResult>;
     logs(): Promise<Readable>;
 }

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

@@ -43,9 +43,11 @@ class StartedGenericContainer {
             const { hostIps } = yield (0, docker_client_1.dockerClient)();
             this.inspectResult = yield (0, inspect_container_1.inspectContainer)(this.container);
             const startTime = this.inspectResult.state.startedAt;
-            (yield (0, container_logs_1.containerLogs)(this.container, { since: startTime }))
-                .on("data", (data) => logger_1.containerLog.trace(`${this.container.id}: ${data.trim()}`))
-                .on("err", (data) => logger_1.containerLog.error(`${this.container.id}: ${data.trim()}`));
+            if (logger_1.containerLog.enabled()) {
+                (yield (0, container_logs_1.containerLogs)(this.container, { since: startTime }))
+                    .on("data", (data) => logger_1.containerLog.trace(`${this.container.id}: ${data.trim()}`))
+                    .on("err", (data) => logger_1.containerLog.error(`${this.container.id}: ${data.trim()}`));
+            }
             this.boundPorts = bound_ports_1.BoundPorts.fromInspectResult(hostIps, this.inspectResult).filter(Array.from(this.boundPorts.iterator()).map((port) => port[0]));
             yield (0, wait_for_container_1.waitForContainer)(this.container, this.waitStrategy, this.host, this.boundPorts, startTime);
         });
@@ -53,9 +55,15 @@ class StartedGenericContainer {
     stopContainer(options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             logger_1.log.info(`Stopping container with ID: ${this.container.id}`);
+            if (this.containerIsStopping) {
+                yield this.containerIsStopping();
+            }
             const resolvedOptions = Object.assign({ timeout: 0, removeVolumes: true }, options);
             yield (0, stop_container_1.stopContainer)(this.container, { timeout: resolvedOptions.timeout });
             yield (0, remove_container_1.removeContainer)(this.container, { removeVolumes: resolvedOptions.removeVolumes });
+            if (this.containerIsStopped) {
+                yield this.containerIsStopped();
+            }
             return new stopped_generic_container_1.StoppedGenericContainer();
         });
     }
@@ -86,9 +94,8 @@ class StartedGenericContainer {
     getIpAddress(networkName) {
         return this.inspectResult.networkSettings[networkName].ipAddress;
     }
-    exec(command, options = {}) {
-        const resolvedOptions = Object.assign({ stdin: true, detach: false, tty: true }, options);
-        return (0, exec_container_1.execContainer)(this.container, command, resolvedOptions);
+    exec(command) {
+        return (0, exec_container_1.execContainer)(this.container, command);
     }
     logs() {
         return (0, container_logs_1.containerLogs)(this.container);

package/dist/src/index.d.ts

@@ -7,9 +7,10 @@ export { StartedDockerComposeEnvironment } from "./docker-compose-environment/st
 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 { Wait } from "./wait-strategy/wait";
+export { StartupCheckStrategy, StartupStatus } from "./wait-strategy/startup-check-strategy";
 export { PullPolicy, DefaultPullPolicy, AlwaysPullPolicy } from "./pull-policy";
+export { InspectResult } from "./docker/functions/container/inspect-container";
 export { AbstractStartedContainer } from "./modules/abstract-started-container";
 export { PostgreSqlContainer, StartedPostgreSqlContainer } from "./modules/postgresql/postgresql-container";
 export { KafkaContainer, StartedKafkaContainer } from "./modules/kafka/kafka-container";

package/dist/src/index.js

@@ -19,9 +19,9 @@ 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");
+var wait_1 = require("./wait-strategy/wait");
 Object.defineProperty(exports, "Wait", { enumerable: true, get: function () { return wait_1.Wait; } });
-var startup_check_strategy_1 = require("./startup-check-strategy");
+var startup_check_strategy_1 = require("./wait-strategy/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; } });

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

@@ -5,7 +5,9 @@ import { Readable } from "stream";
 export declare class AbstractStartedContainer implements StartedTestContainer {
     protected readonly startedTestContainer: StartedTestContainer;
     constructor(startedTestContainer: StartedTestContainer);
+    protected containerStopping?(): Promise<void>;
     stop(options?: Partial<StopOptions>): Promise<StoppedTestContainer>;
+    protected containerStopped?(): Promise<void>;
     restart(options?: Partial<RestartOptions>): Promise<void>;
     getHost(): string;
     getFirstMappedPort(): number;

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

@@ -15,7 +15,16 @@ class AbstractStartedContainer {
         this.startedTestContainer = startedTestContainer;
     }
     stop(options) {
-        return this.startedTestContainer.stop(options);
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.containerStopping) {
+                yield this.containerStopping();
+            }
+            const stoppedContainer = this.startedTestContainer.stop(options);
+            if (this.containerStopped) {
+                yield this.containerStopped();
+            }
+            return stoppedContainer;
+        });
     }
     restart(options) {
         return __awaiter(this, void 0, void 0, function* () {

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

@@ -28,7 +28,7 @@ class ArangoDBContainer extends __1.GenericContainer {
             start: { get: () => super.start }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            this.withExposedPorts(...(this.hasExposedPorts ? this.ports : [ARANGODB_PORT]))
+            this.withExposedPorts(...(this.hasExposedPorts ? this.opts.exposedPorts : [ARANGODB_PORT]))
                 .withWaitStrategy(__1.Wait.forLogMessage("Have fun!"))
                 .withEnvironment({ ARANGO_ROOT_PASSWORD: this.password })
                 .withStartupTimeout(120000);

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

@@ -22,8 +22,14 @@ class ElasticsearchContainer extends __1.GenericContainer {
             start: { get: () => super.start }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            this.withExposedPorts(...(this.hasExposedPorts ? this.ports : [ELASTIC_SEARCH_HTTP_PORT]))
+            this.withExposedPorts(...(this.hasExposedPorts ? this.opts.exposedPorts : [ELASTIC_SEARCH_HTTP_PORT]))
                 .withEnvironment({ "discovery.type": "single-node" })
+                .withCopyContentToContainer([
+                {
+                    content: "-Xms2G\n-Xmx2G\n",
+                    target: "/usr/share/elasticsearch/config/jvm.options.d/elasticsearch-default-memory-vm.options",
+                },
+            ])
                 .withStartupTimeout(120000);
             return new StartedElasticsearchContainer(yield _super.start.call(this));
         });

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

@@ -1,5 +1,4 @@
 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";
@@ -32,9 +31,9 @@ export declare class KafkaContainer extends GenericContainer {
     constructor(image?: string);
     withZooKeeper(host: string, port: number): this;
     withSaslSslListener(options: SaslSslListenerOptions): this;
-    protected preStart(): Promise<void>;
+    protected beforeContainerStarted(): Promise<void>;
     start(): Promise<StartedKafkaContainer>;
-    protected postStart(container: StartedTestContainer, inspectResult: InspectResult, boundPorts: BoundPorts): Promise<void>;
+    protected containerStarted(container: StartedTestContainer, inspectResult: InspectResult): Promise<void>;
     private addPlaintextAndSecureListener;
     private addPlaintextListener;
     private updateAdvertisedListeners;

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

@@ -44,7 +44,7 @@ class KafkaContainer extends generic_container_1.GenericContainer {
         this.saslSslConfig = options;
         return this;
     }
-    preStart() {
+    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}` });
@@ -81,9 +81,9 @@ class KafkaContainer extends generic_container_1.GenericContainer {
             return new StartedKafkaContainer(yield _super.start.call(this));
         });
     }
-    postStart(container, inspectResult, boundPorts) {
+    containerStarted(container, inspectResult) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.updateAdvertisedListeners(container, inspectResult, boundPorts);
+            yield this.updateAdvertisedListeners(container, inspectResult);
             if (this.saslSslConfig) {
                 yield this.createUser(container, this.saslSslConfig.sasl);
             }
@@ -117,12 +117,12 @@ class KafkaContainer extends generic_container_1.GenericContainer {
             KAFKA_LISTENERS: `PLAINTEXT://0.0.0.0:${KAFKA_PORT},BROKER://0.0.0.0:${KAFKA_BROKER_PORT}`,
         }).withExposedPorts(KAFKA_PORT);
     }
-    updateAdvertisedListeners(container, inspectResult, boundPorts) {
+    updateAdvertisedListeners(container, inspectResult) {
         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)}`;
+            let bootstrapServers = `PLAINTEXT://${container.getHost()}:${container.getMappedPort(KAFKA_PORT)}`;
             if (this.saslSslConfig) {
-                bootstrapServers = `${bootstrapServers},SECURE://${container.getHost()}:${boundPorts.getBinding(this.saslSslConfig.port)}`;
+                bootstrapServers = `${bootstrapServers},SECURE://${container.getHost()}:${container.getMappedPort(this.saslSslConfig.port)}`;
             }
             const { output, exitCode } = yield container.exec([
                 "kafka-configs",
@@ -132,7 +132,7 @@ class KafkaContainer extends generic_container_1.GenericContainer {
                 "--entity-type",
                 "brokers",
                 "--entity-name",
-                this.environment["KAFKA_BROKER_ID"],
+                this.opts.environment["KAFKA_BROKER_ID"],
                 "--add-config",
                 `advertised.listeners=[${bootstrapServers},${brokerAdvertisedListener}]`,
             ]);
@@ -149,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.environment["KAFKA_ZOOKEEPER_CONNECT"],
+                this.opts.environment["KAFKA_ZOOKEEPER_CONNECT"],
                 "--entity-type",
                 "users",
                 "--entity-name",

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

@@ -5,7 +5,7 @@ export declare class MongoDBContainer extends GenericContainer {
     private readonly dockerImageName;
     constructor(image?: string);
     start(): Promise<StartedMongoDBContainer>;
-    protected postStart(startedTestContainer: StartedTestContainer): Promise<void>;
+    protected containerStarted(startedTestContainer: StartedTestContainer): Promise<void>;
     private initReplicaSet;
     private executeMongoEvalCommand;
     private buildMongoEvalCommand;

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

@@ -12,7 +12,7 @@ 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 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 {
@@ -32,7 +32,7 @@ class MongoDBContainer extends generic_container_1.GenericContainer {
             return new StartedMongoDBContainer(yield _super.start.call(this));
         });
     }
-    postStart(startedTestContainer) {
+    containerStarted(startedTestContainer) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.initReplicaSet(startedTestContainer);
         });

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

@@ -42,7 +42,7 @@ class MySqlContainer extends generic_container_1.GenericContainer {
             start: { get: () => super.start }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            this.withExposedPorts(...(this.hasExposedPorts ? this.ports : [MYSQL_PORT]))
+            this.withExposedPorts(...(this.hasExposedPorts ? this.opts.exposedPorts : [MYSQL_PORT]))
                 .withEnvironment({
                 MYSQL_DATABASE: this.database,
                 MYSQL_ROOT_PASSWORD: this.rootPassword,

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

@@ -12,7 +12,7 @@ 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 wait_1 = require("../../wait-strategy/wait");
 const CLIENT_PORT = 4222;
 const ROUTING_PORT_FOR_CLUSTERING = 6222;
 const HTTP_MANAGEMENT_PORT = 8222;
@@ -64,7 +64,9 @@ class NatsContainer extends generic_container_1.GenericContainer {
                 return result;
             }
             this.withCommand(buildCmdsFromArgs(this.args))
-                .withExposedPorts(...(this.hasExposedPorts ? this.ports : [CLIENT_PORT, ROUTING_PORT_FOR_CLUSTERING, HTTP_MANAGEMENT_PORT]))
+                .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());

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

@@ -38,7 +38,7 @@ class Neo4jContainer extends __1.GenericContainer {
             start: { get: () => super.start }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            this.withExposedPorts(...(this.hasExposedPorts ? this.ports : [BOLT_PORT, HTTP_PORT]))
+            this.withExposedPorts(...(this.hasExposedPorts ? this.opts.exposedPorts : [BOLT_PORT, HTTP_PORT]))
                 .withWaitStrategy(__1.Wait.forLogMessage("Started."))
                 .withEnvironment({ NEO4J_AUTH: `${USERNAME}/${this.password}` })
                 .withStartupTimeout(120000);