testcontainers 9.2.0 → 9.3.0

package/dist/src/modules/postgresql/postgresql-container.d.ts

@@ -0,0 +1,28 @@
+import { GenericContainer } from "../../generic-container/generic-container";
+import { StartedTestContainer } from "../../test-container";
+import { AbstractStartedContainer } from "../abstract-started-container";
+export declare class PostgreSqlContainer extends GenericContainer {
+    private database;
+    private username;
+    private password;
+    constructor(image?: string);
+    withDatabase(database: string): this;
+    withUsername(username: string): this;
+    withPassword(password: string): this;
+    start(): Promise<StartedPostgreSqlContainer>;
+}
+export declare class StartedPostgreSqlContainer extends AbstractStartedContainer {
+    private readonly database;
+    private readonly username;
+    private readonly password;
+    private readonly port;
+    constructor(startedTestContainer: StartedTestContainer, database: string, username: string, password: string);
+    getPort(): number;
+    getDatabase(): string;
+    getUsername(): string;
+    getPassword(): string;
+    /**
+     * @returns A connection URI in the form of `postgres[ql]://[username[:password]@][host[:port],]/database`
+     */
+    getConnectionUri(): string;
+}

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

@@ -0,0 +1,87 @@
+"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.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 POSTGRES_PORT = 5432;
+class PostgreSqlContainer extends generic_container_1.GenericContainer {
+    constructor(image = "postgres:13.3-alpine") {
+        super(image);
+        this.database = "test";
+        this.username = "test";
+        this.password = "test";
+    }
+    withDatabase(database) {
+        this.database = database;
+        return this;
+    }
+    withUsername(username) {
+        this.username = username;
+        return this;
+    }
+    withPassword(password) {
+        this.password = password;
+        return this;
+    }
+    start() {
+        const _super = Object.create(null, {
+            start: { get: () => super.start }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            this.withExposedPorts(...(this.hasExposedPorts ? this.ports : [POSTGRES_PORT]))
+                .withEnvironment({
+                POSTGRES_DB: this.database,
+                POSTGRES_USER: this.username,
+                POSTGRES_PASSWORD: this.password,
+            })
+                .withWaitStrategy(wait_1.Wait.forLogMessage(/.*database system is ready to accept connections.*/, 2))
+                .withStartupTimeout(120000);
+            return new StartedPostgreSqlContainer(yield _super.start.call(this), this.database, this.username, this.password);
+        });
+    }
+}
+exports.PostgreSqlContainer = PostgreSqlContainer;
+class StartedPostgreSqlContainer extends abstract_started_container_1.AbstractStartedContainer {
+    constructor(startedTestContainer, database, username, password) {
+        super(startedTestContainer);
+        this.database = database;
+        this.username = username;
+        this.password = password;
+        this.port = startedTestContainer.getMappedPort(5432);
+    }
+    getPort() {
+        return this.port;
+    }
+    getDatabase() {
+        return this.database;
+    }
+    getUsername() {
+        return this.username;
+    }
+    getPassword() {
+        return this.password;
+    }
+    /**
+     * @returns A connection URI in the form of `postgres[ql]://[username[:password]@][host[:port],]/database`
+     */
+    getConnectionUri() {
+        const url = new URL("", "postgres://");
+        url.hostname = this.getHost();
+        url.port = this.getPort().toString();
+        url.pathname = this.getDatabase();
+        url.username = this.getUsername();
+        url.password = this.getPassword();
+        return url.toString();
+    }
+}
+exports.StartedPostgreSqlContainer = StartedPostgreSqlContainer;

package/dist/src/network.d.ts

@@ -0,0 +1,17 @@
+import { Uuid } from "./uuid";
+import { CreateNetworkOptions } from "./docker/functions/network/create-network";
+export declare class Network {
+    private readonly createNetworkOptions;
+    constructor(createNetworkOptions?: Partial<CreateNetworkOptions>, uuid?: Uuid);
+    start(): Promise<StartedNetwork>;
+}
+export declare class StartedNetwork {
+    private readonly id;
+    private readonly options;
+    constructor(id: string, options: CreateNetworkOptions);
+    getId(): string;
+    getName(): string;
+    stop(): Promise<StoppedNetwork>;
+}
+export declare class StoppedNetwork {
+}

package/dist/src/network.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.StoppedNetwork = exports.StartedNetwork = exports.Network = void 0;
+const uuid_1 = require("./uuid");
+const logger_1 = require("./logger");
+const reaper_1 = require("./reaper");
+const create_network_1 = require("./docker/functions/network/create-network");
+const remove_network_1 = require("./docker/functions/network/remove-network");
+class Network {
+    constructor(createNetworkOptions = {}, uuid = new uuid_1.RandomUuid()) {
+        this.createNetworkOptions = Object.assign({ name: uuid.nextUuid(), driver: "bridge", checkDuplicate: true, internal: false, attachable: false, ingress: false, enableIPv6: false }, createNetworkOptions);
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield reaper_1.ReaperInstance.getInstance();
+            const id = yield (0, create_network_1.createNetwork)(this.createNetworkOptions);
+            logger_1.log.info(`Started network with ID: ${id}`);
+            return new StartedNetwork(id, this.createNetworkOptions);
+        });
+    }
+}
+exports.Network = Network;
+class StartedNetwork {
+    constructor(id, options) {
+        this.id = id;
+        this.options = options;
+    }
+    getId() {
+        return this.id;
+    }
+    getName() {
+        return this.options.name;
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.log.info(`Stopping network with ID: ${this.id}`);
+            yield (0, remove_network_1.removeNetwork)(this.id);
+            return new StoppedNetwork();
+        });
+    }
+}
+exports.StartedNetwork = StartedNetwork;
+class StoppedNetwork {
+}
+exports.StoppedNetwork = StoppedNetwork;

package/dist/src/port-check.d.ts

@@ -0,0 +1,17 @@
+import Dockerode from "dockerode";
+export interface PortCheck {
+    isBound(port: number): Promise<boolean>;
+}
+export declare class HostPortCheck implements PortCheck {
+    private readonly host;
+    constructor(host: string);
+    isBound(port: number): Promise<boolean>;
+}
+export declare class InternalPortCheck implements PortCheck {
+    private readonly container;
+    private isDistroless;
+    private commandOutputs;
+    constructor(container: Dockerode.Container);
+    isBound(port: number): Promise<boolean>;
+    private commandOutputsKey;
+}

package/dist/src/port-check.js

@@ -0,0 +1,84 @@
+"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.InternalPortCheck = exports.HostPortCheck = void 0;
+const net_1 = require("net");
+const exec_container_1 = require("./docker/functions/container/exec-container");
+const logger_1 = require("./logger");
+class HostPortCheck {
+    constructor(host) {
+        this.host = host;
+    }
+    isBound(port) {
+        return new Promise((resolve) => {
+            const socket = new net_1.Socket();
+            socket
+                .setTimeout(1000)
+                .on("error", () => {
+                socket.destroy();
+                resolve(false);
+            })
+                .on("timeout", () => {
+                socket.destroy();
+                resolve(false);
+            })
+                .connect(port, this.host, () => {
+                socket.end();
+                resolve(true);
+            });
+        });
+    }
+}
+exports.HostPortCheck = HostPortCheck;
+class InternalPortCheck {
+    constructor(container) {
+        this.container = container;
+        this.isDistroless = false;
+        this.commandOutputs = new Set();
+    }
+    isBound(port) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const portHex = port.toString(16).padStart(4, "0");
+            const commands = [
+                ["/bin/sh", "-c", `cat /proc/net/tcp* | awk '{print $2}' | grep -i :${portHex}`],
+                ["/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 isBound = commandResults.some((result) => result.exitCode === 0);
+            if (!isBound && logger_1.log.enabled()) {
+                const shellExists = commandResults.some((result) => result.exitCode !== 126);
+                if (!shellExists) {
+                    if (!this.isDistroless) {
+                        this.isDistroless = true;
+                        logger_1.log.error(`The HostPortWaitStrategy will not work on a distroless image, use an alternate wait strategy for container ${this.container.id}`);
+                    }
+                }
+                else {
+                    commandResults
+                        .map((result) => (Object.assign(Object.assign({}, result), { output: result.output.trim() })))
+                        .filter((result) => result.exitCode !== 126 && result.output.length > 0)
+                        .forEach((result) => {
+                        if (!this.commandOutputs.has(this.commandOutputsKey(result.output))) {
+                            logger_1.log.trace(`Port check result for container ${this.container.id} exit code ${result.exitCode}: ${result.output}`);
+                            this.commandOutputs.add(this.commandOutputsKey(result.output));
+                        }
+                    });
+                }
+            }
+            return isBound;
+        });
+    }
+    commandOutputsKey(output) {
+        return `${this.container.id}:${output}`;
+    }
+}
+exports.InternalPortCheck = InternalPortCheck;

package/dist/src/port-forwarder.d.ts

@@ -0,0 +1,17 @@
+import { SshConnection } from "ssh-remote-port-forward";
+import { StartedTestContainer } from "./test-container";
+export declare class PortForwarder {
+    private readonly sshConnection;
+    private readonly container;
+    constructor(sshConnection: SshConnection, container: StartedTestContainer);
+    exposeHostPort(port: number): Promise<void>;
+    getNetworkId(): string;
+    getIpAddress(): string;
+    private getNetworkName;
+}
+export declare class PortForwarderInstance {
+    private static instance;
+    static isRunning(): boolean;
+    static getInstance(): Promise<PortForwarder>;
+    private static createInstance;
+}

package/dist/src/port-forwarder.js

@@ -0,0 +1,81 @@
+"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.PortForwarderInstance = exports.PortForwarder = void 0;
+const ssh_remote_port_forward_1 = require("ssh-remote-port-forward");
+const logger_1 = require("./logger");
+const generic_container_1 = require("./generic-container/generic-container");
+const uuid_1 = require("./uuid");
+const session_id_1 = require("./docker/session-id");
+const docker_client_1 = require("./docker/docker-client");
+const images_1 = require("./images");
+class PortForwarder {
+    constructor(sshConnection, container) {
+        this.sshConnection = sshConnection;
+        this.container = container;
+    }
+    exposeHostPort(port) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.log.info(`Exposing host port ${port}`);
+            yield this.sshConnection.remoteForward("localhost", port);
+        });
+    }
+    getNetworkId() {
+        return this.container.getNetworkId(this.getNetworkName());
+    }
+    getIpAddress() {
+        return this.container.getIpAddress(this.getNetworkName());
+    }
+    getNetworkName() {
+        return this.container.getNetworkNames()[0];
+    }
+}
+exports.PortForwarder = PortForwarder;
+class PortForwarderInstance {
+    static isRunning() {
+        return this.instance !== undefined;
+    }
+    static getInstance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.instance) {
+                this.instance = this.createInstance();
+            }
+            return this.instance;
+        });
+    }
+    static createInstance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.log.debug(`Creating new Port Forwarder`);
+            const username = "root";
+            const password = new uuid_1.RandomUuid().nextUuid();
+            const containerPort = process.env["TESTCONTAINERS_SSHD_PORT"]
+                ? { container: 22, host: Number(process.env["TESTCONTAINERS_SSHD_PORT"]) }
+                : 22;
+            const container = yield new generic_container_1.GenericContainer(images_1.SSHD_IMAGE)
+                .withName(`testcontainers-port-forwarder-${session_id_1.sessionId}`)
+                .withExposedPorts(containerPort)
+                .withEnvironment({ PASSWORD: password })
+                .withCommand([
+                "sh",
+                "-c",
+                `echo "${username}:$PASSWORD" | chpasswd && /usr/sbin/sshd -D -o PermitRootLogin=yes -o AddressFamily=inet -o GatewayPorts=yes -o AllowAgentForwarding=yes -o AllowTcpForwarding=yes -o KexAlgorithms=+diffie-hellman-group1-sha1 -o HostkeyAlgorithms=+ssh-rsa`,
+            ])
+                .start();
+            const host = (yield (0, docker_client_1.dockerClient)()).host;
+            const port = container.getMappedPort(22);
+            logger_1.log.debug(`Connecting to Port Forwarder on ${host}:${port}`);
+            const connection = yield (0, ssh_remote_port_forward_1.createSshConnection)({ host, port, username, password });
+            connection.unref();
+            return new PortForwarder(connection, container);
+        });
+    }
+}
+exports.PortForwarderInstance = PortForwarderInstance;

package/dist/src/port-generator.d.ts

@@ -0,0 +1,15 @@
+export interface PortGenerator {
+    generatePort(): Promise<number>;
+}
+export declare class RandomUniquePortGenerator implements PortGenerator {
+    private readonly portGenerator;
+    private static readonly assignedPorts;
+    constructor(portGenerator?: PortGenerator);
+    generatePort(): Promise<number>;
+}
+export declare class FixedPortGenerator implements PortGenerator {
+    private readonly ports;
+    private portIndex;
+    constructor(ports: number[]);
+    generatePort(): Promise<number>;
+}

package/dist/src/port-generator.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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FixedPortGenerator = exports.RandomUniquePortGenerator = void 0;
+const get_port_1 = __importDefault(require("get-port"));
+class RandomPortGenerator {
+    generatePort() {
+        return (0, get_port_1.default)({ port: this.randomBetweenInclusive(10000, 65535) });
+    }
+    randomBetweenInclusive(min, max) {
+        return Math.floor(Math.random() * (max - min + 1) + min);
+    }
+}
+class RandomUniquePortGenerator {
+    constructor(portGenerator = new RandomPortGenerator()) {
+        this.portGenerator = portGenerator;
+    }
+    generatePort() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let port;
+            do {
+                port = yield this.portGenerator.generatePort();
+            } while (RandomUniquePortGenerator.assignedPorts.has(port));
+            RandomUniquePortGenerator.assignedPorts.add(port);
+            return port;
+        });
+    }
+}
+exports.RandomUniquePortGenerator = RandomUniquePortGenerator;
+RandomUniquePortGenerator.assignedPorts = new Set();
+class FixedPortGenerator {
+    constructor(ports) {
+        this.ports = ports;
+        this.portIndex = 0;
+    }
+    generatePort() {
+        return Promise.resolve(this.ports[this.portIndex++]);
+    }
+}
+exports.FixedPortGenerator = FixedPortGenerator;

package/dist/src/port.d.ts

@@ -0,0 +1,10 @@
+import { HostIps } from "./docker/lookup-host-ips";
+import { HostPortBindings } from "./docker/types";
+export type PortWithBinding = {
+    container: number;
+    host: number;
+};
+export type PortWithOptionalBinding = number | PortWithBinding;
+export declare const getContainerPort: (port: PortWithOptionalBinding) => number;
+export declare const hasHostBinding: (port: PortWithOptionalBinding) => port is PortWithBinding;
+export declare const resolveHostPortBinding: (hostIps: HostIps, hostPortBindings: HostPortBindings) => number;

package/dist/src/port.js

@@ -0,0 +1,47 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveHostPortBinding = exports.hasHostBinding = exports.getContainerPort = void 0;
+const net = __importStar(require("net"));
+const getContainerPort = (port) => typeof port === "number" ? port : port.container;
+exports.getContainerPort = getContainerPort;
+const hasHostBinding = (port) => {
+    return typeof port === "object" && port.host !== undefined;
+};
+exports.hasHostBinding = hasHostBinding;
+const resolveHostPortBinding = (hostIps, hostPortBindings) => {
+    if (isDualStackIp(hostPortBindings)) {
+        return hostPortBindings[0].hostPort;
+    }
+    for (const { family } of hostIps) {
+        const hostPortBinding = hostPortBindings.find(({ hostIp }) => net.isIP(hostIp) === family);
+        if (hostPortBinding !== undefined) {
+            return hostPortBinding.hostPort;
+        }
+    }
+    throw new Error("No host port found for host IP");
+};
+exports.resolveHostPortBinding = resolveHostPortBinding;
+const isDualStackIp = (hostPortBindings) => hostPortBindings.length === 1 && hostPortBindings[0].hostIp === "";

package/dist/src/pull-policy.d.ts

@@ -0,0 +1,9 @@
+export interface PullPolicy {
+    shouldPull(): boolean;
+}
+export declare class DefaultPullPolicy implements PullPolicy {
+    shouldPull(): boolean;
+}
+export declare class AlwaysPullPolicy implements PullPolicy {
+    shouldPull(): boolean;
+}

package/dist/src/pull-policy.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlwaysPullPolicy = exports.DefaultPullPolicy = void 0;
+class DefaultPullPolicy {
+    shouldPull() {
+        return false;
+    }
+}
+exports.DefaultPullPolicy = DefaultPullPolicy;
+class AlwaysPullPolicy {
+    shouldPull() {
+        return true;
+    }
+}
+exports.AlwaysPullPolicy = AlwaysPullPolicy;

package/dist/src/reaper.d.ts

@@ -0,0 +1,14 @@
+export interface Reaper {
+    addProject(projectName: string): void;
+    getContainerId(): string;
+    stop(): void;
+}
+export declare class ReaperInstance {
+    private static instance?;
+    static getInstance(): Promise<Reaper>;
+    static stopInstance(): Promise<void>;
+    private static isEnabled;
+    private static isPrivileged;
+    private static createDisabledInstance;
+    private static createRealInstance;
+}