testcontainers 8.16.0 → 9.0.1

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,20 +8,18 @@ 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;
     withStartupTimeout(startupTimeout: number): this;
     up(services?: Array<string>): Promise<StartedDockerComposeEnvironment>;
-    private waitForContainer;
-    private getWaitStrategy;
 }

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

@@ -14,7 +14,6 @@ const bound_ports_1 = require("../bound-ports");
 const container_name_resolver_1 = require("../docker-compose/functions/container-name-resolver");
 const started_generic_container_1 = require("../generic-container/started-generic-container");
 const logger_1 = require("../logger");
-const port_check_1 = require("../port-check");
 const wait_strategy_1 = require("../wait-strategy");
 const reaper_1 = require("../reaper");
 const uuid_1 = require("../uuid");
@@ -26,13 +25,14 @@ 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");
 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,
@@ -104,9 +104,11 @@ class DockerComposeEnvironment {
                     .on("err", (data) => logger_1.containerLog.error(`${containerName}: ${data}`));
                 const inspectResult = yield (0, inspect_container_1.inspectContainer)(container);
                 const boundPorts = bound_ports_1.BoundPorts.fromInspectResult(inspectResult);
+                const host = (yield (0, docker_client_1.dockerClient)()).host;
+                const waitStrategy = (this.waitStrategy[containerName] ? this.waitStrategy[containerName] : (0, wait_strategy_1.defaultWaitStrategy)(host, container)).withStartupTimeout(this.startupTimeout);
                 try {
                     logger_1.log.info(`Waiting for container ${containerName} to be ready`);
-                    yield this.waitForContainer(container, containerName, boundPorts);
+                    yield (0, wait_for_container_1.waitForContainer)(container, waitStrategy, boundPorts);
                     logger_1.log.info(`Container ${containerName} is ready`);
                 }
                 catch (err) {
@@ -119,30 +121,14 @@ class DockerComposeEnvironment {
                     }
                     throw err;
                 }
-                return new started_generic_container_1.StartedGenericContainer(container, (yield (0, docker_client_1.dockerClient)()).host, inspectResult, boundPorts, containerName, this.getWaitStrategy((yield (0, docker_client_1.dockerClient)()).host, container, containerName).withStartupTimeout(this.startupTimeout));
+                return new started_generic_container_1.StartedGenericContainer(container, host, inspectResult, boundPorts, containerName, waitStrategy);
             })))).reduce((map, startedGenericContainer) => {
                 const containerName = startedGenericContainer.getName();
                 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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const waitStrategy = this.getWaitStrategy((yield (0, docker_client_1.dockerClient)()).host, container, containerName);
-            yield waitStrategy.withStartupTimeout(this.startupTimeout).waitUntilReady(container, boundPorts);
-        });
-    }
-    getWaitStrategy(host, container, containerName) {
-        if (this.waitStrategy[containerName]) {
-            return this.waitStrategy[containerName];
-        }
-        else {
-            const hostPortCheck = new port_check_1.HostPortCheck(host);
-            const internalPortCheck = new port_check_1.InternalPortCheck(container);
-            return new wait_strategy_1.HostPortWaitStrategy(hostPortCheck, internalPortCheck);
-        }
-    }
 }
 exports.DockerComposeEnvironment = DockerComposeEnvironment;

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";
@@ -9,8 +9,8 @@ export declare class GenericContainerBuilder {
     private buildArgs;
     private pullPolicy;
     private cache;
-    constructor(context: BuildContext, dockerfileName: string, uuid?: Uuid);
-    withBuildArg(key: string, value: string): GenericContainerBuilder;
+    constructor(context: string, dockerfileName: string, uuid?: Uuid);
+    withBuildArgs(buildArgs: BuildArgs): GenericContainerBuilder;
     withPullPolicy(pullPolicy: PullPolicy): this;
     withCache(cache: boolean): this;
     build(image?: string): Promise<GenericContainer>;

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

@@ -34,8 +34,8 @@ class GenericContainerBuilder {
         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) {

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

@@ -1,26 +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, Ulimits } 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;
@@ -44,21 +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;
+    withCommand(command: string[]): this;
     withEntrypoint(entrypoint: string[]): this;
-    withName(name: ContainerName): this;
+    withName(name: string): this;
     withLabels(labels: Labels): this;
-    withEnv(key: EnvKey, value: EnvValue): this;
+    withEnvironment(environment: Environment): this;
     withTmpFs(tmpFs: TmpFs): this;
     withUlimits(ulimits: Ulimits): this;
     withAddedCapabilities(...capabilities: string[]): this;
     withDroppedCapabilities(...capabilities: string[]): this;
-    withNetworkMode(networkMode: NetworkMode): 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;
@@ -68,9 +67,7 @@ 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

@@ -16,7 +16,6 @@ exports.GenericContainer = void 0;
 const archiver_1 = __importDefault(require("archiver"));
 const bound_ports_1 = require("../bound-ports");
 const logger_1 = require("../logger");
-const port_check_1 = require("../port-check");
 const pull_policy_1 = require("../pull-policy");
 const reaper_1 = require("../reaper");
 const docker_image_name_1 = require("../docker-image-name");
@@ -30,21 +29,20 @@ 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 stop_container_1 = require("../docker/functions/container/stop-container");
-const remove_container_1 = require("../docker/functions/container/remove-container");
 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");
 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 +76,8 @@ 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,
@@ -119,14 +117,18 @@ class GenericContainer {
         });
     }
     reuseContainer(startedContainer) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const inspectResult = yield (0, inspect_container_1.inspectContainer)(startedContainer);
             const boundPorts = bound_ports_1.BoundPorts.fromInspectResult(inspectResult).filter(this.ports);
-            yield this.waitForContainer(startedContainer, boundPorts);
-            return new started_generic_container_1.StartedGenericContainer(startedContainer, (yield (0, docker_client_1.dockerClient)()).host, inspectResult, boundPorts, inspectResult.name, this.getWaitStrategy((yield (0, docker_client_1.dockerClient)()).host, startedContainer).withStartupTimeout(this.startupTimeout));
+            const host = (yield (0, docker_client_1.dockerClient)()).host;
+            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, 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()) {
@@ -159,8 +161,10 @@ class GenericContainer {
                 .on("err", (data) => logger_1.containerLog.error(`${container.id}: ${data.trim()}`));
             const inspectResult = yield (0, inspect_container_1.inspectContainer)(container);
             const boundPorts = bound_ports_1.BoundPorts.fromInspectResult(inspectResult).filter(this.ports);
-            yield this.waitForContainer(container, boundPorts);
-            const startedContainer = new started_generic_container_1.StartedGenericContainer(container, (yield (0, docker_client_1.dockerClient)()).host, inspectResult, boundPorts, inspectResult.name, this.getWaitStrategy((yield (0, docker_client_1.dockerClient)()).host, container).withStartupTimeout(this.startupTimeout));
+            const host = (yield (0, docker_client_1.dockerClient)()).host;
+            const waitStrategy = ((_a = this.waitStrategy) !== null && _a !== void 0 ? _a : (0, wait_strategy_1.defaultWaitStrategy)(host, container)).withStartupTimeout(this.startupTimeout);
+            yield (0, wait_for_container_1.waitForContainer)(container, waitStrategy, 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);
             }
@@ -170,8 +174,8 @@ class GenericContainer {
     get hasExposedPorts() {
         return this.ports.length !== 0;
     }
-    withCmd(cmd) {
-        this.cmd = cmd;
+    withCommand(command) {
+        this.command = command;
         return this;
     }
     withEntrypoint(entrypoint) {
@@ -183,27 +187,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 = ulimits;
+        this.ulimits = Object.assign(Object.assign({}, this.ulimits), ulimits);
         return this;
     }
     withAddedCapabilities(...capabilities) {
-        this.addedCapabilities = capabilities;
+        var _a;
+        this.addedCapabilities = [...((_a = this.addedCapabilities) !== null && _a !== void 0 ? _a : []), ...capabilities];
         return this;
     }
     withDroppedCapabilities(...capabilities) {
-        this.droppedCapabilities = 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) {
@@ -211,23 +221,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) {
@@ -266,12 +272,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() {
@@ -280,34 +288,5 @@ class GenericContainer {
         }
         return this.tarToCopy;
     }
-    waitForContainer(container, boundPorts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            logger_1.log.debug(`Waiting for container to be ready: ${container.id}`);
-            const waitStrategy = this.getWaitStrategy((yield (0, docker_client_1.dockerClient)()).host, container);
-            try {
-                yield waitStrategy.withStartupTimeout(this.startupTimeout).waitUntilReady(container, boundPorts);
-                logger_1.log.info("Container is ready");
-            }
-            catch (err) {
-                logger_1.log.error(`Container failed to be ready: ${err}`);
-                try {
-                    yield (0, stop_container_1.stopContainer)(container, { timeout: 0 });
-                    yield (0, remove_container_1.removeContainer)(container, { removeVolumes: true });
-                }
-                catch (stopErr) {
-                    logger_1.log.error(`Failed to stop container after it failed to be ready: ${stopErr}`);
-                }
-                throw err;
-            }
-        });
-    }
-    getWaitStrategy(host, container) {
-        if (this.waitStrategy) {
-            return this.waitStrategy;
-        }
-        const hostPortCheck = new port_check_1.HostPortCheck(host);
-        const internalPortCheck = new port_check_1.InternalPortCheck(container);
-        return new wait_strategy_1.HostPortWaitStrategy(hostPortCheck, internalPortCheck);
-    }
 }
 exports.GenericContainer = GenericContainer;

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 { ExecOptions, RestartOptions, StartedTestContainer, StopOptions, 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,18 @@ 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

@@ -19,6 +19,7 @@ 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");
 class StartedGenericContainer {
     constructor(container, host, inspectResult, boundPorts, name, waitStrategy) {
         this.container = container;
@@ -39,7 +40,7 @@ class StartedGenericContainer {
             yield (0, restart_container_1.restartContainer)(this.container, resolvedOptions);
             this.inspectResult = yield (0, inspect_container_1.inspectContainer)(this.container);
             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);
+            yield (0, wait_for_container_1.waitForContainer)(this.container, this.waitStrategy, this.boundPorts);
         });
     }
     stopContainer(options = {}) {
@@ -51,26 +52,6 @@ class StartedGenericContainer {
             return new stopped_generic_container_1.StoppedGenericContainer();
         });
     }
-    waitForContainer(container, boundPorts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            logger_1.log.debug(`Waiting for container to be ready: ${container.id}`);
-            try {
-                yield this.waitStrategy.waitUntilReady(container, boundPorts);
-                logger_1.log.info("Container is ready");
-            }
-            catch (err) {
-                logger_1.log.error(`Container failed to be ready: ${err}`);
-                try {
-                    yield (0, stop_container_1.stopContainer)(container, { timeout: 0 });
-                    yield (0, remove_container_1.removeContainer)(container, { removeVolumes: true });
-                }
-                catch (stopErr) {
-                    logger_1.log.error(`Failed to stop container after it failed to be ready: ${stopErr}`);
-                }
-                throw err;
-            }
-        });
-    }
     getHost() {
         return this.host;
     }

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

@@ -1,21 +1,20 @@
 /// <reference types="node" />
 import { RestartOptions, StartedTestContainer, StopOptions, StoppedTestContainer } from "../test-container";
-import { Port } from "../port";
-import { ContainerName, Host, Id, Command, ExecResult, Labels } from "../docker/types";
+import { ExecResult, Labels } from "../docker/types";
 import { Readable } from "stream";
 export declare class AbstractStartedContainer {
     protected readonly startedTestContainer: StartedTestContainer;
     constructor(startedTestContainer: StartedTestContainer);
     stop(options?: Partial<StopOptions>): Promise<StoppedTestContainer>;
     restart(options?: Partial<RestartOptions>): Promise<void>;
-    getHost(): Host;
-    getMappedPort(port: Port): Port;
-    getName(): ContainerName;
+    getHost(): string;
+    getMappedPort(port: number): number;
+    getName(): string;
     getLabels(): Labels;
-    getId(): Id;
+    getId(): string;
     getNetworkNames(): string[];
     getNetworkId(networkName: string): string;
     getIpAddress(networkName: string): string;
-    exec(command: Command[]): Promise<ExecResult>;
+    exec(command: string[]): Promise<ExecResult>;
     logs(): Promise<Readable>;
 }

package/dist/modules/arangodb/arangodb-container.js

@@ -16,7 +16,7 @@ const abstract_started_container_1 = require("../abstract-started-container");
 const ARANGODB_PORT = 8529;
 const USERNAME = "root";
 class ArangoDBContainer extends __1.GenericContainer {
-    constructor(image = "arangodb:3.7.13", password = new uuid_1.RandomUuid().nextUuid()) {
+    constructor(image = "arangodb:3.10.0", password = new uuid_1.RandomUuid().nextUuid()) {
         super(image);
         this.password = password;
     }
@@ -31,7 +31,7 @@ class ArangoDBContainer extends __1.GenericContainer {
         return __awaiter(this, void 0, void 0, function* () {
             this.withExposedPorts(...(this.hasExposedPorts ? this.ports : [ARANGODB_PORT]))
                 .withWaitStrategy(__1.Wait.forLogMessage("Have fun!"))
-                .withEnv("ARANGO_ROOT_PASSWORD", this.password)
+                .withEnvironment({ ARANGO_ROOT_PASSWORD: this.password })
                 .withStartupTimeout(120000);
             return new StartedArangoContainer(yield _super.start.call(this), this.password);
         });

package/dist/modules/elasticsearch/elasticsearch-container.js

@@ -14,7 +14,7 @@ const __1 = require("../..");
 const abstract_started_container_1 = require("../abstract-started-container");
 const ELASTIC_SEARCH_HTTP_PORT = 9200;
 class ElasticsearchContainer extends __1.GenericContainer {
-    constructor(image = "docker.elastic.co/elasticsearch/elasticsearch:7.9.2") {
+    constructor(image = "elasticsearch:7.17.7") {
         super(image);
     }
     start() {
@@ -23,7 +23,7 @@ class ElasticsearchContainer extends __1.GenericContainer {
         });
         return __awaiter(this, void 0, void 0, function* () {
             this.withExposedPorts(...(this.hasExposedPorts ? this.ports : [ELASTIC_SEARCH_HTTP_PORT]))
-                .withEnv("discovery.type", "single-node")
+                .withEnvironment({ "discovery.type": "single-node" })
                 .withStartupTimeout(120000);
             return new StartedElasticsearchContainer(yield _super.start.call(this));
         });

package/dist/modules/kafka/kafka-container.d.ts

@@ -1,11 +1,10 @@
 import { GenericContainer } from "../../generic-container/generic-container";
 import { BoundPorts } from "../../bound-ports";
-import { Port } from "../../port";
 import { StartedTestContainer } from "../..";
 import { AbstractStartedContainer } from "../abstract-started-container";
-import { Host } from "../../docker/types";
 import { InspectResult } from "../../docker/functions/container/inspect-container";
-export declare const KAFKA_IMAGE = "confluentinc/cp-kafka:5.5.4";
+import { Content } from "../../docker/types";
+export declare const KAFKA_IMAGE = "confluentinc/cp-kafka:7.2.2";
 interface SaslSslListenerOptions {
     sasl: SaslOptions;
     port: number;
@@ -21,7 +20,7 @@ interface User {
     password: string;
 }
 interface PKCS12CertificateStore {
-    content: Parameters<GenericContainer["withCopyContentToContainer"]>[0];
+    content: Content;
     passphrase: string;
 }
 export declare class KafkaContainer extends GenericContainer {
@@ -31,7 +30,7 @@ export declare class KafkaContainer extends GenericContainer {
     private zooKeeperPort?;
     private saslSslConfig?;
     constructor(image?: string);
-    withZooKeeper(host: Host, port: Port): this;
+    withZooKeeper(host: string, port: number): this;
     withSaslSslListener(options: SaslSslListenerOptions): this;
     protected preStart(): Promise<void>;
     start(): Promise<StartedKafkaContainer>;