testcontainers 9.10.1 → 9.12.0-beta.0

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

@@ -18,7 +18,6 @@ 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 port_forwarder_1 = require("../port-forwarder");
 const pull_image_1 = require("../docker/functions/image/pull-image");
@@ -47,19 +46,19 @@ class GenericContainer {
         this.waitStrategy = wait_1.Wait.forListeningPorts();
         this.networkAliases = [];
         this.pullPolicy = new pull_policy_1.DefaultPullPolicy();
+        this.filesToCopy = [];
+        this.directoriesToCopy = [];
+        this.contentsToCopy = [];
         const imageName = docker_image_name_1.DockerImageName.fromString(image);
         this.opts = (0, create_container_options_1.initCreateContainerOptions)(imageName, imageName.isReaper());
     }
     start() {
         return __awaiter(this, void 0, void 0, function* () {
-            const { dockerode, info } = yield (0, docker_client_1.getDockerClient)();
-            yield (0, pull_image_1.pullImage)(dockerode, info.dockerInfo.indexServerAddress, {
+            const dockerClient = yield (0, docker_client_1.getDockerClient)();
+            yield (0, pull_image_1.pullImage)(dockerClient.dockerode, dockerClient.info.dockerInfo.indexServerAddress, {
                 imageName: this.opts.imageName,
                 force: this.pullPolicy.shouldPull(),
             });
-            if (!this.opts.reusable && !this.opts.imageName.isReaper()) {
-                yield reaper_1.ReaperInstance.getInstance();
-            }
             if (this.beforeContainerStarted) {
                 yield this.beforeContainerStarted();
             }
@@ -70,41 +69,33 @@ class GenericContainer {
                 const portForwarder = yield port_forwarder_1.PortForwarderInstance.getInstance();
                 this.opts.extraHosts.push({ host: "host.testcontainers.internal", ipAddress: portForwarder.getIpAddress() });
             }
-            if (this.networkAliases.length > 0) {
-                this.opts.networkMode = undefined;
-            }
-            else {
-                this.opts.networkMode = this.networkMode;
-            }
+            this.opts.networkMode = this.networkAliases.length > 0 ? undefined : this.networkMode;
             if (this.opts.reusable) {
-                const containerHash = (0, hash_1.hash)(JSON.stringify(this.opts));
-                this.opts.labels = Object.assign(Object.assign({}, this.opts.labels), { [labels_1.LABEL_TESTCONTAINERS_CONTAINER_HASH]: containerHash });
-                logger_1.log.debug(`Container reuse has been enabled with 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}"`, { containerId: container.id });
-                        return this.reuseContainer(container);
-                    }
-                    else {
-                        logger_1.log.debug("No container found to reuse");
-                        return this.startContainer(this.opts);
-                    }
-                }));
-            }
-            else {
-                return this.startContainer(this.opts);
+                return this.reuseOrStartContainer(dockerClient);
             }
+            return this.startContainer(dockerClient, this.opts);
         });
     }
-    reuseContainer(container) {
+    reuseOrStartContainer(dockerClient) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const containerHash = (0, hash_1.hash)(JSON.stringify(this.opts));
+            this.opts.labels = Object.assign(Object.assign({}, this.opts.labels), { [labels_1.LABEL_TESTCONTAINERS_CONTAINER_HASH]: containerHash });
+            logger_1.log.debug(`Container reuse has been enabled with hash "${containerHash}"`);
+            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}"`, { containerId: container.id });
+                    return this.reuseContainer(dockerClient, container);
+                }
+                logger_1.log.debug("No container found to reuse");
+                return this.startContainer(dockerClient, this.opts);
+            }));
+        });
+    }
+    reuseContainer(dockerClient, container) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { host, hostIps } = yield (0, docker_client_1.getDockerClient)();
             const inspectResult = yield (0, inspect_container_1.inspectContainer)(container);
-            const boundPorts = bound_ports_1.BoundPorts.fromInspectResult(hostIps, inspectResult).filter(this.opts.exposedPorts);
+            const boundPorts = bound_ports_1.BoundPorts.fromInspectResult(dockerClient.hostIps, inspectResult).filter(this.opts.exposedPorts);
             if (this.startupTimeout !== undefined) {
                 this.waitStrategy.withStartupTimeout(this.startupTimeout);
             }
@@ -112,7 +103,7 @@ class GenericContainer {
                 yield this.containerStarting(inspectResult, true);
             }
             yield (0, wait_for_container_1.waitForContainer)(container, this.waitStrategy, boundPorts);
-            const startedContainer = new started_generic_container_1.StartedGenericContainer(container, host, inspectResult, boundPorts, inspectResult.name, this.waitStrategy);
+            const startedContainer = new started_generic_container_1.StartedGenericContainer(container, dockerClient.host, inspectResult, boundPorts, inspectResult.name, this.waitStrategy);
             if (this.containerStarted) {
                 yield this.containerStarted(startedContainer, inspectResult, true);
             }
@@ -122,20 +113,11 @@ class GenericContainer {
             return startedContainer;
         });
     }
-    startContainer(createContainerOptions) {
+    startContainer(dockerClient, createContainerOptions) {
         return __awaiter(this, void 0, void 0, function* () {
-            const container = yield (0, create_container_1.createContainer)(createContainerOptions);
+            const container = yield (0, create_container_1.createContainer)(dockerClient.sessionId, createContainerOptions);
             if (!this.opts.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: [],
-                    });
-                }
+                yield this.connectContainerToPortForwarder(container);
             }
             if (this.networkMode && this.networkAliases.length > 0) {
                 yield (0, connect_network_1.connectNetwork)({
@@ -144,9 +126,10 @@ class GenericContainer {
                     networkAliases: this.networkAliases,
                 });
             }
-            if (this.tarToCopy) {
-                this.tarToCopy.finalize();
-                yield (0, put_container_archive_1.putContainerArchive)({ container, stream: this.tarToCopy, containerPath: "/" });
+            if (this.filesToCopy.length > 0 || this.directoriesToCopy.length > 0 || this.contentsToCopy.length > 0) {
+                const archive = this.createArchiveToCopyToContainer();
+                archive.finalize();
+                yield (0, put_container_archive_1.putContainerArchive)({ container, stream: archive, containerPath: "/" });
             }
             logger_1.log.info(`Starting container for image "${this.opts.imageName}"...`, { containerId: container.id });
             if (this.containerCreated) {
@@ -154,19 +137,17 @@ class GenericContainer {
             }
             yield (0, start_container_1.startContainer)(container);
             logger_1.log.info(`Started container for image "${this.opts.imageName}"`, { containerId: container.id });
-            const { host, hostIps } = yield (0, docker_client_1.getDockerClient)();
             const inspectResult = yield (0, inspect_container_1.inspectContainer)(container);
-            const boundPorts = bound_ports_1.BoundPorts.fromInspectResult(hostIps, inspectResult).filter(this.opts.exposedPorts);
+            const boundPorts = bound_ports_1.BoundPorts.fromInspectResult(dockerClient.hostIps, inspectResult).filter(this.opts.exposedPorts);
             if (this.startupTimeout !== undefined) {
                 this.waitStrategy.withStartupTimeout(this.startupTimeout);
             }
             if (logger_1.containerLog.enabled() || this.logConsumer !== undefined) {
-                const logStream = yield (0, container_logs_1.containerLogs)(container);
                 if (this.logConsumer !== undefined) {
-                    this.logConsumer(logStream);
+                    this.logConsumer(yield (0, container_logs_1.containerLogs)(container));
                 }
                 if (logger_1.containerLog.enabled()) {
-                    logStream
+                    (yield (0, container_logs_1.containerLogs)(container))
                         .on("data", (data) => logger_1.containerLog.trace(data.trim(), { containerId: container.id }))
                         .on("err", (data) => logger_1.containerLog.error(data.trim(), { containerId: container.id }));
                 }
@@ -175,7 +156,7 @@ class GenericContainer {
                 yield this.containerStarting(inspectResult, false);
             }
             yield (0, wait_for_container_1.waitForContainer)(container, this.waitStrategy, boundPorts);
-            const startedContainer = new started_generic_container_1.StartedGenericContainer(container, host, inspectResult, boundPorts, inspectResult.name, this.waitStrategy);
+            const startedContainer = new started_generic_container_1.StartedGenericContainer(container, dockerClient.host, inspectResult, boundPorts, inspectResult.name, this.waitStrategy);
             if (this.containerStarted) {
                 yield this.containerStarted(startedContainer, inspectResult, false);
             }
@@ -185,6 +166,33 @@ class GenericContainer {
             return startedContainer;
         });
     }
+    connectContainerToPortForwarder(container) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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: [],
+                });
+            }
+        });
+    }
+    createArchiveToCopyToContainer() {
+        const tar = (0, archiver_1.default)("tar");
+        for (const { source, target, mode } of this.filesToCopy) {
+            tar.file(source, { name: target, mode });
+        }
+        for (const { source, target, mode } of this.directoriesToCopy) {
+            tar.directory(source, target, { mode });
+        }
+        for (const { content, target, mode } of this.contentsToCopy) {
+            tar.append(content, { name: target, mode });
+        }
+        return tar;
+    }
     get hasExposedPorts() {
         return this.opts.exposedPorts.length !== 0;
     }
@@ -287,31 +295,26 @@ class GenericContainer {
         return this;
     }
     withCopyFilesToContainer(filesToCopy) {
-        const tar = this.getTarToCopy();
-        filesToCopy.forEach(({ source, target }) => tar.file(source, { name: target }));
+        this.filesToCopy = [...this.filesToCopy, ...filesToCopy];
         return this;
     }
-    withCopyContentToContainer(contentsToCopy) {
-        const tar = this.getTarToCopy();
-        contentsToCopy.forEach(({ content, target }) => tar.append(content, { name: target }));
+    withCopyDirectoriesToContainer(directoriesToCopy) {
+        this.directoriesToCopy = [...this.directoriesToCopy, ...directoriesToCopy];
         return this;
     }
-    getTarToCopy() {
-        if (!this.tarToCopy) {
-            this.tarToCopy = (0, archiver_1.default)("tar");
-        }
-        return this.tarToCopy;
+    withCopyContentToContainer(contentsToCopy) {
+        this.contentsToCopy = [...this.contentsToCopy, ...contentsToCopy];
+        return this;
     }
     withWorkingDir(workingDir) {
         this.opts.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.opts.resourcesQuota = { memory: ram, cpu: cpuQuota };
+        this.opts.resourcesQuota = {
+            memory: memory !== undefined ? memory * Math.pow(1024, 3) : undefined,
+            cpu: cpu !== undefined ? cpu * Math.pow(10, 9) : undefined,
+        };
         return this;
     }
     withSharedMemorySize(bytes) {

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

@@ -2,7 +2,7 @@
 /// <reference types="node" />
 import { RestartOptions, StartedTestContainer, StopOptions, StoppedTestContainer } from "../test-container";
 import Dockerode from "dockerode";
-import { ContentToCopy, ExecResult, FileToCopy, Labels } from "../docker/types";
+import { ContentToCopy, DirectoryToCopy, ExecResult, FileToCopy, Labels } from "../docker/types";
 import { InspectResult } from "../docker/functions/container/inspect-container";
 import { BoundPorts } from "../bound-ports";
 import { Readable } from "stream";
@@ -32,6 +32,7 @@ export declare class StartedGenericContainer implements StartedTestContainer {
     getNetworkId(networkName: string): string;
     getIpAddress(networkName: string): string;
     copyFilesToContainer(filesToCopy: FileToCopy[]): Promise<void>;
+    copyDirectoriesToContainer(directoriesToCopy: DirectoryToCopy[]): Promise<void>;
     copyContentToContainer(contentsToCopy: ContentToCopy[]): Promise<void>;
     copyArchiveFromContainer(path: string): Promise<NodeJS.ReadableStream>;
     exec(command: string | string[]): Promise<ExecResult>;

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

@@ -122,6 +122,16 @@ class StartedGenericContainer {
             logger_1.log.debug(`Copied files to container`, { containerId: this.container.id });
         });
     }
+    copyDirectoriesToContainer(directoriesToCopy) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.log.debug(`Copying directories to container...`, { containerId: this.container.id });
+            const tar = (0, archiver_1.default)("tar");
+            directoriesToCopy.forEach(({ source, target }) => tar.directory(source, target));
+            tar.finalize();
+            yield (0, put_container_archive_1.putContainerArchive)({ container: this.container, stream: tar, containerPath: "/" });
+            logger_1.log.debug(`Copied directories to container`, { containerId: this.container.id });
+        });
+    }
     copyContentToContainer(contentsToCopy) {
         return __awaiter(this, void 0, void 0, function* () {
             logger_1.log.debug(`Copying content to container...`, { containerId: this.container.id });

package/dist/src/index.d.ts

@@ -1,6 +1,6 @@
 export { TestContainer, StartedTestContainer, StoppedTestContainer } from "./test-container";
 export { GenericContainer } from "./generic-container/generic-container";
-export { GenericContainerBuilder } from "./generic-container/generic-container-builder";
+export { GenericContainerBuilder, BuildOptions } from "./generic-container/generic-container-builder";
 export { TestContainers } from "./test-containers";
 export { DockerComposeEnvironment } from "./docker-compose-environment/docker-compose-environment";
 export { StartedDockerComposeEnvironment } from "./docker-compose-environment/started-docker-compose-environment";

package/dist/src/modules/abstract-started-container.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import { RestartOptions, StartedTestContainer, StopOptions, StoppedTestContainer } from "../test-container";
-import { ContentToCopy, ExecResult, FileToCopy, Labels } from "../docker/types";
+import { ContentToCopy, DirectoryToCopy, ExecResult, FileToCopy, Labels } from "../docker/types";
 import { Readable } from "stream";
 export declare class AbstractStartedContainer implements StartedTestContainer {
     protected readonly startedTestContainer: StartedTestContainer;
@@ -20,6 +20,7 @@ export declare class AbstractStartedContainer implements StartedTestContainer {
     getNetworkId(networkName: string): string;
     getIpAddress(networkName: string): string;
     copyFilesToContainer(filesToCopy: FileToCopy[]): Promise<void>;
+    copyDirectoriesToContainer(directoriesToCopy: DirectoryToCopy[]): Promise<void>;
     copyContentToContainer(contentsToCopy: ContentToCopy[]): Promise<void>;
     copyArchiveFromContainer(path: string): Promise<NodeJS.ReadableStream>;
     exec(command: string | string[]): Promise<ExecResult>;

package/dist/src/modules/abstract-started-container.js

@@ -63,6 +63,11 @@ class AbstractStartedContainer {
             return this.startedTestContainer.copyFilesToContainer(filesToCopy);
         });
     }
+    copyDirectoriesToContainer(directoriesToCopy) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.startedTestContainer.copyDirectoriesToContainer(directoriesToCopy);
+        });
+    }
     copyContentToContainer(contentsToCopy) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.startedTestContainer.copyContentToContainer(contentsToCopy);

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

@@ -35,14 +35,17 @@ class SeleniumContainer extends generic_container_1.GenericContainer {
         return __awaiter(this, void 0, void 0, function* () {
             this.withExposedPorts(SELENIUM_PORT, VNC_PORT)
                 .withSharedMemorySize(2 * 1024 * 1024 * 1024)
-                .withWaitStrategy(wait_1.Wait.forHttp("/wd/hub/status", SELENIUM_PORT).forResponsePredicate((response) => {
-                try {
-                    return JSON.parse(response).value.ready;
-                }
-                catch (_a) {
-                    return false;
-                }
-            }));
+                .withWaitStrategy(wait_1.Wait.forAll([
+                wait_1.Wait.forListeningPorts(),
+                wait_1.Wait.forHttp("/wd/hub/status", SELENIUM_PORT).forResponsePredicate((response) => {
+                    try {
+                        return JSON.parse(response).value.ready;
+                    }
+                    catch (_a) {
+                        return false;
+                    }
+                }),
+            ]));
         });
     }
     withRecording() {

package/dist/src/network.js

@@ -12,9 +12,9 @@ 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");
+const docker_client_1 = require("./docker/client/docker-client");
 class Network {
     constructor(createNetworkOptions = {}, uuid = new uuid_1.RandomUuid()) {
         this.createNetworkOptions = createNetworkOptions;
@@ -25,9 +25,9 @@ class Network {
         return __awaiter(this, void 0, void 0, function* () {
             const name = this.uuid.nextUuid();
             const options = Object.assign({ name, driver: "bridge", checkDuplicate: true, internal: false, attachable: false, ingress: false, enableIPv6: false }, this.createNetworkOptions);
-            yield reaper_1.ReaperInstance.getInstance();
             logger_1.log.info(`Starting network "${name}"...`);
-            const id = yield (0, create_network_1.createNetwork)(options);
+            const { sessionId } = yield (0, docker_client_1.getDockerClient)();
+            const id = yield (0, create_network_1.createNetwork)(sessionId, options);
             logger_1.log.info(`Started network "${name}" with ID "${id}"`);
             return new StartedNetwork(id, options);
         });

package/dist/src/port-forwarder.js

@@ -14,7 +14,6 @@ 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/client/docker-client");
 const images_1 = require("./images");
 class PortForwarder {
@@ -60,8 +59,9 @@ class PortForwarderInstance {
             const containerPort = process.env["TESTCONTAINERS_SSHD_PORT"]
                 ? { container: 22, host: Number(process.env["TESTCONTAINERS_SSHD_PORT"]) }
                 : 22;
+            const { sessionId } = yield (0, docker_client_1.getDockerClient)();
             const container = yield new generic_container_1.GenericContainer(images_1.SSHD_IMAGE)
-                .withName(`testcontainers-port-forwarder-${session_id_1.sessionId}`)
+                .withName(`testcontainers-port-forwarder-${sessionId}`)
                 .withExposedPorts(containerPort)
                 .withEnvironment({ PASSWORD: password })
                 .withCommand([

package/dist/src/reaper.d.ts

@@ -1,14 +1,5 @@
-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;
-}
+import { PartialDockerClient } from "./docker/client/docker-client-types";
+import Dockerode from "dockerode";
+export declare function registerSessionIdForCleanup(sessionId: string): Promise<void>;
+export declare function registerComposeProjectForCleanup(project: string): Promise<void>;
+export declare function startReaper(dockerClient: PartialDockerClient, sessionId: string, existingReaperContainer?: Dockerode.ContainerInfo): Promise<void>;