testcontainers 9.12.0 → 10.0.0-beta.5

package/dist/src/test-containers.js

@@ -1,22 +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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TestContainers = void 0;
-const port_forwarder_1 = require("./port-forwarder");
-class TestContainers {
-    static exposeHostPorts(...ports) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const portForwarder = yield port_forwarder_1.PortForwarderInstance.getInstance();
-            yield Promise.all(ports.map((port) => portForwarder.exposeHostPort(port)));
-        });
-    }
-}
-exports.TestContainers = TestContainers;

package/dist/src/wait-for-container.d.ts

@@ -1,4 +0,0 @@
-import Dockerode from "dockerode";
-import { BoundPorts } from "./bound-ports";
-import { WaitStrategy } from "./wait-strategy/wait-strategy";
-export declare const waitForContainer: (container: Dockerode.Container, waitStrategy: WaitStrategy, boundPorts: BoundPorts, startTime?: Date) => Promise<void>;

package/dist/src/wait-for-container.js

@@ -1,34 +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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.waitForContainer = void 0;
-const logger_1 = require("./logger");
-const stop_container_1 = require("./docker/functions/container/stop-container");
-const remove_container_1 = require("./docker/functions/container/remove-container");
-const waitForContainer = (container, waitStrategy, boundPorts, startTime) => __awaiter(void 0, void 0, void 0, function* () {
-    logger_1.log.debug(`Waiting for container to be ready...`, { containerId: container.id });
-    try {
-        yield waitStrategy.waitUntilReady(container, boundPorts, startTime);
-        logger_1.log.info(`Container is ready`, { containerId: container.id });
-    }
-    catch (err) {
-        logger_1.log.error(`Container failed to be ready: ${err}`, { containerId: container.id });
-        try {
-            yield (0, stop_container_1.stopContainer)(container, { timeout: 0 });
-            yield (0, remove_container_1.removeContainer)(container, { removeVolumes: true });
-        }
-        catch (stopErr) {
-            logger_1.log.error(`Failed to stop container after it failed to be ready: ${stopErr}`, { containerId: container.id });
-        }
-        throw err;
-    }
-});
-exports.waitForContainer = waitForContainer;

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

@@ -1,57 +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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompositeWaitStrategy = void 0;
-const wait_strategy_1 = require("./wait-strategy");
-const logger_1 = require("../logger");
-class CompositeWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
-    constructor(waitStrategies) {
-        super();
-        this.waitStrategies = waitStrategies;
-    }
-    waitUntilReady(container, boundPorts, startTime) {
-        return __awaiter(this, void 0, void 0, function* () {
-            logger_1.log.debug(`Waiting for composite...`, { containerId: container.id });
-            return new Promise((resolve, reject) => {
-                let deadlineTimeout;
-                if (this.deadline !== undefined) {
-                    deadlineTimeout = setTimeout(() => {
-                        const message = `Composite wait strategy not successful after ${this.deadline}ms`;
-                        logger_1.log.error(message, { containerId: container.id });
-                        reject(new Error(message));
-                    }, this.deadline);
-                }
-                Promise.all(this.waitStrategies.map((waitStrategy) => waitStrategy.waitUntilReady(container, boundPorts, startTime)))
-                    .then(() => {
-                    logger_1.log.debug(`Composite wait strategy complete`, { containerId: container.id });
-                    resolve();
-                })
-                    .catch((err) => reject(err))
-                    .finally(() => {
-                    if (deadlineTimeout) {
-                        clearTimeout(deadlineTimeout);
-                    }
-                });
-            });
-        });
-    }
-    withStartupTimeout(startupTimeout) {
-        this.waitStrategies
-            .filter((waitStrategy) => !waitStrategy.isStartupTimeoutSet())
-            .forEach((waitStrategy) => waitStrategy.withStartupTimeout(startupTimeout));
-        return this;
-    }
-    withDeadline(deadline) {
-        this.deadline = deadline;
-        return this;
-    }
-}
-exports.CompositeWaitStrategy = CompositeWaitStrategy;

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

@@ -1,36 +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());
-    });
-};
-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...`, { containerId: 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;
-                const message = `Health check not healthy after ${timeout}ms`;
-                logger_1.log.error(message, { containerId: container.id });
-                throw new Error(message);
-            }, this.startupTimeout);
-            if (status !== "healthy") {
-                const message = `Health check failed: ${status}`;
-                logger_1.log.error(message, { containerId: container.id });
-                throw new Error(message);
-            }
-            logger_1.log.debug(`Health check wait strategy complete`, { containerId: container.id });
-        });
-    }
-}
-exports.HealthCheckWaitStrategy = HealthCheckWaitStrategy;

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

@@ -1,59 +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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HostPortWaitStrategy = void 0;
-const port_check_1 = require("../port-check");
-const logger_1 = require("../logger");
-const retry_strategy_1 = require("../retry-strategy");
-const wait_strategy_1 = require("./wait-strategy");
-const docker_client_1 = require("../docker/client/docker-client");
-class HostPortWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
-    waitUntilReady(container, boundPorts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { dockerode, containerRuntime, host } = yield (0, docker_client_1.getDockerClient)();
-            const hostPortCheck = new port_check_1.HostPortCheck(host);
-            const internalPortCheck = new port_check_1.InternalPortCheck(dockerode, containerRuntime, container);
-            yield Promise.all([
-                this.waitForHostPorts(hostPortCheck, container, boundPorts),
-                this.waitForInternalPorts(internalPortCheck, container, boundPorts),
-            ]);
-        });
-    }
-    waitForHostPorts(portCheck, 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}...`, { containerId: container.id });
-                yield this.waitForPort(container, hostPort, portCheck);
-                logger_1.log.debug(`Host port ${hostPort} ready`, { containerId: container.id });
-            }
-            logger_1.log.debug(`Host port wait strategy complete`, { containerId: container.id });
-        });
-    }
-    waitForInternalPorts(portCheck, 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}...`, { containerId: container.id });
-                yield this.waitForPort(container, internalPort, portCheck);
-                logger_1.log.debug(`Internal port ${internalPort} ready`, { containerId: 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 message = `Port ${port} not bound after ${this.startupTimeout}ms`;
-                logger_1.log.error(message, { containerId: container.id });
-                throw new Error(message);
-            }, this.startupTimeout);
-        });
-    }
-}
-exports.HostPortWaitStrategy = HostPortWaitStrategy;

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

@@ -1,120 +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.HttpWaitStrategy = void 0;
-const wait_strategy_1 = require("./wait-strategy");
-const retry_strategy_1 = require("../retry-strategy");
-const node_fetch_1 = __importDefault(require("node-fetch"));
-const https_1 = __importDefault(require("https"));
-const docker_client_1 = require("../docker/client/docker-client");
-const logger_1 = require("../logger");
-class HttpWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
-    constructor(path, port) {
-        super();
-        this.protocol = "http";
-        this.method = "GET";
-        this.headers = {};
-        this.predicates = [];
-        this._allowInsecure = false;
-        this.readTimeout = 1000;
-        this.path = path;
-        this.port = port;
-    }
-    forStatusCode(statusCode) {
-        this.predicates.push((response) => __awaiter(this, void 0, void 0, function* () { return response.status === statusCode; }));
-        return this;
-    }
-    forStatusCodeMatching(predicate) {
-        this.predicates.push((response) => __awaiter(this, void 0, void 0, function* () { return predicate(response.status); }));
-        return this;
-    }
-    forResponsePredicate(predicate) {
-        this.predicates.push((response) => __awaiter(this, void 0, void 0, function* () { return predicate(yield response.text()); }));
-        return this;
-    }
-    withMethod(method) {
-        this.method = method;
-        return this;
-    }
-    withHeaders(headers) {
-        this.headers = Object.assign(Object.assign({}, this.headers), headers);
-        return this;
-    }
-    withBasicCredentials(username, password) {
-        const base64Encoded = Buffer.from(`${username}:${password}`).toString("base64");
-        this.headers = Object.assign(Object.assign({}, this.headers), { Authorization: `Basic ${base64Encoded}` });
-        return this;
-    }
-    withReadTimeout(readTimeout) {
-        this.readTimeout = readTimeout;
-        return this;
-    }
-    usingTls() {
-        this.protocol = "https";
-        return this;
-    }
-    allowInsecure() {
-        this._allowInsecure = true;
-        return this;
-    }
-    waitUntilReady(container, boundPorts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            logger_1.log.debug(`Waiting for HTTP...`, { containerId: container.id });
-            const { host } = yield (0, docker_client_1.getDockerClient)();
-            yield new retry_strategy_1.IntervalRetryStrategy(this.readTimeout).retryUntil(() => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    const url = `${this.protocol}://${host}:${boundPorts.getBinding(this.port)}${this.path}`;
-                    return yield (0, node_fetch_1.default)(url, {
-                        method: this.method,
-                        timeout: this.readTimeout,
-                        headers: this.headers,
-                        agent: this.getAgent(),
-                    });
-                }
-                catch (_a) {
-                    return undefined;
-                }
-            }), (response) => __awaiter(this, void 0, void 0, function* () {
-                if (response === undefined) {
-                    return false;
-                }
-                else if (!this.predicates.length) {
-                    return response.ok;
-                }
-                else {
-                    for (const predicate of this.predicates) {
-                        const result = yield predicate(response);
-                        if (!result) {
-                            return false;
-                        }
-                    }
-                    return true;
-                }
-            }), () => {
-                const message = `URL ${this.path} not accessible after ${this.startupTimeout}ms`;
-                logger_1.log.error(message, { containerId: container.id });
-                throw new Error(message);
-            }, this.startupTimeout);
-            logger_1.log.debug(`HTTP wait strategy complete`, { containerId: container.id });
-        });
-    }
-    getAgent() {
-        if (this._allowInsecure) {
-            return new https_1.default.Agent({
-                rejectUnauthorized: false,
-            });
-        }
-    }
-}
-exports.HttpWaitStrategy = HttpWaitStrategy;

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

@@ -1,69 +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.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, boundPorts, startTime) {
-        return __awaiter(this, void 0, void 0, function* () {
-            logger_1.log.debug(`Waiting for log message "${this.message}"...`, { containerId: container.id });
-            const stream = yield (0, container_logs_1.containerLogs)(container, { since: startTime });
-            return new Promise((resolve, reject) => {
-                const timeout = setTimeout(() => {
-                    const message = `Log message "${this.message}" not received after ${this.startupTimeout}ms`;
-                    logger_1.log.error(message, { containerId: container.id });
-                    reject(new Error(message));
-                }, this.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);
-                            logger_1.log.debug(`Log wait strategy complete`, { containerId: container.id });
-                            resolve();
-                        }
-                    }
-                };
-                (0, byline_1.default)(stream)
-                    .on("data", lineProcessor)
-                    .on("err", lineProcessor)
-                    .on("end", () => {
-                    stream.destroy();
-                    clearTimeout(timeout);
-                    const message = `Log stream ended and message "${this.message}" was not received`;
-                    logger_1.log.error(message, { containerId: container.id });
-                    reject(new Error(message));
-                });
-            });
-        });
-    }
-}
-exports.LogWaitStrategy = LogWaitStrategy;

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

@@ -1,39 +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());
-    });
-};
-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");
-const docker_client_1 = require("../docker/client/docker-client");
-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}"...`, { containerId: container.id });
-            const { dockerode, containerRuntime } = yield (0, docker_client_1.getDockerClient)();
-            yield new retry_strategy_1.IntervalRetryStrategy(100).retryUntil(() => __awaiter(this, void 0, void 0, function* () {
-                const { exitCode } = yield (0, exec_container_1.execContainer)(dockerode, containerRuntime, container, ["/bin/sh", "-c", this.command], false);
-                return exitCode;
-            }), (exitCode) => exitCode === 0, () => {
-                const message = `Shell command "${this.command}" not successful after ${this.startupTimeout}ms`;
-                logger_1.log.error(message, { containerId: container.id });
-                throw new Error(message);
-            }, this.startupTimeout);
-            logger_1.log.debug(`Shell wait strategy complete`, { containerId: container.id });
-        });
-    }
-}
-exports.ShellWaitStrategy = ShellWaitStrategy;

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

@@ -1,35 +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());
-    });
-};
-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/client/docker-client");
-const logger_1 = require("../logger");
-class StartupCheckStrategy extends wait_strategy_1.AbstractWaitStrategy {
-    waitUntilReady(container) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { dockerode } = yield (0, docker_client_1.getDockerClient)();
-            const startupStatus = yield new retry_strategy_1.IntervalRetryStrategy(1000).retryUntil(() => __awaiter(this, void 0, void 0, function* () { return yield this.checkStartupState(dockerode, container.id); }), (startupStatus) => startupStatus === "SUCCESS" || startupStatus === "FAIL", () => {
-                const message = `Container not accessible after ${this.startupTimeout}ms`;
-                logger_1.log.error(message, { containerId: container.id });
-                return new Error(message);
-            }, this.startupTimeout);
-            if (startupStatus instanceof Error) {
-                throw startupStatus;
-            }
-            else if (startupStatus === "FAIL") {
-                throw new Error(`Container failed to start for ${container.id}`);
-            }
-        });
-    }
-}
-exports.StartupCheckStrategy = StartupCheckStrategy;