testcontainers 9.2.0 → 9.3.0

package/dist/src/system-info.js

@@ -0,0 +1,51 @@
+"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.getSystemInfo = void 0;
+const logger_1 = require("./logger");
+const docker_compose_1 = require("docker-compose");
+const get_info_1 = require("./docker/functions/get-info");
+let systemInfo;
+const getSystemInfo = (dockerode) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    if (systemInfo !== undefined) {
+        return systemInfo;
+    }
+    logger_1.log.debug("Fetching system info");
+    const nodeInfo = getNodeInfo();
+    const dockerInfo = yield (0, get_info_1.getDockerInfo)(dockerode);
+    const dockerComposeInfo = yield getDockerComposeInfo();
+    systemInfo = { nodeInfo, dockerInfo, dockerComposeInfo };
+    logger_1.log.debug(`System info:
+  System: Node version: ${nodeInfo.version}, Platform: ${nodeInfo.platform}, Arch: ${nodeInfo.architecture}
+  Container runtime: OS: ${dockerInfo.operatingSystem}, Version: ${dockerInfo.serverVersion}, Arch: ${dockerInfo.architecture}, CPUs: ${dockerInfo.cpus}, Memory: ${dockerInfo.memory} 
+  Compose: Installed: ${dockerComposeInfo !== undefined}, Version: ${(_a = dockerComposeInfo === null || dockerComposeInfo === void 0 ? void 0 : dockerComposeInfo.version) !== null && _a !== void 0 ? _a : "N/A"}`);
+    return systemInfo;
+});
+exports.getSystemInfo = getSystemInfo;
+const getNodeInfo = () => {
+    return {
+        version: process.version,
+        architecture: process.arch,
+        platform: process.platform,
+    };
+};
+const getDockerComposeInfo = () => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        return {
+            version: (yield (0, docker_compose_1.version)()).data.version,
+        };
+    }
+    catch (err) {
+        logger_1.log.info(`Unable to detect docker-compose version, is it installed? ${err}`);
+        return undefined;
+    }
+});

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

@@ -0,0 +1,66 @@
+/// <reference types="node" />
+import { PortWithOptionalBinding } from "./port";
+import { PullPolicy } from "./pull-policy";
+import { WaitStrategy } from "./wait-strategy";
+import { Readable } from "stream";
+import { ExecResult, ExtraHost, TmpFs, Labels, Ulimits, BindMount, FileToCopy, ContentToCopy, Environment, ResourcesQuota } from "./docker/types";
+import { StartedNetwork } from "./network";
+export interface TestContainer {
+    start(): Promise<StartedTestContainer>;
+    withEnvironment(environment: Environment): this;
+    withCommand(command: string[]): this;
+    withEntrypoint(entrypoint: string[]): this;
+    withTmpFs(tmpFs: TmpFs): this;
+    withUlimits(ulimits: Ulimits): this;
+    withAddedCapabilities(...capabilities: string[]): this;
+    withDroppedCapabilities(...capabilities: string[]): this;
+    withExposedPorts(...ports: PortWithOptionalBinding[]): this;
+    withBindMounts(bindMounts: BindMount[]): this;
+    withWaitStrategy(waitStrategy: WaitStrategy): this;
+    withStartupTimeout(startupTimeoutMs: number): this;
+    withNetwork(network: StartedNetwork): this;
+    withNetworkMode(networkMode: string): this;
+    withExtraHosts(extraHosts: ExtraHost[]): this;
+    withDefaultLogDriver(): this;
+    withPrivilegedMode(): this;
+    withUser(user: string): this;
+    withPullPolicy(pullPolicy: PullPolicy): this;
+    withReuse(): this;
+    withCopyFilesToContainer(filesToCopy: FileToCopy[]): this;
+    withCopyContentToContainer(contentsToCopy: ContentToCopy[]): this;
+    withWorkingDir(workingDir: string): this;
+    withResourcesQuota(resourcesQuota: ResourcesQuota): this;
+}
+export interface RestartOptions {
+    timeout: number;
+}
+export interface StopOptions {
+    timeout: number;
+    removeVolumes: boolean;
+}
+export interface DockerComposeDownOptions {
+    timeout: number;
+    removeVolumes: boolean;
+}
+export interface ExecOptions {
+    tty: boolean;
+    detach: boolean;
+    stdin: boolean;
+}
+export interface StartedTestContainer {
+    stop(options?: Partial<StopOptions>): Promise<StoppedTestContainer>;
+    restart(options?: Partial<RestartOptions>): Promise<void>;
+    getHost(): string;
+    getFirstMappedPort(): number;
+    getMappedPort(port: number): number;
+    getName(): string;
+    getLabels(): Labels;
+    getId(): string;
+    getNetworkNames(): string[];
+    getNetworkId(networkName: string): string;
+    getIpAddress(networkName: string): string;
+    exec(command: string[], options?: Partial<ExecOptions>): Promise<ExecResult>;
+    logs(): Promise<Readable>;
+}
+export interface StoppedTestContainer {
+}

package/dist/src/test-container.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,3 @@
+export declare class TestContainers {
+    static exposeHostPorts(...ports: number[]): Promise<void>;
+}

package/dist/src/test-containers.js

@@ -0,0 +1,22 @@
+"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/type-guards.d.ts

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

package/dist/src/type-guards.js

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

package/dist/src/uuid.d.ts

@@ -0,0 +1,6 @@
+export interface Uuid {
+    nextUuid(): string;
+}
+export declare class RandomUuid implements Uuid {
+    nextUuid(): string;
+}

package/dist/src/uuid.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RandomUuid = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+class RandomUuid {
+    nextUuid() {
+        return crypto_1.default.randomUUID();
+    }
+}
+exports.RandomUuid = RandomUuid;

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

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

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

@@ -0,0 +1,34 @@
+"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, host, boundPorts, startTime) => __awaiter(void 0, void 0, void 0, function* () {
+    logger_1.log.debug(`Waiting for container to be ready: ${container.id}`);
+    try {
+        yield waitStrategy.waitUntilReady(container, host, boundPorts, startTime);
+        logger_1.log.info(`Container is ready: ${container.id}`);
+    }
+    catch (err) {
+        logger_1.log.error(`Container failed to be ready: ${container.id}: ${err}`);
+        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: ${container.id}: ${stopErr}`);
+        }
+        throw err;
+    }
+});
+exports.waitForContainer = waitForContainer;

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

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

package/dist/src/wait-strategy.js

@@ -0,0 +1,137 @@
+"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.d.ts

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

package/dist/src/wait.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "testcontainers",
   "author": "Cristian Greco",
-  "version": "9.2.0",
+  "version": "9.3.0",
   "main": "dist/src/index",
   "types": "dist/src/index",
   "keywords": [