testcontainers 9.1.2 → 9.1.3

package/README.md

@@ -793,7 +793,7 @@ const { GenericContainer } = require("testcontainers");
 
 const container = await new GenericContainer("redis")
   .withExposedPorts(6379)
-  .withStartupTimeout(120000)
+  .withStartupTimeout(120000) // wait 120s 
   .start();
 ```
 

package/dist/docker/functions/container/container-logs.d.ts

@@ -1,3 +1,3 @@
 import Dockerode from "dockerode";
 import { Readable } from "stream";
-export declare const containerLogs: (container: Dockerode.Container) => Promise<Readable>;
+export declare const containerLogs: (container: Dockerode.Container, options?: Omit<Dockerode.ContainerLogsOptions, "follow" | "stdout" | "stderr">) => Promise<Readable>;

package/dist/docker/functions/container/container-logs.js

@@ -13,9 +13,9 @@ exports.containerLogs = void 0;
 const logger_1 = require("../../../logger");
 const demux_stream_1 = require("../demux-stream");
 const docker_client_1 = require("../../docker-client");
-const containerLogs = (container) => __awaiter(void 0, void 0, void 0, function* () {
+const containerLogs = (container, options) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        const stream = (yield container.logs({ follow: true, stdout: true, stderr: true }));
+        const stream = (yield container.logs(Object.assign({ follow: true, stdout: true, stderr: true }, options)));
         stream.socket.unref();
         return (0, demux_stream_1.demuxStream)((yield (0, docker_client_1.dockerClient)()).dockerode, stream);
     }

package/dist/docker/functions/container/inspect-container.d.ts

@@ -11,6 +11,8 @@ export declare type InspectResult = {
     state: {
         status: string;
         running: boolean;
+        startedAt: Date;
+        finishedAt: Date | undefined;
     };
     labels: Labels;
 };

package/dist/docker/functions/container/inspect-container.js

@@ -14,13 +14,19 @@ const logger_1 = require("../../../logger");
 const inspectContainer = (container) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const inspectResult = yield container.inspect();
+        const finishedAt = new Date(inspectResult.State.FinishedAt);
         return {
             name: inspectResult.Name,
             hostname: inspectResult.Config.Hostname,
             ports: getPorts(inspectResult),
             healthCheckStatus: getHealthCheckStatus(inspectResult),
             networkSettings: getNetworkSettings(inspectResult),
-            state: { status: inspectResult.State.Status, running: inspectResult.State.Running },
+            state: {
+                status: inspectResult.State.Status,
+                running: inspectResult.State.Running,
+                startedAt: new Date(inspectResult.State.StartedAt),
+                finishedAt: finishedAt.getTime() < 0 ? undefined : finishedAt,
+            },
             labels: inspectResult.Config.Labels,
         };
     }

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

@@ -59,7 +59,7 @@ export declare class GenericContainer implements TestContainer {
     withExposedPorts(...ports: PortWithOptionalBinding[]): this;
     withBindMounts(bindMounts: BindMount[]): this;
     withHealthCheck(healthCheck: HealthCheck): this;
-    withStartupTimeout(startupTimeout: number): this;
+    withStartupTimeout(startupTimeoutMs: number): this;
     withWaitStrategy(waitStrategy: WaitStrategy): this;
     withDefaultLogDriver(): this;
     withPrivilegedMode(): this;

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

@@ -14,6 +14,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GenericContainer = void 0;
 const archiver_1 = __importDefault(require("archiver"));
+const async_lock_1 = __importDefault(require("async-lock"));
 const bound_ports_1 = require("../bound-ports");
 const logger_1 = require("../logger");
 const pull_policy_1 = require("../pull-policy");
@@ -36,6 +37,7 @@ const hash_1 = require("../hash");
 const get_container_1 = require("../docker/functions/container/get-container");
 const labels_1 = require("../labels");
 const wait_for_container_1 = require("../wait-for-container");
+const reusableContainerCreationLock = new async_lock_1.default();
 class GenericContainer {
     constructor(image) {
         this.image = image;
@@ -101,15 +103,20 @@ class GenericContainer {
                 const containerHash = (0, hash_1.hash)(JSON.stringify(createContainerOptions));
                 createContainerOptions.labels = Object.assign(Object.assign({}, createContainerOptions.labels), { [labels_1.LABEL_CONTAINER_HASH]: containerHash });
                 logger_1.log.debug(`Container reuse has been enabled, hash: ${containerHash}`);
-                const container = yield (0, get_container_1.getContainerByHash)(containerHash);
-                if (container !== undefined) {
-                    logger_1.log.debug(`Found container to reuse with hash: ${containerHash}`);
-                    return this.reuseContainer(container);
-                }
-                else {
-                    logger_1.log.debug("No container found to reuse");
-                    return this.startContainer(createContainerOptions);
-                }
+                // We might have several async processes try to create a reusable container
+                // at once, to avoid possibly creating too many of these, use a lock
+                // on the containerHash, this ensures that only single reusable instance is created
+                return reusableContainerCreationLock.acquire(containerHash, () => __awaiter(this, void 0, void 0, function* () {
+                    const container = yield (0, get_container_1.getContainerByHash)(containerHash);
+                    if (container !== undefined) {
+                        logger_1.log.debug(`Found container to reuse with hash: ${containerHash}`);
+                        return this.reuseContainer(container);
+                    }
+                    else {
+                        logger_1.log.debug("No container found to reuse");
+                        return this.startContainer(createContainerOptions);
+                    }
+                }));
             }
             else {
                 return this.startContainer(createContainerOptions);
@@ -240,8 +247,8 @@ class GenericContainer {
         this.healthCheck = healthCheck;
         return this;
     }
-    withStartupTimeout(startupTimeout) {
-        this.startupTimeout = startupTimeout;
+    withStartupTimeout(startupTimeoutMs) {
+        this.startupTimeout = startupTimeoutMs;
         return this;
     }
     withWaitStrategy(waitStrategy) {

package/dist/http-wait-strategy.js

@@ -81,7 +81,7 @@ class HttpWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
                 catch (_a) {
                     return undefined;
                 }
-            }), (response) => {
+            }), (response) => __awaiter(this, void 0, void 0, function* () {
                 if (response === undefined) {
                     return false;
                 }
@@ -89,9 +89,15 @@ class HttpWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
                     return response.ok;
                 }
                 else {
-                    return this.predicates.every((predicate) => predicate(response));
+                    for (const predicate of this.predicates) {
+                        const result = yield predicate(response);
+                        if (!result) {
+                            return false;
+                        }
+                    }
+                    return true;
                 }
-            }, () => {
+            }), () => {
                 throw new Error(`URL ${this.path} not accessible after ${this.startupTimeout}ms for ${container.id}`);
             }, this.startupTimeout);
         });

package/dist/retry-strategy.d.ts

@@ -1,17 +1,17 @@
 import { Clock, Time } from "./clock";
 export interface RetryStrategy<T, U> {
-    retryUntil(fn: () => Promise<T>, predicate: (result: T) => boolean, onTimeout: () => U, timeout: number): Promise<T | U>;
+    retryUntil(fn: () => Promise<T>, predicate: (result: T) => boolean | Promise<boolean>, onTimeout: () => U, timeout: number): Promise<T | U>;
 }
 declare abstract class AbstractRetryStrategy<T, U> implements RetryStrategy<T, U> {
     protected readonly clock: Clock;
     protected constructor(clock?: Clock);
-    abstract retryUntil(fn: () => Promise<T>, predicate: (result: T) => boolean, onTimeout: () => U, timeout: number): Promise<T | U>;
+    abstract retryUntil(fn: () => Promise<T>, predicate: (result: T) => boolean | Promise<boolean>, onTimeout: () => U, timeout: number): Promise<T | U>;
     protected hasTimedOut(timeout: number, startTime: Time): boolean;
     protected wait(duration: number): Promise<void>;
 }
 export declare class IntervalRetryStrategy<T, U> extends AbstractRetryStrategy<T, U> {
     private readonly interval;
     constructor(interval: number);
-    retryUntil(fn: (attempt: number) => Promise<T>, predicate: (result: T) => boolean, onTimeout: () => U, timeout: number): Promise<T | U>;
+    retryUntil(fn: (attempt: number) => Promise<T>, predicate: (result: T) => boolean | Promise<boolean>, onTimeout: () => U, timeout: number): Promise<T | U>;
 }
 export {};

package/dist/retry-strategy.js

@@ -32,7 +32,7 @@ class IntervalRetryStrategy extends AbstractRetryStrategy {
             const startTime = this.clock.getTime();
             let attemptNumber = 0;
             let result = yield fn(attemptNumber++);
-            while (!predicate(result)) {
+            while (!(yield predicate(result))) {
                 if (this.hasTimedOut(timeout, startTime)) {
                     return onTimeout();
                 }

package/dist/test-container.d.ts

@@ -17,7 +17,7 @@ export interface TestContainer {
     withExposedPorts(...ports: PortWithOptionalBinding[]): this;
     withBindMounts(bindMounts: BindMount[]): this;
     withWaitStrategy(waitStrategy: WaitStrategy): this;
-    withStartupTimeout(startupTimeout: number): this;
+    withStartupTimeout(startupTimeoutMs: number): this;
     withNetwork(network: StartedNetwork): this;
     withNetworkMode(networkMode: string): this;
     withExtraHosts(extraHosts: ExtraHost[]): this;

package/dist/wait-strategy.d.ts

@@ -23,6 +23,8 @@ export declare type Log = string;
 export declare class LogWaitStrategy extends AbstractWaitStrategy {
     private readonly message;
     constructor(message: Log | RegExp);
+    private containerRestartedLogOptions;
+    private hasContainerRestarted;
     waitUntilReady(container: Dockerode.Container): Promise<void>;
 }
 export declare class HealthCheckWaitStrategy extends AbstractWaitStrategy {

package/dist/wait-strategy.js

@@ -74,10 +74,26 @@ class LogWaitStrategy extends AbstractWaitStrategy {
         super();
         this.message = message;
     }
+    containerRestartedLogOptions(inspectResult) {
+        const { finishedAt } = inspectResult.state;
+        if (finishedAt === undefined) {
+            return undefined;
+        }
+        return {
+            since: finishedAt.getTime() / 1000,
+            timestamps: true,
+        };
+    }
+    hasContainerRestarted(inspectResult) {
+        const { finishedAt, status } = inspectResult.state;
+        return finishedAt !== undefined && status === "running";
+    }
     waitUntilReady(container) {
         return __awaiter(this, void 0, void 0, function* () {
             logger_1.log.debug(`Waiting for log message "${this.message}"`);
-            const stream = yield (0, container_logs_1.containerLogs)(container);
+            const inspect = yield (0, inspect_container_1.inspectContainer)(container);
+            const logsOptions = this.hasContainerRestarted(inspect) ? this.containerRestartedLogOptions(inspect) : undefined;
+            const stream = yield (0, container_logs_1.containerLogs)(container, logsOptions);
             return new Promise((resolve, reject) => {
                 const startupTimeout = this.startupTimeout;
                 const timeout = setTimeout(() => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "testcontainers",
   "author": "Cristian Greco",
-  "version": "9.1.2",
+  "version": "9.1.3",
   "main": "dist/index",
   "types": "dist/index",
   "keywords": [
@@ -35,26 +35,28 @@
   "dependencies": {
     "@balena/dockerignore": "^1.0.2",
     "@types/archiver": "^5.3.1",
-    "@types/dockerode": "^3.3.12",
+    "@types/dockerode": "^3.3.14",
     "archiver": "^5.3.1",
+    "async-lock": "^1.4.0",
     "byline": "^5.0.0",
     "debug": "^4.3.4",
-    "docker-compose": "^0.23.17",
+    "docker-compose": "^0.23.19",
     "dockerode": "^3.3.4",
     "get-port": "^5.1.1",
-    "node-fetch": "^2.6.7",
+    "node-fetch": "^2.6.9",
     "properties-reader": "^2.2.0",
     "ssh-remote-port-forward": "^1.0.4",
     "tar-fs": "^2.1.1"
   },
   "devDependencies": {
     "@elastic/elasticsearch": "^7.17.0",
+    "@types/async-lock": "^1.4.0",
     "@types/byline": "^4.2.33",
     "@types/debug": "4.1.7",
-    "@types/jest": "^29.2.0",
-    "@types/node": "^18.11.7",
+    "@types/jest": "^29.2.6",
+    "@types/node": "^18.11.19",
     "@types/node-fetch": "^2.6.2",
-    "@types/pg": "^8.6.5",
+    "@types/pg": "^8.6.6",
     "@types/properties-reader": "^2.1.1",
     "@types/tar-fs": "^2.0.1",
     "@typescript-eslint/eslint-plugin": "^5.41.0",
@@ -63,18 +65,18 @@
     "cross-env": "^7.0.3",
     "eslint": "^8.26.0",
     "eslint-config-prettier": "^8.5.0",
-    "husky": "^8.0.1",
+    "husky": "^8.0.3",
     "jest": "^29.2.2",
-    "kafkajs": "^2.2.2",
-    "lint-staged": "^13.0.3",
+    "kafkajs": "^2.2.3",
+    "lint-staged": "^13.0.4",
+    "mongoose": "^6.7.5",
     "mysql2": "^2.3.3",
-    "mongoose": "^6.7.0",
     "nats": "^2.8.0",
     "neo4j-driver": "^5.2.0",
     "pg": "^8.8.0",
     "prettier": "^2.7.1",
     "rimraf": "^3.0.2",
-    "ts-jest": "^29.0.3",
+    "ts-jest": "^29.0.5",
     "ts-node": "^10.9.1",
     "typescript": "^4.8.4",
     "wait-for-expect": "^3.0.2"