testcontainers 9.3.0 → 9.4.0

package/dist/src/wait-strategy.js

@@ -1,137 +0,0 @@
-"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.defaultWaitStrategy = exports.HealthCheckWaitStrategy = exports.LogWaitStrategy = exports.HostPortWaitStrategy = exports.AbstractWaitStrategy = void 0;
-const byline_1 = __importDefault(require("byline"));
-const logger_1 = require("./logger");
-const port_check_1 = require("./port-check");
-const retry_strategy_1 = require("./retry-strategy");
-const container_logs_1 = require("./docker/functions/container/container-logs");
-const inspect_container_1 = require("./docker/functions/container/inspect-container");
-class AbstractWaitStrategy {
-    constructor() {
-        this.startupTimeout = 60000;
-    }
-    withStartupTimeout(startupTimeout) {
-        this.startupTimeout = startupTimeout;
-        return this;
-    }
-}
-exports.AbstractWaitStrategy = AbstractWaitStrategy;
-class HostPortWaitStrategy extends 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* () {
-            const retryStrategy = new retry_strategy_1.IntervalRetryStrategy(100);
-            yield retryStrategy.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;
-class LogWaitStrategy extends 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;
-class HealthCheckWaitStrategy extends AbstractWaitStrategy {
-    waitUntilReady(container) {
-        return __awaiter(this, void 0, void 0, function* () {
-            logger_1.log.debug(`Waiting for health check for ${container.id}`);
-            const retryStrategy = new retry_strategy_1.IntervalRetryStrategy(100);
-            const status = yield retryStrategy.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;
-const defaultWaitStrategy = (host, container) => new HostPortWaitStrategy(new port_check_1.HostPortCheck(host), new port_check_1.InternalPortCheck(container));
-exports.defaultWaitStrategy = defaultWaitStrategy;

package/dist/src/wait.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Wait = void 0;
-const wait_strategy_1 = require("./wait-strategy");
-const http_wait_strategy_1 = require("./http-wait-strategy");
-class Wait {
-    static forLogMessage(message, times = 1) {
-        return new wait_strategy_1.LogWaitStrategy(message, times);
-    }
-    static forHealthCheck() {
-        return new wait_strategy_1.HealthCheckWaitStrategy();
-    }
-    static forHttp(path, port) {
-        return new http_wait_strategy_1.HttpWaitStrategy(path, port);
-    }
-}
-exports.Wait = Wait;