testcontainers 8.14.0 → 8.16.0

package/README.md

@@ -5,8 +5,6 @@
 [![Node.js CI](https://github.com/testcontainers/testcontainers-node/actions/workflows/node.js.yml/badge.svg?branch=master)](https://github.com/testcontainers/testcontainers-node/actions/workflows/node.js.yml)
 [![npm version](https://badge.fury.io/js/testcontainers.svg)](https://www.npmjs.com/package/testcontainers)
 [![npm version](https://img.shields.io/npm/dm/testcontainers.svg)](https://www.npmjs.com/package/testcontainers)
-[![Thundra Foresight](https://thundra-assets-prod.s3.us-west-2.amazonaws.com/images/badges/thundra-foresight-badge-enabled.svg)](https://foresight.thundra.live/testRuns/57175ecb-d5ac-4129-957a-9dd617fd27d0)
-[![Foresight Test Summary](https://foresight.service.thundra.us/public/api/v1/badge/test/57175ecb-d5ac-4129-957a-9dd617fd27d0)](https://foresight.thundra.live/testruns/57175ecb-d5ac-4129-957a-9dd617fd27d0)
 
 ## Install
 
@@ -22,8 +20,11 @@ The following environment variables are supported:
 
 - `DEBUG=testcontainers` Enable testcontainers logs
 - `DEBUG=testcontainers:containers` Enable container logs
+- `DEBUG=testcontainers:exec` Enable container exec logs
 - `DEBUG=testcontainers*` Enable all logs
 
+Note that you can enable specific loggers, e.g: `DEBUG=testcontainers,testcontainers:exec`.
+
 ### Docker
 
 - `DOCKER_HOST=tcp://docker:2375` Sets the URL of the docker daemon
@@ -134,6 +135,16 @@ const container = await GenericContainer.fromDockerfile(buildContext, "my-docker
   .build();
 ```
 
+Build the image without using the cache:
+
+```javascript
+const { GenericContainer } = require("testcontainers");
+
+const container = await GenericContainer.fromDockerfile(buildContext, "my-dockerfile")
+  .withCache(false)
+  .build();
+```
+
 Creating a container with multiple exposed ports:
 
 ```javascript
@@ -193,6 +204,16 @@ const container = await new GenericContainer("alpine")
   .start();
 ```
 
+Creating a container with entrypoint:
+
+```javascript
+const { GenericContainer } = require("testcontainers");
+
+const container = await new GenericContainer("alpine")
+  .withEntrypoint(["cat"])
+  .start();
+```
+
 Execute commands inside a running container:
 
 ```javascript
@@ -242,6 +263,41 @@ const container = await new GenericContainer("postgres")
   .start();
 ```
 
+Creating a container with ulimits:
+
+```javascript
+const { GenericContainer } = require("testcontainers");
+
+const container = await new GenericContainer("aline")
+  .withUlimits({ 
+    memlock: { 
+      hard: -1, 
+      soft: -1 
+    }
+  })
+  .start();
+```
+
+Creating a container with added [capabilities](https://man7.org/linux/man-pages/man7/capabilities.7.html):
+
+```javascript
+const { GenericContainer } = require("testcontainers");
+
+const container = await new GenericContainer("aline")
+  .withAddedCapabilities("NET_ADMIN", "IPC_LOCK")
+  .start();
+```
+
+Creating a container with dropped [capabilities](https://man7.org/linux/man-pages/man7/capabilities.7.html):
+
+```javascript
+const { GenericContainer } = require("testcontainers");
+
+const container = await new GenericContainer("aline")
+  .withDroppedCapabilities("NET_ADMIN", "IPC_LOCK")
+  .start();
+```
+
 Copy a file to a container before it is started:
 
 ```javascript
@@ -666,6 +722,30 @@ const environment = await new DockerComposeEnvironment(composeFilePath, composeF
   .up();
 ```
 
+Testcontainers will not wait for an environment to down, to override:
+
+```javascript
+const { GenericContainer } = require("testcontainers");
+
+const environment = await new DockerComposeEnvironment(composeFilePath, composeFile).up();
+
+await environment.down({ 
+  timeout: 10000 
+});
+```
+
+Testcontainers will remove associated volumes created by the environment when downed, to override:
+
+```javascript
+const { GenericContainer } = require("testcontainers");
+
+const environment = await new DockerComposeEnvironment(composeFilePath, composeFile).up();
+
+await environment.down({
+  removeVolumes: false
+});
+```
+
 ## Wait Strategies
 
 Ordinarily Testcontainers will wait for up to 60 seconds for the container's mapped network ports to start listening.

package/dist/docker/functions/container/create-container.d.ts

@@ -1,11 +1,12 @@
 import { DockerImageName } from "../../../docker-image-name";
 import Dockerode from "dockerode";
 import { PortWithOptionalBinding } from "../../../port";
-import { BindMount, Command, ContainerName, Env, ExtraHost, HealthCheck, Labels, NetworkMode, TmpFs } from "../../types";
+import { BindMount, Command, ContainerName, Env, ExtraHost, HealthCheck, Labels, NetworkMode, TmpFs, Ulimits } from "../../types";
 export declare type CreateContainerOptions = {
     imageName: DockerImageName;
     env: Env;
     cmd: Command[];
+    entrypoint?: string[];
     bindMounts: BindMount[];
     tmpFs: TmpFs;
     exposedPorts: PortWithOptionalBinding[];
@@ -19,6 +20,9 @@ export declare type CreateContainerOptions = {
     autoRemove: boolean;
     extraHosts: ExtraHost[];
     ipcMode?: string;
+    ulimits?: Ulimits;
+    addedCapabilities?: string[];
+    droppedCapabilities?: string[];
     user?: string;
 };
 export declare const createContainer: (options: CreateContainerOptions) => Promise<Dockerode.Container>;

package/dist/docker/functions/container/create-container.js

@@ -25,6 +25,7 @@ const createContainer = (options) => __awaiter(void 0, void 0, void 0, function*
             Env: getEnv(options.env),
             ExposedPorts: getExposedPorts(options.exposedPorts),
             Cmd: options.cmd,
+            Entrypoint: options.entrypoint,
             Labels: (0, create_labels_1.createLabels)(options.reusable, options.imageName, options.labels),
             // @ts-ignore
             Healthcheck: getHealthCheck(options.healthCheck),
@@ -38,6 +39,9 @@ const createContainer = (options) => __awaiter(void 0, void 0, void 0, function*
                 Tmpfs: options.tmpFs,
                 LogConfig: getLogConfig(options.useDefaultLogDriver),
                 Privileged: options.privilegedMode,
+                Ulimits: getUlimits(options.ulimits),
+                CapAdd: options.addedCapabilities,
+                CapDrop: options.droppedCapabilities,
             },
         });
     }
@@ -95,3 +99,13 @@ const getLogConfig = (useDefaultLogDriver) => {
         Config: {},
     };
 };
+const getUlimits = (ulimits) => {
+    if (!ulimits) {
+        return undefined;
+    }
+    return Object.entries(ulimits).map(([key, value]) => ({
+        Name: key,
+        Hard: value.hard,
+        Soft: value.soft,
+    }));
+};

package/dist/docker/functions/container/exec-container.d.ts

@@ -1,3 +1,9 @@
 import { Command, ExecResult } from "../../types";
 import Dockerode from "dockerode";
-export declare const execContainer: (container: Dockerode.Container, command: Command[]) => Promise<ExecResult>;
+declare type ExecContainerOptions = {
+    tty: boolean;
+    stdin: boolean;
+    detach: boolean;
+};
+export declare const execContainer: (container: Dockerode.Container, command: Command[], options: ExecContainerOptions, shouldLog?: boolean) => Promise<ExecResult>;
+export {};

package/dist/docker/functions/container/exec-container.js

@@ -8,39 +8,38 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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.execContainer = void 0;
 const logger_1 = require("../../../logger");
-const execContainer = (container, command) => __awaiter(void 0, void 0, void 0, function* () {
+const byline_1 = __importDefault(require("byline"));
+const execContainer = (container, command, options, shouldLog = true) => __awaiter(void 0, void 0, void 0, function* () {
+    const chunks = [];
     try {
         const exec = yield container.exec({
             Cmd: command,
             AttachStdout: true,
             AttachStderr: true,
         });
-        const stream = yield startExec(exec);
-        const chunks = [];
+        const stream = yield startExec(exec, options);
         stream.on("data", (chunk) => chunks.push(chunk));
+        if (shouldLog) {
+            (0, byline_1.default)(stream).on("data", (line) => logger_1.execLog.trace(`${container.id}: ${line}`));
+        }
         const exitCode = yield waitForExec(exec);
         stream.destroy();
         return { output: chunks.join(""), exitCode };
     }
     catch (err) {
-        logger_1.log.error(`Failed to exec container ${container.id} with command "${command.join(" ")}": ${err}`);
+        logger_1.log.error(`Failed to exec container ${container.id} with command "${command.join(" ")}": ${err}. Container output: ${chunks.join("")}`);
         throw err;
     }
 });
 exports.execContainer = execContainer;
-const startExec = (exec) => __awaiter(void 0, void 0, void 0, function* () {
+const startExec = (exec, options) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        const options = {
-            Detach: false,
-            Tty: true,
-            stream: true,
-            stdin: true,
-            stdout: true,
-            stderr: true,
-        };
         const stream = yield exec.start(options);
         stream.setEncoding("utf-8");
         return stream;

package/dist/docker/functions/image/build-image.d.ts

@@ -8,5 +8,6 @@ export declare type BuildImageOptions = {
     buildArgs: BuildArgs;
     pullPolicy: PullPolicy;
     registryConfig: RegistryConfig;
+    cache: boolean;
 };
 export declare const buildImage: (options: BuildImageOptions) => Promise<void>;

package/dist/docker/functions/image/build-image.js

@@ -37,21 +37,26 @@ const buildImage = (options) => __awaiter(void 0, void 0, void 0, function* () {
             },
         });
         const { dockerode } = yield (0, docker_client_1.dockerClient)();
-        return new Promise((resolve) => dockerode
-            .buildImage(tarStream, {
+        const buildImageOptions = {
             dockerfile: options.dockerfileName,
+            // @ts-ignore
+            nocache: !options.cache,
             buildargs: options.buildArgs,
             t: options.imageName.toString(),
             labels: (0, create_labels_1.createLabels)(false, options.imageName),
             registryconfig: options.registryConfig,
             pull: options.pullPolicy.shouldPull() ? "any" : undefined,
-        })
-            .then((stream) => (0, byline_1.default)(stream))
-            .then((stream) => {
-            stream.setEncoding("utf-8");
-            stream.on("data", (line) => logger_1.log.trace(`${options.imageName.toString()}: ${line}`));
-            stream.on("end", () => resolve());
-        }));
+        };
+        return new Promise((resolve) => {
+            dockerode
+                .buildImage(tarStream, buildImageOptions)
+                .then((stream) => (0, byline_1.default)(stream))
+                .then((stream) => {
+                stream.setEncoding("utf-8");
+                stream.on("data", (line) => logger_1.log.trace(`${options.imageName.toString()}: ${line}`));
+                stream.on("end", () => resolve());
+            });
+        });
     }
     catch (err) {
         logger_1.log.error(`Failed to build image: ${err}`);

package/dist/docker/types.d.ts

@@ -15,6 +15,12 @@ export declare type BindMount = {
 export declare type TmpFs = {
     [dir in Dir]: Dir;
 };
+export declare type Ulimits = {
+    [name: string]: {
+        hard: number | undefined;
+        soft: number | undefined;
+    };
+};
 export declare type HealthCheck = {
     test: string;
     interval?: number;

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.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.js

@@ -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`);

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

@@ -8,9 +8,11 @@ export declare class GenericContainerBuilder {
     private readonly uuid;
     private buildArgs;
     private pullPolicy;
+    private cache;
     constructor(context: BuildContext, dockerfileName: string, uuid?: Uuid);
     withBuildArg(key: string, value: string): 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,6 +32,7 @@ class GenericContainerBuilder {
         this.uuid = uuid;
         this.buildArgs = {};
         this.pullPolicy = new pull_policy_1.DefaultPullPolicy();
+        this.cache = true;
     }
     withBuildArg(key, value) {
         this.buildArgs[key] = value;
@@ -41,6 +42,10 @@ class GenericContainerBuilder {
         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

@@ -6,7 +6,7 @@ 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 { BindMode, BindMount, BuildContext, Command, ContainerName, Dir, Env, EnvKey, EnvValue, ExtraHost, HealthCheck, NetworkMode, TmpFs, Labels, Ulimits } from "../docker/types";
 import { InspectResult } from "../docker/functions/container/inspect-container";
 import { GenericContainerBuilder } from "./generic-container-builder";
 export declare class GenericContainer implements TestContainer {
@@ -18,6 +18,7 @@ export declare class GenericContainer implements TestContainer {
     protected networkAliases: string[];
     protected ports: PortWithOptionalBinding[];
     protected cmd: Command[];
+    protected entrypoint?: string[];
     protected bindMounts: BindMount[];
     protected name?: ContainerName;
     protected labels: Labels;
@@ -28,6 +29,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;
@@ -41,10 +45,14 @@ export declare class GenericContainer implements TestContainer {
     protected postStart?(container: StartedTestContainer, inspectResult: InspectResult, boundPorts: BoundPorts): Promise<void>;
     protected get hasExposedPorts(): boolean;
     withCmd(cmd: Command[]): this;
+    withEntrypoint(entrypoint: string[]): this;
     withName(name: ContainerName): this;
     withLabels(labels: Labels): this;
     withEnv(key: EnvKey, value: EnvValue): this;
     withTmpFs(tmpFs: TmpFs): this;
+    withUlimits(ulimits: Ulimits): this;
+    withAddedCapabilities(...capabilities: string[]): this;
+    withDroppedCapabilities(...capabilities: string[]): this;
     withNetworkMode(networkMode: NetworkMode): this;
     withNetworkAliases(...networkAliases: string[]): this;
     withExtraHosts(...extraHosts: ExtraHost[]): this;

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

@@ -80,6 +80,7 @@ class GenericContainer {
                 imageName: this.imageName,
                 env: this.env,
                 cmd: this.cmd,
+                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) {
@@ -170,6 +174,10 @@ class GenericContainer {
         this.cmd = cmd;
         return this;
     }
+    withEntrypoint(entrypoint) {
+        this.entrypoint = entrypoint;
+        return this;
+    }
     withName(name) {
         this.name = name;
         return this;
@@ -186,6 +194,18 @@ class GenericContainer {
         this.tmpFs = tmpFs;
         return this;
     }
+    withUlimits(ulimits) {
+        this.ulimits = ulimits;
+        return this;
+    }
+    withAddedCapabilities(...capabilities) {
+        this.addedCapabilities = capabilities;
+        return this;
+    }
+    withDroppedCapabilities(...capabilities) {
+        this.droppedCapabilities = capabilities;
+        return this;
+    }
     withNetworkMode(networkMode) {
         this.networkMode = networkMode;
         return this;

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

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { RestartOptions, StartedTestContainer, StopOptions, StoppedTestContainer } from "../test-container";
+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 { InspectResult } from "../docker/functions/container/inspect-container";
@@ -27,6 +27,6 @@ export declare class StartedGenericContainer implements StartedTestContainer {
     getNetworkNames(): string[];
     getNetworkId(networkName: string): string;
     getIpAddress(networkName: string): string;
-    exec(command: Command[]): Promise<ExecResult>;
+    exec(command: Command[], 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);
         });
     }
@@ -96,8 +95,9 @@ class StartedGenericContainer {
     getIpAddress(networkName) {
         return this.inspectResult.networkSettings[networkName].ipAddress;
     }
-    exec(command) {
-        return (0, exec_container_1.execContainer)(this.container, command);
+    exec(command, options = {}) {
+        const resolvedOptions = Object.assign({ stdin: true, detach: false, tty: true }, options);
+        return (0, exec_container_1.execContainer)(this.container, command, resolvedOptions);
     }
     logs() {
         return (0, container_logs_1.containerLogs)(this.container);

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 {};

package/dist/logger.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.containerLog = exports.log = exports.FakeLogger = void 0;
+exports.execLog = exports.containerLog = exports.log = exports.FakeLogger = void 0;
 const debug_1 = __importDefault(require("debug"));
 class DebugLogger {
     constructor(namespace) {
@@ -52,3 +52,4 @@ class FakeLogger {
 exports.FakeLogger = FakeLogger;
 exports.log = new DebugLogger("testcontainers");
 exports.containerLog = new DebugLogger("testcontainers:containers");
+exports.execLog = new DebugLogger("testcontainers:exec");

package/dist/port-check.js

@@ -52,7 +52,7 @@ class InternalPortCheck {
                 ["/bin/sh", "-c", `nc -vz -w 1 localhost ${port}`],
                 ["/bin/bash", "-c", `</dev/tcp/localhost/${port}`],
             ];
-            const commandResults = yield Promise.all(commands.map((command) => (0, exec_container_1.execContainer)(this.container, command)));
+            const commandResults = yield Promise.all(commands.map((command) => (0, exec_container_1.execContainer)(this.container, command, { stdin: true, detach: false, tty: true }, false)));
             const isBound = commandResults.some((result) => result.exitCode === 0);
             if (!isBound) {
                 const shellExists = commandResults.some((result) => result.exitCode !== 126);

package/dist/test-container.d.ts

@@ -3,12 +3,16 @@ import { Port, PortWithOptionalBinding } from "./port";
 import { PullPolicy } from "./pull-policy";
 import { WaitStrategy } from "./wait-strategy";
 import { Readable } from "stream";
-import { BindMode, Command, ContainerName, Dir, EnvKey, EnvValue, ExecResult, ExtraHost, Host, Id, NetworkMode, TmpFs, Labels } from "./docker/types";
+import { BindMode, Command, ContainerName, Dir, EnvKey, EnvValue, ExecResult, ExtraHost, Host, Id, NetworkMode, TmpFs, Labels, Ulimits } from "./docker/types";
 export interface TestContainer {
     start(): Promise<StartedTestContainer>;
     withEnv(key: EnvKey, value: EnvValue): this;
     withCmd(cmd: Command[]): this;
+    withEntrypoint(entrypoint: string[]): this;
     withTmpFs(tmpFs: TmpFs): this;
+    withUlimits(ulimits: Ulimits): this;
+    withAddedCapabilities(...capabilities: string[]): this;
+    withDroppedCapabilities(...capabilities: string[]): this;
     withExposedPorts(...ports: PortWithOptionalBinding[]): this;
     withBindMount(source: Dir, target: Dir, bindMode: BindMode): this;
     withWaitStrategy(waitStrategy: WaitStrategy): this;
@@ -30,6 +34,15 @@ export interface StopOptions {
     timeout: number;
     removeVolumes: boolean;
 }
+export interface DockerComposeDownOptions {
+    timeout: number;
+    removeVolumes: boolean;
+}
+export interface ExecOptions {
+    tty: boolean;
+    detach: boolean;
+    stdin: boolean;
+}
 export interface StartedTestContainer {
     stop(options?: Partial<StopOptions>): Promise<StoppedTestContainer>;
     restart(options?: Partial<RestartOptions>): Promise<void>;
@@ -41,7 +54,7 @@ export interface StartedTestContainer {
     getNetworkNames(): string[];
     getNetworkId(networkName: string): string;
     getIpAddress(networkName: string): string;
-    exec(command: Command[]): Promise<ExecResult>;
+    exec(command: Command[], options?: Partial<ExecOptions>): Promise<ExecResult>;
     logs(): Promise<Readable>;
 }
 export interface StoppedTestContainer {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "testcontainers",
   "author": "Cristian Greco",
-  "version": "8.14.0",
+  "version": "8.16.0",
   "main": "dist/index",
   "types": "dist/index",
   "keywords": [