testcontainers 9.10.1 → 9.12.0-beta.0

package/dist/src/docker-compose/docker-compose-client.js

@@ -0,0 +1,221 @@
+"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;
+};
+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.getDockerComposeClient = void 0;
+const logger_1 = require("../logger");
+const docker_compose_1 = __importStar(require("docker-compose"));
+const docker_compose_options_1 = require("./docker-compose-options");
+function getDockerComposeClient(compat) {
+    switch (compat) {
+        case undefined:
+            return new MissingDockerComposeClient();
+        case "v1":
+            return new DockerComposeV1Client();
+        case "v2":
+            return new DockerComposeV2Client();
+    }
+}
+exports.getDockerComposeClient = getDockerComposeClient;
+class DockerComposeV1Client {
+    up(options, services) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (services) {
+                    logger_1.log.info(`Upping DockerCompose environment services ${services.join(", ")}...`);
+                    yield docker_compose_1.default.upMany(services, yield (0, docker_compose_options_1.defaultDockerComposeOptions)(options));
+                }
+                else {
+                    logger_1.log.info(`Upping DockerCompose environment...`);
+                    yield docker_compose_1.default.upAll(yield (0, docker_compose_options_1.defaultDockerComposeOptions)(options));
+                }
+                logger_1.log.info(`Upped DockerCompose environment`);
+            }
+            catch (err) {
+                yield handleAndRethrow(err, (error) => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        logger_1.log.error(`Failed to up DockerCompose environment: ${error.message}`);
+                        yield this.down(options, { removeVolumes: true, timeout: 0 });
+                    }
+                    catch (_a) {
+                        logger_1.log.error(`Failed to down DockerCompose environment after failed up`);
+                    }
+                }));
+            }
+        });
+    }
+    pull(options, services) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (services) {
+                    logger_1.log.info(`Pulling DockerCompose environment images "${services.join('", "')}"...`);
+                    yield docker_compose_1.default.pullMany(services, yield (0, docker_compose_options_1.defaultDockerComposeOptions)(Object.assign(Object.assign({}, options), { logger: logger_1.pullLog })));
+                }
+                else {
+                    logger_1.log.info(`Pulling DockerCompose environment images...`);
+                    yield docker_compose_1.default.pullAll(yield (0, docker_compose_options_1.defaultDockerComposeOptions)(Object.assign(Object.assign({}, options), { logger: logger_1.pullLog })));
+                }
+                logger_1.log.info(`Pulled DockerCompose environment`);
+            }
+            catch (err) {
+                yield handleAndRethrow(err, (error) => __awaiter(this, void 0, void 0, function* () { return logger_1.log.error(`Failed to pull DockerCompose environment images: ${error.message}`); }));
+            }
+        });
+    }
+    stop(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                logger_1.log.info(`Stopping DockerCompose environment...`);
+                yield docker_compose_1.default.stop(yield (0, docker_compose_options_1.defaultDockerComposeOptions)(options));
+                logger_1.log.info(`Stopped DockerCompose environment`);
+            }
+            catch (err) {
+                yield handleAndRethrow(err, (error) => __awaiter(this, void 0, void 0, function* () { return logger_1.log.error(`Failed to stop DockerCompose environment: ${error.message}`); }));
+            }
+        });
+    }
+    down(options, downOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                logger_1.log.info(`Downing DockerCompose environment...`);
+                yield docker_compose_1.default.down(Object.assign(Object.assign({}, (yield (0, docker_compose_options_1.defaultDockerComposeOptions)(options))), { commandOptions: dockerComposeDownCommandOptions(downOptions) }));
+                logger_1.log.info(`Downed DockerCompose environment`);
+            }
+            catch (err) {
+                yield handleAndRethrow(err, (error) => __awaiter(this, void 0, void 0, function* () { return logger_1.log.error(`Failed to down DockerCompose environment: ${error.message}`); }));
+            }
+        });
+    }
+}
+class DockerComposeV2Client {
+    up(options, services) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (services) {
+                    logger_1.log.info(`Upping DockerCompose environment services ${services.join(", ")}...`);
+                    yield docker_compose_1.v2.upMany(services, yield (0, docker_compose_options_1.defaultDockerComposeOptions)(options));
+                }
+                else {
+                    logger_1.log.info(`Upping DockerCompose environment...`);
+                    yield docker_compose_1.v2.upAll(yield (0, docker_compose_options_1.defaultDockerComposeOptions)(options));
+                }
+                logger_1.log.info(`Upped DockerCompose environment`);
+            }
+            catch (err) {
+                yield handleAndRethrow(err, (error) => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        logger_1.log.error(`Failed to up DockerCompose environment: ${error.message}`);
+                        yield this.down(options, { removeVolumes: true, timeout: 0 });
+                    }
+                    catch (_a) {
+                        logger_1.log.error(`Failed to down DockerCompose environment after failed up`);
+                    }
+                }));
+            }
+        });
+    }
+    pull(options, services) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (services) {
+                    logger_1.log.info(`Pulling DockerCompose environment images "${services.join('", "')}"...`);
+                    yield docker_compose_1.v2.pullMany(services, yield (0, docker_compose_options_1.defaultDockerComposeOptions)(Object.assign(Object.assign({}, options), { logger: logger_1.pullLog })));
+                }
+                else {
+                    logger_1.log.info(`Pulling DockerCompose environment images...`);
+                    yield docker_compose_1.v2.pullAll(yield (0, docker_compose_options_1.defaultDockerComposeOptions)(Object.assign(Object.assign({}, options), { logger: logger_1.pullLog })));
+                }
+                logger_1.log.info(`Pulled DockerCompose environment`);
+            }
+            catch (err) {
+                yield handleAndRethrow(err, (error) => __awaiter(this, void 0, void 0, function* () { return logger_1.log.error(`Failed to pull DockerCompose environment images: ${error.message}`); }));
+            }
+        });
+    }
+    stop(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                logger_1.log.info(`Stopping DockerCompose environment...`);
+                yield docker_compose_1.v2.stop(yield (0, docker_compose_options_1.defaultDockerComposeOptions)(options));
+                logger_1.log.info(`Stopped DockerCompose environment`);
+            }
+            catch (err) {
+                yield handleAndRethrow(err, (error) => __awaiter(this, void 0, void 0, function* () { return logger_1.log.error(`Failed to stop DockerCompose environment: ${error.message}`); }));
+            }
+        });
+    }
+    down(options, downOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                logger_1.log.info(`Downing DockerCompose environment...`);
+                yield docker_compose_1.v2.down(Object.assign(Object.assign({}, (yield (0, docker_compose_options_1.defaultDockerComposeOptions)(options))), { commandOptions: dockerComposeDownCommandOptions(downOptions) }));
+                logger_1.log.info(`Downed DockerCompose environment`);
+            }
+            catch (err) {
+                yield handleAndRethrow(err, (error) => __awaiter(this, void 0, void 0, function* () { return logger_1.log.error(`Failed to down DockerCompose environment: ${error.message}`); }));
+            }
+        });
+    }
+}
+class MissingDockerComposeClient {
+    up() {
+        throw new Error("DockerCompose is not installed");
+    }
+    pull() {
+        throw new Error("DockerCompose is not installed");
+    }
+    stop() {
+        throw new Error("DockerCompose is not installed");
+    }
+    down() {
+        throw new Error("DockerCompose is not installed");
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function handleAndRethrow(err, handle) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const error = err instanceof Error ? err : new Error(err.err.trim());
+        yield handle(error);
+        throw error;
+    });
+}
+function dockerComposeDownCommandOptions(options) {
+    const result = [];
+    if (options.removeVolumes) {
+        result.push("-v");
+    }
+    if (options.timeout) {
+        result.push("-t", `${options.timeout / 1000}`);
+    }
+    return result;
+}

package/dist/src/docker-compose/docker-compose-options.d.ts

@@ -1,5 +1,6 @@
 import { Environment } from "../docker/types";
 import { Logger } from "../logger";
+import { IDockerComposeOptions } from "docker-compose";
 export type DockerComposeOptions = {
     filePath: string;
     files: string | string[];
@@ -9,3 +10,8 @@ export type DockerComposeOptions = {
     environment?: Environment;
     logger?: Logger;
 };
+export declare const defaultDockerComposeOptions: ({ environment, ...options }: DockerComposeOptions) => Promise<Partial<IDockerComposeOptions>>;
+export type DockerComposeDownOptions = {
+    timeout: number;
+    removeVolumes: boolean;
+};

package/dist/src/docker-compose/docker-compose-options.js

@@ -1,2 +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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultDockerComposeOptions = void 0;
+const logger_1 = require("../logger");
+const docker_client_1 = require("../docker/client/docker-client");
+const os_1 = require("os");
+const type_guards_1 = require("../type-guards");
+const defaultDockerComposeOptions = (_a) => __awaiter(void 0, void 0, void 0, function* () {
+    var _b;
+    var { environment = {} } = _a, options = __rest(_a, ["environment"]);
+    const { composeEnvironment } = yield (0, docker_client_1.getDockerClient)();
+    const log = (_b = options.logger) !== null && _b !== void 0 ? _b : logger_1.composeLog;
+    return {
+        log: false,
+        callback: log.enabled()
+            ? (chunk) => {
+                chunk
+                    .toString()
+                    .split(os_1.EOL)
+                    .filter(type_guards_1.isNotEmptyString)
+                    .forEach((line) => log.trace(line.trim()));
+            }
+            : undefined,
+        cwd: options.filePath,
+        config: options.files,
+        composeOptions: options.composeOptions,
+        commandOptions: options.commandOptions,
+        env: Object.assign(Object.assign(Object.assign(Object.assign({}, process.env), { COMPOSE_PROJECT_NAME: options.projectName }), composeEnvironment), environment),
+    };
+});
+exports.defaultDockerComposeOptions = defaultDockerComposeOptions;

package/dist/src/docker-compose-environment/docker-compose-environment.js

@@ -11,10 +11,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DockerComposeEnvironment = void 0;
 const bound_ports_1 = require("../bound-ports");
-const container_name_resolver_1 = require("../docker-compose/functions/container-name-resolver");
+const container_name_resolver_1 = require("../docker-compose/container-name-resolver");
 const started_generic_container_1 = require("../generic-container/started-generic-container");
 const logger_1 = require("../logger");
-const reaper_1 = require("../reaper");
 const uuid_1 = require("../uuid");
 const list_containers_1 = require("../docker/functions/container/list-containers");
 const get_container_1 = require("../docker/functions/container/get-container");
@@ -22,12 +21,10 @@ const docker_client_1 = require("../docker/client/docker-client");
 const inspect_container_1 = require("../docker/functions/container/inspect-container");
 const container_logs_1 = require("../docker/functions/container/container-logs");
 const started_docker_compose_environment_1 = require("./started-docker-compose-environment");
-const docker_compose_down_1 = require("../docker-compose/functions/docker-compose-down");
-const docker_compose_up_1 = require("../docker-compose/functions/docker-compose-up");
 const wait_for_container_1 = require("../wait-for-container");
 const pull_policy_1 = require("../pull-policy");
-const docker_compose_pull_1 = require("../docker-compose/functions/docker-compose-pull");
 const wait_1 = require("../wait-strategy/wait");
+const reaper_1 = require("../reaper");
 class DockerComposeEnvironment {
     constructor(composeFilePath, composeFiles, uuid = new uuid_1.RandomUuid()) {
         this.build = false;
@@ -77,7 +74,8 @@ class DockerComposeEnvironment {
     up(services) {
         return __awaiter(this, void 0, void 0, function* () {
             logger_1.log.info(`Starting DockerCompose environment "${this.projectName}"...`);
-            (yield reaper_1.ReaperInstance.getInstance()).addProject(this.projectName);
+            const { dockerComposeClient } = yield (0, docker_client_1.getDockerClient)();
+            yield (0, reaper_1.registerComposeProjectForCleanup)(this.projectName);
             const options = {
                 filePath: this.composeFilePath,
                 files: this.composeFiles,
@@ -96,9 +94,10 @@ class DockerComposeEnvironment {
             }
             this.profiles.forEach((profile) => composeOptions.push("--profile", profile));
             if (this.pullPolicy.shouldPull()) {
-                yield (0, docker_compose_pull_1.dockerComposePull)(options, services);
+                yield dockerComposeClient.pull(options, services);
             }
-            yield (0, docker_compose_up_1.dockerComposeUp)(Object.assign(Object.assign({}, options), { commandOptions, composeOptions, environment: this.environment }), services);
+            yield dockerComposeClient.up(Object.assign(Object.assign({}, options), { commandOptions,
+                composeOptions, environment: this.environment }), services);
             const startedContainers = (yield (0, list_containers_1.listContainers)()).filter((container) => container.Labels["com.docker.compose.project"] === this.projectName);
             const startedContainerNames = startedContainers.reduce((containerNames, startedContainer) => [
                 ...containerNames,
@@ -127,7 +126,7 @@ class DockerComposeEnvironment {
                 }
                 catch (err) {
                     try {
-                        yield (0, docker_compose_down_1.dockerComposeDown)(options, { removeVolumes: true, timeout: 0 });
+                        yield dockerComposeClient.down(options, { removeVolumes: true, timeout: 0 });
                     }
                     catch (_a) {
                         logger_1.log.warn(`Failed to stop DockerCompose environment after failed up`);

package/dist/src/docker-compose-environment/started-docker-compose-environment.d.ts

@@ -1,8 +1,7 @@
 import { StartedGenericContainer } from "../generic-container/started-generic-container";
 import { StoppedDockerComposeEnvironment } from "./stopped-docker-compose-environment";
 import { DownedDockerComposeEnvironment } from "./downed-docker-compose-environment";
-import { DockerComposeOptions } from "../docker-compose/docker-compose-options";
-import { DockerComposeDownOptions } from "../test-container";
+import { DockerComposeDownOptions, DockerComposeOptions } from "../docker-compose/docker-compose-options";
 export declare class StartedDockerComposeEnvironment {
     private readonly startedGenericContainers;
     private readonly options;

package/dist/src/docker-compose-environment/started-docker-compose-environment.js

@@ -11,10 +11,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StartedDockerComposeEnvironment = void 0;
 const logger_1 = require("../logger");
-const docker_compose_down_1 = require("../docker-compose/functions/docker-compose-down");
-const docker_compose_stop_1 = require("../docker-compose/functions/docker-compose-stop");
 const stopped_docker_compose_environment_1 = require("./stopped-docker-compose-environment");
 const downed_docker_compose_environment_1 = require("./downed-docker-compose-environment");
+const docker_client_1 = require("../docker/client/docker-client");
 class StartedDockerComposeEnvironment {
     constructor(startedGenericContainers, options) {
         this.startedGenericContainers = startedGenericContainers;
@@ -22,14 +21,16 @@ class StartedDockerComposeEnvironment {
     }
     stop() {
         return __awaiter(this, void 0, void 0, function* () {
-            yield (0, docker_compose_stop_1.dockerComposeStop)(this.options);
+            const { dockerComposeClient } = yield (0, docker_client_1.getDockerClient)();
+            yield dockerComposeClient.stop(this.options);
             return new stopped_docker_compose_environment_1.StoppedDockerComposeEnvironment(this.options);
         });
     }
     down(options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { dockerComposeClient } = yield (0, docker_client_1.getDockerClient)();
             const downOptions = Object.assign({ timeout: 0, removeVolumes: true }, options);
-            yield (0, docker_compose_down_1.dockerComposeDown)(this.options, downOptions);
+            yield dockerComposeClient.down(this.options, downOptions);
             return new downed_docker_compose_environment_1.DownedDockerComposeEnvironment();
         });
     }

package/dist/src/docker-compose-environment/stopped-docker-compose-environment.d.ts

@@ -1,6 +1,5 @@
 import { DownedDockerComposeEnvironment } from "./downed-docker-compose-environment";
-import { DockerComposeOptions } from "../docker-compose/docker-compose-options";
-import { DockerComposeDownOptions } from "../test-container";
+import { DockerComposeDownOptions, DockerComposeOptions } from "../docker-compose/docker-compose-options";
 export declare class StoppedDockerComposeEnvironment {
     private readonly options;
     constructor(options: DockerComposeOptions);

package/dist/src/docker-compose-environment/stopped-docker-compose-environment.js

@@ -10,16 +10,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StoppedDockerComposeEnvironment = void 0;
-const docker_compose_down_1 = require("../docker-compose/functions/docker-compose-down");
 const downed_docker_compose_environment_1 = require("./downed-docker-compose-environment");
+const docker_client_1 = require("../docker/client/docker-client");
 class StoppedDockerComposeEnvironment {
     constructor(options) {
         this.options = options;
     }
     down(options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
+            const { dockerComposeClient } = yield (0, docker_client_1.getDockerClient)();
             const resolvedOptions = Object.assign({ timeout: 0, removeVolumes: true }, options);
-            yield (0, docker_compose_down_1.dockerComposeDown)(this.options, resolvedOptions);
+            yield dockerComposeClient.down(this.options, resolvedOptions);
             return new downed_docker_compose_environment_1.DownedDockerComposeEnvironment();
         });
     }

package/dist/src/file-lock.d.ts

@@ -0,0 +1 @@
+export declare function withFileLock<T>(fileName: string, fn: () => T): Promise<T>;

package/dist/src/file-lock.js

@@ -0,0 +1,47 @@
+"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.withFileLock = void 0;
+const path_1 = __importDefault(require("path"));
+const tmp_1 = __importDefault(require("tmp"));
+const promises_1 = require("fs/promises");
+const logger_1 = require("./logger");
+const proper_lockfile_1 = __importDefault(require("proper-lockfile"));
+function withFileLock(fileName, fn) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const file = yield createEmptyTmpFile(fileName);
+        let releaseLockFn;
+        try {
+            logger_1.log.debug(`Acquiring lock file "${file}"...`);
+            releaseLockFn = yield proper_lockfile_1.default.lock(file, { retries: { forever: true } });
+            logger_1.log.debug(`Acquired lock file "${file}"`);
+            return yield fn();
+        }
+        finally {
+            if (releaseLockFn) {
+                logger_1.log.debug(`Releasing lock file "${file}"...`);
+                yield releaseLockFn();
+                logger_1.log.debug(`Released lock file "${file}"`);
+            }
+        }
+    });
+}
+exports.withFileLock = withFileLock;
+function createEmptyTmpFile(fileName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const file = path_1.default.resolve(tmp_1.default.tmpdir, fileName);
+        yield (0, promises_1.writeFile)(file, "");
+        return file;
+    });
+}

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

@@ -2,6 +2,9 @@ import { BuildArgs } from "../docker/types";
 import { PullPolicy } from "../pull-policy";
 import { Uuid } from "../uuid";
 import { GenericContainer } from "./generic-container";
+export type BuildOptions = {
+    deleteOnExit: boolean;
+};
 export declare class GenericContainerBuilder {
     private readonly context;
     private readonly dockerfileName;
@@ -13,6 +16,6 @@ export declare class GenericContainerBuilder {
     withBuildArgs(buildArgs: BuildArgs): GenericContainerBuilder;
     withPullPolicy(pullPolicy: PullPolicy): this;
     withCache(cache: boolean): this;
-    build(image?: string): Promise<GenericContainer>;
+    build(image?: string, options?: BuildOptions): Promise<GenericContainer>;
     private getRegistryConfig;
 }

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

@@ -15,7 +15,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GenericContainerBuilder = void 0;
 const pull_policy_1 = require("../pull-policy");
 const uuid_1 = require("../uuid");
-const reaper_1 = require("../reaper");
 const docker_image_name_1 = require("../docker-image-name");
 const path_1 = __importDefault(require("path"));
 const logger_1 = require("../logger");
@@ -46,23 +45,23 @@ class GenericContainerBuilder {
         this.cache = cache;
         return this;
     }
-    // https://github.com/containers/buildah/issues/1034
-    build(image = `localhost/${this.uuid.nextUuid()}:${this.uuid.nextUuid()}`) {
+    build(image = `localhost/${this.uuid.nextUuid()}:${this.uuid.nextUuid()}`, options = { deleteOnExit: true }) {
         return __awaiter(this, void 0, void 0, function* () {
             const imageName = docker_image_name_1.DockerImageName.fromString(image);
-            yield reaper_1.ReaperInstance.getInstance();
+            const { sessionId } = yield (0, docker_client_1.getDockerClient)();
             const dockerfile = path_1.default.resolve(this.context, this.dockerfileName);
             logger_1.log.debug(`Preparing to build Dockerfile "${dockerfile}" as image "${imageName}"...`);
             const imageNames = yield (0, dockerfile_parser_1.getDockerfileImages)(dockerfile, this.buildArgs);
             const { dockerode, info } = yield (0, docker_client_1.getDockerClient)();
             const registryConfig = yield this.getRegistryConfig(info.dockerInfo.indexServerAddress, imageNames);
-            yield (0, build_image_1.buildImage)({
+            yield (0, build_image_1.buildImage)(sessionId, {
                 imageName: imageName,
                 context: this.context,
                 dockerfileName: this.dockerfileName,
                 buildArgs: this.buildArgs,
                 pullPolicy: this.pullPolicy,
                 cache: this.cache,
+                deleteOnExit: options.deleteOnExit,
                 registryConfig,
             });
             const container = new generic_container_1.GenericContainer(imageName.toString());

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

@@ -1,11 +1,10 @@
 /// <reference types="node" />
-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/wait-strategy";
-import { BindMount, ContentToCopy, Environment, ExtraHost, FileToCopy, HealthCheck, Labels, ResourcesQuota, TmpFs, Ulimits } from "../docker/types";
+import { BindMount, ContentToCopy, DirectoryToCopy, Environment, ExtraHost, FileToCopy, HealthCheck, Labels, ResourcesQuota, TmpFs, Ulimits } from "../docker/types";
 import { CreateContainerOptions } from "../docker/functions/container/create-container";
 import { InspectResult } from "../docker/functions/container/inspect-container";
 import { GenericContainerBuilder } from "./generic-container-builder";
@@ -17,11 +16,13 @@ export declare class GenericContainer implements TestContainer {
     protected opts: CreateContainerOptions;
     protected startupTimeout?: number;
     protected waitStrategy: WaitStrategy;
-    protected tarToCopy?: archiver.Archiver;
     protected networkMode?: string;
     protected networkAliases: string[];
     protected pullPolicy: PullPolicy;
     protected logConsumer?: (stream: Readable) => unknown;
+    protected filesToCopy: FileToCopy[];
+    protected directoriesToCopy: DirectoryToCopy[];
+    protected contentsToCopy: ContentToCopy[];
     constructor(image: string);
     /**
      * @deprecated Since version 9.4.0. Will be removed in version 10.0.0. Use `beforeContainerStarted` instead.
@@ -31,8 +32,11 @@ export declare class GenericContainer implements TestContainer {
     protected containerCreated?(containerId: string): Promise<void>;
     protected containerStarting?(inspectResult: InspectResult, reused: boolean): Promise<void>;
     start(): Promise<StartedTestContainer>;
+    private reuseOrStartContainer;
     private reuseContainer;
     private startContainer;
+    private connectContainerToPortForwarder;
+    private createArchiveToCopyToContainer;
     /**
      * @deprecated Since version 9.4.0. Will be removed in version 10.0.0. Use `containerStarted` instead.
      */
@@ -64,8 +68,8 @@ export declare class GenericContainer implements TestContainer {
     withPullPolicy(pullPolicy: PullPolicy): this;
     withIpcMode(ipcMode: string): this;
     withCopyFilesToContainer(filesToCopy: FileToCopy[]): this;
+    withCopyDirectoriesToContainer(directoriesToCopy: DirectoryToCopy[]): this;
     withCopyContentToContainer(contentsToCopy: ContentToCopy[]): this;
-    protected getTarToCopy(): archiver.Archiver;
     withWorkingDir(workingDir: string): this;
     withResourcesQuota({ memory, cpu }: ResourcesQuota): this;
     withSharedMemorySize(bytes: number): this;