testcontainers 9.5.0 → 9.7.0

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/modules/nats/nats-container.js

@@ -19,7 +19,7 @@ const HTTP_MANAGEMENT_PORT = 8222;
 const USER_ARGUMENT_KEY = "--user";
 const PASS_ARGUMENT_KEY = "--pass";
 class NatsContainer extends generic_container_1.GenericContainer {
-    constructor(image = "nats:2.8-alpine") {
+    constructor(image = "nats:2.8.4-alpine") {
         super(image);
         this.args = {};
         this.args[USER_ARGUMENT_KEY] = "test";

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,19 @@ 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 name = this.uuid.nextUuid();
+            const options = Object.assign({ name, 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);
-            logger_1.log.info(`Started network with ID: ${id}`);
-            return new StartedNetwork(id, this.createNetworkOptions);
+            logger_1.log.info(`Starting network "${name}"...`);
+            const id = yield (0, create_network_1.createNetwork)(options);
+            logger_1.log.info(`Started network "${name}" with ID "${id}"`);
+            return new StartedNetwork(id, options);
         });
     }
 }
@@ -42,8 +47,9 @@ class StartedNetwork {
     }
     stop() {
         return __awaiter(this, void 0, void 0, function* () {
-            logger_1.log.info(`Stopping network with ID: ${this.id}`);
+            logger_1.log.info(`Stopping network with ID "${this.id}"...`);
             yield (0, remove_network_1.removeNetwork)(this.id);
+            logger_1.log.info(`Stopped network with ID "${this.id}"`);
             return new StoppedNetwork();
         });
     }

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,14 +54,16 @@ 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);
                 if (!shellExists) {
                     if (!this.isDistroless) {
                         this.isDistroless = true;
-                        logger_1.log.error(`The HostPortWaitStrategy will not work on a distroless image, use an alternate wait strategy for container ${this.container.id}`);
+                        logger_1.log.error(`The HostPortWaitStrategy will not work on a distroless image, use an alternate wait strategy`, {
+                            containerId: this.container.id,
+                        });
                     }
                 }
                 else {
@@ -68,7 +72,9 @@ class InternalPortCheck {
                         .filter((result) => result.exitCode !== 126 && result.output.length > 0)
                         .forEach((result) => {
                         if (!this.commandOutputs.has(this.commandOutputsKey(result.output))) {
-                            logger_1.log.trace(`Port check result for container ${this.container.id} exit code ${result.exitCode}: ${result.output}`);
+                            logger_1.log.trace(`Port check result exit code ${result.exitCode}: ${result.output}`, {
+                                containerId: this.container.id,
+                            });
                             this.commandOutputs.add(this.commandOutputsKey(result.output));
                         }
                     });

package/dist/src/port-forwarder.js

@@ -24,8 +24,9 @@ class PortForwarder {
     }
     exposeHostPort(port) {
         return __awaiter(this, void 0, void 0, function* () {
-            logger_1.log.info(`Exposing host port ${port}`);
+            logger_1.log.info(`Exposing host port ${port}...`);
             yield this.sshConnection.remoteForward("localhost", port);
+            logger_1.log.info(`Exposed host port ${port}`);
         });
     }
     getNetworkId() {
@@ -53,7 +54,7 @@ class PortForwarderInstance {
     }
     static createInstance() {
         return __awaiter(this, void 0, void 0, function* () {
-            logger_1.log.debug(`Creating new Port Forwarder`);
+            logger_1.log.debug(`Creating new Port Forwarder...`);
             const username = "root";
             const password = new uuid_1.RandomUuid().nextUuid();
             const containerPort = process.env["TESTCONTAINERS_SSHD_PORT"]
@@ -71,8 +72,9 @@ class PortForwarderInstance {
                 .start();
             const host = (yield (0, docker_client_1.dockerClient)()).host;
             const port = container.getMappedPort(22);
-            logger_1.log.debug(`Connecting to Port Forwarder on ${host}:${port}`);
+            logger_1.log.debug(`Connecting to Port Forwarder on "${host}:${port}"...`);
             const connection = yield (0, ssh_remote_port_forward_1.createSshConnection)({ host, port, username, password });
+            logger_1.log.debug(`Connected to Port Forwarder on "${host}:${port}"`);
             connection.unref();
             return new PortForwarder(connection, container);
         });

package/dist/src/reaper.js

@@ -77,7 +77,7 @@ class ReaperInstance {
         return process.env.TESTCONTAINERS_RYUK_PRIVILEGED === "true";
     }
     static createDisabledInstance() {
-        logger_1.log.debug(`Not creating new Reaper for session: ${session_id_1.sessionId}`);
+        logger_1.log.debug(`Not creating new Reaper for session "${session_id_1.sessionId}"`);
         return Promise.resolve(new DisabledReaper());
     }
     static createRealInstance() {
@@ -85,7 +85,7 @@ class ReaperInstance {
             const containerPort = process.env["TESTCONTAINERS_RYUK_PORT"]
                 ? { container: 8080, host: Number(process.env["TESTCONTAINERS_RYUK_PORT"]) }
                 : 8080;
-            logger_1.log.debug(`Creating new Reaper for session: ${session_id_1.sessionId}`);
+            logger_1.log.debug(`Creating new Reaper for session "${session_id_1.sessionId}"...`);
             const container = new generic_container_1.GenericContainer(images_1.REAPER_IMAGE)
                 .withName(`testcontainers-ryuk-${session_id_1.sessionId}`)
                 .withExposedPorts(containerPort)
@@ -106,7 +106,7 @@ class ReaperInstance {
             const retryStrategy = new retry_strategy_1.IntervalRetryStrategy(1000);
             const retryResult = yield retryStrategy.retryUntil((attempt) => {
                 return new Promise((resolve) => {
-                    logger_1.log.debug(`Connecting to Reaper (attempt ${attempt + 1}) ${containerId} on ${host}:${port}`);
+                    logger_1.log.debug(`Connecting to Reaper (attempt ${attempt + 1}) on "${host}:${port}"...`, { containerId });
                     const socket = new net_1.Socket();
                     socket
                         .unref()
@@ -114,21 +114,25 @@ class ReaperInstance {
                         .on("error", (err) => logger_1.log.error(`Reaper ${containerId} socket error: ${err}`))
                         .on("close", (hadError) => {
                         if (hadError) {
-                            logger_1.log.error(`Connection to Reaper ${containerId} closed with error`);
+                            logger_1.log.error(`Connection to Reaper closed with error`, { containerId });
                         }
                         else {
-                            logger_1.log.warn(`Connection to Reaper ${containerId} closed`);
+                            logger_1.log.warn(`Connection to Reaper closed`, { containerId });
                         }
                         resolve(undefined);
                     })
                         .connect((0, port_1.getContainerPort)(port), host, () => {
-                        logger_1.log.debug(`Connected to Reaper ${containerId}`);
+                        logger_1.log.debug(`Connected to Reaper`, { containerId });
                         socket.write(`label=${labels_1.LABEL_TESTCONTAINERS_SESSION_ID}=${session_id_1.sessionId}\r\n`);
                         const reaper = new RealReaper(startedContainer, socket);
                         resolve(reaper);
                     });
                 });
-            }, (result) => result !== undefined, () => new Error(`Failed to connect to Reaper ${containerId}`), 4000);
+            }, (result) => result !== undefined, () => {
+                const message = `Failed to connect to Reaper`;
+                logger_1.log.error(message, { containerId });
+                return new Error(message);
+            }, 4000);
             if (retryResult instanceof RealReaper) {
                 return retryResult;
             }

package/dist/src/registry-auth-locator/credential-provider.js

@@ -21,20 +21,18 @@ class CredentialProvider {
                 return undefined;
             }
             const programName = `docker-credential-${credentialProviderName}`;
-            logger_1.log.debug(`Executing Docker credential provider: ${programName}`);
+            logger_1.log.debug(`Executing Docker credential provider "${programName}"`);
             const credentials = yield this.listCredentials(programName);
             if (!Object.keys(credentials).some((aRegistry) => (0, registry_matches_1.registryMatches)(aRegistry, registry))) {
-                logger_1.log.debug(`No credential found for registry: "${registry}"`);
+                logger_1.log.debug(`No credential found for registry "${registry}"`);
                 return undefined;
             }
             const response = yield this.runCredentialProvider(registry, programName);
-            const authConfig = {
+            return {
                 username: response.Username,
                 password: response.Secret,
                 registryAddress: response.ServerURL,
             };
-            logger_1.log.debug(`Docker credential provider found auth config for ${registry}`);
-            return authConfig;
         });
     }
     listCredentials(providerName) {

package/dist/src/registry-auth-locator/get-auth-config.js

@@ -47,18 +47,18 @@ const registryAuthLocators = [new cred_helpers_1.CredHelpers(), new creds_store_
 const authsCache = new Map();
 const getAuthConfig = (registry) => __awaiter(void 0, void 0, void 0, function* () {
     if (authsCache.has(registry)) {
-        logger_1.log.debug(`Re-using cached auth for registry ${registry}`);
+        logger_1.log.debug(`Auth config cache hit for registry "${registry}"`);
         return authsCache.get(registry);
     }
     for (const registryAuthLocator of registryAuthLocators) {
         const authConfig = yield registryAuthLocator.getAuthConfig(registry, yield dockerConfig);
         if (authConfig) {
-            logger_1.log.debug(`Found applicable registry auth locator for registry "${registry}": ${registryAuthLocator.getName()}`);
+            logger_1.log.debug(`Auth config found for registry "${registry}": ${registryAuthLocator.getName()}`);
             authsCache.set(registry, authConfig);
             return authConfig;
         }
     }
-    logger_1.log.debug(`No registry auth locator found for registry: "${registry}"`);
+    logger_1.log.debug(`No registry auth locator found for registry "${registry}"`);
     authsCache.set(registry, undefined);
     return undefined;
 });

package/dist/src/system-info.js

@@ -19,15 +19,12 @@ const getSystemInfo = (dockerode) => __awaiter(void 0, void 0, void 0, function*
     if (systemInfo !== undefined) {
         return systemInfo;
     }
-    logger_1.log.debug("Fetching system info");
+    logger_1.log.debug("Fetching system info...");
     const nodeInfo = getNodeInfo();
     const dockerInfo = yield (0, get_info_1.getDockerInfo)(dockerode);
     const dockerComposeInfo = yield getDockerComposeInfo();
     systemInfo = { nodeInfo, dockerInfo, dockerComposeInfo };
-    logger_1.log.debug(`System info:
-  System: Node version: ${nodeInfo.version}, Platform: ${nodeInfo.platform}, Arch: ${nodeInfo.architecture}
-  Container runtime: OS: ${dockerInfo.operatingSystem}, Version: ${dockerInfo.serverVersion}, Arch: ${dockerInfo.architecture}, CPUs: ${dockerInfo.cpus}, Memory: ${dockerInfo.memory} 
-  Compose: Installed: ${dockerComposeInfo !== undefined}, Version: ${(_a = dockerComposeInfo === null || dockerComposeInfo === void 0 ? void 0 : dockerComposeInfo.version) !== null && _a !== void 0 ? _a : "N/A"}`);
+    logger_1.log.debug(`Node version: ${nodeInfo.version}, Platform: ${nodeInfo.platform}, Arch: ${nodeInfo.architecture}, OS: ${dockerInfo.operatingSystem}, Version: ${dockerInfo.serverVersion}, Arch: ${dockerInfo.architecture}, CPUs: ${dockerInfo.cpus}, Memory: ${dockerInfo.memory}, Compose installed: ${dockerComposeInfo !== undefined}, Compose version: ${(_a = dockerComposeInfo === null || dockerComposeInfo === void 0 ? void 0 : dockerComposeInfo.version) !== null && _a !== void 0 ? _a : "N/A"}`);
     return systemInfo;
 });
 exports.getSystemInfo = getSystemInfo;

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

@@ -30,6 +30,7 @@ export interface TestContainer {
     withCopyContentToContainer(contentsToCopy: ContentToCopy[]): this;
     withWorkingDir(workingDir: string): this;
     withResourcesQuota(resourcesQuota: ResourcesQuota): this;
+    withLogConsumer(logConsumer: (stream: Readable) => unknown): this;
 }
 export interface RestartOptions {
     timeout: number;
@@ -42,11 +43,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 +55,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/uuid.js

@@ -7,7 +7,7 @@ exports.RandomUuid = void 0;
 const crypto_1 = __importDefault(require("crypto"));
 class RandomUuid {
     nextUuid() {
-        return crypto_1.default.randomUUID();
+        return crypto_1.default.createHash("md5").update(crypto_1.default.randomUUID()).digest("hex").substring(0, 12);
     }
 }
 exports.RandomUuid = RandomUuid;

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,20 +13,20 @@ 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* () {
-    logger_1.log.debug(`Waiting for container to be ready: ${container.id}`);
+const waitForContainer = (container, waitStrategy, boundPorts, startTime) => __awaiter(void 0, void 0, void 0, function* () {
+    logger_1.log.debug(`Waiting for container to be ready...`, { containerId: container.id });
     try {
-        yield waitStrategy.waitUntilReady(container, host, boundPorts, startTime);
-        logger_1.log.info(`Container is ready: ${container.id}`);
+        yield waitStrategy.waitUntilReady(container, boundPorts, startTime);
+        logger_1.log.info(`Container is ready`, { containerId: container.id });
     }
     catch (err) {
-        logger_1.log.error(`Container failed to be ready: ${container.id}: ${err}`);
+        logger_1.log.error(`Container failed to be ready: ${err}`, { containerId: container.id });
         try {
             yield (0, stop_container_1.stopContainer)(container, { timeout: 0 });
             yield (0, remove_container_1.removeContainer)(container, { removeVolumes: true });
         }
         catch (stopErr) {
-            logger_1.log.error(`Failed to stop container after it failed to be ready: ${container.id}: ${stopErr}`);
+            logger_1.log.error(`Failed to stop container after it failed to be ready: ${stopErr}`, { containerId: container.id });
         }
         throw 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(`Waiting for composite...`, { containerId: 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`;
+                        logger_1.log.error(message, { containerId: container.id });
+                        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.isStartupTimeoutSet())
+            .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

@@ -17,13 +17,17 @@ const wait_strategy_1 = require("./wait-strategy");
 class HealthCheckWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
     waitUntilReady(container) {
         return __awaiter(this, void 0, void 0, function* () {
-            logger_1.log.debug(`Waiting for health check for ${container.id}`);
+            logger_1.log.debug(`Waiting for health check...`, { containerId: 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}`);
+                const message = `Health check not healthy after ${timeout}ms`;
+                logger_1.log.error(message, { containerId: container.id });
+                throw new Error(message);
             }, this.startupTimeout);
             if (status !== "healthy") {
-                throw new Error(`Health check failed: ${status} for ${container.id}`);
+                const message = `Health check failed: ${status}`;
+                logger_1.log.error(message, { containerId: container.id });
+                throw new Error(message);
             }
         });
     }

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,43 +10,47 @@ 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);
-                logger_1.log.debug(`Host port ${hostPort} ready for ${container.id}`);
+                logger_1.log.debug(`Waiting for host port ${hostPort}...`, { containerId: container.id });
+                yield this.waitForPort(container, hostPort, portCheck);
+                logger_1.log.debug(`Host port ${hostPort} ready`, { containerId: 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);
-                logger_1.log.debug(`Internal port ${internalPort} ready for ${container.id}`);
+                logger_1.log.debug(`Waiting for internal port ${internalPort}...`, { containerId: container.id });
+                yield this.waitForPort(container, internalPort, portCheck);
+                logger_1.log.debug(`Internal port ${internalPort} ready`, { containerId: container.id });
             }
         });
     }
     waitForPort(container, port, portCheck) {
         return __awaiter(this, void 0, void 0, function* () {
             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}`);
+                const message = `Port ${port} not bound after ${this.startupTimeout}ms`;
+                logger_1.log.error(message, { containerId: container.id });
+                throw new Error(message);
             }, this.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,8 @@ 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");
+const logger_1 = require("../logger");
 class HttpWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
     constructor(path, port) {
         super();
@@ -66,8 +68,10 @@ class HttpWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
         this._allowInsecure = true;
         return this;
     }
-    waitUntilReady(container, host, boundPorts) {
+    waitUntilReady(container, boundPorts) {
         return __awaiter(this, void 0, void 0, function* () {
+            logger_1.log.debug(`Waiting for HTTP...`, { containerId: container.id });
+            const { host } = yield (0, docker_client_1.dockerClient)();
             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}`;
@@ -98,7 +102,9 @@ class HttpWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
                     return true;
                 }
             }), () => {
-                throw new Error(`URL ${this.path} not accessible after ${this.startupTimeout}ms for ${container.id}`);
+                const message = `URL ${this.path} not accessible after ${this.startupTimeout}ms`;
+                logger_1.log.error(message, { containerId: container.id });
+                throw new Error(message);
             }, this.startupTimeout);
         });
     }

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,17 +23,16 @@ class LogWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
         this.message = message;
         this.times = times;
     }
-    waitUntilReady(container, host, boundPorts, startTime) {
+    waitUntilReady(container, boundPorts, startTime) {
         return __awaiter(this, void 0, void 0, function* () {
-            logger_1.log.debug(`Waiting for log message "${this.message}" for ${container.id}`);
+            logger_1.log.debug(`Waiting for log message "${this.message}"...`, { containerId: container.id });
             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);
+                    const message = `Log message "${this.message}" not received after ${this.startupTimeout}ms`;
+                    logger_1.log.error(message, { containerId: container.id });
                     reject(new Error(message));
-                }, startupTimeout);
+                }, this.startupTimeout);
                 const comparisonFn = (line) => {
                     if (this.message instanceof RegExp) {
                         return this.message.test(line);
@@ -58,7 +57,9 @@ class LogWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
                     .on("end", () => {
                     stream.destroy();
                     clearTimeout(timeout);
-                    reject(new Error(`Log stream ended and message "${this.message}" was not received for ${container.id}`));
+                    const message = `Log stream ended and message "${this.message}" was not received`;
+                    logger_1.log.error(message, { containerId: container.id });
+                    reject(new Error(message));
                 });
             });
         });