testcontainers 7.23.0 → 8.0.0

package/README.md

@@ -5,6 +5,8 @@
 [![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
 
@@ -16,12 +18,18 @@ npm i -D testcontainers
 
 The following environment variables are supported:
 
-- `DEBUG=testcontainers` See output
-- `DEBUG=testcontainers:containers` See container output
-- `DEBUG=testcontainers*` See all output
-- `DOCKER_HOST=tcp://docker:2375` Daemon socket to connect to
+- `DEBUG=testcontainers` See testcontainers logs
+- `DEBUG=testcontainers:containers` See container logs
+- `DEBUG=testcontainers*` See all logs
+- `DOCKER_HOST=tcp://docker:2375` Sets the URL of the docker daemon
+- `DOCKER_TLS_VERIFY=1` When set to anything other than an empty string, enables TLS communication with the docker
+  daemon
+- `DOCKER_CERT_PATH=/some/path` Configures the path to the ca.pem, cert.pem, and key.pem files used for TLS
+  verification. Defaults to ~/.docker
 - `TESTCONTAINERS_HOST_OVERRIDE=docker.svc.local` Docker's host on which ports are exposed
-- `TESTCONTAINERS_DOCKER_SOCKET_OVERRIDE=/var/run/docker.sock` Path to Docker's socket. Used by [ryuk](#ryuk) and other [auxiliary containers](#auxiliary-containers) that need to perform Docker actions
+- `TESTCONTAINERS_DOCKER_SOCKET_OVERRIDE=/var/run/docker.sock` Path to Docker's socket. Used by [ryuk](#ryuk) and
+  other [auxiliary containers](#auxiliary-containers) that need to perform Docker actions
+- `TESTCONTAINERS_RYUK_PRIVILEGED=true` Run [ryuk](#ryuk) as a privileged container
 - `TESTCONTAINERS_RYUK_DISABLED=true` Disable [ryuk](#ryuk)
 - `RYUK_CONTAINER_IMAGE=registry.mycompany.com/mirror/ryuk:0.3.0` Custom image for [ryuk](#ryuk)
 - `SSHD_CONTAINER_IMAGE=registry.mycompany.com/mirror/sshd:1.0.0` Custom image for [SSHd](#SSHd)
@@ -136,7 +144,7 @@ Creating a container with a command:
 const { GenericContainer } = require("testcontainers");
 
 const container = await new GenericContainer("alpine")
-  .withCmd(["top"])
+  .withCmd(["sleep", "infinity"])
   .start();
 ```
 
@@ -146,7 +154,7 @@ Execute commands inside a running container:
 const { GenericContainer } = require("testcontainers");
 
 const container = await new GenericContainer("alpine")
-  .withCmd(["top"])
+  .withCmd(["sleep", "infinity"])
   .start();
 
 const { output, exitCode } = await container.exec(["echo", "hello", "world"]);
@@ -263,12 +271,12 @@ const network = await new Network()
     .start();
 
 const container = await new GenericContainer("alpine")
-  .withCmd(["top"])
+  .withCmd(["sleep", "infinity"])
   .withNetworkMode(network.getName())
   .start();
 
 const fooContainer = await new GenericContainer("alpine")
-  .withCmd(["top"])
+  .withCmd(["sleep", "infinity"])
   .withNetworkMode(network.getName())
   .withNetworkAliases("foo", "bar")
   .start();
@@ -276,6 +284,22 @@ const fooContainer = await new GenericContainer("alpine")
 expect((await container.exec(["nslookup", "foo"])).exitCode).toBe(0);
 ```
 
+Add hostname mappings:
+
+```javascript
+const { GenericContainer } = require("testcontainers");
+
+const container = await new GenericContainer("alpine")
+  .withExtraHosts(
+    { host: "foo", ipAddress: "10.11.12.13" },
+    { host: "bar", ipAddress: "11.12.13.14" }
+  )
+  .start();
+
+expect((await container.exec(["nslookup", "foo"])).exitCode).toBe(0);
+expect((await container.exec(["nslookup", "bar"])).exitCode).toBe(0);
+```
+
 Specifying a pull policy. Note that if omitted will use the `DefaultPullPolicy` which will use a locally cached image 
 if one already exists, this is usually the preferred option. In cases where there is a local image for a given tag 
 but the remote image with the same tag may have changed (for example when using the `latest` tag), you can tell 
@@ -401,7 +425,7 @@ server.listen(8000);
 await TestContainers.exposeHostPorts(8000);
 
 const container = await new GenericContainer("alpine")
-  .withCmd(["top"])
+  .withCmd(["sleep", "infinity"])
   .start();
 
 const { output } = await container.exec(["curl", `http://host.testcontainers.internal:8000`]);
@@ -634,8 +658,9 @@ Once started, this container keeps track of containers/images/networks/volumes c
 automatically clean them up 10s after connectivity with testcontainers is lost. This is useful for example if a test 
 starts a container and then terminates unexpectedly, as it will be automatically removed.
 
-ryuk must be run with privileged mode; in CI environments such as Bit Bucket where this isn't supported, ryuk can be 
-disabled by setting the environment variable `TESTCONTAINERS_RYUK_DISABLED` to `true`.
+ryuk by default does not run privileged, if necessary this can be overridden by setting the environment variable 
+`TESTCONTAINERS_RYUK_PRIVILEGED` to `true`. If necessary, ryuk can be disabled enirely by setting the environment 
+variable `TESTCONTAINERS_RYUK_DISABLED` to `true`.
 
 ### SSHd
 
@@ -665,3 +690,4 @@ depending on file sizes and network constraints. It's unlikely that the default
 timeouts set by test frameworks are sufficient.
 
 - Increase the test timeout via the methods provided by the testing framework.
+

package/dist/bound-ports.d.ts

@@ -1,7 +1,10 @@
 import { Port } from "./port";
+import { InspectResult } from "./docker/functions/container/inspect-container";
 export declare class BoundPorts {
     private readonly ports;
     getBinding(port: Port): Port;
     setBinding(key: Port, value: Port): void;
     iterator(): Iterable<[Port, Port]>;
+    filter(ports: Port[]): BoundPorts;
+    static fromInspectResult(inspectResult: InspectResult): BoundPorts;
 }

package/dist/bound-ports.js

@@ -18,5 +18,19 @@ class BoundPorts {
     iterator() {
         return this.ports;
     }
+    filter(ports) {
+        const boundPorts = new BoundPorts();
+        for (const [internalPort, hostPort] of this.iterator()) {
+            if (ports.includes(internalPort)) {
+                boundPorts.setBinding(internalPort, hostPort);
+            }
+        }
+        return boundPorts;
+    }
+    static fromInspectResult(inspectResult) {
+        const boundPorts = new BoundPorts();
+        Object.entries(inspectResult.ports).forEach(([internalPort, hostPort]) => boundPorts.setBinding(parseInt(internalPort), hostPort));
+        return boundPorts;
+    }
 }
 exports.BoundPorts = BoundPorts;

package/dist/docker/dockerode.js

@@ -5,6 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dockerode = void 0;
 const dockerode_1 = __importDefault(require("dockerode"));
-const logger_1 = require("../logger");
-logger_1.log.debug("Creating new Docker instance");
+const testcontainers_properties_file_1 = require("../testcontainers-properties-file");
+testcontainers_properties_file_1.loadTestcontainersPropertiesFile();
 exports.dockerode = new dockerode_1.default();

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

@@ -1,6 +1,6 @@
 import { DockerImageName } from "../../../docker-image-name";
-import { BoundPorts } from "../../../bound-ports";
 import Dockerode from "dockerode";
+import { Port } from "../../../port";
 import { BindMount, Command, ContainerName, Env, ExtraHost, HealthCheck, NetworkMode, TmpFs } from "../../types";
 export declare type CreateContainerOptions = {
     imageName: DockerImageName;
@@ -8,7 +8,7 @@ export declare type CreateContainerOptions = {
     cmd: Command[];
     bindMounts: BindMount[];
     tmpFs: TmpFs;
-    boundPorts: BoundPorts;
+    exposedPorts: Port[];
     name?: ContainerName;
     networkMode?: NetworkMode;
     healthCheck?: HealthCheck;

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

@@ -21,7 +21,7 @@ const createContainer = (options) => __awaiter(void 0, void 0, void 0, function*
             User: options.user,
             Image: options.imageName.toString(),
             Env: getEnv(options.env),
-            ExposedPorts: getExposedPorts(options.boundPorts),
+            ExposedPorts: getExposedPorts(options.exposedPorts),
             Cmd: options.cmd,
             Labels: create_labels_1.createLabels(options.imageName),
             // @ts-ignore
@@ -31,7 +31,7 @@ const createContainer = (options) => __awaiter(void 0, void 0, void 0, function*
                 ExtraHosts: getExtraHosts(options.extraHosts),
                 AutoRemove: options.autoRemove,
                 NetworkMode: options.networkMode,
-                PortBindings: getPortBindings(options.boundPorts),
+                PortBindings: getPortBindings(options.exposedPorts),
                 Binds: getBindMounts(options.bindMounts),
                 Tmpfs: options.tmpFs,
                 LogConfig: getLogConfig(options.useDefaultLogDriver),
@@ -46,20 +46,20 @@ const createContainer = (options) => __awaiter(void 0, void 0, void 0, function*
 });
 exports.createContainer = createContainer;
 const getEnv = (env) => Object.entries(env).reduce((dockerodeEnvironment, [key, value]) => [...dockerodeEnvironment, `${key}=${value}`], []);
-const getExposedPorts = (boundPorts) => {
+const getExposedPorts = (exposedPorts) => {
     const dockerodeExposedPorts = {};
-    for (const [internalPort] of boundPorts.iterator()) {
-        dockerodeExposedPorts[internalPort.toString()] = {};
+    for (const exposedPort of exposedPorts) {
+        dockerodeExposedPorts[exposedPort.toString()] = {};
     }
     return dockerodeExposedPorts;
 };
 const getExtraHosts = (extraHosts) => {
     return extraHosts.map((extraHost) => `${extraHost.host}:${extraHost.ipAddress}`);
 };
-const getPortBindings = (boundPorts) => {
+const getPortBindings = (exposedPorts) => {
     const dockerodePortBindings = {};
-    for (const [internalPort, hostPort] of boundPorts.iterator()) {
-        dockerodePortBindings[internalPort.toString()] = [{ HostPort: hostPort.toString() }];
+    for (const exposedPort of exposedPorts) {
+        dockerodePortBindings[exposedPort] = [{ HostPort: "0" }];
     }
     return dockerodePortBindings;
 };

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

@@ -19,18 +19,11 @@ const execContainer = (container, command) => __awaiter(void 0, void 0, void 0,
             AttachStderr: true,
         });
         const stream = yield startExec(exec);
-        return yield new Promise((resolve) => {
-            const chunks = [];
-            stream.on("data", (chunk) => chunks.push(chunk));
-            const interval = setInterval(() => __awaiter(void 0, void 0, void 0, function* () {
-                const { running, exitCode } = yield inspectExec(exec);
-                if (!running) {
-                    clearInterval(interval);
-                    stream.destroy();
-                    resolve({ output: chunks.join(""), exitCode });
-                }
-            }), 100);
-        });
+        const chunks = [];
+        stream.on("data", (chunk) => chunks.push(chunk));
+        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}`);
@@ -72,3 +65,14 @@ const inspectExec = (exec) => __awaiter(void 0, void 0, void 0, function* () {
         throw err;
     }
 });
+const waitForExec = (exec) => __awaiter(void 0, void 0, void 0, function* () {
+    return new Promise((resolve) => {
+        const interval = setInterval(() => __awaiter(void 0, void 0, void 0, function* () {
+            const { running, exitCode } = yield inspectExec(exec);
+            if (!running) {
+                clearInterval(interval);
+                resolve(exitCode);
+            }
+        }), 100);
+    });
+});

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

@@ -1,10 +1,9 @@
-import { ContainerName, HealthCheckStatus, NetworkSettings } from "../../types";
-import { Port } from "../../../port";
+import { ContainerName, HealthCheckStatus, NetworkSettings, Ports } from "../../types";
 import Dockerode from "dockerode";
 export declare type InspectResult = {
     name: ContainerName;
-    internalPorts: Port[];
-    hostPorts: Port[];
+    hostname: string;
+    ports: Ports;
     healthCheckStatus: HealthCheckStatus;
     networkSettings: {
         [networkName: string]: NetworkSettings;

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

@@ -15,9 +15,9 @@ const inspectContainer = (container) => __awaiter(void 0, void 0, void 0, functi
     try {
         const inspectResult = yield container.inspect();
         return {
-            hostPorts: getHostPorts(inspectResult),
-            internalPorts: getInternalPorts(inspectResult),
-            name: getName(inspectResult),
+            name: inspectResult.Name,
+            hostname: inspectResult.Config.Hostname,
+            ports: getPorts(inspectResult),
             healthCheckStatus: getHealthCheckStatus(inspectResult),
             networkSettings: getNetworkSettings(inspectResult),
             state: { status: inspectResult.State.Status, running: inspectResult.State.Running },
@@ -29,11 +29,13 @@ const inspectContainer = (container) => __awaiter(void 0, void 0, void 0, functi
     }
 });
 exports.inspectContainer = inspectContainer;
-const getHostPorts = (inspectInfo) => Object.values(inspectInfo.NetworkSettings.Ports)
-    .filter((portsArray) => portsArray !== null)
-    .map((portsArray) => Number(portsArray[0].HostPort));
-const getInternalPorts = (inspectInfo) => Object.keys(inspectInfo.NetworkSettings.Ports).map((port) => Number(port.split("/")[0]));
-const getName = (inspectInfo) => inspectInfo.Name;
+const getPorts = (inspectInfo) => Object.entries(inspectInfo.NetworkSettings.Ports)
+    .filter(([, hostPorts]) => hostPorts !== null)
+    .map(([internalPort, hostPorts]) => {
+    const hostPort = hostPorts[0].HostPort;
+    return { [parseInt(internalPort.split("/")[0])]: parseInt(hostPort) };
+})
+    .reduce((acc, curr) => (Object.assign(Object.assign({}, acc), curr)), {});
 const getHealthCheckStatus = (inspectResult) => {
     const health = inspectResult.State.Health;
     if (health === undefined) {

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

@@ -23,7 +23,7 @@ const create_labels_1 = require("../create-labels");
 const buildImage = (options) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         logger_1.log.info(`Building image '${options.imageName.toString()}' with context '${options.context}'`);
-        const dockerIgnoreFiles = yield docker_ignore_1.findDockerIgnoreFiles(options.context);
+        const dockerIgnoreFiles = yield docker_ignore_1.findDockerIgnoreFiles(options.context, options.dockerfileName);
         const tarStream = tar_fs_1.default.pack(options.context, { ignore: (name) => dockerIgnoreFiles.has(slash_1.default(name)) });
         return new Promise((resolve) => dockerode_1.dockerode
             .buildImage(tarStream, {

package/dist/docker/get-docker-host.js

@@ -16,16 +16,15 @@ exports.getDockerHost = void 0;
 const logger_1 = require("../logger");
 const run_in_container_1 = require("./functions/run-in-container");
 const fs_1 = __importDefault(require("fs"));
+const url_1 = require("url");
 const DEFAULT_HOST = "localhost";
 const getDockerHost = (dockerode) => __awaiter(void 0, void 0, void 0, function* () {
-    if (process.env.DOCKER_HOST) {
-        logger_1.log.info(`Detected DOCKER_HOST environment variable: ${process.env.DOCKER_HOST}`);
-    }
     for (const [hostStrategyName, hostStrategy] of Object.entries(hostStrategies(dockerode))) {
         const result = yield hostStrategy();
         if (result) {
-            logger_1.log.info(`Docker host strategy ${hostStrategyName}: ${result}`);
-            return result;
+            const hostname = result === DEFAULT_HOST ? DEFAULT_HOST : new url_1.URL(result).hostname;
+            logger_1.log.info(`Docker host strategy ${hostStrategyName}: ${hostname}`);
+            return hostname;
         }
     }
     logger_1.log.info(`Docker host strategy FALLBACK: ${DEFAULT_HOST}`);
@@ -33,6 +32,11 @@ const getDockerHost = (dockerode) => __awaiter(void 0, void 0, void 0, function*
 });
 exports.getDockerHost = getDockerHost;
 const hostStrategies = (dockerode) => ({
+    DOCKER_HOST: () => __awaiter(void 0, void 0, void 0, function* () {
+        if (process.env.DOCKER_HOST) {
+            return process.env.DOCKER_HOST;
+        }
+    }),
     MODEM: () => __awaiter(void 0, void 0, void 0, function* () { return dockerode.modem.host; }),
     TESTCONTAINERS_HOST_OVERRIDE: () => __awaiter(void 0, void 0, void 0, function* () { return process.env["TESTCONTAINERS_HOST_OVERRIDE"]; }),
     OUTSIDE_CONTAINER: () => __awaiter(void 0, void 0, void 0, function* () {

package/dist/docker/types.d.ts

@@ -28,6 +28,9 @@ export declare type ExtraHost = {
 };
 export declare type NetworkMode = string;
 export declare type ContainerName = string;
+export declare type Ports = {
+    [internalPort: number]: number;
+};
 export declare type AuthConfig = {
     username: string;
     password: string;

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

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

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

@@ -0,0 +1,2 @@
+export { upMany, upAll, down, stop, version } from "docker-compose";
+export type { IDockerComposeOptions } from "docker-compose";

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.version = exports.stop = exports.down = exports.upAll = exports.upMany = void 0;
+const testcontainers_properties_file_1 = require("../testcontainers-properties-file");
+testcontainers_properties_file_1.loadTestcontainersPropertiesFile();
+var docker_compose_1 = require("docker-compose");
+Object.defineProperty(exports, "upMany", { enumerable: true, get: function () { return docker_compose_1.upMany; } });
+Object.defineProperty(exports, "upAll", { enumerable: true, get: function () { return docker_compose_1.upAll; } });
+Object.defineProperty(exports, "down", { enumerable: true, get: function () { return docker_compose_1.down; } });
+Object.defineProperty(exports, "stop", { enumerable: true, get: function () { return docker_compose_1.stop; } });
+Object.defineProperty(exports, "version", { enumerable: true, get: function () { return docker_compose_1.version; } });

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

@@ -10,9 +10,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dockerComposeDown = void 0;
-const docker_compose_1 = require("docker-compose");
 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* () {
     logger_1.log.info(`Downing DockerCompose environment`);
     try {

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

@@ -11,7 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dockerComposeStop = void 0;
 const logger_1 = require("../../logger");
-const docker_compose_1 = require("docker-compose");
+const docker_compose_1 = require("../docker-compose");
 const default_docker_compose_options_1 = require("../default-docker-compose-options");
 const dockerComposeStop = (options) => __awaiter(void 0, void 0, void 0, function* () {
     logger_1.log.info(`Stopping DockerCompose environment`);

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

@@ -11,7 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dockerComposeUp = void 0;
 const logger_1 = require("../../logger");
-const docker_compose_1 = require("docker-compose");
+const docker_compose_1 = require("../docker-compose");
 const default_docker_compose_options_1 = require("../default-docker-compose-options");
 const docker_compose_down_1 = require("./docker-compose-down");
 const dockerComposeUp = (options, services) => __awaiter(void 0, void 0, void 0, function* () {

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

@@ -20,7 +20,6 @@ export declare class DockerComposeEnvironment {
     withWaitStrategy(containerName: string, waitStrategy: WaitStrategy): this;
     withStartupTimeout(startupTimeout: number): this;
     up(services?: Array<string>): Promise<StartedDockerComposeEnvironment>;
-    private getBoundPorts;
     private waitForContainer;
     private getWaitStrategy;
 }

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

@@ -80,10 +80,7 @@ class DockerComposeEnvironment {
                 commandOptions.push("--no-recreate");
             }
             const composeOptions = [];
-            this.profiles.forEach((profile) => {
-                composeOptions.push("--profile");
-                composeOptions.push(profile);
-            });
+            this.profiles.forEach((profile) => composeOptions.push("--profile", profile));
             yield docker_compose_up_1.dockerComposeUp(Object.assign(Object.assign({}, options), { commandOptions, composeOptions, env: this.env }), services);
             const startedContainers = (yield list_containers_1.listContainers()).filter((container) => container.Labels["com.docker.compose.project"] === this.projectName);
             const startedContainerNames = startedContainers.reduce((containerNames, startedContainer) => [
@@ -98,7 +95,7 @@ class DockerComposeEnvironment {
                     .on("data", (data) => logger_1.containerLog.trace(`${containerName}: ${data}`))
                     .on("err", (data) => logger_1.containerLog.error(`${containerName}: ${data}`));
                 const inspectResult = yield inspect_container_1.inspectContainer(container);
-                const boundPorts = this.getBoundPorts(startedContainer);
+                const boundPorts = bound_ports_1.BoundPorts.fromInspectResult(inspectResult);
                 try {
                     logger_1.log.info(`Waiting for container ${containerName} to be ready`);
                     yield this.waitForContainer(container, containerName, boundPorts);
@@ -120,14 +117,9 @@ 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, options);
+            return new started_docker_compose_environment_1.StartedDockerComposeEnvironment(startedGenericContainers, Object.assign(Object.assign({}, options), { composeOptions, env: this.env }));
         });
     }
-    getBoundPorts(containerInfo) {
-        const boundPorts = new bound_ports_1.BoundPorts();
-        containerInfo.Ports.filter((port) => port.PublicPort !== undefined).forEach((port) => boundPorts.setBinding(port.PrivatePort, port.PublicPort));
-        return boundPorts;
-    }
     waitForContainer(container, containerName, boundPorts) {
         return __awaiter(this, void 0, void 0, function* () {
             const waitStrategy = this.getWaitStrategy(yield docker_host_1.dockerHost, container, containerName);

package/dist/docker-ignore.d.ts

@@ -1 +1 @@
-export declare const findDockerIgnoreFiles: (context: string) => Promise<Set<string>>;
+export declare const findDockerIgnoreFiles: (context: string, dockerfileName: string) => Promise<Set<string>>;

package/dist/docker-ignore.js

@@ -17,7 +17,7 @@ const fs_1 = require("fs");
 const os_1 = __importDefault(require("os"));
 const glob_1 = __importDefault(require("glob"));
 const path_1 = __importDefault(require("path"));
-const findDockerIgnoreFiles = (context) => __awaiter(void 0, void 0, void 0, function* () {
+const findDockerIgnoreFiles = (context, dockerfileName) => __awaiter(void 0, void 0, void 0, function* () {
     const dockerIgnoreFilePath = path_1.default.join(context, ".dockerignore");
     if (!fs_1.existsSync(dockerIgnoreFilePath)) {
         return new Set();
@@ -25,6 +25,7 @@ const findDockerIgnoreFiles = (context) => __awaiter(void 0, void 0, void 0, fun
     const dockerIgnorePatterns = (yield fs_1.promises.readFile(dockerIgnoreFilePath, { encoding: "utf-8" }))
         .toString()
         .split(os_1.default.EOL)
+        .filter((dockerIgnorePattern) => dockerIgnorePattern !== dockerfileName)
         .map((dockerIgnorePattern) => path_1.default.resolve(context, dockerIgnorePattern));
     const dockerIgnoreMatches = (yield Promise.all(dockerIgnorePatterns.map(findIgnoredFilesForPattern))).reduce((prev, next) => [...prev, ...next]);
     return new Set(dockerIgnoreMatches);

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

@@ -6,7 +6,8 @@ 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, HealthCheck, NetworkMode, TmpFs } from "../docker/types";
+import { BindMode, BindMount, BuildContext, Command, ContainerName, Dir, Env, EnvKey, EnvValue, ExtraHost, HealthCheck, NetworkMode, TmpFs } from "../docker/types";
+import { InspectResult } from "../docker/functions/container/inspect-container";
 import { GenericContainerBuilder } from "./generic-container-builder";
 export declare class GenericContainer implements TestContainer {
     readonly image: string;
@@ -31,14 +32,18 @@ export declare class GenericContainer implements TestContainer {
     protected tarToCopy?: archiver.Archiver;
     private extraHosts;
     constructor(image: string);
+    protected preStart?(): Promise<void>;
     start(): Promise<StartedTestContainer>;
+    protected postStart?(container: StartedTestContainer, inspectResult: InspectResult, boundPorts: BoundPorts): Promise<void>;
     withCmd(cmd: Command[]): this;
     withName(name: ContainerName): this;
     withEnv(key: EnvKey, value: EnvValue): this;
     withTmpFs(tmpFs: TmpFs): this;
     withNetworkMode(networkMode: NetworkMode): this;
     withNetworkAliases(...networkAliases: string[]): this;
+    withExtraHosts(...extraHosts: ExtraHost[]): this;
     withExposedPorts(...ports: Port[]): this;
+    protected addExposedPorts(...ports: Port[]): this;
     withBindMount(source: Dir, target: Dir, bindMode?: BindMode): this;
     withHealthCheck(healthCheck: HealthCheck): this;
     withStartupTimeout(startupTimeout: number): this;
@@ -51,7 +56,6 @@ export declare class GenericContainer implements TestContainer {
     withCopyFileToContainer(sourcePath: string, containerPath: string): this;
     withCopyContentToContainer(content: string | Buffer | Readable, containerPath: string): this;
     protected getTarToCopy(): archiver.Archiver;
-    protected preCreate?(boundPorts: BoundPorts): Promise<void>;
     private waitForContainer;
     private getWaitStrategy;
 }

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

@@ -14,8 +14,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GenericContainer = void 0;
 const archiver_1 = __importDefault(require("archiver"));
+const bound_ports_1 = require("../bound-ports");
 const logger_1 = require("../logger");
-const port_binder_1 = require("../port-binder");
 const port_check_1 = require("../port-check");
 const pull_policy_1 = require("../pull-policy");
 const reaper_1 = require("../reaper");
@@ -61,12 +61,11 @@ class GenericContainer {
                 force: this.pullPolicy.shouldPull(),
                 authConfig: yield registry_auth_locator_1.getAuthConfig(this.imageName.registry),
             });
-            const boundPorts = yield new port_binder_1.PortBinder().bind(this.ports);
             if (!this.imageName.isReaper()) {
                 yield reaper_1.ReaperInstance.getInstance();
             }
-            if (this.preCreate) {
-                yield this.preCreate(boundPorts);
+            if (this.preStart) {
+                yield this.preStart();
             }
             if (!this.imageName.isHelperContainer() && port_forwarder_1.PortForwarderInstance.isRunning()) {
                 const portForwarder = yield port_forwarder_1.PortForwarderInstance.getInstance();
@@ -78,7 +77,7 @@ class GenericContainer {
                 cmd: this.cmd,
                 bindMounts: this.bindMounts,
                 tmpFs: this.tmpFs,
-                boundPorts,
+                exposedPorts: this.ports,
                 name: this.name,
                 networkMode: this.networkAliases.length > 0 ? undefined : this.networkMode,
                 healthCheck: this.healthCheck,
@@ -94,7 +93,11 @@ class GenericContainer {
                 const portForwarderNetworkId = portForwarder.getNetworkId();
                 const excludedNetworks = [portForwarderNetworkId, "none", "host"];
                 if (!this.networkMode || !excludedNetworks.includes(this.networkMode)) {
-                    yield connect_network_1.connectNetwork({ containerId: container.id, networkId: portForwarderNetworkId, networkAliases: [] });
+                    yield connect_network_1.connectNetwork({
+                        containerId: container.id,
+                        networkId: portForwarderNetworkId,
+                        networkAliases: [],
+                    });
                 }
             }
             if (this.networkMode && this.networkAliases.length > 0) {
@@ -114,8 +117,13 @@ class GenericContainer {
                 .on("data", (data) => logger_1.containerLog.trace(`${container.id}: ${data.trim()}`))
                 .on("err", (data) => logger_1.containerLog.error(`${container.id}: ${data.trim()}`));
             const inspectResult = yield inspect_container_1.inspectContainer(container);
+            const boundPorts = bound_ports_1.BoundPorts.fromInspectResult(inspectResult).filter(this.ports);
             yield this.waitForContainer(container, boundPorts);
-            return new started_generic_container_1.StartedGenericContainer(container, yield docker_host_1.dockerHost, inspectResult, boundPorts, inspectResult.name);
+            const startedContainer = new started_generic_container_1.StartedGenericContainer(container, yield docker_host_1.dockerHost, inspectResult, boundPorts, inspectResult.name);
+            if (this.postStart) {
+                yield this.postStart(startedContainer, inspectResult, boundPorts);
+            }
+            return startedContainer;
         });
     }
     withCmd(cmd) {
@@ -142,10 +150,18 @@ class GenericContainer {
         this.networkAliases = networkAliases;
         return this;
     }
+    withExtraHosts(...extraHosts) {
+        this.extraHosts.push(...extraHosts);
+        return this;
+    }
     withExposedPorts(...ports) {
         this.ports = ports;
         return this;
     }
+    addExposedPorts(...ports) {
+        this.ports.push(...ports);
+        return this;
+    }
     withBindMount(source, target, bindMode = "rw") {
         this.bindMounts.push({ source, target, bindMode });
         return this;

package/dist/log-system-diagnostics.js

@@ -1,23 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -30,7 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logSystemDiagnostics = void 0;
 const logger_1 = require("./logger");
-const dockerCompose = __importStar(require("docker-compose"));
+const docker_compose_1 = require("./docker-compose/docker-compose");
 const get_info_1 = require("./docker/functions/get-info");
 const logSystemDiagnostics = () => __awaiter(void 0, void 0, void 0, function* () {
     const info = {
@@ -51,7 +32,7 @@ const getNodeInfo = () => {
 const getDockerComposeInfo = () => __awaiter(void 0, void 0, void 0, function* () {
     try {
         return {
-            version: (yield dockerCompose.version()).data.version,
+            version: (yield docker_compose_1.version()).data.version,
         };
     }
     catch (err) {

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

@@ -1,34 +1,23 @@
 import { GenericContainer } from "../../generic-container/generic-container";
 import { BoundPorts } from "../../bound-ports";
-import { StartedNetwork } from "../../network";
 import { Port } from "../../port";
-import { StartedTestContainer, StoppedTestContainer } from "../..";
-import { StopOptions } from "../../test-container";
+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";
-export declare const ZK_IMAGE = "confluentinc/cp-zookeeper:5.5.4";
 export declare class KafkaContainer extends GenericContainer {
-    private readonly zooKeeperImage;
-    private readonly host;
     private readonly uuid;
     private readonly portGenerator;
     private isZooKeeperProvided;
     private zooKeeperHost?;
     private zooKeeperPort?;
-    private network?;
-    private zooKeeperContainer?;
-    constructor(image?: string, host?: Host, zooKeeperImage?: string);
+    constructor(image?: string);
     withZooKeeper(host: Host, port: Port): this;
-    protected preCreate(boundPorts: BoundPorts): Promise<void>;
+    protected preStart(): Promise<void>;
     start(): Promise<StartedKafkaContainer>;
+    protected postStart(container: StartedTestContainer, inspectResult: InspectResult, boundPorts: BoundPorts): Promise<void>;
 }
 export declare class StartedKafkaContainer extends AbstractStartedContainer {
-    private readonly network?;
-    private readonly zooKeeperContainer?;
-    private readonly zooKeeperPort?;
-    constructor(startedTestContainer: StartedTestContainer, network?: StartedNetwork | undefined, zooKeeperContainer?: StartedTestContainer | undefined, zooKeeperPort?: number | undefined);
-    stop(options?: Partial<StopOptions>): Promise<StoppedTestContainer>;
-    getZookeeperName(): string | undefined;
-    getZookeeperPort(): number | undefined;
+    constructor(startedTestContainer: StartedTestContainer);
 }

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

@@ -9,26 +9,33 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StartedKafkaContainer = exports.KafkaContainer = exports.ZK_IMAGE = exports.KAFKA_IMAGE = void 0;
+exports.StartedKafkaContainer = exports.KafkaContainer = exports.KAFKA_IMAGE = void 0;
 const generic_container_1 = require("../../generic-container/generic-container");
-const network_1 = require("../../network");
 const uuid_1 = require("../../uuid");
-const logger_1 = require("../../logger");
 const abstract_started_container_1 = require("../abstract-started-container");
 const port_generator_1 = require("../../port-generator");
 const docker_host_1 = require("../../docker/docker-host");
 const KAFKA_PORT = 9093;
 const KAFKA_BROKER_PORT = 9092;
 exports.KAFKA_IMAGE = "confluentinc/cp-kafka:5.5.4";
-exports.ZK_IMAGE = "confluentinc/cp-zookeeper:5.5.4";
 class KafkaContainer extends generic_container_1.GenericContainer {
-    constructor(image = exports.KAFKA_IMAGE, host, zooKeeperImage = exports.ZK_IMAGE) {
+    constructor(image = exports.KAFKA_IMAGE) {
         super(image);
-        this.zooKeeperImage = zooKeeperImage;
         this.uuid = new uuid_1.RandomUuid();
         this.portGenerator = new port_generator_1.RandomUniquePortGenerator();
         this.isZooKeeperProvided = false;
-        this.host = host === undefined ? this.uuid.nextUuid() : host;
+        this.withExposedPorts(KAFKA_PORT)
+            .withStartupTimeout(180000)
+            .withEnv("KAFKA_LISTENERS", `PLAINTEXT://0.0.0.0:${KAFKA_PORT},BROKER://0.0.0.0:${KAFKA_BROKER_PORT}`)
+            .withEnv("KAFKA_LISTENER_SECURITY_PROTOCOL_MAP", "BROKER:PLAINTEXT,PLAINTEXT:PLAINTEXT")
+            .withEnv("KAFKA_INTER_BROKER_LISTENER_NAME", "BROKER")
+            .withEnv("KAFKA_BROKER_ID", "1")
+            .withEnv("KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR", "1")
+            .withEnv("KAFKA_OFFSETS_TOPIC_NUM_PARTITIONS", "1")
+            .withEnv("KAFKA_TRANSACTION_STATE_LOG_MIN_ISR", "1")
+            .withEnv("KAFKA_LOG_FLUSH_INTERVAL_MESSAGES", "9223372036854775807")
+            .withEnv("KAFKA_GROUP_INITIAL_REBALANCE_DELAY_MS", "0")
+            .withEnv("KAFKA_CONFLUENT_SUPPORT_METRICS_ENABLE", "false");
     }
     withZooKeeper(host, port) {
         this.isZooKeeperProvided = true;
@@ -36,10 +43,27 @@ class KafkaContainer extends generic_container_1.GenericContainer {
         this.zooKeeperPort = port;
         return this;
     }
-    preCreate(boundPorts) {
+    preStart() {
         return __awaiter(this, void 0, void 0, function* () {
-            const kafkaInternalPort = boundPorts.getBinding(KAFKA_PORT);
-            this.withEnv("KAFKA_ADVERTISED_LISTENERS", `PLAINTEXT://${this.host}:${KAFKA_BROKER_PORT},EXTERNAL_LISTENER://${yield docker_host_1.dockerHost}:${kafkaInternalPort}`);
+            const network = this.networkMode && this.networkAliases.length > 0 ? this.networkAliases[0] : "localhost";
+            this.withEnv("KAFKA_ADVERTISED_LISTENERS", `BROKER://${network}:${KAFKA_BROKER_PORT}`);
+            let command = "#!/bin/bash\n";
+            if (this.isZooKeeperProvided) {
+                this.withEnv("KAFKA_ZOOKEEPER_CONNECT", `${this.zooKeeperHost}:${this.zooKeeperPort}`);
+            }
+            else {
+                this.zooKeeperHost = this.uuid.nextUuid();
+                this.zooKeeperPort = yield this.portGenerator.generatePort();
+                this.addExposedPorts(this.zooKeeperPort);
+                this.withEnv("KAFKA_ZOOKEEPER_CONNECT", `localhost:${this.zooKeeperPort}`);
+                command += "echo 'clientPort=" + this.zooKeeperPort + "' > zookeeper.properties\n";
+                command += "echo 'dataDir=/var/lib/zookeeper/data' >> zookeeper.properties\n";
+                command += "echo 'dataLogDir=/var/lib/zookeeper/log' >> zookeeper.properties\n";
+                command += "zookeeper-server-start zookeeper.properties &\n";
+            }
+            command += "echo '' > /etc/confluent/docker/ensure \n";
+            command += "/etc/confluent/docker/run \n";
+            this.withCmd(["sh", "-c", command]);
         });
     }
     start() {
@@ -47,71 +71,35 @@ class KafkaContainer extends generic_container_1.GenericContainer {
             start: { get: () => super.start }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            this.withName(this.host)
-                .withStartupTimeout(180000)
-                .withEnv("KAFKA_LISTENER_SECURITY_PROTOCOL_MAP", "PLAINTEXT:PLAINTEXT,EXTERNAL_LISTENER:PLAINTEXT")
-                .withEnv("KAFKA_INTER_BROKER_LISTENER_NAME", "PLAINTEXT")
-                .withEnv("KAFKA_BROKER_ID", "1")
-                .withEnv("KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR", "1")
-                .withEnv("KAFKA_CONFLUENT_SUPPORT_METRICS_ENABLE", "false")
-                .withEnv("KAFKA_LISTENERS", `PLAINTEXT://0.0.0.0:${KAFKA_BROKER_PORT},EXTERNAL_LISTENER://0.0.0.0:${KAFKA_PORT}`);
-            let zooKeeperPort;
-            if (this.isZooKeeperProvided) {
-                this.withEnv("KAFKA_ZOOKEEPER_CONNECT", `${this.zooKeeperHost}:${this.zooKeeperPort}`);
-            }
-            else {
-                const zooKeeperHost = this.uuid.nextUuid();
-                zooKeeperPort = yield this.portGenerator.generatePort();
-                this.withEnv("KAFKA_ZOOKEEPER_CONNECT", `${zooKeeperHost}:${zooKeeperPort}`);
-                const zookeeperContainer = new generic_container_1.GenericContainer(this.zooKeeperImage)
-                    .withName(zooKeeperHost)
-                    .withEnv("ZOOKEEPER_CLIENT_PORT", zooKeeperPort.toString());
-                if (this.networkMode !== undefined) {
-                    zookeeperContainer.withNetworkMode(this.networkMode);
-                }
-                else {
-                    this.network = yield new network_1.Network().start();
-                    this.withNetworkMode(this.network.getName());
-                    zookeeperContainer.withNetworkMode(this.network.getName());
-                }
-                this.zooKeeperContainer = yield zookeeperContainer.start();
+            return new StartedKafkaContainer(yield _super.start.call(this));
+        });
+    }
+    postStart(container, inspectResult, boundPorts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const brokerAdvertisedListener = `BROKER://${inspectResult.hostname}:${KAFKA_BROKER_PORT}`;
+            const bootstrapServers = `PLAINTEXT://${yield docker_host_1.dockerHost}:${boundPorts.getBinding(KAFKA_PORT)}`;
+            const { output, exitCode } = yield container.exec([
+                "kafka-configs",
+                "--alter",
+                "--bootstrap-server",
+                brokerAdvertisedListener,
+                "--entity-type",
+                "brokers",
+                "--entity-name",
+                this.env["KAFKA_BROKER_ID"],
+                "--add-config",
+                `advertised.listeners=[${bootstrapServers},${brokerAdvertisedListener}]`,
+            ]);
+            if (exitCode !== 0) {
+                throw new Error(`Kafka container configuration failed with exit code ${exitCode}: ${output}`);
             }
-            return new StartedKafkaContainer(yield _super.start.call(this), this.network, this.zooKeeperContainer, zooKeeperPort);
         });
     }
 }
 exports.KafkaContainer = KafkaContainer;
 class StartedKafkaContainer extends abstract_started_container_1.AbstractStartedContainer {
-    constructor(startedTestContainer, network, zooKeeperContainer, zooKeeperPort) {
+    constructor(startedTestContainer) {
         super(startedTestContainer);
-        this.network = network;
-        this.zooKeeperContainer = zooKeeperContainer;
-        this.zooKeeperPort = zooKeeperPort;
-    }
-    stop(options) {
-        const _super = Object.create(null, {
-            stop: { get: () => super.stop }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            logger_1.log.debug("Stopping Kafka container");
-            const stoppedContainer = yield _super.stop.call(this, options);
-            if (this.zooKeeperContainer) {
-                logger_1.log.debug("Stopping ZooKeeper container");
-                yield this.zooKeeperContainer.stop(options);
-            }
-            if (this.network) {
-                logger_1.log.debug("Stopping Kafka network");
-                yield this.network.stop();
-            }
-            return stoppedContainer;
-        });
-    }
-    getZookeeperName() {
-        var _a;
-        return (_a = this.zooKeeperContainer) === null || _a === void 0 ? void 0 : _a.getName();
-    }
-    getZookeeperPort() {
-        return this.zooKeeperPort;
     }
 }
 exports.StartedKafkaContainer = StartedKafkaContainer;

package/dist/reaper.d.ts

@@ -8,6 +8,7 @@ export declare class ReaperInstance {
     static getInstance(): Promise<Reaper>;
     static stopInstance(): Promise<void>;
     private static isEnabled;
+    private static isPrivileged;
     private static createDisabledInstance;
     private static createRealInstance;
 }

package/dist/reaper.js

@@ -68,6 +68,9 @@ class ReaperInstance {
     static isEnabled() {
         return process.env.TESTCONTAINERS_RYUK_DISABLED !== "true";
     }
+    static isPrivileged() {
+        return process.env.TESTCONTAINERS_RYUK_PRIVILEGED === "true";
+    }
     static createDisabledInstance() {
         logger_1.log.debug(`Not creating new Reaper for session: ${session_id_1.sessionId}`);
         return Promise.resolve(new DisabledReaper());
@@ -77,33 +80,36 @@ class ReaperInstance {
         return __awaiter(this, void 0, void 0, function* () {
             const dockerSocket = (_a = process.env["TESTCONTAINERS_DOCKER_SOCKET_OVERRIDE"]) !== null && _a !== void 0 ? _a : "/var/run/docker.sock";
             logger_1.log.debug(`Creating new Reaper for session: ${session_id_1.sessionId}`);
-            const container = yield new generic_container_1.GenericContainer(images_1.REAPER_IMAGE)
+            const container = new generic_container_1.GenericContainer(images_1.REAPER_IMAGE)
                 .withName(`testcontainers-ryuk-${session_id_1.sessionId}`)
                 .withExposedPorts(8080)
-                .withBindMount(dockerSocket, "/var/run/docker.sock")
-                .withPrivilegedMode()
-                .start();
+                .withBindMount(dockerSocket, "/var/run/docker.sock");
+            if (this.isPrivileged()) {
+                container.withPrivilegedMode();
+            }
+            const startedContainer = yield container.start();
+            const containerId = startedContainer.getId();
             const host = yield docker_host_1.dockerHost;
-            const port = container.getMappedPort(8080);
-            logger_1.log.debug(`Connecting to Reaper ${container.getId()} on ${host}:${port}`);
+            const port = startedContainer.getMappedPort(8080);
+            logger_1.log.debug(`Connecting to Reaper ${containerId} on ${host}:${port}`);
             const socket = new net_1.Socket();
             socket.unref();
             socket
-                .on("timeout", () => logger_1.log.error(`Reaper ${container.getId()} socket timed out`))
-                .on("error", (err) => logger_1.log.error(`Reaper ${container.getId()} socket error: ${err}`))
+                .on("timeout", () => logger_1.log.error(`Reaper ${containerId} socket timed out`))
+                .on("error", (err) => logger_1.log.error(`Reaper ${containerId} socket error: ${err}`))
                 .on("close", (hadError) => {
                 if (hadError) {
-                    logger_1.log.error(`Connection to Reaper ${container.getId()} closed with error`);
+                    logger_1.log.error(`Connection to Reaper ${containerId} closed with error`);
                 }
                 else {
-                    logger_1.log.warn(`Connection to Reaper ${container.getId()} closed`);
+                    logger_1.log.warn(`Connection to Reaper ${containerId} closed`);
                 }
             });
             return new Promise((resolve) => {
                 socket.connect(port, host, () => {
-                    logger_1.log.debug(`Connected to Reaper ${container.getId()}`);
+                    logger_1.log.debug(`Connected to Reaper ${containerId}`);
                     socket.write(`label=org.testcontainers.session-id=${session_id_1.sessionId}\r\n`);
-                    const reaper = new RealReaper(container, socket);
+                    const reaper = new RealReaper(startedContainer, socket);
                     resolve(reaper);
                 });
             });

package/dist/test-container.d.ts

@@ -3,7 +3,7 @@ import { Port } from "./port";
 import { PullPolicy } from "./pull-policy";
 import { WaitStrategy } from "./wait-strategy";
 import { Readable } from "stream";
-import { BindMode, Command, ContainerName, Dir, EnvKey, EnvValue, ExecResult, Host, Id, NetworkMode, TmpFs } from "./docker/types";
+import { BindMode, Command, ContainerName, Dir, EnvKey, EnvValue, ExecResult, ExtraHost, Host, Id, NetworkMode, TmpFs } from "./docker/types";
 export interface TestContainer {
     start(): Promise<StartedTestContainer>;
     withEnv(key: EnvKey, value: EnvValue): this;
@@ -14,6 +14,7 @@ export interface TestContainer {
     withWaitStrategy(waitStrategy: WaitStrategy): this;
     withStartupTimeout(startupTimeout: number): this;
     withNetworkMode(networkMode: NetworkMode): this;
+    withExtraHosts(...extraHosts: ExtraHost[]): this;
     withDefaultLogDriver(): this;
     withPrivilegedMode(): this;
     withUser(user: string): this;

package/dist/testcontainers-properties-file.d.ts

@@ -0,0 +1 @@
+export declare const loadTestcontainersPropertiesFile: () => void;

package/dist/testcontainers-properties-file.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTestcontainersPropertiesFile = void 0;
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("./logger");
+const os_1 = require("os");
+const fs_1 = require("fs");
+const properties_reader_1 = __importDefault(require("properties-reader"));
+const loadTestcontainersPropertiesFile = () => {
+    const file = path_1.default.resolve(os_1.homedir(), ".testcontainers.properties");
+    if (fs_1.existsSync(file)) {
+        logger_1.log.debug("Found .testcontainers.properties file");
+        const string = fs_1.readFileSync(file, { encoding: "utf-8" });
+        const properties = properties_reader_1.default("").read(string);
+        const host = properties.get("docker.host");
+        if (host !== null) {
+            logger_1.log.debug(`Setting DOCKER_HOST to ${host}`);
+            process.env.DOCKER_HOST = host;
+        }
+        const tlsVerify = properties.get("docker.tls.verify");
+        if (tlsVerify !== null) {
+            logger_1.log.debug(`Setting DOCKER_TLS_VERIFY to ${tlsVerify}`);
+            process.env.DOCKER_TLS_VERIFY = `${tlsVerify}`;
+        }
+        const certPath = properties.get("docker.cert.path");
+        if (certPath !== null) {
+            logger_1.log.debug(`Setting DOCKER_CERT_PATH to ${certPath}`);
+            process.env.DOCKER_CERT_PATH = certPath;
+        }
+    }
+};
+exports.loadTestcontainersPropertiesFile = loadTestcontainersPropertiesFile;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "testcontainers",
   "author": "Cristian Greco",
-  "version": "7.23.0",
+  "version": "8.0.0",
   "main": "dist/index",
   "types": "dist/index",
   "keywords": [
@@ -26,7 +26,7 @@
     "pre-commit": "lint-staged",
     "build": "npm run clean && tsc",
     "clean": "rimraf dist",
-    "test": "cross-env DEBUG=testcontainers jest --maxWorkers=2",
+    "test": "cross-env DEBUG=testcontainers jest --runInBand",
     "format": "prettier --write package.json \"src/**/*.ts\"",
     "lint": "eslint --fix package.json \"src/**/*.ts\"",
     "updateDeps": "npx npm-check-updates -u"
@@ -41,6 +41,7 @@
     "dockerode": "^3.3.1",
     "get-port": "^5.1.1",
     "glob": "^7.2.0",
+    "properties-reader": "^2.2.0",
     "slash": "^3.0.0",
     "ssh-remote-port-forward": "^1.0.4",
     "tar-fs": "^2.1.1"
@@ -54,6 +55,7 @@
     "@types/node": "^16.9.6",
     "@types/node-fetch": "^2.5.11",
     "@types/pg": "^8.6.1",
+    "@types/properties-reader": "^2.1.1",
     "@types/tar-fs": "^2.0.1",
     "@typescript-eslint/eslint-plugin": "^4.31.2",
     "@typescript-eslint/parser": "^4.31.2",