testcontainers 9.2.0 → 9.3.0

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

@@ -0,0 +1,77 @@
+import archiver from "archiver";
+import { BoundPorts } from "../bound-ports";
+import { PortWithOptionalBinding } from "../port";
+import { PullPolicy } from "../pull-policy";
+import { StartedTestContainer, TestContainer } from "../test-container";
+import { WaitStrategy } from "../wait-strategy";
+import { BindMount, ContentToCopy, Environment, ExtraHost, FileToCopy, HealthCheck, Labels, TmpFs, Ulimits, ResourcesQuota } from "../docker/types";
+import { InspectResult } from "../docker/functions/container/inspect-container";
+import { GenericContainerBuilder } from "./generic-container-builder";
+import { StartedNetwork } from "../network";
+export declare class GenericContainer implements TestContainer {
+    readonly image: string;
+    static fromDockerfile(context: string, dockerfileName?: string): GenericContainerBuilder;
+    private readonly imageName;
+    protected environment: Environment;
+    protected networkMode?: string;
+    protected networkAliases: string[];
+    protected ports: PortWithOptionalBinding[];
+    protected command: string[];
+    protected entrypoint?: string[];
+    protected bindMounts: BindMount[];
+    protected name?: string;
+    protected labels: Labels;
+    protected tmpFs: TmpFs;
+    protected healthCheck?: HealthCheck;
+    protected waitStrategy?: WaitStrategy;
+    protected startupTimeout: number;
+    protected useDefaultLogDriver: boolean;
+    protected privilegedMode: boolean;
+    protected workingDir?: string;
+    protected ipcMode?: string;
+    protected ulimits?: Ulimits;
+    protected addedCapabilities?: string[];
+    protected droppedCapabilities?: string[];
+    protected user?: string;
+    protected pullPolicy: PullPolicy;
+    protected reuse: boolean;
+    protected tarToCopy?: archiver.Archiver;
+    protected resourcesQuota?: ResourcesQuota;
+    private extraHosts;
+    constructor(image: string);
+    protected preStart?(): Promise<void>;
+    start(): Promise<StartedTestContainer>;
+    private reuseContainer;
+    private startContainer;
+    protected postStart?(container: StartedTestContainer, inspectResult: InspectResult, boundPorts: BoundPorts): Promise<void>;
+    protected get hasExposedPorts(): boolean;
+    withCommand(command: string[]): this;
+    withEntrypoint(entrypoint: string[]): this;
+    withName(name: string): this;
+    withLabels(labels: Labels): this;
+    withEnvironment(environment: Environment): this;
+    withTmpFs(tmpFs: TmpFs): this;
+    withUlimits(ulimits: Ulimits): this;
+    withAddedCapabilities(...capabilities: string[]): this;
+    withDroppedCapabilities(...capabilities: string[]): this;
+    withNetwork(network: StartedNetwork): this;
+    withNetworkMode(networkMode: string): this;
+    withNetworkAliases(...networkAliases: string[]): this;
+    withExtraHosts(extraHosts: ExtraHost[]): this;
+    withExposedPorts(...ports: PortWithOptionalBinding[]): this;
+    withBindMounts(bindMounts: BindMount[]): this;
+    withHealthCheck(healthCheck: HealthCheck): this;
+    withStartupTimeout(startupTimeoutMs: number): this;
+    withWaitStrategy(waitStrategy: WaitStrategy): this;
+    withDefaultLogDriver(): this;
+    withPrivilegedMode(): this;
+    withUser(user: string): this;
+    withReuse(): this;
+    withPullPolicy(pullPolicy: PullPolicy): this;
+    withIpcMode(ipcMode: string): this;
+    withCopyFilesToContainer(filesToCopy: FileToCopy[]): this;
+    withCopyContentToContainer(contentsToCopy: ContentToCopy[]): this;
+    protected getTarToCopy(): archiver.Archiver;
+    withWorkingDir(workingDir: string): this;
+    withResourcesQuota({ memory, cpu }: ResourcesQuota): this;
+}

package/dist/src/generic-container/generic-container.js

@@ -0,0 +1,312 @@
+"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.GenericContainer = void 0;
+const archiver_1 = __importDefault(require("archiver"));
+const async_lock_1 = __importDefault(require("async-lock"));
+const bound_ports_1 = require("../bound-ports");
+const logger_1 = require("../logger");
+const pull_policy_1 = require("../pull-policy");
+const reaper_1 = require("../reaper");
+const docker_image_name_1 = require("../docker-image-name");
+const wait_strategy_1 = require("../wait-strategy");
+const port_forwarder_1 = require("../port-forwarder");
+const pull_image_1 = require("../docker/functions/image/pull-image");
+const create_container_1 = require("../docker/functions/container/create-container");
+const connect_network_1 = require("../docker/functions/network/connect-network");
+const docker_client_1 = require("../docker/docker-client");
+const inspect_container_1 = require("../docker/functions/container/inspect-container");
+const start_container_1 = require("../docker/functions/container/start-container");
+const container_logs_1 = require("../docker/functions/container/container-logs");
+const put_container_archive_1 = require("../docker/functions/container/put-container-archive");
+const generic_container_builder_1 = require("./generic-container-builder");
+const started_generic_container_1 = require("./started-generic-container");
+const hash_1 = require("../hash");
+const get_container_1 = require("../docker/functions/container/get-container");
+const labels_1 = require("../labels");
+const wait_for_container_1 = require("../wait-for-container");
+const reusableContainerCreationLock = new async_lock_1.default();
+class GenericContainer {
+    static fromDockerfile(context, dockerfileName = "Dockerfile") {
+        return new generic_container_builder_1.GenericContainerBuilder(context, dockerfileName);
+    }
+    constructor(image) {
+        this.image = image;
+        this.environment = {};
+        this.networkAliases = [];
+        this.ports = [];
+        this.command = [];
+        this.bindMounts = [];
+        this.labels = {};
+        this.tmpFs = {};
+        this.startupTimeout = 60000;
+        this.useDefaultLogDriver = false;
+        this.privilegedMode = false;
+        this.pullPolicy = new pull_policy_1.DefaultPullPolicy();
+        this.reuse = false;
+        this.extraHosts = [];
+        this.imageName = docker_image_name_1.DockerImageName.fromString(image);
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { dockerode, indexServerAddress } = yield (0, docker_client_1.dockerClient)();
+            yield (0, pull_image_1.pullImage)(dockerode, indexServerAddress, {
+                imageName: this.imageName,
+                force: this.pullPolicy.shouldPull(),
+            });
+            if (!this.reuse && !this.imageName.isReaper()) {
+                yield reaper_1.ReaperInstance.getInstance();
+            }
+            if (this.preStart) {
+                yield this.preStart();
+            }
+            if (!this.imageName.isHelperContainer() && port_forwarder_1.PortForwarderInstance.isRunning()) {
+                const portForwarder = yield port_forwarder_1.PortForwarderInstance.getInstance();
+                this.extraHosts.push({ host: "host.testcontainers.internal", ipAddress: portForwarder.getIpAddress() });
+            }
+            const createContainerOptions = {
+                imageName: this.imageName,
+                environment: this.environment,
+                command: this.command,
+                entrypoint: this.entrypoint,
+                bindMounts: this.bindMounts,
+                tmpFs: this.tmpFs,
+                exposedPorts: this.ports,
+                name: this.name,
+                labels: this.labels,
+                reusable: this.reuse,
+                networkMode: this.networkAliases.length > 0 ? undefined : this.networkMode,
+                healthCheck: this.healthCheck,
+                useDefaultLogDriver: this.useDefaultLogDriver,
+                privilegedMode: this.privilegedMode,
+                autoRemove: this.imageName.isReaper(),
+                extraHosts: this.extraHosts,
+                ipcMode: this.ipcMode,
+                ulimits: this.ulimits,
+                addedCapabilities: this.addedCapabilities,
+                droppedCapabilities: this.droppedCapabilities,
+                user: this.user,
+                workingDir: this.workingDir,
+                resourcesQuota: this.resourcesQuota,
+            };
+            if (this.reuse) {
+                const containerHash = (0, hash_1.hash)(JSON.stringify(createContainerOptions));
+                createContainerOptions.labels = Object.assign(Object.assign({}, createContainerOptions.labels), { [labels_1.LABEL_TESTCONTAINERS_CONTAINER_HASH]: containerHash });
+                logger_1.log.debug(`Container reuse has been enabled, hash: ${containerHash}`);
+                // We might have several async processes try to create a reusable container
+                // at once, to avoid possibly creating too many of these, use a lock
+                // on the containerHash, this ensures that only single reusable instance is created
+                return reusableContainerCreationLock.acquire(containerHash, () => __awaiter(this, void 0, void 0, function* () {
+                    const container = yield (0, get_container_1.getContainerByHash)(containerHash);
+                    if (container !== undefined) {
+                        logger_1.log.debug(`Found container to reuse with hash: ${containerHash}`);
+                        return this.reuseContainer(container);
+                    }
+                    else {
+                        logger_1.log.debug("No container found to reuse");
+                        return this.startContainer(createContainerOptions);
+                    }
+                }));
+            }
+            else {
+                return this.startContainer(createContainerOptions);
+            }
+        });
+    }
+    reuseContainer(startedContainer) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { host, hostIps } = yield (0, docker_client_1.dockerClient)();
+            const inspectResult = yield (0, inspect_container_1.inspectContainer)(startedContainer);
+            const boundPorts = bound_ports_1.BoundPorts.fromInspectResult(hostIps, inspectResult).filter(this.ports);
+            const waitStrategy = ((_a = this.waitStrategy) !== null && _a !== void 0 ? _a : (0, wait_strategy_1.defaultWaitStrategy)(host, startedContainer)).withStartupTimeout(this.startupTimeout);
+            yield (0, wait_for_container_1.waitForContainer)(startedContainer, waitStrategy, host, boundPorts);
+            return new started_generic_container_1.StartedGenericContainer(startedContainer, host, inspectResult, boundPorts, inspectResult.name, waitStrategy);
+        });
+    }
+    startContainer(createContainerOptions) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const container = yield (0, create_container_1.createContainer)(createContainerOptions);
+            if (!this.imageName.isHelperContainer() && port_forwarder_1.PortForwarderInstance.isRunning()) {
+                const portForwarder = yield port_forwarder_1.PortForwarderInstance.getInstance();
+                const portForwarderNetworkId = portForwarder.getNetworkId();
+                const excludedNetworks = [portForwarderNetworkId, "none", "host"];
+                if (!this.networkMode || !excludedNetworks.includes(this.networkMode)) {
+                    yield (0, connect_network_1.connectNetwork)({
+                        containerId: container.id,
+                        networkId: portForwarderNetworkId,
+                        networkAliases: [],
+                    });
+                }
+            }
+            if (this.networkMode && this.networkAliases.length > 0) {
+                yield (0, connect_network_1.connectNetwork)({
+                    containerId: container.id,
+                    networkId: this.networkMode,
+                    networkAliases: this.networkAliases,
+                });
+            }
+            if (this.tarToCopy) {
+                this.tarToCopy.finalize();
+                yield (0, put_container_archive_1.putContainerArchive)({ container, stream: this.tarToCopy, containerPath: "/" });
+            }
+            logger_1.log.info(`Starting container ${this.imageName} with ID: ${container.id}`);
+            yield (0, start_container_1.startContainer)(container);
+            const { host, hostIps } = yield (0, docker_client_1.dockerClient)();
+            const inspectResult = yield (0, inspect_container_1.inspectContainer)(container);
+            const boundPorts = bound_ports_1.BoundPorts.fromInspectResult(hostIps, inspectResult).filter(this.ports);
+            const waitStrategy = ((_a = this.waitStrategy) !== null && _a !== void 0 ? _a : (0, wait_strategy_1.defaultWaitStrategy)(host, container)).withStartupTimeout(this.startupTimeout);
+            (yield (0, container_logs_1.containerLogs)(container))
+                .on("data", (data) => logger_1.containerLog.trace(`${container.id}: ${data.trim()}`))
+                .on("err", (data) => logger_1.containerLog.error(`${container.id}: ${data.trim()}`));
+            yield (0, wait_for_container_1.waitForContainer)(container, waitStrategy, host, boundPorts);
+            const startedContainer = new started_generic_container_1.StartedGenericContainer(container, host, inspectResult, boundPorts, inspectResult.name, waitStrategy);
+            if (this.postStart) {
+                yield this.postStart(startedContainer, inspectResult, boundPorts);
+            }
+            return startedContainer;
+        });
+    }
+    get hasExposedPorts() {
+        return this.ports.length !== 0;
+    }
+    withCommand(command) {
+        this.command = command;
+        return this;
+    }
+    withEntrypoint(entrypoint) {
+        this.entrypoint = entrypoint;
+        return this;
+    }
+    withName(name) {
+        this.name = name;
+        return this;
+    }
+    withLabels(labels) {
+        this.labels = Object.assign(Object.assign({}, this.labels), labels);
+        return this;
+    }
+    withEnvironment(environment) {
+        this.environment = Object.assign(Object.assign({}, this.environment), environment);
+        return this;
+    }
+    withTmpFs(tmpFs) {
+        this.tmpFs = Object.assign(Object.assign({}, this.tmpFs), tmpFs);
+        return this;
+    }
+    withUlimits(ulimits) {
+        this.ulimits = Object.assign(Object.assign({}, this.ulimits), ulimits);
+        return this;
+    }
+    withAddedCapabilities(...capabilities) {
+        var _a;
+        this.addedCapabilities = [...((_a = this.addedCapabilities) !== null && _a !== void 0 ? _a : []), ...capabilities];
+        return this;
+    }
+    withDroppedCapabilities(...capabilities) {
+        var _a;
+        this.droppedCapabilities = [...((_a = this.droppedCapabilities) !== null && _a !== void 0 ? _a : []), ...capabilities];
+        return this;
+    }
+    withNetwork(network) {
+        this.networkMode = network.getName();
+        return this;
+    }
+    withNetworkMode(networkMode) {
+        this.networkMode = networkMode;
+        return this;
+    }
+    withNetworkAliases(...networkAliases) {
+        this.networkAliases = [...this.networkAliases, ...networkAliases];
+        return this;
+    }
+    withExtraHosts(extraHosts) {
+        this.extraHosts = [...this.extraHosts, ...extraHosts];
+        return this;
+    }
+    withExposedPorts(...ports) {
+        this.ports = [...this.ports, ...ports];
+        return this;
+    }
+    withBindMounts(bindMounts) {
+        this.bindMounts = bindMounts.map((bindMount) => (Object.assign({ mode: "rw" }, bindMount)));
+        return this;
+    }
+    withHealthCheck(healthCheck) {
+        this.healthCheck = healthCheck;
+        return this;
+    }
+    withStartupTimeout(startupTimeoutMs) {
+        this.startupTimeout = startupTimeoutMs;
+        return this;
+    }
+    withWaitStrategy(waitStrategy) {
+        this.waitStrategy = waitStrategy;
+        return this;
+    }
+    withDefaultLogDriver() {
+        this.useDefaultLogDriver = true;
+        return this;
+    }
+    withPrivilegedMode() {
+        this.privilegedMode = true;
+        return this;
+    }
+    withUser(user) {
+        this.user = user;
+        return this;
+    }
+    withReuse() {
+        this.reuse = true;
+        return this;
+    }
+    withPullPolicy(pullPolicy) {
+        this.pullPolicy = pullPolicy;
+        return this;
+    }
+    withIpcMode(ipcMode) {
+        this.ipcMode = ipcMode;
+        return this;
+    }
+    withCopyFilesToContainer(filesToCopy) {
+        const tar = this.getTarToCopy();
+        filesToCopy.forEach(({ source, target }) => tar.file(source, { name: target }));
+        return this;
+    }
+    withCopyContentToContainer(contentsToCopy) {
+        const tar = this.getTarToCopy();
+        contentsToCopy.forEach(({ content, target }) => tar.append(content, { name: target }));
+        return this;
+    }
+    getTarToCopy() {
+        if (!this.tarToCopy) {
+            this.tarToCopy = (0, archiver_1.default)("tar");
+        }
+        return this.tarToCopy;
+    }
+    withWorkingDir(workingDir) {
+        this.workingDir = workingDir;
+        return this;
+    }
+    withResourcesQuota({ memory, cpu }) {
+        // Memory and CPU units from here: https://docs.docker.com/engine/api/v1.42/#tag/Container/operation/ContainerCreate
+        // see Memory, NanoCpus parameters
+        const ram = memory !== undefined ? memory * Math.pow(1024, 3) : undefined;
+        const cpuQuota = cpu !== undefined ? cpu * Math.pow(10, 9) : undefined;
+        this.resourcesQuota = { memory: ram, cpu: cpuQuota };
+        return this;
+    }
+}
+exports.GenericContainer = GenericContainer;

package/dist/src/generic-container/started-generic-container.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+import { ExecOptions, RestartOptions, StartedTestContainer, StopOptions, StoppedTestContainer } from "../test-container";
+import Dockerode from "dockerode";
+import { ExecResult, Labels } from "../docker/types";
+import { InspectResult } from "../docker/functions/container/inspect-container";
+import { BoundPorts } from "../bound-ports";
+import { Readable } from "stream";
+import { WaitStrategy } from "../wait-strategy";
+export declare class StartedGenericContainer implements StartedTestContainer {
+    private readonly container;
+    private readonly host;
+    private inspectResult;
+    private boundPorts;
+    private readonly name;
+    private readonly waitStrategy;
+    constructor(container: Dockerode.Container, host: string, inspectResult: InspectResult, boundPorts: BoundPorts, name: string, waitStrategy: WaitStrategy);
+    stop(options?: Partial<StopOptions>): Promise<StoppedTestContainer>;
+    restart(options?: Partial<RestartOptions>): Promise<void>;
+    private stopContainer;
+    getHost(): string;
+    getFirstMappedPort(): number;
+    getMappedPort(port: number): number;
+    getId(): string;
+    getName(): string;
+    getLabels(): Labels;
+    getNetworkNames(): string[];
+    getNetworkId(networkName: string): string;
+    getIpAddress(networkName: string): string;
+    exec(command: string[], options?: Partial<ExecOptions>): Promise<ExecResult>;
+    logs(): Promise<Readable>;
+}

package/dist/src/generic-container/started-generic-container.js

@@ -0,0 +1,97 @@
+"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.StartedGenericContainer = void 0;
+const inspect_container_1 = require("../docker/functions/container/inspect-container");
+const bound_ports_1 = require("../bound-ports");
+const logger_1 = require("../logger");
+const remove_container_1 = require("../docker/functions/container/remove-container");
+const exec_container_1 = require("../docker/functions/container/exec-container");
+const container_logs_1 = require("../docker/functions/container/container-logs");
+const stopped_generic_container_1 = require("./stopped-generic-container");
+const stop_container_1 = require("../docker/functions/container/stop-container");
+const restart_container_1 = require("../docker/functions/container/restart-container");
+const wait_for_container_1 = require("../wait-for-container");
+const docker_client_1 = require("../docker/docker-client");
+class StartedGenericContainer {
+    constructor(container, host, inspectResult, boundPorts, name, waitStrategy) {
+        this.container = container;
+        this.host = host;
+        this.inspectResult = inspectResult;
+        this.boundPorts = boundPorts;
+        this.name = name;
+        this.waitStrategy = waitStrategy;
+    }
+    stop(options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.stopContainer(options);
+        });
+    }
+    restart(options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resolvedOptions = Object.assign({ timeout: 0 }, options);
+            logger_1.log.info(`Restarting container with ID: ${this.container.id}`);
+            yield (0, restart_container_1.restartContainer)(this.container, resolvedOptions);
+            const { hostIps } = yield (0, docker_client_1.dockerClient)();
+            this.inspectResult = yield (0, inspect_container_1.inspectContainer)(this.container);
+            const startTime = this.inspectResult.state.startedAt;
+            (yield (0, container_logs_1.containerLogs)(this.container, { since: startTime }))
+                .on("data", (data) => logger_1.containerLog.trace(`${this.container.id}: ${data.trim()}`))
+                .on("err", (data) => logger_1.containerLog.error(`${this.container.id}: ${data.trim()}`));
+            this.boundPorts = bound_ports_1.BoundPorts.fromInspectResult(hostIps, this.inspectResult).filter(Array.from(this.boundPorts.iterator()).map((port) => port[0]));
+            yield (0, wait_for_container_1.waitForContainer)(this.container, this.waitStrategy, this.host, this.boundPorts, startTime);
+        });
+    }
+    stopContainer(options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.log.info(`Stopping container with ID: ${this.container.id}`);
+            const resolvedOptions = Object.assign({ timeout: 0, removeVolumes: true }, options);
+            yield (0, stop_container_1.stopContainer)(this.container, { timeout: resolvedOptions.timeout });
+            yield (0, remove_container_1.removeContainer)(this.container, { removeVolumes: resolvedOptions.removeVolumes });
+            return new stopped_generic_container_1.StoppedGenericContainer();
+        });
+    }
+    getHost() {
+        return this.host;
+    }
+    getFirstMappedPort() {
+        return this.boundPorts.getFirstBinding();
+    }
+    getMappedPort(port) {
+        return this.boundPorts.getBinding(port);
+    }
+    getId() {
+        return this.container.id;
+    }
+    getName() {
+        return this.name;
+    }
+    getLabels() {
+        return this.inspectResult.labels;
+    }
+    getNetworkNames() {
+        return Object.keys(this.inspectResult.networkSettings);
+    }
+    getNetworkId(networkName) {
+        return this.inspectResult.networkSettings[networkName].networkId;
+    }
+    getIpAddress(networkName) {
+        return this.inspectResult.networkSettings[networkName].ipAddress;
+    }
+    exec(command, options = {}) {
+        const resolvedOptions = Object.assign({ stdin: true, detach: false, tty: true }, options);
+        return (0, exec_container_1.execContainer)(this.container, command, resolvedOptions);
+    }
+    logs() {
+        return (0, container_logs_1.containerLogs)(this.container);
+    }
+}
+exports.StartedGenericContainer = StartedGenericContainer;

package/dist/src/generic-container/stopped-generic-container.d.ts

@@ -0,0 +1,3 @@
+import { StoppedTestContainer } from "../test-container";
+export declare class StoppedGenericContainer implements StoppedTestContainer {
+}

package/dist/src/generic-container/stopped-generic-container.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoppedGenericContainer = void 0;
+class StoppedGenericContainer {
+}
+exports.StoppedGenericContainer = StoppedGenericContainer;

package/dist/src/hash.d.ts

@@ -0,0 +1 @@
+export declare const hash: (str: string) => string;

package/dist/src/hash.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hash = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const hash = (str) => {
+    return crypto_1.default.createHash("md5").update(str).digest("hex");
+};
+exports.hash = hash;

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

@@ -0,0 +1,27 @@
+import Dockerode from "dockerode";
+import { BoundPorts } from "./bound-ports";
+import { AbstractWaitStrategy } from "./wait-strategy";
+export declare class HttpWaitStrategy extends AbstractWaitStrategy {
+    private readonly path;
+    private readonly port;
+    private protocol;
+    private method;
+    private headers;
+    private predicates;
+    private _allowInsecure;
+    private readTimeout;
+    constructor(path: string, port: number);
+    forStatusCode(statusCode: number): HttpWaitStrategy;
+    forStatusCodeMatching(predicate: (statusCode: number) => boolean): HttpWaitStrategy;
+    forResponsePredicate(predicate: (response: string) => boolean): HttpWaitStrategy;
+    withMethod(method: string): HttpWaitStrategy;
+    withHeaders(headers: {
+        [key: string]: string;
+    }): HttpWaitStrategy;
+    withBasicCredentials(username: string, password: string): HttpWaitStrategy;
+    withReadTimeout(readTimeout: number): HttpWaitStrategy;
+    usingTls(): HttpWaitStrategy;
+    allowInsecure(): HttpWaitStrategy;
+    waitUntilReady(container: Dockerode.Container, host: string, boundPorts: BoundPorts): Promise<void>;
+    private getAgent;
+}