testcontainers 8.15.0 → 9.0.0

package/dist/docker/types.d.ts

@@ -1,33 +1,44 @@
-export declare type Id = string;
-export declare type Host = string;
-export declare type EnvKey = string;
-export declare type EnvValue = string;
-export declare type Env = {
-    [key in EnvKey]: EnvValue;
+/// <reference types="node" />
+/// <reference types="node" />
+import { Readable } from "stream";
+export declare type Environment = {
+    [key in string]: string;
 };
-export declare type Dir = string;
 export declare type BindMode = "rw" | "ro" | "z" | "Z";
 export declare type BindMount = {
-    source: Dir;
-    target: Dir;
-    bindMode: BindMode;
+    source: string;
+    target: string;
+    mode?: BindMode;
+};
+export declare type FileToCopy = {
+    source: string;
+    target: string;
+};
+export declare type Content = string | Buffer | Readable;
+export declare type ContentToCopy = {
+    content: Content;
+    target: string;
 };
 export declare type TmpFs = {
-    [dir in Dir]: Dir;
+    [dir in string]: string;
+};
+export declare type Ulimits = {
+    [name: string]: {
+        hard: number | undefined;
+        soft: number | undefined;
+    };
 };
 export declare type HealthCheck = {
-    test: string;
+    test: ["CMD-SHELL", string] | ["CMD", ...string[]];
     interval?: number;
     timeout?: number;
     retries?: number;
     startPeriod?: number;
 };
 export declare type ExtraHost = {
-    host: Host;
+    host: string;
     ipAddress: string;
 };
-export declare type NetworkMode = string;
-export declare type ContainerName = string;
 export declare type Labels = {
     [key: string]: string;
 };
@@ -46,16 +57,12 @@ export declare type RegistryConfig = {
         password: string;
     };
 };
-export declare type BuildContext = string;
 export declare type BuildArgs = {
-    [key in EnvKey]: EnvValue;
+    [key in string]: string;
 };
-export declare type StreamOutput = string;
-export declare type ExitCode = number;
-export declare type Command = string;
 export declare type ExecResult = {
-    output: StreamOutput;
-    exitCode: ExitCode;
+    output: string;
+    exitCode: number;
 };
 export declare type HealthCheckStatus = "none" | "starting" | "unhealthy" | "healthy";
 export declare type NetworkSettings = {

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

@@ -1,3 +1,3 @@
 import { IDockerComposeOptions } from "./docker-compose";
 import { DockerComposeOptions } from "./docker-compose-options";
-export declare const defaultDockerComposeOptions: ({ env, ...options }: DockerComposeOptions) => Partial<IDockerComposeOptions>;
+export declare const defaultDockerComposeOptions: ({ environment, ...options }: DockerComposeOptions) => Partial<IDockerComposeOptions>;

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

@@ -13,14 +13,14 @@ var __rest = (this && this.__rest) || function (s, e) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultDockerComposeOptions = void 0;
 const defaultDockerComposeOptions = (_a) => {
-    var { env = {} } = _a, options = __rest(_a, ["env"]);
+    var { environment = {} } = _a, options = __rest(_a, ["environment"]);
     return {
         log: false,
         cwd: options.filePath,
         config: options.files,
         composeOptions: options.composeOptions,
         commandOptions: options.commandOptions,
-        env: Object.assign(Object.assign(Object.assign({}, process.env), { COMPOSE_PROJECT_NAME: options.projectName }), env),
+        env: Object.assign(Object.assign(Object.assign({}, process.env), { COMPOSE_PROJECT_NAME: options.projectName }), environment),
     };
 };
 exports.defaultDockerComposeOptions = defaultDockerComposeOptions;

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

@@ -1,9 +1,9 @@
-import { Env } from "../docker/types";
+import { Environment } from "../docker/types";
 export declare type DockerComposeOptions = {
     filePath: string;
     files: string | string[];
     projectName: string;
     commandOptions?: string[];
     composeOptions?: string[];
-    env?: Env;
+    environment?: Environment;
 };

package/dist/docker-compose/functions/docker-compose-down.d.ts

@@ -1,2 +1,3 @@
 import { DockerComposeOptions } from "../docker-compose-options";
-export declare const dockerComposeDown: (options: DockerComposeOptions) => Promise<void>;
+import { DockerComposeDownOptions } from "../../test-container";
+export declare const dockerComposeDown: (options: DockerComposeOptions, downOptions: DockerComposeDownOptions) => Promise<void>;

package/dist/docker-compose/functions/docker-compose-down.js

@@ -13,10 +13,10 @@ exports.dockerComposeDown = void 0;
 const logger_1 = require("../../logger");
 const default_docker_compose_options_1 = require("../default-docker-compose-options");
 const docker_compose_1 = require("../docker-compose");
-const dockerComposeDown = (options) => __awaiter(void 0, void 0, void 0, function* () {
+const dockerComposeDown = (options, downOptions) => __awaiter(void 0, void 0, void 0, function* () {
     logger_1.log.info(`Downing DockerCompose environment`);
     try {
-        yield (0, docker_compose_1.down)(Object.assign(Object.assign({}, (0, default_docker_compose_options_1.defaultDockerComposeOptions)(options)), { commandOptions: ["-v"] }));
+        yield (0, docker_compose_1.down)(Object.assign(Object.assign({}, (0, default_docker_compose_options_1.defaultDockerComposeOptions)(options)), { commandOptions: commandOptions(downOptions) }));
         logger_1.log.info(`Downed DockerCompose environment`);
     }
     catch (err) {
@@ -26,3 +26,13 @@ const dockerComposeDown = (options) => __awaiter(void 0, void 0, void 0, functio
     }
 });
 exports.dockerComposeDown = dockerComposeDown;
+const commandOptions = (options) => {
+    const result = [];
+    if (options.removeVolumes) {
+        result.push("-v");
+    }
+    if (options.timeout) {
+        result.push("-t", `${options.timeout / 1000}`);
+    }
+    return result;
+};

package/dist/docker-compose/functions/docker-compose-up.d.ts

@@ -1,2 +1,2 @@
 import { DockerComposeOptions } from "../docker-compose-options";
-export declare const dockerComposeUp: (options: DockerComposeOptions, services?: string[] | undefined) => Promise<void>;
+export declare const dockerComposeUp: (options: DockerComposeOptions, services?: Array<string>) => Promise<void>;

package/dist/docker-compose/functions/docker-compose-up.js

@@ -29,7 +29,7 @@ const dockerComposeUp = (options, services) => __awaiter(void 0, void 0, void 0,
         const errorMessage = err.err || err.message || err;
         logger_1.log.error(`Failed to up DockerCompose environment: ${errorMessage}`);
         try {
-            yield (0, docker_compose_down_1.dockerComposeDown)(options);
+            yield (0, docker_compose_down_1.dockerComposeDown)(options, { removeVolumes: true, timeout: 0 });
         }
         catch (_a) {
             logger_1.log.warn(`Failed to down DockerCompose environment after failed up`);

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

@@ -1,6 +1,6 @@
 import { WaitStrategy } from "../wait-strategy";
 import { Uuid } from "../uuid";
-import { EnvKey, EnvValue } from "../docker/types";
+import { Environment } from "../docker/types";
 import { StartedDockerComposeEnvironment } from "./started-docker-compose-environment";
 export declare class DockerComposeEnvironment {
     private readonly composeFilePath;
@@ -8,15 +8,15 @@ export declare class DockerComposeEnvironment {
     private projectName;
     private build;
     private recreate;
-    private envFile;
+    private environmentFile;
     private profiles;
-    private env;
+    private environment;
     private waitStrategy;
     private startupTimeout;
     constructor(composeFilePath: string, composeFiles: string | string[], uuid?: Uuid);
     withBuild(): this;
-    withEnv(key: EnvKey, value: EnvValue): this;
-    withEnvFile(envFile: string): this;
+    withEnvironment(environment: Environment): this;
+    withEnvironmentFile(environmentFile: string): this;
     withProfiles(...profiles: string[]): this;
     withNoRecreate(): this;
     withWaitStrategy(containerName: string, waitStrategy: WaitStrategy): this;

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

@@ -30,9 +30,9 @@ class DockerComposeEnvironment {
     constructor(composeFilePath, composeFiles, uuid = new uuid_1.RandomUuid()) {
         this.build = false;
         this.recreate = true;
-        this.envFile = "";
+        this.environmentFile = "";
         this.profiles = [];
-        this.env = {};
+        this.environment = {};
         this.waitStrategy = {};
         this.startupTimeout = 60000;
         this.composeFilePath = composeFilePath;
@@ -43,16 +43,16 @@ class DockerComposeEnvironment {
         this.build = true;
         return this;
     }
-    withEnv(key, value) {
-        this.env[key] = value;
+    withEnvironment(environment) {
+        this.environment = Object.assign(Object.assign({}, this.environment), environment);
         return this;
     }
-    withEnvFile(envFile) {
-        this.envFile = envFile;
+    withEnvironmentFile(environmentFile) {
+        this.environmentFile = environmentFile;
         return this;
     }
     withProfiles(...profiles) {
-        this.profiles = profiles;
+        this.profiles = [...this.profiles, ...profiles];
         return this;
     }
     withNoRecreate() {
@@ -85,11 +85,11 @@ class DockerComposeEnvironment {
                 commandOptions.push("--no-recreate");
             }
             const composeOptions = [];
-            if (this.envFile) {
-                composeOptions.push("--env-file", this.envFile);
+            if (this.environmentFile) {
+                composeOptions.push("--env-file", this.environmentFile);
             }
             this.profiles.forEach((profile) => composeOptions.push("--profile", profile));
-            yield (0, docker_compose_up_1.dockerComposeUp)(Object.assign(Object.assign({}, options), { commandOptions, composeOptions, env: this.env }), services);
+            yield (0, docker_compose_up_1.dockerComposeUp)(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,
@@ -112,7 +112,7 @@ class DockerComposeEnvironment {
                 catch (err) {
                     logger_1.log.error(`Container ${containerName} failed to be ready: ${err}`);
                     try {
-                        yield (0, docker_compose_down_1.dockerComposeDown)(options);
+                        yield (0, docker_compose_down_1.dockerComposeDown)(options, { removeVolumes: true, timeout: 0 });
                     }
                     catch (_a) {
                         logger_1.log.warn(`Failed to stop DockerCompose environment after failed up`);
@@ -125,7 +125,7 @@ class DockerComposeEnvironment {
                 return Object.assign(Object.assign({}, map), { [containerName]: startedGenericContainer });
             }, {});
             logger_1.log.info(`DockerCompose environment started: ${Object.keys(startedGenericContainers).join(", ")}`);
-            return new started_docker_compose_environment_1.StartedDockerComposeEnvironment(startedGenericContainers, Object.assign(Object.assign({}, options), { composeOptions, env: this.env }));
+            return new started_docker_compose_environment_1.StartedDockerComposeEnvironment(startedGenericContainers, Object.assign(Object.assign({}, options), { composeOptions, environment: this.environment }));
         });
     }
     waitForContainer(container, containerName, boundPorts) {

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

@@ -2,6 +2,7 @@ import { StartedGenericContainer } from "../generic-container/started-generic-co
 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";
 export declare class StartedDockerComposeEnvironment {
     private readonly startedGenericContainers;
     private readonly options;
@@ -9,6 +10,6 @@ export declare class StartedDockerComposeEnvironment {
         [containerName: string]: StartedGenericContainer;
     }, options: DockerComposeOptions);
     stop(): Promise<StoppedDockerComposeEnvironment>;
-    down(): Promise<DownedDockerComposeEnvironment>;
+    down(options?: Partial<DockerComposeDownOptions>): Promise<DownedDockerComposeEnvironment>;
     getContainer(containerName: string): StartedGenericContainer;
 }

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

@@ -26,9 +26,10 @@ class StartedDockerComposeEnvironment {
             return new stopped_docker_compose_environment_1.StoppedDockerComposeEnvironment(this.options);
         });
     }
-    down() {
+    down(options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield (0, docker_compose_down_1.dockerComposeDown)(this.options);
+            const downOptions = Object.assign({ timeout: 0, removeVolumes: true }, options);
+            yield (0, docker_compose_down_1.dockerComposeDown)(this.options, downOptions);
             return new downed_docker_compose_environment_1.DownedDockerComposeEnvironment();
         });
     }

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

@@ -1,7 +1,8 @@
 import { DownedDockerComposeEnvironment } from "./downed-docker-compose-environment";
 import { DockerComposeOptions } from "../docker-compose/docker-compose-options";
+import { DockerComposeDownOptions } from "../test-container";
 export declare class StoppedDockerComposeEnvironment {
     private readonly options;
     constructor(options: DockerComposeOptions);
-    down(): Promise<DownedDockerComposeEnvironment>;
+    down(options?: Partial<DockerComposeDownOptions>): Promise<DownedDockerComposeEnvironment>;
 }

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

@@ -16,9 +16,10 @@ class StoppedDockerComposeEnvironment {
     constructor(options) {
         this.options = options;
     }
-    down() {
+    down(options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield (0, docker_compose_down_1.dockerComposeDown)(this.options);
+            const resolvedOptions = Object.assign({ timeout: 0, removeVolumes: true }, options);
+            yield (0, docker_compose_down_1.dockerComposeDown)(this.options, resolvedOptions);
             return new downed_docker_compose_environment_1.DownedDockerComposeEnvironment();
         });
     }

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

@@ -1,4 +1,4 @@
-import { BuildContext } from "../docker/types";
+import { BuildArgs } from "../docker/types";
 import { PullPolicy } from "../pull-policy";
 import { Uuid } from "../uuid";
 import { GenericContainer } from "./generic-container";
@@ -8,9 +8,11 @@ export declare class GenericContainerBuilder {
     private readonly uuid;
     private buildArgs;
     private pullPolicy;
-    constructor(context: BuildContext, dockerfileName: string, uuid?: Uuid);
-    withBuildArg(key: string, value: string): GenericContainerBuilder;
+    private cache;
+    constructor(context: string, dockerfileName: string, uuid?: Uuid);
+    withBuildArgs(buildArgs: BuildArgs): GenericContainerBuilder;
     withPullPolicy(pullPolicy: PullPolicy): this;
+    withCache(cache: boolean): this;
     build(image?: string): Promise<GenericContainer>;
     private getRegistryConfig;
 }

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

@@ -32,15 +32,20 @@ class GenericContainerBuilder {
         this.uuid = uuid;
         this.buildArgs = {};
         this.pullPolicy = new pull_policy_1.DefaultPullPolicy();
+        this.cache = true;
     }
-    withBuildArg(key, value) {
-        this.buildArgs[key] = value;
+    withBuildArgs(buildArgs) {
+        this.buildArgs = buildArgs;
         return this;
     }
     withPullPolicy(pullPolicy) {
         this.pullPolicy = pullPolicy;
         return this;
     }
+    withCache(cache) {
+        this.cache = cache;
+        return this;
+    }
     build(image = `${this.uuid.nextUuid()}:${this.uuid.nextUuid()}`) {
         return __awaiter(this, void 0, void 0, function* () {
             const imageName = docker_image_name_1.DockerImageName.fromString(image);
@@ -55,6 +60,7 @@ class GenericContainerBuilder {
                 dockerfileName: this.dockerfileName,
                 buildArgs: this.buildArgs,
                 pullPolicy: this.pullPolicy,
+                cache: this.cache,
                 registryConfig,
             });
             const container = new generic_container_1.GenericContainer(imageName.toString());

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

@@ -1,25 +1,25 @@
-/// <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";
-import { Readable } from "stream";
-import { BindMode, BindMount, BuildContext, Command, ContainerName, Dir, Env, EnvKey, EnvValue, ExtraHost, HealthCheck, NetworkMode, TmpFs, Labels } from "../docker/types";
+import { BindMount, ContentToCopy, Environment, ExtraHost, FileToCopy, HealthCheck, Labels, TmpFs, Ulimits } 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: BuildContext, dockerfileName?: string): GenericContainerBuilder;
+    static fromDockerfile(context: string, dockerfileName?: string): GenericContainerBuilder;
     private readonly imageName;
-    protected env: Env;
-    protected networkMode?: NetworkMode;
+    protected environment: Environment;
+    protected networkMode?: string;
     protected networkAliases: string[];
     protected ports: PortWithOptionalBinding[];
-    protected cmd: Command[];
+    protected command: string[];
+    protected entrypoint?: string[];
     protected bindMounts: BindMount[];
-    protected name?: ContainerName;
+    protected name?: string;
     protected labels: Labels;
     protected tmpFs: TmpFs;
     protected healthCheck?: HealthCheck;
@@ -28,6 +28,9 @@ export declare class GenericContainer implements TestContainer {
     protected useDefaultLogDriver: boolean;
     protected privilegedMode: boolean;
     protected ipcMode?: string;
+    protected ulimits?: Ulimits;
+    protected addedCapabilities?: string[];
+    protected droppedCapabilities?: string[];
     protected user?: string;
     protected pullPolicy: PullPolicy;
     protected reuse: boolean;
@@ -40,17 +43,21 @@ export declare class GenericContainer implements TestContainer {
     private startContainer;
     protected postStart?(container: StartedTestContainer, inspectResult: InspectResult, boundPorts: BoundPorts): Promise<void>;
     protected get hasExposedPorts(): boolean;
-    withCmd(cmd: Command[]): this;
-    withName(name: ContainerName): this;
+    withCommand(command: string[]): this;
+    withEntrypoint(entrypoint: string[]): this;
+    withName(name: string): this;
     withLabels(labels: Labels): this;
-    withEnv(key: EnvKey, value: EnvValue): this;
+    withEnvironment(environment: Environment): this;
     withTmpFs(tmpFs: TmpFs): this;
-    withNetworkMode(networkMode: NetworkMode): 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;
+    withExtraHosts(extraHosts: ExtraHost[]): this;
     withExposedPorts(...ports: PortWithOptionalBinding[]): this;
-    protected addExposedPorts(...ports: PortWithOptionalBinding[]): this;
-    withBindMount(source: Dir, target: Dir, bindMode?: BindMode): this;
+    withBindMounts(bindMounts: BindMount[]): this;
     withHealthCheck(healthCheck: HealthCheck): this;
     withStartupTimeout(startupTimeout: number): this;
     withWaitStrategy(waitStrategy: WaitStrategy): this;
@@ -60,8 +67,8 @@ export declare class GenericContainer implements TestContainer {
     withReuse(): this;
     withPullPolicy(pullPolicy: PullPolicy): this;
     withIpcMode(ipcMode: string): this;
-    withCopyFileToContainer(sourcePath: string, containerPath: string): this;
-    withCopyContentToContainer(content: string | Buffer | Readable, containerPath: string): this;
+    withCopyFilesToContainer(filesToCopy: FileToCopy[]): this;
+    withCopyContentToContainer(contentsToCopy: ContentToCopy[]): this;
     protected getTarToCopy(): archiver.Archiver;
     private waitForContainer;
     private getWaitStrategy;

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

@@ -41,10 +41,10 @@ const labels_1 = require("../labels");
 class GenericContainer {
     constructor(image) {
         this.image = image;
-        this.env = {};
+        this.environment = {};
         this.networkAliases = [];
         this.ports = [];
-        this.cmd = [];
+        this.command = [];
         this.bindMounts = [];
         this.labels = {};
         this.tmpFs = {};
@@ -78,8 +78,9 @@ class GenericContainer {
             }
             const createContainerOptions = {
                 imageName: this.imageName,
-                env: this.env,
-                cmd: this.cmd,
+                environment: this.environment,
+                command: this.command,
+                entrypoint: this.entrypoint,
                 bindMounts: this.bindMounts,
                 tmpFs: this.tmpFs,
                 exposedPorts: this.ports,
@@ -93,6 +94,9 @@ class GenericContainer {
                 autoRemove: this.imageName.isReaper(),
                 extraHosts: this.extraHosts,
                 ipcMode: this.ipcMode,
+                ulimits: this.ulimits,
+                addedCapabilities: this.addedCapabilities,
+                droppedCapabilities: this.droppedCapabilities,
                 user: this.user,
             };
             if (this.reuse) {
@@ -166,8 +170,12 @@ class GenericContainer {
     get hasExposedPorts() {
         return this.ports.length !== 0;
     }
-    withCmd(cmd) {
-        this.cmd = cmd;
+    withCommand(command) {
+        this.command = command;
+        return this;
+    }
+    withEntrypoint(entrypoint) {
+        this.entrypoint = entrypoint;
         return this;
     }
     withName(name) {
@@ -175,15 +183,33 @@ class GenericContainer {
         return this;
     }
     withLabels(labels) {
-        this.labels = Object.assign({}, labels);
+        this.labels = Object.assign(Object.assign({}, this.labels), labels);
         return this;
     }
-    withEnv(key, value) {
-        this.env[key] = value;
+    withEnvironment(environment) {
+        this.environment = Object.assign(Object.assign({}, this.environment), environment);
         return this;
     }
     withTmpFs(tmpFs) {
-        this.tmpFs = 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) {
@@ -191,23 +217,19 @@ class GenericContainer {
         return this;
     }
     withNetworkAliases(...networkAliases) {
-        this.networkAliases = networkAliases;
+        this.networkAliases = [...this.networkAliases, ...networkAliases];
         return this;
     }
-    withExtraHosts(...extraHosts) {
-        this.extraHosts.push(...extraHosts);
+    withExtraHosts(extraHosts) {
+        this.extraHosts = [...this.extraHosts, ...extraHosts];
         return this;
     }
     withExposedPorts(...ports) {
-        this.ports = ports;
-        return this;
-    }
-    addExposedPorts(...ports) {
-        this.ports.push(...ports);
+        this.ports = [...this.ports, ...ports];
         return this;
     }
-    withBindMount(source, target, bindMode = "rw") {
-        this.bindMounts.push({ source, target, bindMode });
+    withBindMounts(bindMounts) {
+        this.bindMounts = bindMounts.map((bindMount) => (Object.assign({ mode: "rw" }, bindMount)));
         return this;
     }
     withHealthCheck(healthCheck) {
@@ -246,12 +268,14 @@ class GenericContainer {
         this.ipcMode = ipcMode;
         return this;
     }
-    withCopyFileToContainer(sourcePath, containerPath) {
-        this.getTarToCopy().file(sourcePath, { name: containerPath });
+    withCopyFilesToContainer(filesToCopy) {
+        const tar = this.getTarToCopy();
+        filesToCopy.forEach(({ source, target }) => tar.file(source, { name: target }));
         return this;
     }
-    withCopyContentToContainer(content, containerPath) {
-        this.getTarToCopy().append(content, { name: containerPath });
+    withCopyContentToContainer(contentsToCopy) {
+        const tar = this.getTarToCopy();
+        contentsToCopy.forEach(({ content, target }) => tar.append(content, { name: target }));
         return this;
     }
     getTarToCopy() {

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

@@ -1,10 +1,9 @@
 /// <reference types="node" />
 import { RestartOptions, StartedTestContainer, StopOptions, ExecOptions, StoppedTestContainer } from "../test-container";
 import Dockerode from "dockerode";
-import { Command, ContainerName, ExecResult, Host, Id as ContainerId, Labels } from "../docker/types";
+import { ExecResult, Labels } from "../docker/types";
 import { InspectResult } from "../docker/functions/container/inspect-container";
 import { BoundPorts } from "../bound-ports";
-import { Port } from "../port";
 import { Readable } from "stream";
 import { WaitStrategy } from "../wait-strategy";
 export declare class StartedGenericContainer implements StartedTestContainer {
@@ -14,19 +13,19 @@ export declare class StartedGenericContainer implements StartedTestContainer {
     private boundPorts;
     private readonly name;
     private readonly waitStrategy;
-    constructor(container: Dockerode.Container, host: Host, inspectResult: InspectResult, boundPorts: BoundPorts, name: ContainerName, waitStrategy: 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;
     private waitForContainer;
-    getHost(): Host;
-    getMappedPort(port: Port): Port;
-    getId(): ContainerId;
-    getName(): ContainerName;
+    getHost(): string;
+    getMappedPort(port: number): number;
+    getId(): string;
+    getName(): string;
     getLabels(): Labels;
     getNetworkNames(): string[];
     getNetworkId(networkName: string): string;
     getIpAddress(networkName: string): string;
-    exec(command: Command[], options?: Partial<ExecOptions>): Promise<ExecResult>;
+    exec(command: string[], options?: Partial<ExecOptions>): Promise<ExecResult>;
     logs(): Promise<Readable>;
 }

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

@@ -37,9 +37,8 @@ class StartedGenericContainer {
         return __awaiter(this, void 0, void 0, function* () {
             const resolvedOptions = Object.assign({ timeout: 0 }, options);
             yield (0, restart_container_1.restartContainer)(this.container, resolvedOptions);
-            // Inspect the restarted container and update the bound ports
             this.inspectResult = yield (0, inspect_container_1.inspectContainer)(this.container);
-            this.boundPorts = yield bound_ports_1.BoundPorts.fromInspectResult(this.inspectResult).filter(Array.from(this.boundPorts.iterator()).map((port) => port[0]));
+            this.boundPorts = bound_ports_1.BoundPorts.fromInspectResult(this.inspectResult).filter(Array.from(this.boundPorts.iterator()).map((port) => port[0]));
             yield this.waitForContainer(this.container, this.boundPorts);
         });
     }

package/dist/logger.d.ts

@@ -29,4 +29,5 @@ export declare class FakeLogger implements Logger {
 }
 export declare const log: DebugLogger;
 export declare const containerLog: DebugLogger;
+export declare const execLog: DebugLogger;
 export {};