testcontainers 9.4.0 → 9.6.0

package/dist/package.json

@@ -1,7 +1,7 @@
 {
     "name": "testcontainers",
     "author": "Cristian Greco",
-    "version": "9.4.0",
+    "version": "9.6.0",
     "main": "dist/src/index",
     "types": "dist/src/index",
     "keywords": [
@@ -27,8 +27,8 @@
         "build": "npm run clean && tsc -p tsconfig.prod.json",
         "docs:serve": "docker-compose up",
         "clean": "rimraf dist",
-        "test": "cross-env DEBUG=testcontainers,testcontainers:exec,testcontainers:containers jest",
-        "test:ci": "cross-env DEBUG=testcontainers,testcontainers:exec,testcontainers:containers jest --runInBand --coverage",
+        "test": "cross-env DEBUG=testcontainers* jest",
+        "test:ci": "npm run test -- --runInBand --coverage",
         "format": "prettier --write package.json \"src/**/*.ts\"",
         "lint": "eslint --fix package.json \"src/**/*.ts\"",
         "lint:ci": "eslint package.json \"src/**/*.ts\" --max-warnings=0",

package/dist/src/docker/docker-client.d.ts

@@ -1,8 +1,10 @@
 /// <reference types="node" />
 import Dockerode from "dockerode";
 import { HostIps } from "./lookup-host-ips";
+export type Provider = "docker" | "podman";
 type DockerClient = {
     uri: string;
+    provider: Provider;
     host: string;
     hostIps: HostIps;
     dockerode: Dockerode;

package/dist/src/docker/docker-client.js

@@ -43,12 +43,13 @@ const getDockerClient = () => __awaiter(void 0, void 0, void 0, function* () {
             logger_1.log.debug(`Testing Docker client strategy URI: ${uri}`);
             if (yield isDockerDaemonReachable(dockerode)) {
                 const indexServerAddress = (yield (0, system_info_1.getSystemInfo)(dockerode)).dockerInfo.indexServerAddress;
-                const host = yield (0, resolve_host_1.resolveHost)(dockerode, indexServerAddress, uri);
+                const provider = uri.includes("podman.sock") ? "podman" : "docker";
+                const host = yield (0, resolve_host_1.resolveHost)(dockerode, provider, indexServerAddress, uri);
                 const hostIps = yield (0, lookup_host_ips_1.lookupHostIps)(host);
                 logger_1.log.info(`Using Docker client strategy: ${strategy.getName()}, Docker host: ${host} (${hostIps
                     .map((hostIp) => hostIp.address)
                     .join(", ")})`);
-                return { uri, host, hostIps, dockerode, indexServerAddress, composeEnvironment };
+                return { uri, provider, host, hostIps, dockerode, indexServerAddress, composeEnvironment };
             }
             else {
                 logger_1.log.warn(`Docker client strategy ${strategy.getName()} is not reachable`);

package/dist/src/docker/functions/container/exec-container.d.ts

@@ -1,3 +1,4 @@
 import { ExecResult } from "../../types";
 import Dockerode from "dockerode";
-export declare const execContainer: (container: Dockerode.Container, command: string[], shouldLog?: boolean) => Promise<ExecResult>;
+import { Provider } from "../../docker-client";
+export declare const execContainer: (dockerode: Dockerode, provider: Provider, container: Dockerode.Container, command: string[], shouldLog?: boolean) => Promise<ExecResult>;

package/dist/src/docker/functions/container/exec-container.js

@@ -15,7 +15,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.execContainer = void 0;
 const logger_1 = require("../../../logger");
 const byline_1 = __importDefault(require("byline"));
-const execContainer = (container, command, shouldLog = true) => __awaiter(void 0, void 0, void 0, function* () {
+const demux_stream_1 = require("../demux-stream");
+const execContainer = (dockerode, provider, container, command, shouldLog = true) => __awaiter(void 0, void 0, void 0, function* () {
     const chunks = [];
     try {
         const exec = yield container.exec({
@@ -23,7 +24,7 @@ const execContainer = (container, command, shouldLog = true) => __awaiter(void 0
             AttachStdout: true,
             AttachStderr: true,
         });
-        const stream = yield startExec(exec);
+        const stream = yield startExec(dockerode, provider, exec);
         stream.on("data", (chunk) => chunks.push(chunk));
         if (shouldLog && logger_1.execLog.enabled()) {
             (0, byline_1.default)(stream).on("data", (line) => logger_1.execLog.trace(`${container.id}: ${line}`));
@@ -38,11 +39,15 @@ const execContainer = (container, command, shouldLog = true) => __awaiter(void 0
     }
 });
 exports.execContainer = execContainer;
-const startExec = (exec) => __awaiter(void 0, void 0, void 0, function* () {
+const startExec = (dockerode, provider, exec) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const stream = yield exec.start({ stdin: true, Detach: false, Tty: true });
-        stream.setEncoding("utf-8");
-        return stream;
+        if (provider === "podman") {
+            return (0, demux_stream_1.demuxStream)(dockerode, stream);
+        }
+        else {
+            return stream;
+        }
     }
     catch (err) {
         logger_1.log.error(`Failed to start exec: ${err}`);

package/dist/src/docker/functions/container/put-container-archive.js

@@ -10,10 +10,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.putContainerArchive = void 0;
+const stream_1 = require("stream");
 const logger_1 = require("../../../logger");
+const stream_utils_1 = require("../../../stream-utils");
 const putContainerArchive = (options) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        yield options.container.putArchive(options.stream, { path: options.containerPath });
+        const stream = yield options.container.putArchive(options.stream, { path: options.containerPath });
+        yield (0, stream_utils_1.streamToString)(stream_1.Readable.from(stream));
     }
     catch (err) {
         logger_1.log.error(`Failed to put archive to container ${options.container.id}: ${err}`);

package/dist/src/docker/functions/image/image-exists.js

@@ -13,22 +13,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.imageExists = void 0;
-const logger_1 = require("../../../logger");
 const async_lock_1 = __importDefault(require("async-lock"));
-const list_images_1 = require("./list-images");
 const existingImages = new Set();
 const imageCheckLock = new async_lock_1.default();
 const imageExists = (dockerode, imageName) => __awaiter(void 0, void 0, void 0, function* () {
-    logger_1.log.debug(`Checking if image exists: ${imageName}`);
     return imageCheckLock.acquire(imageName.toString(), () => __awaiter(void 0, void 0, void 0, function* () {
         if (existingImages.has(imageName.toString())) {
             return true;
         }
-        const images = yield (0, list_images_1.listImages)(dockerode);
-        images.forEach((name) => {
-            existingImages.add(name.toString());
-        });
-        return existingImages.has(imageName.toString());
+        try {
+            yield dockerode.getImage(imageName.toString()).inspect();
+            existingImages.add(imageName.toString());
+            return true;
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.toLowerCase().includes("no such image")) {
+                return false;
+            }
+            throw err;
+        }
     }));
 });
 exports.imageExists = imageExists;

package/dist/src/docker/pull-stream-parser.d.ts

@@ -7,5 +7,4 @@ export declare class PullStreamParser {
     private readonly logger;
     constructor(dockerImageName: DockerImageName, logger: Logger);
     consume(stream: Readable): Promise<void>;
-    private getOrElse;
 }

package/dist/src/docker/pull-stream-parser.js

@@ -11,53 +11,10 @@ class PullStreamParser {
         this.logger = logger;
     }
     consume(stream) {
-        const messagesById = new Map();
-        const statusesById = new Map();
         return new Promise((resolve) => {
-            (0, byline_1.default)(stream).on("data", (line) => {
-                try {
-                    const json = JSON.parse(line);
-                    const { id, status } = json;
-                    const prefix = id
-                        ? `Pulling ${this.dockerImageName.toString()} - ${id}`
-                        : `Pulling ${this.dockerImageName.toString()}`;
-                    if (status === "Downloading") {
-                        const { current, total } = json.progressDetail;
-                        const percentage = Math.round(100 * (current / total));
-                        const message = `${prefix} - ${json.status} ${percentage}%`;
-                        const messages = this.getOrElse(messagesById, id, new Set());
-                        if (!messages.has(message)) {
-                            messages.add(message);
-                            this.logger.trace(message);
-                        }
-                    }
-                    else {
-                        const statuses = this.getOrElse(statusesById, id, new Set());
-                        if (!statuses.has(status)) {
-                            statuses.add(status);
-                            const message = `${prefix} - ${json.status}`;
-                            const messages = this.getOrElse(messagesById, id, new Set());
-                            if (!messages.has(message)) {
-                                messages.add(message);
-                                this.logger.trace(message);
-                            }
-                        }
-                    }
-                }
-                catch (_a) {
-                    this.logger.warn(`Unexpected message format: ${line}`);
-                }
-            });
+            (0, byline_1.default)(stream).on("data", (line) => this.logger.trace(`Pulling ${this.dockerImageName.toString()}: ${line}`));
             stream.on("end", resolve);
         });
     }
-    getOrElse(map, key, orElse) {
-        const value = map.get(key);
-        if (value === undefined) {
-            map.set(key, orElse);
-            return orElse;
-        }
-        return value;
-    }
 }
 exports.PullStreamParser = PullStreamParser;

package/dist/src/docker/resolve-host.d.ts

@@ -3,4 +3,5 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import Dockerode from "dockerode";
-export declare const resolveHost: (dockerode: Dockerode, indexServerAddress: string, uri: string, env?: NodeJS.ProcessEnv) => Promise<string>;
+import { Provider } from "./docker-client";
+export declare const resolveHost: (dockerode: Dockerode, provider: Provider, indexServerAddress: string, uri: string, env?: NodeJS.ProcessEnv) => Promise<string>;

package/dist/src/docker/resolve-host.js

@@ -14,7 +14,7 @@ const url_1 = require("url");
 const logger_1 = require("../logger");
 const run_in_container_1 = require("./functions/run-in-container");
 const fs_1 = require("fs");
-const resolveHost = (dockerode, indexServerAddress, uri, env = process.env) => __awaiter(void 0, void 0, void 0, function* () {
+const resolveHost = (dockerode, provider, indexServerAddress, uri, env = process.env) => __awaiter(void 0, void 0, void 0, function* () {
     if (env.TESTCONTAINERS_HOST_OVERRIDE !== undefined) {
         return env.TESTCONTAINERS_HOST_OVERRIDE;
     }
@@ -27,7 +27,8 @@ const resolveHost = (dockerode, indexServerAddress, uri, env = process.env) => _
         case "unix:":
         case "npipe:": {
             if (isInContainer()) {
-                const gateway = yield findGateway(dockerode);
+                const networkName = provider === "podman" ? "podman" : "bridge";
+                const gateway = yield findGateway(dockerode, networkName);
                 if (gateway !== undefined) {
                     return gateway;
                 }
@@ -43,10 +44,10 @@ const resolveHost = (dockerode, indexServerAddress, uri, env = process.env) => _
     }
 });
 exports.resolveHost = resolveHost;
-const findGateway = (dockerode) => __awaiter(void 0, void 0, void 0, function* () {
+const findGateway = (dockerode, networkName) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b, _c;
     logger_1.log.debug(`Checking gateway for Docker host`);
-    const inspectResult = yield dockerode.getNetwork("bridge").inspect();
+    const inspectResult = yield dockerode.getNetwork(networkName).inspect();
     return (_c = (_b = (_a = inspectResult === null || inspectResult === void 0 ? void 0 : inspectResult.IPAM) === null || _a === void 0 ? void 0 : _a.Config) === null || _b === void 0 ? void 0 : _b.find((config) => config.Gateway !== undefined)) === null || _c === void 0 ? void 0 : _c.Gateway;
 });
 const findDefaultGateway = (dockerode, indexServerAddress) => __awaiter(void 0, void 0, void 0, function* () {

package/dist/src/docker/rootless-unix-socket-strategy.d.ts

@@ -8,7 +8,8 @@ export declare class RootlessUnixSocketStrategy implements DockerClientStrategy
     constructor(platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv);
     init(): Promise<void>;
     private getSocketPathFromEnv;
-    private getSocketPathFromHomeDir;
+    private getSocketPathFromHomeRunDir;
+    private getSocketPathFromHomeDesktopDir;
     private getSocketPathFromRunDir;
     getDockerClient(): Promise<DockerClientInit>;
     isApplicable(): boolean;

package/dist/src/docker/rootless-unix-socket-strategy.js

@@ -29,7 +29,12 @@ class RootlessUnixSocketStrategy {
                 this.applicable = false;
                 return;
             }
-            this.socketPath = [this.getSocketPathFromEnv(), this.getSocketPathFromHomeDir(), this.getSocketPathFromRunDir()]
+            this.socketPath = [
+                this.getSocketPathFromEnv(),
+                this.getSocketPathFromHomeRunDir(),
+                this.getSocketPathFromHomeDesktopDir(),
+                this.getSocketPathFromRunDir(),
+            ]
                 .filter(type_guards_1.isDefined)
                 .find((candidateSocketPath) => (0, fs_1.existsSync)(candidateSocketPath));
             this.applicable = this.socketPath !== undefined;
@@ -44,9 +49,12 @@ class RootlessUnixSocketStrategy {
             return undefined;
         }
     }
-    getSocketPathFromHomeDir() {
+    getSocketPathFromHomeRunDir() {
         return path_1.default.join(os_1.default.homedir(), ".docker", "run", "docker.sock");
     }
+    getSocketPathFromHomeDesktopDir() {
+        return path_1.default.join(os_1.default.homedir(), ".docker", "desktop", "docker.sock");
+    }
     getSocketPathFromRunDir() {
         return path_1.default.join("/run", "user", `${os_1.default.userInfo().uid}`, "docker.sock");
     }

package/dist/src/docker-compose/functions/docker-compose-pull.d.ts

@@ -0,0 +1,2 @@
+import { DockerComposeOptions } from "../docker-compose-options";
+export declare const dockerComposePull: (options: DockerComposeOptions, services?: Array<string>) => Promise<void>;

package/dist/src/docker-compose/functions/docker-compose-pull.js

@@ -0,0 +1,35 @@
+"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.dockerComposePull = void 0;
+const logger_1 = require("../../logger");
+const docker_compose_1 = require("docker-compose");
+const default_docker_compose_options_1 = require("../default-docker-compose-options");
+const dockerComposePull = (options, services) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        if (services) {
+            logger_1.log.info(`Pulling DockerCompose environment images for ${services.join(", ")}`);
+            yield (0, docker_compose_1.pullMany)(services, yield (0, default_docker_compose_options_1.defaultDockerComposeOptions)(options));
+        }
+        else {
+            logger_1.log.info(`Pulling DockerCompose environment images`);
+            yield (0, docker_compose_1.pullAll)(yield (0, default_docker_compose_options_1.defaultDockerComposeOptions)(options));
+        }
+        logger_1.log.info(`Pulled DockerCompose environment`);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }
+    catch (err) {
+        const errorMessage = err.err || err.message || err || "";
+        logger_1.log.error(`Failed to pull DockerCompose environment images: ${errorMessage.trim()}`);
+        throw new Error(errorMessage);
+    }
+});
+exports.dockerComposePull = dockerComposePull;

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

@@ -2,6 +2,7 @@ import { WaitStrategy } from "../wait-strategy/wait-strategy";
 import { Uuid } from "../uuid";
 import { Environment } from "../docker/types";
 import { StartedDockerComposeEnvironment } from "./started-docker-compose-environment";
+import { PullPolicy } from "../pull-policy";
 export declare class DockerComposeEnvironment {
     private readonly composeFilePath;
     private readonly composeFiles;
@@ -11,14 +12,16 @@ export declare class DockerComposeEnvironment {
     private environmentFile;
     private profiles;
     private environment;
+    private pullPolicy;
     private waitStrategy;
-    private startupTimeout;
+    private startupTimeout?;
     constructor(composeFilePath: string, composeFiles: string | string[], uuid?: Uuid);
     withBuild(): this;
     withEnvironment(environment: Environment): this;
     withEnvironmentFile(environmentFile: string): this;
     withProfiles(...profiles: string[]): this;
     withNoRecreate(): this;
+    withPullPolicy(pullPolicy: PullPolicy): this;
     withWaitStrategy(containerName: string, waitStrategy: WaitStrategy): this;
     withStartupTimeout(startupTimeout: number): this;
     up(services?: Array<string>): Promise<StartedDockerComposeEnvironment>;

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

@@ -25,7 +25,9 @@ const started_docker_compose_environment_1 = require("./started-docker-compose-e
 const docker_compose_down_1 = require("../docker-compose/functions/docker-compose-down");
 const docker_compose_up_1 = require("../docker-compose/functions/docker-compose-up");
 const wait_for_container_1 = require("../wait-for-container");
-const default_wait_strategy_1 = require("../wait-strategy/default-wait-strategy");
+const pull_policy_1 = require("../pull-policy");
+const docker_compose_pull_1 = require("../docker-compose/functions/docker-compose-pull");
+const wait_1 = require("../wait-strategy/wait");
 class DockerComposeEnvironment {
     constructor(composeFilePath, composeFiles, uuid = new uuid_1.RandomUuid()) {
         this.build = false;
@@ -33,8 +35,8 @@ class DockerComposeEnvironment {
         this.environmentFile = "";
         this.profiles = [];
         this.environment = {};
+        this.pullPolicy = new pull_policy_1.DefaultPullPolicy();
         this.waitStrategy = {};
-        this.startupTimeout = 60000;
         this.composeFilePath = composeFilePath;
         this.composeFiles = composeFiles;
         this.projectName = `testcontainers-${uuid.nextUuid()}`;
@@ -60,6 +62,10 @@ class DockerComposeEnvironment {
         this.projectName = "testcontainers-node";
         return this;
     }
+    withPullPolicy(pullPolicy) {
+        this.pullPolicy = pullPolicy;
+        return this;
+    }
     withWaitStrategy(containerName, waitStrategy) {
         this.waitStrategy[containerName] = waitStrategy;
         return this;
@@ -89,6 +95,9 @@ class DockerComposeEnvironment {
                 composeOptions.push("--env-file", this.environmentFile);
             }
             this.profiles.forEach((profile) => composeOptions.push("--profile", profile));
+            if (this.pullPolicy.shouldPull()) {
+                yield (0, docker_compose_pull_1.dockerComposePull)(options, 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) => [
@@ -102,7 +111,12 @@ class DockerComposeEnvironment {
                 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);
-                const waitStrategy = (this.waitStrategy[containerName] ? this.waitStrategy[containerName] : (0, default_wait_strategy_1.defaultWaitStrategy)(host, container)).withStartupTimeout(this.startupTimeout);
+                const waitStrategy = this.waitStrategy[containerName]
+                    ? this.waitStrategy[containerName]
+                    : wait_1.Wait.forListeningPorts();
+                if (this.startupTimeout !== undefined) {
+                    waitStrategy.withStartupTimeout(this.startupTimeout);
+                }
                 if (logger_1.containerLog.enabled()) {
                     (yield (0, container_logs_1.containerLogs)(container))
                         .on("data", (data) => logger_1.containerLog.trace(`${containerName}: ${data.trim()}`))
@@ -110,7 +124,7 @@ class DockerComposeEnvironment {
                 }
                 try {
                     logger_1.log.info(`Waiting for container ${containerName} to be ready`);
-                    yield (0, wait_for_container_1.waitForContainer)(container, waitStrategy, host, boundPorts);
+                    yield (0, wait_for_container_1.waitForContainer)(container, waitStrategy, boundPorts);
                     logger_1.log.info(`Container ${containerName} is ready`);
                 }
                 catch (err) {

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

@@ -13,8 +13,8 @@ export declare class GenericContainer implements TestContainer {
     readonly image: string;
     static fromDockerfile(context: string, dockerfileName?: string): GenericContainerBuilder;
     protected opts: CreateContainerOptions;
-    protected startupTimeout: number;
-    protected waitStrategy?: WaitStrategy;
+    protected startupTimeout?: number;
+    protected waitStrategy: WaitStrategy;
     protected tarToCopy?: archiver.Archiver;
     protected networkMode?: string;
     protected networkAliases: string[];

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

@@ -36,7 +36,7 @@ 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 wait_1 = require("../wait-strategy/wait");
 const reusableContainerCreationLock = new async_lock_1.default();
 class GenericContainer {
     static fromDockerfile(context, dockerfileName = "Dockerfile") {
@@ -44,7 +44,7 @@ class GenericContainer {
     }
     constructor(image) {
         this.image = image;
-        this.startupTimeout = 60000;
+        this.waitStrategy = wait_1.Wait.forListeningPorts();
         this.networkAliases = [];
         this.pullPolicy = new pull_policy_1.DefaultPullPolicy();
         const imageName = docker_image_name_1.DockerImageName.fromString(image);
@@ -101,17 +101,18 @@ class GenericContainer {
         });
     }
     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)(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.startupTimeout !== undefined) {
+                this.waitStrategy.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);
+            yield (0, wait_for_container_1.waitForContainer)(container, this.waitStrategy, boundPorts);
+            const startedContainer = new started_generic_container_1.StartedGenericContainer(container, host, inspectResult, boundPorts, inspectResult.name, this.waitStrategy);
             if (this.containerStarted) {
                 yield this.containerStarted(startedContainer, inspectResult, true);
             }
@@ -122,7 +123,6 @@ class GenericContainer {
         });
     }
     startContainer(createContainerOptions) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const container = yield (0, create_container_1.createContainer)(createContainerOptions);
             if (!this.opts.imageName.isHelperContainer() && port_forwarder_1.PortForwarderInstance.isRunning()) {
@@ -156,7 +156,9 @@ class GenericContainer {
             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.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.startupTimeout !== undefined) {
+                this.waitStrategy.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()}`))
@@ -165,8 +167,8 @@ class GenericContainer {
             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);
+            yield (0, wait_for_container_1.waitForContainer)(container, this.waitStrategy, boundPorts);
+            const startedContainer = new started_generic_container_1.StartedGenericContainer(container, host, inspectResult, boundPorts, inspectResult.name, this.waitStrategy);
             if (this.containerStarted) {
                 yield this.containerStarted(startedContainer, inspectResult, false);
             }

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

@@ -13,6 +13,8 @@ export declare class StartedGenericContainer implements StartedTestContainer {
     private boundPorts;
     private readonly name;
     private readonly waitStrategy;
+    private stoppedContainer?;
+    private stopContainerLock;
     constructor(container: Dockerode.Container, host: string, inspectResult: InspectResult, boundPorts: BoundPorts, name: string, waitStrategy: WaitStrategy);
     protected containerIsStopping?(): Promise<void>;
     stop(options?: Partial<StopOptions>): Promise<StoppedTestContainer>;

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

@@ -8,6 +8,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StartedGenericContainer = void 0;
 const inspect_container_1 = require("../docker/functions/container/inspect-container");
@@ -21,6 +24,7 @@ const stop_container_1 = require("../docker/functions/container/stop-container")
 const restart_container_1 = require("../docker/functions/container/restart-container");
 const wait_for_container_1 = require("../wait-for-container");
 const docker_client_1 = require("../docker/docker-client");
+const async_lock_1 = __importDefault(require("async-lock"));
 class StartedGenericContainer {
     constructor(container, host, inspectResult, boundPorts, name, waitStrategy) {
         this.container = container;
@@ -29,10 +33,17 @@ class StartedGenericContainer {
         this.boundPorts = boundPorts;
         this.name = name;
         this.waitStrategy = waitStrategy;
+        this.stopContainerLock = new async_lock_1.default();
     }
     stop(options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.stopContainer(options);
+            return this.stopContainerLock.acquire("stop", () => __awaiter(this, void 0, void 0, function* () {
+                if (this.stoppedContainer) {
+                    return this.stoppedContainer;
+                }
+                this.stoppedContainer = yield this.stopContainer(options);
+                return this.stoppedContainer;
+            }));
         });
     }
     restart(options = {}) {
@@ -49,7 +60,7 @@ class StartedGenericContainer {
                     .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);
+            yield (0, wait_for_container_1.waitForContainer)(this.container, this.waitStrategy, this.boundPorts, startTime);
         });
     }
     stopContainer(options = {}) {
@@ -95,7 +106,10 @@ class StartedGenericContainer {
         return this.inspectResult.networkSettings[networkName].ipAddress;
     }
     exec(command) {
-        return (0, exec_container_1.execContainer)(this.container, command);
+        return __awaiter(this, void 0, void 0, function* () {
+            const { dockerode, provider } = yield (0, docker_client_1.dockerClient)();
+            return (0, exec_container_1.execContainer)(dockerode, provider, this.container, command);
+        });
     }
     logs() {
         return (0, container_logs_1.containerLogs)(this.container);

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

@@ -26,7 +26,7 @@ class ElasticsearchContainer extends __1.GenericContainer {
                 .withEnvironment({ "discovery.type": "single-node" })
                 .withCopyContentToContainer([
                 {
-                    content: "-Xms2G\n-Xmx2G\n",
+                    content: "-Xmx2G\n",
                     target: "/usr/share/elasticsearch/config/jvm.options.d/elasticsearch-default-memory-vm.options",
                 },
             ])

package/dist/src/network.d.ts

@@ -2,6 +2,7 @@ import { Uuid } from "./uuid";
 import { CreateNetworkOptions } from "./docker/functions/network/create-network";
 export declare class Network {
     private readonly createNetworkOptions;
+    private readonly uuid;
     constructor(createNetworkOptions?: Partial<CreateNetworkOptions>, uuid?: Uuid);
     start(): Promise<StartedNetwork>;
 }

package/dist/src/network.js

@@ -17,14 +17,17 @@ const create_network_1 = require("./docker/functions/network/create-network");
 const remove_network_1 = require("./docker/functions/network/remove-network");
 class Network {
     constructor(createNetworkOptions = {}, uuid = new uuid_1.RandomUuid()) {
-        this.createNetworkOptions = Object.assign({ name: uuid.nextUuid(), driver: "bridge", checkDuplicate: true, internal: false, attachable: false, ingress: false, enableIPv6: false }, createNetworkOptions);
+        this.createNetworkOptions = createNetworkOptions;
+        this.uuid = uuid;
+        this.createNetworkOptions = createNetworkOptions;
     }
     start() {
         return __awaiter(this, void 0, void 0, function* () {
+            const options = Object.assign({ name: this.uuid.nextUuid(), driver: "bridge", checkDuplicate: true, internal: false, attachable: false, ingress: false, enableIPv6: false }, this.createNetworkOptions);
             yield reaper_1.ReaperInstance.getInstance();
-            const id = yield (0, create_network_1.createNetwork)(this.createNetworkOptions);
+            const id = yield (0, create_network_1.createNetwork)(options);
             logger_1.log.info(`Started network with ID: ${id}`);
-            return new StartedNetwork(id, this.createNetworkOptions);
+            return new StartedNetwork(id, options);
         });
     }
 }

package/dist/src/port-check.d.ts

@@ -1,4 +1,5 @@
 import Dockerode from "dockerode";
+import { Provider } from "./docker/docker-client";
 export interface PortCheck {
     isBound(port: number): Promise<boolean>;
 }
@@ -8,10 +9,12 @@ export declare class HostPortCheck implements PortCheck {
     isBound(port: number): Promise<boolean>;
 }
 export declare class InternalPortCheck implements PortCheck {
+    private readonly dockerode;
+    private readonly provider;
     private readonly container;
     private isDistroless;
     private commandOutputs;
-    constructor(container: Dockerode.Container);
+    constructor(dockerode: Dockerode, provider: Provider, container: Dockerode.Container);
     isBound(port: number): Promise<boolean>;
     private commandOutputsKey;
 }

package/dist/src/port-check.js

@@ -39,7 +39,9 @@ class HostPortCheck {
 }
 exports.HostPortCheck = HostPortCheck;
 class InternalPortCheck {
-    constructor(container) {
+    constructor(dockerode, provider, container) {
+        this.dockerode = dockerode;
+        this.provider = provider;
         this.container = container;
         this.isDistroless = false;
         this.commandOutputs = new Set();
@@ -52,7 +54,7 @@ class InternalPortCheck {
                 ["/bin/sh", "-c", `nc -vz -w 1 localhost ${port}`],
                 ["/bin/bash", "-c", `</dev/tcp/localhost/${port}`],
             ];
-            const commandResults = yield Promise.all(commands.map((command) => (0, exec_container_1.execContainer)(this.container, command, false)));
+            const commandResults = yield Promise.all(commands.map((command) => (0, exec_container_1.execContainer)(this.dockerode, this.provider, this.container, command, false)));
             const isBound = commandResults.some((result) => result.exitCode === 0);
             if (!isBound && logger_1.log.enabled()) {
                 const shellExists = commandResults.some((result) => result.exitCode !== 126);

package/dist/src/test-container.d.ts

@@ -42,11 +42,6 @@ export interface DockerComposeDownOptions {
     timeout: number;
     removeVolumes: boolean;
 }
-export interface ExecOptions {
-    tty: boolean;
-    detach: boolean;
-    stdin: boolean;
-}
 export interface StartedTestContainer {
     stop(options?: Partial<StopOptions>): Promise<StoppedTestContainer>;
     restart(options?: Partial<RestartOptions>): Promise<void>;
@@ -59,7 +54,7 @@ export interface 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>;
 }
 export interface StoppedTestContainer {

package/dist/src/wait-for-container.d.ts

@@ -1,4 +1,4 @@
 import Dockerode from "dockerode";
 import { BoundPorts } from "./bound-ports";
 import { WaitStrategy } from "./wait-strategy/wait-strategy";
-export declare const waitForContainer: (container: Dockerode.Container, waitStrategy: WaitStrategy, host: string, boundPorts: BoundPorts, startTime?: Date) => Promise<void>;
+export declare const waitForContainer: (container: Dockerode.Container, waitStrategy: WaitStrategy, boundPorts: BoundPorts, startTime?: Date) => Promise<void>;

package/dist/src/wait-for-container.js

@@ -13,10 +13,10 @@ exports.waitForContainer = void 0;
 const logger_1 = require("./logger");
 const stop_container_1 = require("./docker/functions/container/stop-container");
 const remove_container_1 = require("./docker/functions/container/remove-container");
-const waitForContainer = (container, waitStrategy, host, boundPorts, startTime) => __awaiter(void 0, void 0, void 0, function* () {
+const waitForContainer = (container, waitStrategy, boundPorts, startTime) => __awaiter(void 0, void 0, void 0, function* () {
     logger_1.log.debug(`Waiting for container to be ready: ${container.id}`);
     try {
-        yield waitStrategy.waitUntilReady(container, host, boundPorts, startTime);
+        yield waitStrategy.waitUntilReady(container, boundPorts, startTime);
         logger_1.log.info(`Container is ready: ${container.id}`);
     }
     catch (err) {

package/dist/src/wait-strategy/composite-wait-strategy.d.ts

@@ -0,0 +1,11 @@
+import { AbstractWaitStrategy, WaitStrategy } from "./wait-strategy";
+import Dockerode from "dockerode";
+import { BoundPorts } from "../bound-ports";
+export declare class CompositeWaitStrategy extends AbstractWaitStrategy {
+    private readonly waitStrategies;
+    private deadline?;
+    constructor(waitStrategies: WaitStrategy[]);
+    waitUntilReady(container: Dockerode.Container, boundPorts: BoundPorts, startTime?: Date): Promise<void>;
+    withStartupTimeout(startupTimeout: number): this;
+    withDeadline(deadline: number): this;
+}

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

@@ -0,0 +1,54 @@
+"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.CompositeWaitStrategy = void 0;
+const wait_strategy_1 = require("./wait-strategy");
+const logger_1 = require("../logger");
+class CompositeWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
+    constructor(waitStrategies) {
+        super();
+        this.waitStrategies = waitStrategies;
+    }
+    waitUntilReady(container, boundPorts, startTime) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.log.debug(`Starting composite wait strategy for ${container.id}`);
+            return new Promise((resolve, reject) => {
+                let deadlineTimeout;
+                if (this.deadline !== undefined) {
+                    deadlineTimeout = setTimeout(() => {
+                        const message = `Composite wait strategy not successful after ${this.deadline}ms for ${container.id}`;
+                        logger_1.log.error(message);
+                        reject(new Error(message));
+                    }, this.deadline);
+                }
+                Promise.all(this.waitStrategies.map((waitStrategy) => waitStrategy.waitUntilReady(container, boundPorts, startTime)))
+                    .then(() => resolve())
+                    .catch((err) => reject(err))
+                    .finally(() => {
+                    if (deadlineTimeout) {
+                        clearTimeout(deadlineTimeout);
+                    }
+                });
+            });
+        });
+    }
+    withStartupTimeout(startupTimeout) {
+        this.waitStrategies
+            .filter((waitStrategy) => waitStrategy.getStartupTimeout() === undefined)
+            .forEach((waitStrategy) => waitStrategy.withStartupTimeout(startupTimeout));
+        return this;
+    }
+    withDeadline(deadline) {
+        this.deadline = deadline;
+        return this;
+    }
+}
+exports.CompositeWaitStrategy = CompositeWaitStrategy;

package/dist/src/wait-strategy/health-check-wait-strategy.js

@@ -16,12 +16,13 @@ const inspect_container_1 = require("../docker/functions/container/inspect-conta
 const wait_strategy_1 = require("./wait-strategy");
 class HealthCheckWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
     waitUntilReady(container) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             logger_1.log.debug(`Waiting for health check for ${container.id}`);
             const status = yield new retry_strategy_1.IntervalRetryStrategy(100).retryUntil(() => __awaiter(this, void 0, void 0, function* () { return (yield (0, inspect_container_1.inspectContainer)(container)).healthCheckStatus; }), (healthCheckStatus) => healthCheckStatus === "healthy" || healthCheckStatus === "unhealthy", () => {
                 const timeout = this.startupTimeout;
                 throw new Error(`Health check not healthy after ${timeout}ms for ${container.id}`);
-            }, this.startupTimeout);
+            }, (_a = this.startupTimeout) !== null && _a !== void 0 ? _a : wait_strategy_1.DEFAULT_STARTUP_TIMEOUT);
             if (status !== "healthy") {
                 throw new Error(`Health check failed: ${status} for ${container.id}`);
             }

package/dist/src/wait-strategy/host-port-wait-strategy.d.ts

@@ -1,12 +1,8 @@
-import { PortCheck } from "../port-check";
 import Dockerode from "dockerode";
 import { BoundPorts } from "../bound-ports";
 import { AbstractWaitStrategy } from "./wait-strategy";
 export declare class HostPortWaitStrategy extends AbstractWaitStrategy {
-    private readonly hostPortCheck;
-    private readonly internalPortCheck;
-    constructor(hostPortCheck: PortCheck, internalPortCheck: PortCheck);
-    waitUntilReady(container: Dockerode.Container, host: string, boundPorts: BoundPorts): Promise<void>;
+    waitUntilReady(container: Dockerode.Container, boundPorts: BoundPorts): Promise<void>;
     private waitForHostPorts;
     private waitForInternalPorts;
     private waitForPort;

package/dist/src/wait-strategy/host-port-wait-strategy.js

@@ -10,44 +10,48 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HostPortWaitStrategy = void 0;
+const port_check_1 = require("../port-check");
 const logger_1 = require("../logger");
 const retry_strategy_1 = require("../retry-strategy");
 const wait_strategy_1 = require("./wait-strategy");
+const docker_client_1 = require("../docker/docker-client");
 class HostPortWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
-    constructor(hostPortCheck, internalPortCheck) {
-        super();
-        this.hostPortCheck = hostPortCheck;
-        this.internalPortCheck = internalPortCheck;
-    }
-    waitUntilReady(container, host, boundPorts) {
+    waitUntilReady(container, boundPorts) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield Promise.all([this.waitForHostPorts(container, boundPorts), this.waitForInternalPorts(container, boundPorts)]);
+            const { dockerode, provider, host } = yield (0, docker_client_1.dockerClient)();
+            const hostPortCheck = new port_check_1.HostPortCheck(host);
+            const internalPortCheck = new port_check_1.InternalPortCheck(dockerode, provider, container);
+            yield Promise.all([
+                this.waitForHostPorts(hostPortCheck, container, boundPorts),
+                this.waitForInternalPorts(internalPortCheck, container, boundPorts),
+            ]);
         });
     }
-    waitForHostPorts(container, boundPorts) {
+    waitForHostPorts(portCheck, container, boundPorts) {
         return __awaiter(this, void 0, void 0, function* () {
             for (const [, hostPort] of boundPorts.iterator()) {
                 logger_1.log.debug(`Waiting for host port ${hostPort} for ${container.id}`);
-                yield this.waitForPort(container, hostPort, this.hostPortCheck);
+                yield this.waitForPort(container, hostPort, portCheck);
                 logger_1.log.debug(`Host port ${hostPort} ready for ${container.id}`);
             }
         });
     }
-    waitForInternalPorts(container, boundPorts) {
+    waitForInternalPorts(portCheck, container, boundPorts) {
         return __awaiter(this, void 0, void 0, function* () {
             for (const [internalPort] of boundPorts.iterator()) {
                 logger_1.log.debug(`Waiting for internal port ${internalPort} for ${container.id}`);
-                yield this.waitForPort(container, internalPort, this.internalPortCheck);
+                yield this.waitForPort(container, internalPort, portCheck);
                 logger_1.log.debug(`Internal port ${internalPort} ready for ${container.id}`);
             }
         });
     }
     waitForPort(container, port, portCheck) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            const startupTimeout = (_a = this.startupTimeout) !== null && _a !== void 0 ? _a : wait_strategy_1.DEFAULT_STARTUP_TIMEOUT;
             yield new retry_strategy_1.IntervalRetryStrategy(100).retryUntil(() => portCheck.isBound(port), (isBound) => isBound, () => {
-                const timeout = this.startupTimeout;
-                throw new Error(`Port ${port} not bound after ${timeout}ms for ${container.id}`);
-            }, this.startupTimeout);
+                throw new Error(`Port ${port} not bound after ${startupTimeout}ms for ${container.id}`);
+            }, startupTimeout);
         });
     }
 }

package/dist/src/wait-strategy/http-wait-strategy.d.ts

@@ -22,6 +22,6 @@ export declare class HttpWaitStrategy extends AbstractWaitStrategy {
     withReadTimeout(readTimeout: number): HttpWaitStrategy;
     usingTls(): HttpWaitStrategy;
     allowInsecure(): HttpWaitStrategy;
-    waitUntilReady(container: Dockerode.Container, host: string, boundPorts: BoundPorts): Promise<void>;
+    waitUntilReady(container: Dockerode.Container, boundPorts: BoundPorts): Promise<void>;
     private getAgent;
 }

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

@@ -17,6 +17,7 @@ const wait_strategy_1 = require("./wait-strategy");
 const retry_strategy_1 = require("../retry-strategy");
 const node_fetch_1 = __importDefault(require("node-fetch"));
 const https_1 = __importDefault(require("https"));
+const docker_client_1 = require("../docker/docker-client");
 class HttpWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
     constructor(path, port) {
         super();
@@ -66,8 +67,11 @@ class HttpWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
         this._allowInsecure = true;
         return this;
     }
-    waitUntilReady(container, host, boundPorts) {
+    waitUntilReady(container, boundPorts) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            const { host } = yield (0, docker_client_1.dockerClient)();
+            const startupTimeout = (_a = this.startupTimeout) !== null && _a !== void 0 ? _a : wait_strategy_1.DEFAULT_STARTUP_TIMEOUT;
             yield new retry_strategy_1.IntervalRetryStrategy(this.readTimeout).retryUntil(() => __awaiter(this, void 0, void 0, function* () {
                 try {
                     const url = `${this.protocol}://${host}:${boundPorts.getBinding(this.port)}${this.path}`;
@@ -78,7 +82,7 @@ class HttpWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
                         agent: this.getAgent(),
                     });
                 }
-                catch (_a) {
+                catch (_b) {
                     return undefined;
                 }
             }), (response) => __awaiter(this, void 0, void 0, function* () {
@@ -98,8 +102,8 @@ class HttpWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
                     return true;
                 }
             }), () => {
-                throw new Error(`URL ${this.path} not accessible after ${this.startupTimeout}ms for ${container.id}`);
-            }, this.startupTimeout);
+                throw new Error(`URL ${this.path} not accessible after ${startupTimeout}ms for ${container.id}`);
+            }, startupTimeout);
         });
     }
     getAgent() {

package/dist/src/wait-strategy/log-wait-strategy.d.ts

@@ -6,5 +6,5 @@ export declare class LogWaitStrategy extends AbstractWaitStrategy {
     private readonly message;
     private readonly times;
     constructor(message: Log | RegExp, times: number);
-    waitUntilReady(container: Dockerode.Container, host: string, boundPorts: BoundPorts, startTime?: Date): Promise<void>;
+    waitUntilReady(container: Dockerode.Container, boundPorts: BoundPorts, startTime?: Date): Promise<void>;
 }

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

@@ -23,12 +23,13 @@ class LogWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
         this.message = message;
         this.times = times;
     }
-    waitUntilReady(container, host, boundPorts, startTime) {
+    waitUntilReady(container, boundPorts, startTime) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             logger_1.log.debug(`Waiting for log message "${this.message}" for ${container.id}`);
+            const startupTimeout = (_a = this.startupTimeout) !== null && _a !== void 0 ? _a : wait_strategy_1.DEFAULT_STARTUP_TIMEOUT;
             const stream = yield (0, container_logs_1.containerLogs)(container, { since: startTime });
             return new Promise((resolve, reject) => {
-                const startupTimeout = this.startupTimeout;
                 const timeout = setTimeout(() => {
                     const message = `Log message "${this.message}" not received after ${startupTimeout}ms for ${container.id}`;
                     logger_1.log.error(message);

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

@@ -14,21 +14,24 @@ const logger_1 = require("../logger");
 const wait_strategy_1 = require("./wait-strategy");
 const retry_strategy_1 = require("../retry-strategy");
 const exec_container_1 = require("../docker/functions/container/exec-container");
+const docker_client_1 = require("../docker/docker-client");
 class ShellWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
     constructor(command) {
         super();
         this.command = command;
     }
     waitUntilReady(container) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             logger_1.log.debug(`Waiting for successful shell command ${this.command} for ${container.id}`);
+            const { dockerode, provider } = yield (0, docker_client_1.dockerClient)();
+            const startupTimeout = (_a = this.startupTimeout) !== null && _a !== void 0 ? _a : wait_strategy_1.DEFAULT_STARTUP_TIMEOUT;
             yield new retry_strategy_1.IntervalRetryStrategy(100).retryUntil(() => __awaiter(this, void 0, void 0, function* () {
-                const { exitCode } = yield (0, exec_container_1.execContainer)(container, ["/bin/sh", "-c", this.command], false);
+                const { exitCode } = yield (0, exec_container_1.execContainer)(dockerode, provider, container, ["/bin/sh", "-c", this.command], false);
                 return exitCode;
             }), (exitCode) => exitCode === 0, () => {
-                const timeout = this.startupTimeout;
-                throw new Error(`Shell command not successful after ${timeout}ms for ${container.id}`);
-            }, this.startupTimeout);
+                throw new Error(`Shell command "${this.command}" not successful after ${startupTimeout}ms for ${container.id}`);
+            }, startupTimeout);
         });
     }
 }

package/dist/src/wait-strategy/startup-check-strategy.js

@@ -15,9 +15,11 @@ const retry_strategy_1 = require("../retry-strategy");
 const docker_client_1 = require("../docker/docker-client");
 class StartupCheckStrategy extends wait_strategy_1.AbstractWaitStrategy {
     waitUntilReady(container) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const { dockerode } = yield (0, docker_client_1.dockerClient)();
-            const startupStatus = yield new retry_strategy_1.IntervalRetryStrategy(1000).retryUntil(() => __awaiter(this, void 0, void 0, function* () { return yield this.checkStartupState(dockerode, container.id); }), (startupStatus) => startupStatus === "SUCCESS" || startupStatus === "FAIL", () => new Error(`Container not accessible after ${this.startupTimeout}ms for ${container.id}`), this.startupTimeout);
+            const startupTimeout = (_a = this.startupTimeout) !== null && _a !== void 0 ? _a : wait_strategy_1.DEFAULT_STARTUP_TIMEOUT;
+            const startupStatus = yield new retry_strategy_1.IntervalRetryStrategy(1000).retryUntil(() => __awaiter(this, void 0, void 0, function* () { return yield this.checkStartupState(dockerode, container.id); }), (startupStatus) => startupStatus === "SUCCESS" || startupStatus === "FAIL", () => new Error(`Container not accessible after ${startupTimeout}ms for ${container.id}`), startupTimeout);
             if (startupStatus instanceof Error) {
                 throw startupStatus;
             }

package/dist/src/wait-strategy/wait-strategy.d.ts

@@ -1,11 +1,14 @@
 import { BoundPorts } from "../bound-ports";
 import Dockerode from "dockerode";
+export declare const DEFAULT_STARTUP_TIMEOUT = 60000;
 export interface WaitStrategy {
-    waitUntilReady(container: Dockerode.Container, host: string, boundPorts: BoundPorts, startTime?: Date): Promise<void>;
+    waitUntilReady(container: Dockerode.Container, boundPorts: BoundPorts, startTime?: Date): Promise<void>;
     withStartupTimeout(startupTimeout: number): WaitStrategy;
+    getStartupTimeout(): number | undefined;
 }
 export declare abstract class AbstractWaitStrategy implements WaitStrategy {
-    protected startupTimeout: number;
-    abstract waitUntilReady(container: Dockerode.Container, host: string, boundPorts: BoundPorts, startTime?: Date): Promise<void>;
-    withStartupTimeout(startupTimeout: number): WaitStrategy;
+    protected startupTimeout?: number;
+    abstract waitUntilReady(container: Dockerode.Container, boundPorts: BoundPorts, startTime?: Date): Promise<void>;
+    withStartupTimeout(startupTimeout: number): this;
+    getStartupTimeout(): number | undefined;
 }

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

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractWaitStrategy = void 0;
+exports.AbstractWaitStrategy = exports.DEFAULT_STARTUP_TIMEOUT = void 0;
+exports.DEFAULT_STARTUP_TIMEOUT = 60000;
 class AbstractWaitStrategy {
-    constructor() {
-        this.startupTimeout = 60000;
-    }
     withStartupTimeout(startupTimeout) {
         this.startupTimeout = startupTimeout;
         return this;
     }
+    getStartupTimeout() {
+        return this.startupTimeout;
+    }
 }
 exports.AbstractWaitStrategy = AbstractWaitStrategy;

package/dist/src/wait-strategy/wait.d.ts

@@ -2,7 +2,10 @@ import { WaitStrategy } from "./wait-strategy";
 import { HttpWaitStrategy } from "./http-wait-strategy";
 import { Log } from "./log-wait-strategy";
 import { ShellWaitStrategy } from "./shell-wait-strategy";
+import { CompositeWaitStrategy } from "./composite-wait-strategy";
 export declare class Wait {
+    static forAll(waitStrategies: WaitStrategy[]): CompositeWaitStrategy;
+    static forListeningPorts(): WaitStrategy;
     static forLogMessage(message: Log | RegExp, times?: number): WaitStrategy;
     static forHealthCheck(): WaitStrategy;
     static forHttp(path: string, port: number): HttpWaitStrategy;

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

@@ -5,7 +5,15 @@ const http_wait_strategy_1 = require("./http-wait-strategy");
 const health_check_wait_strategy_1 = require("./health-check-wait-strategy");
 const log_wait_strategy_1 = require("./log-wait-strategy");
 const shell_wait_strategy_1 = require("./shell-wait-strategy");
+const host_port_wait_strategy_1 = require("./host-port-wait-strategy");
+const composite_wait_strategy_1 = require("./composite-wait-strategy");
 class Wait {
+    static forAll(waitStrategies) {
+        return new composite_wait_strategy_1.CompositeWaitStrategy(waitStrategies);
+    }
+    static forListeningPorts() {
+        return new host_port_wait_strategy_1.HostPortWaitStrategy();
+    }
     static forLogMessage(message, times = 1) {
         return new log_wait_strategy_1.LogWaitStrategy(message, times);
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "testcontainers",
   "author": "Cristian Greco",
-  "version": "9.4.0",
+  "version": "9.6.0",
   "main": "dist/src/index",
   "types": "dist/src/index",
   "keywords": [
@@ -27,8 +27,8 @@
     "build": "npm run clean && tsc -p tsconfig.prod.json",
     "docs:serve": "docker-compose up",
     "clean": "rimraf dist",
-    "test": "cross-env DEBUG=testcontainers,testcontainers:exec,testcontainers:containers jest",
-    "test:ci": "cross-env DEBUG=testcontainers,testcontainers:exec,testcontainers:containers jest --runInBand --coverage",
+    "test": "cross-env DEBUG=testcontainers* jest",
+    "test:ci": "npm run test -- --runInBand --coverage",
     "format": "prettier --write package.json \"src/**/*.ts\"",
     "lint": "eslint --fix package.json \"src/**/*.ts\"",
     "lint:ci": "eslint package.json \"src/**/*.ts\" --max-warnings=0",

package/dist/src/docker/functions/image/list-images.d.ts

@@ -1,3 +0,0 @@
-import { DockerImageName } from "../../../docker-image-name";
-import Dockerode from "dockerode";
-export declare const listImages: (dockerode: Dockerode) => Promise<DockerImageName[]>;

package/dist/src/docker/functions/image/list-images.js

@@ -1,34 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.listImages = void 0;
-const docker_image_name_1 = require("../../../docker-image-name");
-const logger_1 = require("../../../logger");
-const listImages = (dockerode) => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        const images = yield dockerode.listImages();
-        return images.reduce((dockerImageNames, image) => {
-            var _a;
-            if (isDanglingImage(image)) {
-                return dockerImageNames;
-            }
-            const repoTags = (_a = image.RepoTags) !== null && _a !== void 0 ? _a : [];
-            const dockerImageNamesForImage = repoTags.map((imageRepoTag) => docker_image_name_1.DockerImageName.fromString(imageRepoTag));
-            return [...dockerImageNames, ...dockerImageNamesForImage];
-        }, []);
-    }
-    catch (err) {
-        logger_1.log.error(`Failed to list images: ${err}`);
-        throw err;
-    }
-});
-exports.listImages = listImages;
-const isDanglingImage = (image) => image.RepoTags === null;

package/dist/src/wait-strategy/default-wait-strategy.d.ts

@@ -1,3 +0,0 @@
-import Dockerode from "dockerode";
-import { HostPortWaitStrategy } from "./host-port-wait-strategy";
-export declare const defaultWaitStrategy: (host: string, container: Dockerode.Container) => HostPortWaitStrategy;

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

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultWaitStrategy = void 0;
-const host_port_wait_strategy_1 = require("./host-port-wait-strategy");
-const port_check_1 = require("../port-check");
-const defaultWaitStrategy = (host, container) => new host_port_wait_strategy_1.HostPortWaitStrategy(new port_check_1.HostPortCheck(host), new port_check_1.InternalPortCheck(container));
-exports.defaultWaitStrategy = defaultWaitStrategy;