testcontainers 9.1.2 → 9.1.4-beta.0

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/package.json

@@ -0,0 +1,93 @@
+{
+    "name": "testcontainers",
+    "author": "Cristian Greco",
+    "version": "9.1.4-beta.0",
+    "main": "dist/index",
+    "types": "dist/index",
+    "keywords": [
+        "docker",
+        "testcontainers"
+    ],
+    "files": [
+        "dist"
+    ],
+    "description": "Testcontainers is a NodeJS library that supports tests, providing lightweight, throwaway instances of common databases, Selenium web browsers, or anything else that can run in a Docker container.",
+    "license": "MIT",
+    "homepage": "https://github.com/testcontainers/testcontainers-node#readme",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/testcontainers/testcontainers-node"
+    },
+    "bugs": {
+        "url": "https://github.com/testcontainers/testcontainers-node/issues"
+    },
+    "scripts": {
+        "prepare": "npm run build && husky install",
+        "pre-commit": "lint-staged",
+        "build": "npm run clean && tsc -p tsconfig.prod.json",
+        "clean": "rimraf dist",
+        "test": "cross-env DEBUG=testcontainers,testcontainers:exec jest --runInBand",
+        "format": "prettier --write package.json \"src/**/*.ts\"",
+        "lint": "eslint --fix package.json \"src/**/*.ts\"",
+        "updateDeps": "npx npm-check-updates -u",
+        "validateEngine": "npx ls-engines"
+    },
+    "dependencies": {
+        "@balena/dockerignore": "^1.0.2",
+        "@types/archiver": "^5.3.1",
+        "@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.19",
+        "dockerode": "^3.3.4",
+        "get-port": "^5.1.1",
+        "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.6",
+        "@types/node": "^18.11.19",
+        "@types/node-fetch": "^2.6.2",
+        "@types/pg": "^8.6.6",
+        "@types/properties-reader": "^2.1.1",
+        "@types/tar-fs": "^2.0.1",
+        "@typescript-eslint/eslint-plugin": "^5.41.0",
+        "@typescript-eslint/parser": "^5.41.0",
+        "arangojs": "^8.0.0",
+        "cross-env": "^7.0.3",
+        "eslint": "^8.26.0",
+        "eslint-config-prettier": "^8.5.0",
+        "husky": "^8.0.3",
+        "jest": "^29.2.2",
+        "kafkajs": "^2.2.3",
+        "lint-staged": "^13.0.4",
+        "mongoose": "^6.7.5",
+        "mysql2": "^2.3.3",
+        "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.5",
+        "ts-node": "^10.9.1",
+        "typescript": "^4.8.4",
+        "wait-for-expect": "^3.0.2"
+    },
+    "lint-staged": {
+        "src/**/*.ts": [
+            "prettier --write",
+            "eslint --fix"
+        ]
+    },
+    "engines": {
+        "node": ">= 10.16"
+    }
+}

package/dist/{docker → src/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 → src/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 → src/docker}/functions/container/get-container.js

@@ -31,7 +31,7 @@ const getContainerByHash = (hash) => __awaiter(void 0, void 0, void 0, function*
             limit: 1,
             filters: {
                 status: ["running"],
-                label: [`${labels_1.LABEL_CONTAINER_HASH}=${hash}`],
+                label: [`${labels_1.LABEL_TESTCONTAINERS_CONTAINER_HASH}=${hash}`],
             },
         });
         if (containers.length === 0) {

package/dist/{docker → src/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 → src/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/{docker → src/docker}/functions/create-labels.js

@@ -3,13 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLabels = void 0;
 const session_id_1 = require("../session-id");
 const labels_1 = require("../../labels");
+const package_json_1 = require("../../../package.json");
 const createLabels = (reusable, dockerImageName, extraLabels = {}) => {
-    const labels = Object.assign({}, extraLabels);
+    const labels = Object.assign(Object.assign({}, extraLabels), { [labels_1.LABEL_TESTCONTAINERS]: "true", [labels_1.LABEL_TESTCONTAINERS_LANG]: "node", [labels_1.LABEL_TESTCONTAINERS_VERSION]: package_json_1.version });
     if (dockerImageName && dockerImageName.isReaper()) {
         return labels;
     }
     if (!reusable) {
-        labels[labels_1.LABEL_SESSION_ID] = session_id_1.sessionId;
+        labels[labels_1.LABEL_TESTCONTAINERS_SESSION_ID] = session_id_1.sessionId;
     }
     return labels;
 };

package/dist/{generic-container → src/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 → src/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;
@@ -99,17 +101,22 @@ class GenericContainer {
             };
             if (this.reuse) {
                 const containerHash = (0, hash_1.hash)(JSON.stringify(createContainerOptions));
-                createContainerOptions.labels = Object.assign(Object.assign({}, createContainerOptions.labels), { [labels_1.LABEL_CONTAINER_HASH]: containerHash });
+                createContainerOptions.labels = Object.assign(Object.assign({}, createContainerOptions.labels), { [labels_1.LABEL_TESTCONTAINERS_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 → src/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/src/labels.d.ts

@@ -0,0 +1,5 @@
+export declare const LABEL_TESTCONTAINERS = "org.testcontainers";
+export declare const LABEL_TESTCONTAINERS_LANG = "org.testcontainers.lang";
+export declare const LABEL_TESTCONTAINERS_VERSION = "org.testcontainers.version";
+export declare const LABEL_TESTCONTAINERS_SESSION_ID = "org.testcontainers.session-id";
+export declare const LABEL_TESTCONTAINERS_CONTAINER_HASH = "org.testcontainers.container-hash";

package/dist/src/labels.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LABEL_TESTCONTAINERS_CONTAINER_HASH = exports.LABEL_TESTCONTAINERS_SESSION_ID = exports.LABEL_TESTCONTAINERS_VERSION = exports.LABEL_TESTCONTAINERS_LANG = exports.LABEL_TESTCONTAINERS = void 0;
+exports.LABEL_TESTCONTAINERS = "org.testcontainers";
+exports.LABEL_TESTCONTAINERS_LANG = "org.testcontainers.lang";
+exports.LABEL_TESTCONTAINERS_VERSION = "org.testcontainers.version";
+exports.LABEL_TESTCONTAINERS_SESSION_ID = "org.testcontainers.session-id";
+exports.LABEL_TESTCONTAINERS_CONTAINER_HASH = "org.testcontainers.container-hash";

package/dist/{reaper.js → src/reaper.js}

@@ -118,7 +118,7 @@ class ReaperInstance {
                     })
                         .connect((0, port_1.getContainerPort)(port), host, () => {
                         logger_1.log.debug(`Connected to Reaper ${containerId}`);
-                        socket.write(`label=${labels_1.LABEL_SESSION_ID}=${session_id_1.sessionId}\r\n`);
+                        socket.write(`label=${labels_1.LABEL_TESTCONTAINERS_SESSION_ID}=${session_id_1.sessionId}\r\n`);
                         const reaper = new RealReaper(startedContainer, socket);
                         resolve(reaper);
                     });

package/dist/{retry-strategy.d.ts → src/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 → src/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 → src/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 → src/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 → src/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.4-beta.0",
   "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"

package/dist/labels.d.ts

@@ -1,2 +0,0 @@
-export declare const LABEL_SESSION_ID = "org.testcontainers.session-id";
-export declare const LABEL_CONTAINER_HASH = "org.testcontainers.container-hash";

package/dist/labels.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LABEL_CONTAINER_HASH = exports.LABEL_SESSION_ID = void 0;
-exports.LABEL_SESSION_ID = "org.testcontainers.session-id";
-exports.LABEL_CONTAINER_HASH = "org.testcontainers.container-hash";