testcontainers 9.3.0 → 9.5.0

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

@@ -12,7 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.StartedPostgreSqlContainer = exports.PostgreSqlContainer = void 0;
 const generic_container_1 = require("../../generic-container/generic-container");
 const abstract_started_container_1 = require("../abstract-started-container");
-const wait_1 = require("../../wait");
+const wait_1 = require("../../wait-strategy/wait");
 const POSTGRES_PORT = 5432;
 class PostgreSqlContainer extends generic_container_1.GenericContainer {
     constructor(image = "postgres:13.3-alpine") {
@@ -38,7 +38,7 @@ class PostgreSqlContainer extends generic_container_1.GenericContainer {
             start: { get: () => super.start }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            this.withExposedPorts(...(this.hasExposedPorts ? this.ports : [POSTGRES_PORT]))
+            this.withExposedPorts(...(this.hasExposedPorts ? this.opts.exposedPorts : [POSTGRES_PORT]))
                 .withEnvironment({
                 POSTGRES_DB: this.database,
                 POSTGRES_USER: this.username,

package/dist/src/port-check.js

@@ -52,7 +52,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, { stdin: true, detach: false, tty: true }, false)));
+            const commandResults = yield Promise.all(commands.map((command) => (0, exec_container_1.execContainer)(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/reaper.js

@@ -17,7 +17,7 @@ const session_id_1 = require("./docker/session-id");
 const images_1 = require("./images");
 const port_1 = require("./port");
 const labels_1 = require("./labels");
-const wait_1 = require("./wait");
+const wait_1 = require("./wait-strategy/wait");
 const retry_strategy_1 = require("./retry-strategy");
 const get_remote_docker_unix_socket_path_1 = require("./docker/get-remote-docker-unix-socket-path");
 const docker_client_1 = require("./docker/docker-client");

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

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { PortWithOptionalBinding } from "./port";
 import { PullPolicy } from "./pull-policy";
-import { WaitStrategy } from "./wait-strategy";
+import { WaitStrategy } from "./wait-strategy/wait-strategy";
 import { Readable } from "stream";
 import { ExecResult, ExtraHost, TmpFs, Labels, Ulimits, BindMount, FileToCopy, ContentToCopy, Environment, ResourcesQuota } from "./docker/types";
 import { StartedNetwork } from "./network";

package/dist/src/type-guards.d.ts

@@ -1 +1,3 @@
 export declare const isDefined: <T>(value: T | undefined) => value is T;
+export declare const isEmptyString: (value: string) => value is string;
+export declare const isNotEmptyString: (value: string) => value is string;

package/dist/src/type-guards.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isDefined = void 0;
-const isDefined = (value) => {
-    return value !== undefined;
-};
+exports.isNotEmptyString = exports.isEmptyString = exports.isDefined = void 0;
+const isDefined = (value) => value !== undefined;
 exports.isDefined = isDefined;
+const isEmptyString = (value) => value.trim() === "";
+exports.isEmptyString = isEmptyString;
+const isNotEmptyString = (value) => !(0, exports.isEmptyString)(value);
+exports.isNotEmptyString = isNotEmptyString;

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";
+import { WaitStrategy } from "./wait-strategy/wait-strategy";
 export declare const waitForContainer: (container: Dockerode.Container, waitStrategy: WaitStrategy, host: string, boundPorts: BoundPorts, startTime?: Date) => Promise<void>;

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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,7 @@
+"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;

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

@@ -0,0 +1,5 @@
+import Dockerode from "dockerode";
+import { AbstractWaitStrategy } from "./wait-strategy";
+export declare class HealthCheckWaitStrategy extends AbstractWaitStrategy {
+    waitUntilReady(container: Dockerode.Container): Promise<void>;
+}

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

@@ -0,0 +1,31 @@
+"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.HealthCheckWaitStrategy = void 0;
+const logger_1 = require("../logger");
+const retry_strategy_1 = require("../retry-strategy");
+const inspect_container_1 = require("../docker/functions/container/inspect-container");
+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}`);
+            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);
+            if (status !== "healthy") {
+                throw new Error(`Health check failed: ${status} for ${container.id}`);
+            }
+        });
+    }
+}
+exports.HealthCheckWaitStrategy = HealthCheckWaitStrategy;

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

@@ -0,0 +1,13 @@
+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>;
+    private waitForHostPorts;
+    private waitForInternalPorts;
+    private waitForPort;
+}

package/dist/src/wait-strategy/host-port-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.HostPortWaitStrategy = void 0;
+const logger_1 = require("../logger");
+const retry_strategy_1 = require("../retry-strategy");
+const wait_strategy_1 = require("./wait-strategy");
+class HostPortWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
+    constructor(hostPortCheck, internalPortCheck) {
+        super();
+        this.hostPortCheck = hostPortCheck;
+        this.internalPortCheck = internalPortCheck;
+    }
+    waitUntilReady(container, host, boundPorts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all([this.waitForHostPorts(container, boundPorts), this.waitForInternalPorts(container, boundPorts)]);
+        });
+    }
+    waitForHostPorts(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}`);
+            }
+        });
+    }
+    waitForInternalPorts(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}`);
+            }
+        });
+    }
+    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}`);
+            }, this.startupTimeout);
+        });
+    }
+}
+exports.HostPortWaitStrategy = HostPortWaitStrategy;

package/dist/src/{http-wait-strategy.d.ts → wait-strategy/http-wait-strategy.d.ts}

@@ -1,5 +1,5 @@
 import Dockerode from "dockerode";
-import { BoundPorts } from "./bound-ports";
+import { BoundPorts } from "../bound-ports";
 import { AbstractWaitStrategy } from "./wait-strategy";
 export declare class HttpWaitStrategy extends AbstractWaitStrategy {
     private readonly path;

package/dist/src/{http-wait-strategy.js → wait-strategy/http-wait-strategy.js}

@@ -14,7 +14,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpWaitStrategy = void 0;
 const wait_strategy_1 = require("./wait-strategy");
-const retry_strategy_1 = require("./retry-strategy");
+const retry_strategy_1 = require("../retry-strategy");
 const node_fetch_1 = __importDefault(require("node-fetch"));
 const https_1 = __importDefault(require("https"));
 class HttpWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {

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

@@ -0,0 +1,10 @@
+import Dockerode from "dockerode";
+import { BoundPorts } from "../bound-ports";
+import { AbstractWaitStrategy } from "./wait-strategy";
+export type Log = string;
+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>;
+}

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

@@ -0,0 +1,67 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogWaitStrategy = void 0;
+const logger_1 = require("../logger");
+const container_logs_1 = require("../docker/functions/container/container-logs");
+const byline_1 = __importDefault(require("byline"));
+const wait_strategy_1 = require("./wait-strategy");
+class LogWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
+    constructor(message, times) {
+        super();
+        this.message = message;
+        this.times = times;
+    }
+    waitUntilReady(container, host, boundPorts, startTime) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.log.debug(`Waiting for log message "${this.message}" for ${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);
+                    reject(new Error(message));
+                }, startupTimeout);
+                const comparisonFn = (line) => {
+                    if (this.message instanceof RegExp) {
+                        return this.message.test(line);
+                    }
+                    else {
+                        return line.includes(this.message);
+                    }
+                };
+                let count = 0;
+                const lineProcessor = (line) => {
+                    if (comparisonFn(line)) {
+                        if (++count === this.times) {
+                            stream.destroy();
+                            clearTimeout(timeout);
+                            resolve();
+                        }
+                    }
+                };
+                (0, byline_1.default)(stream)
+                    .on("data", lineProcessor)
+                    .on("err", lineProcessor)
+                    .on("end", () => {
+                    stream.destroy();
+                    clearTimeout(timeout);
+                    reject(new Error(`Log stream ended and message "${this.message}" was not received for ${container.id}`));
+                });
+            });
+        });
+    }
+}
+exports.LogWaitStrategy = LogWaitStrategy;

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

@@ -0,0 +1,7 @@
+import Dockerode from "dockerode";
+import { AbstractWaitStrategy } from "./wait-strategy";
+export declare class ShellWaitStrategy extends AbstractWaitStrategy {
+    private readonly command;
+    constructor(command: string);
+    waitUntilReady(container: Dockerode.Container): Promise<void>;
+}

package/dist/src/wait-strategy/shell-wait-strategy.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.ShellWaitStrategy = void 0;
+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");
+class ShellWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
+    constructor(command) {
+        super();
+        this.command = command;
+    }
+    waitUntilReady(container) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.log.debug(`Waiting for successful shell command ${this.command} for ${container.id}`);
+            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);
+                return exitCode;
+            }), (exitCode) => exitCode === 0, () => {
+                const timeout = this.startupTimeout;
+                throw new Error(`Shell command not successful after ${timeout}ms for ${container.id}`);
+            }, this.startupTimeout);
+        });
+    }
+}
+exports.ShellWaitStrategy = ShellWaitStrategy;

package/dist/src/{startup-check-strategy.js → wait-strategy/startup-check-strategy.js}

@@ -11,8 +11,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StartupCheckStrategy = void 0;
 const wait_strategy_1 = require("./wait-strategy");
-const retry_strategy_1 = require("./retry-strategy");
-const docker_client_1 = require("./docker/docker-client");
+const retry_strategy_1 = require("../retry-strategy");
+const docker_client_1 = require("../docker/docker-client");
 class StartupCheckStrategy extends wait_strategy_1.AbstractWaitStrategy {
     waitUntilReady(container) {
         return __awaiter(this, void 0, void 0, function* () {

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

@@ -0,0 +1,11 @@
+import { BoundPorts } from "../bound-ports";
+import Dockerode from "dockerode";
+export interface WaitStrategy {
+    waitUntilReady(container: Dockerode.Container, host: string, boundPorts: BoundPorts, startTime?: Date): Promise<void>;
+    withStartupTimeout(startupTimeout: number): WaitStrategy;
+}
+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;
+}

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

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

package/dist/src/{wait.d.ts → wait-strategy/wait.d.ts}

@@ -1,7 +1,10 @@
-import { Log, WaitStrategy } from "./wait-strategy";
+import { WaitStrategy } from "./wait-strategy";
 import { HttpWaitStrategy } from "./http-wait-strategy";
+import { Log } from "./log-wait-strategy";
+import { ShellWaitStrategy } from "./shell-wait-strategy";
 export declare class Wait {
     static forLogMessage(message: Log | RegExp, times?: number): WaitStrategy;
     static forHealthCheck(): WaitStrategy;
     static forHttp(path: string, port: number): HttpWaitStrategy;
+    static forSuccessfulCommand(command: string): ShellWaitStrategy;
 }

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Wait = void 0;
+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");
+class Wait {
+    static forLogMessage(message, times = 1) {
+        return new log_wait_strategy_1.LogWaitStrategy(message, times);
+    }
+    static forHealthCheck() {
+        return new health_check_wait_strategy_1.HealthCheckWaitStrategy();
+    }
+    static forHttp(path, port) {
+        return new http_wait_strategy_1.HttpWaitStrategy(path, port);
+    }
+    static forSuccessfulCommand(command) {
+        return new shell_wait_strategy_1.ShellWaitStrategy(command);
+    }
+}
+exports.Wait = Wait;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "testcontainers",
   "author": "Cristian Greco",
-  "version": "9.3.0",
+  "version": "9.5.0",
   "main": "dist/src/index",
   "types": "dist/src/index",
   "keywords": [
@@ -38,7 +38,7 @@
   "dependencies": {
     "@balena/dockerignore": "^1.0.2",
     "@types/archiver": "^5.3.2",
-    "@types/dockerode": "^3.3.15",
+    "@types/dockerode": "^3.3.16",
     "archiver": "^5.3.1",
     "async-lock": "^1.4.0",
     "byline": "^5.0.0",
@@ -56,33 +56,33 @@
     "@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/jest": "^29.5.0",
+    "@types/node": "^18.15.11",
+    "@types/node-fetch": "^2.6.3",
     "@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",
+    "@typescript-eslint/eslint-plugin": "^5.57.0",
+    "@typescript-eslint/parser": "^5.57.0",
+    "arangojs": "^8.2.0",
     "cross-env": "^7.0.3",
-    "eslint": "^8.26.0",
-    "eslint-config-prettier": "^8.5.0",
+    "eslint": "^8.37.0",
+    "eslint-config-prettier": "^8.8.0",
     "eslint-plugin-prettier": "^4.2.1",
     "husky": "^8.0.3",
     "jest": "^29.5.0",
     "kafkajs": "^2.2.4",
-    "lint-staged": "^13.0.4",
-    "mongoose": "^6.7.5",
+    "lint-staged": "^13.2.0",
+    "mongoose": "^6.10.4",
     "mysql2": "^2.3.3",
-    "nats": "^2.8.0",
-    "neo4j-driver": "^5.2.0",
-    "pg": "^8.8.0",
-    "prettier": "^2.7.1",
+    "nats": "^2.13.1",
+    "neo4j-driver": "^5.6.0",
+    "pg": "^8.10.0",
+    "prettier": "^2.8.7",
     "rimraf": "^3.0.2",
     "ts-jest": "^29.0.5",
     "ts-node": "^10.9.1",
-    "typescript": "^4.8.4",
+    "typescript": "^4.9.5",
     "wait-for-expect": "^3.0.2"
   },
   "lint-staged": {

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

@@ -1,32 +0,0 @@
-import { BoundPorts } from "./bound-ports";
-import { PortCheck } from "./port-check";
-import Dockerode from "dockerode";
-export interface WaitStrategy {
-    waitUntilReady(container: Dockerode.Container, host: string, boundPorts: BoundPorts, startTime?: Date): Promise<void>;
-    withStartupTimeout(startupTimeout: number): WaitStrategy;
-}
-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;
-}
-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>;
-    private waitForHostPorts;
-    private waitForInternalPorts;
-    private waitForPort;
-}
-export type Log = string;
-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>;
-}
-export declare class HealthCheckWaitStrategy extends AbstractWaitStrategy {
-    waitUntilReady(container: Dockerode.Container): Promise<void>;
-}
-export declare const defaultWaitStrategy: (host: string, container: Dockerode.Container) => HostPortWaitStrategy;