testcontainers 12.0.3 → 12.0.4

package/build/container-runtime/clients/container/docker-container-client.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DockerContainerClient = void 0;
 const stream_1 = require("stream");
+const promises_1 = require("stream/promises");
 const common_1 = require("../../../common");
 class DockerContainerClient {
     dockerode;
@@ -216,11 +217,18 @@ class DockerContainerClient {
             };
             processStream(stdoutStream, stdoutChunks);
             processStream(stderrStream, stderrChunks);
-            await new Promise((res, rej) => {
-                stream.on("end", res);
-                stream.on("error", rej);
-            });
-            stream.destroy();
+            try {
+                await new Promise((res, rej) => {
+                    stream.on("end", res);
+                    stream.on("error", rej);
+                });
+                stdoutStream.end();
+                stderrStream.end();
+                await Promise.all([(0, promises_1.finished)(stdoutStream), (0, promises_1.finished)(stderrStream)]);
+            }
+            finally {
+                stream.destroy();
+            }
             const inspectResult = await exec.inspect();
             const exitCode = inspectResult.ExitCode ?? -1;
             const output = outputChunks.join("");

package/build/version.d.ts

@@ -1 +1 @@
-export declare const LIB_VERSION = "12.0.3";
+export declare const LIB_VERSION = "12.0.4";

package/build/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LIB_VERSION = void 0;
-exports.LIB_VERSION = "12.0.3";
+exports.LIB_VERSION = "12.0.4";

package/build/wait-strategies/http-wait-strategy.d.ts

@@ -23,10 +23,10 @@ export declare class HttpWaitStrategy extends AbstractWaitStrategy {
         [key: string]: string;
     }): this;
     withBasicCredentials(username: string, password: string): this;
-    withReadTimeout(startupTimeoutMs: number): this;
+    withReadTimeout(readTimeoutMs: number): this;
     usingTls(): this;
     allowInsecure(): this;
     waitUntilReady(container: Dockerode.Container, boundPorts: BoundPorts): Promise<void>;
     private handleContainerExit;
-    private getAgent;
+    private createInsecureAgent;
 }

package/build/wait-strategies/http-wait-strategy.js

@@ -47,8 +47,8 @@ class HttpWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
         this.headers = { ...this.headers, Authorization: `Basic ${base64Encoded}` };
         return this;
     }
-    withReadTimeout(startupTimeoutMs) {
-        this.readTimeoutMs = startupTimeoutMs;
+    withReadTimeout(readTimeoutMs) {
+        this.readTimeoutMs = readTimeoutMs;
         return this;
     }
     usingTls() {
@@ -65,50 +65,60 @@ class HttpWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
         let containerExited = false;
         const client = await (0, container_runtime_1.getContainerRuntimeClient)();
         const { abortOnContainerExit } = this.options;
-        await new common_1.IntervalRetry(this.readTimeoutMs).retryUntil(async () => {
-            try {
-                const url = `${this.protocol}://${client.info.containerRuntime.host}:${boundPorts.getBinding(this.port)}${this.path}`;
-                if (abortOnContainerExit) {
-                    const containerStatus = (await client.container.inspect(container)).State.Status;
-                    if (containerStatus === exitStatus) {
-                        containerExited = true;
-                        return;
+        // Scoped per invocation: one strategy instance can drive concurrent waits, so a shared
+        // agent would let one finished wait destroy a dispatcher another is still using.
+        const agent = this.createInsecureAgent();
+        try {
+            await new common_1.IntervalRetry(this.readTimeoutMs).retryUntil(async () => {
+                try {
+                    const url = `${this.protocol}://${client.info.containerRuntime.host}:${boundPorts.getBinding(this.port)}${this.path}`;
+                    if (abortOnContainerExit) {
+                        const containerStatus = (await client.container.inspect(container)).State.Status;
+                        if (containerStatus === exitStatus) {
+                            containerExited = true;
+                            return;
+                        }
                     }
+                    return (0, undici_response_parser_1.undiciResponseToFetchResponse)(await (0, undici_1.request)(url, {
+                        method: this.method,
+                        signal: AbortSignal.timeout(this.readTimeoutMs),
+                        headers: this.headers,
+                        dispatcher: agent,
+                    }));
+                }
+                catch {
+                    return undefined;
+                }
+            }, async (response) => {
+                if (abortOnContainerExit && containerExited) {
+                    return true;
+                }
+                if (response === undefined) {
+                    return false;
                 }
-                return (0, undici_response_parser_1.undiciResponseToFetchResponse)(await (0, undici_1.request)(url, {
-                    method: this.method,
-                    signal: AbortSignal.timeout(this.readTimeoutMs),
-                    headers: this.headers,
-                    dispatcher: this.getAgent(),
-                }));
-            }
-            catch {
-                return undefined;
-            }
-        }, async (response) => {
-            if (abortOnContainerExit && containerExited) {
-                return true;
-            }
-            if (response === undefined) {
-                return false;
-            }
-            else if (!this.predicates.length) {
-                return response.ok;
-            }
-            else {
-                for (const predicate of this.predicates) {
-                    const result = await predicate(response);
-                    if (!result) {
-                        return false;
+                else if (!this.predicates.length) {
+                    return response.ok;
+                }
+                else {
+                    for (const predicate of this.predicates) {
+                        const result = await predicate(response);
+                        if (!result) {
+                            return false;
+                        }
                     }
+                    return true;
                 }
-                return true;
-            }
-        }, () => {
-            const message = `URL ${this.path} not accessible after ${this.startupTimeoutMs}ms`;
-            common_1.log.error(message, { containerId: container.id });
-            throw new Error(message);
-        }, this.startupTimeoutMs);
+            }, () => {
+                const message = `URL ${this.path} not accessible after ${this.startupTimeoutMs}ms`;
+                common_1.log.error(message, { containerId: container.id });
+                throw new Error(message);
+            }, this.startupTimeoutMs);
+        }
+        finally {
+            // Force-close: status-only predicates never read the body, so a graceful close() could
+            // hang waiting on unreleased connections. Nothing left to drain once the wait is done.
+            await agent?.destroy();
+        }
         if (abortOnContainerExit && containerExited) {
             return this.handleContainerExit(container);
         }
@@ -132,14 +142,15 @@ class HttpWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
         common_1.log.error(message, { containerId: container.id });
         throw new Error(message);
     }
-    getAgent() {
-        if (this._allowInsecure) {
-            return new undici_1.Agent({
-                connect: {
-                    rejectUnauthorized: false,
-                },
-            });
+    createInsecureAgent() {
+        if (!this._allowInsecure) {
+            return undefined;
         }
+        return new undici_1.Agent({
+            connect: {
+                rejectUnauthorized: false,
+            },
+        });
     }
 }
 exports.HttpWaitStrategy = HttpWaitStrategy;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testcontainers",
-  "version": "12.0.3",
+  "version": "12.0.4",
   "author": "Cristian Greco",
   "license": "MIT",
   "keywords": [
@@ -38,13 +38,13 @@
     "debug": "^4.4.3",
     "docker-compose": "^1.4.2",
     "dockerode": "^5.0.0",
-    "get-port": "^7.2.0",
+    "get-port": "^5.1.1",
     "proper-lockfile": "^4.1.2",
     "properties-reader": "^3.0.1",
     "ssh-remote-port-forward": "^1.0.4",
     "tar-fs": "^3.1.2",
     "tmp": "^0.2.7",
-    "undici": "^8.3.0"
+    "undici": "^8.5.0"
   },
   "devDependencies": {
     "@types/archiver": "^7.0.0",