testcontainers 9.0.0 → 9.1.0

package/README.md

@@ -832,6 +832,85 @@ const container = await new GenericContainer("redis")
   .start();
 ```
 
+### HTTP
+
+Default behaviour of waiting for a 200 response:
+
+```javascript
+const { GenericContainer, Wait } = require("testcontainers");
+
+const container = await new GenericContainer("redis")
+  .withExposedPorts(6379)
+  .withWaitStrategy(Wait.forHttp("/health", 8080))
+  .start();
+```
+
+Specify status code:
+
+```javascript
+.withWaitStrategy(Wait.forHttp("/health", 8080)
+  .forStatusCode(201))
+
+.withWaitStrategy(Wait.forHttp("/health", 8080)
+  .forStatusCodeMatching(statusCode => statusCode === 201))
+```
+
+Specify response body:
+
+```javascript
+.withWaitStrategy(Wait.forHttp("/health", 8080)
+  .forResponsePredicate(response => response === "OK"))
+```
+
+Customise the request:
+
+```javascript
+.withWaitStrategy(Wait.forHttp("/health", 8080)
+  .withMethod("POST")
+  .withHeaders({ X_CUSTOM_VALUE: "custom" })
+  .withBasicCredentials("username", "password")
+  .withReadTimeout(10000))
+```
+
+Use TLS:
+
+```javascript
+.withWaitStrategy(Wait.forHttp("/health", 8443)
+  .useTls())
+```
+
+Allow insecure TLS:
+
+```javascript
+.withWaitStrategy(Wait.forHttp("/health", 8443)
+  .useTls()
+  .insecureTls())
+```
+
+### Other Startup Strategies
+
+If none of these options meet your requirements, you can create your own subclass of `StartupCheckStrategy`:
+
+```javascript
+const Dockerode = require("dockerode");
+const { 
+  GenericContainer, 
+  StartupCheckStrategy,
+  StartupStatus
+} = require("testcontainers");
+
+class ReadyAfterDelayWaitStrategy extends StartupCheckStrategy {
+  public checkStartupState(dockerClient: Dockerode, containerId: string): Promise<StartupStatus> {
+    return new Promise((resolve) => setTimeout(() => resolve("SUCCESS"), 3000));
+  }
+}
+
+const container = await new GenericContainer("redis")
+  .withExposedPorts(6379)
+  .withWaitStrategy(new ReadyAfterDelayWaitStrategy())
+  .start();
+```
+
 ## Authentication
 
 Testcontainers will automatically pick up and use credentials from `$HOME/.docker/config.json`, using

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

@@ -22,6 +22,4 @@ export declare class DockerComposeEnvironment {
     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,6 +25,7 @@ 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;
@@ -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, host, boundPorts);
                     logger_1.log.info(`Container ${containerName} is ready`);
                 }
                 catch (err) {
@@ -119,7 +121,7 @@ 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 });
@@ -128,21 +130,5 @@ class DockerComposeEnvironment {
             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.d.ts

@@ -70,6 +70,4 @@ export declare class GenericContainer implements TestContainer {
     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,14 +29,13 @@ 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;
@@ -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, host, 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, host, 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);
             }
@@ -284,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,5 +1,5 @@
 /// <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 { ExecResult, Labels } from "../docker/types";
 import { InspectResult } from "../docker/functions/container/inspect-container";
@@ -17,7 +17,6 @@ export declare class StartedGenericContainer implements StartedTestContainer {
     stop(options?: Partial<StopOptions>): Promise<StoppedTestContainer>;
     restart(options?: Partial<RestartOptions>): Promise<void>;
     private stopContainer;
-    private waitForContainer;
     getHost(): string;
     getMappedPort(port: number): number;
     getId(): string;

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.host, 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/http-wait-strategy.d.ts

@@ -0,0 +1,27 @@
+import Dockerode from "dockerode";
+import { BoundPorts } from "./bound-ports";
+import { AbstractWaitStrategy } from "./wait-strategy";
+export declare class HttpWaitStrategy extends AbstractWaitStrategy {
+    private readonly path;
+    private readonly port;
+    private protocol;
+    private method;
+    private headers;
+    private predicates;
+    private _allowInsecure;
+    private readTimeout;
+    constructor(path: string, port: number);
+    forStatusCode(statusCode: number): HttpWaitStrategy;
+    forStatusCodeMatching(predicate: (statusCode: number) => boolean): HttpWaitStrategy;
+    forResponsePredicate(predicate: (response: string) => boolean): HttpWaitStrategy;
+    withMethod(method: string): HttpWaitStrategy;
+    withHeaders(headers: {
+        [key: string]: string;
+    }): HttpWaitStrategy;
+    withBasicCredentials(username: string, password: string): HttpWaitStrategy;
+    withReadTimeout(readTimeout: number): HttpWaitStrategy;
+    usingTls(): HttpWaitStrategy;
+    allowInsecure(): HttpWaitStrategy;
+    waitUntilReady(container: Dockerode.Container, host: string, boundPorts: BoundPorts): Promise<void>;
+    private getAgent;
+}

package/dist/http-wait-strategy.js

@@ -0,0 +1,107 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpWaitStrategy = void 0;
+const wait_strategy_1 = require("./wait-strategy");
+const retry_strategy_1 = require("./retry-strategy");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const https_1 = __importDefault(require("https"));
+class HttpWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
+    constructor(path, port) {
+        super();
+        this.protocol = "http";
+        this.method = "GET";
+        this.headers = {};
+        this.predicates = [];
+        this._allowInsecure = false;
+        this.readTimeout = 1000;
+        this.path = path;
+        this.port = port;
+    }
+    forStatusCode(statusCode) {
+        this.predicates.push((response) => __awaiter(this, void 0, void 0, function* () { return response.status === statusCode; }));
+        return this;
+    }
+    forStatusCodeMatching(predicate) {
+        this.predicates.push((response) => __awaiter(this, void 0, void 0, function* () { return predicate(response.status); }));
+        return this;
+    }
+    forResponsePredicate(predicate) {
+        this.predicates.push((response) => __awaiter(this, void 0, void 0, function* () { return predicate(yield response.text()); }));
+        return this;
+    }
+    withMethod(method) {
+        this.method = method;
+        return this;
+    }
+    withHeaders(headers) {
+        this.headers = Object.assign(Object.assign({}, this.headers), headers);
+        return this;
+    }
+    withBasicCredentials(username, password) {
+        const base64Encoded = Buffer.from(`${username}:${password}`).toString("base64");
+        this.headers = Object.assign(Object.assign({}, this.headers), { Authorization: `Bearer ${base64Encoded}` });
+        return this;
+    }
+    withReadTimeout(readTimeout) {
+        this.readTimeout = readTimeout;
+        return this;
+    }
+    usingTls() {
+        this.protocol = "https";
+        return this;
+    }
+    allowInsecure() {
+        this._allowInsecure = true;
+        return this;
+    }
+    waitUntilReady(container, host, boundPorts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield new retry_strategy_1.IntervalRetryStrategy(this.readTimeout).retryUntil(() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const url = `${this.protocol}://${host}:${boundPorts.getBinding(this.port)}${this.path}`;
+                    return yield (0, node_fetch_1.default)(url, {
+                        method: this.method,
+                        timeout: this.readTimeout,
+                        headers: this.headers,
+                        agent: this.getAgent(),
+                    });
+                }
+                catch (_a) {
+                    return undefined;
+                }
+            }), (response) => {
+                if (response === undefined) {
+                    return false;
+                }
+                else if (!this.predicates.length) {
+                    return response.ok;
+                }
+                else {
+                    return this.predicates.every((predicate) => predicate(response));
+                }
+            }, () => {
+                throw new Error(`URL ${this.path} not accessible after ${this.startupTimeout}ms for ${container.id}`);
+            }, this.startupTimeout);
+        });
+    }
+    getAgent() {
+        if (this._allowInsecure) {
+            return new https_1.default.Agent({
+                rejectUnauthorized: false,
+            });
+        }
+    }
+}
+exports.HttpWaitStrategy = HttpWaitStrategy;

package/dist/index.d.ts

@@ -8,6 +8,7 @@ export { StoppedDockerComposeEnvironment } from "./docker-compose-environment/st
 export { DownedDockerComposeEnvironment } from "./docker-compose-environment/downed-docker-compose-environment";
 export { Network, StartedNetwork, StoppedNetwork } from "./network";
 export { Wait } from "./wait";
+export { StartupCheckStrategy, StartupStatus } from "./startup-check-strategy";
 export { PullPolicy, DefaultPullPolicy, AlwaysPullPolicy } from "./pull-policy";
 export { PostgreSqlContainer, StartedPostgreSqlContainer } from "./modules/postgresql/postgresql-container";
 export { KafkaContainer, StartedKafkaContainer } from "./modules/kafka/kafka-container";

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StartedMongoDBContainer = exports.MongoDBContainer = exports.StartedNatsContainer = exports.NatsContainer = exports.StartedMySqlContainer = exports.MySqlContainer = exports.StartedElasticsearchContainer = exports.ElasticsearchContainer = exports.StartedArangoContainer = exports.ArangoDBContainer = exports.StartedNeo4jContainer = exports.Neo4jContainer = exports.StartedKafkaContainer = exports.KafkaContainer = exports.StartedPostgreSqlContainer = exports.PostgreSqlContainer = exports.AlwaysPullPolicy = exports.DefaultPullPolicy = exports.Wait = exports.StoppedNetwork = exports.StartedNetwork = exports.Network = exports.DownedDockerComposeEnvironment = exports.StoppedDockerComposeEnvironment = exports.StartedDockerComposeEnvironment = exports.DockerComposeEnvironment = exports.TestContainers = exports.GenericContainerBuilder = exports.GenericContainer = void 0;
+exports.StartedMongoDBContainer = exports.MongoDBContainer = exports.StartedNatsContainer = exports.NatsContainer = exports.StartedMySqlContainer = exports.MySqlContainer = exports.StartedElasticsearchContainer = exports.ElasticsearchContainer = exports.StartedArangoContainer = exports.ArangoDBContainer = exports.StartedNeo4jContainer = exports.Neo4jContainer = exports.StartedKafkaContainer = exports.KafkaContainer = exports.StartedPostgreSqlContainer = exports.PostgreSqlContainer = exports.AlwaysPullPolicy = exports.DefaultPullPolicy = exports.StartupCheckStrategy = exports.Wait = exports.StoppedNetwork = exports.StartedNetwork = exports.Network = exports.DownedDockerComposeEnvironment = exports.StoppedDockerComposeEnvironment = exports.StartedDockerComposeEnvironment = exports.DockerComposeEnvironment = exports.TestContainers = exports.GenericContainerBuilder = exports.GenericContainer = void 0;
 var generic_container_1 = require("./generic-container/generic-container");
 Object.defineProperty(exports, "GenericContainer", { enumerable: true, get: function () { return generic_container_1.GenericContainer; } });
 var generic_container_builder_1 = require("./generic-container/generic-container-builder");
@@ -21,6 +21,8 @@ Object.defineProperty(exports, "StartedNetwork", { enumerable: true, get: functi
 Object.defineProperty(exports, "StoppedNetwork", { enumerable: true, get: function () { return network_1.StoppedNetwork; } });
 var wait_1 = require("./wait");
 Object.defineProperty(exports, "Wait", { enumerable: true, get: function () { return wait_1.Wait; } });
+var startup_check_strategy_1 = require("./startup-check-strategy");
+Object.defineProperty(exports, "StartupCheckStrategy", { enumerable: true, get: function () { return startup_check_strategy_1.StartupCheckStrategy; } });
 var pull_policy_1 = require("./pull-policy");
 Object.defineProperty(exports, "DefaultPullPolicy", { enumerable: true, get: function () { return pull_policy_1.DefaultPullPolicy; } });
 Object.defineProperty(exports, "AlwaysPullPolicy", { enumerable: true, get: function () { return pull_policy_1.AlwaysPullPolicy; } });

package/dist/reaper.js

@@ -18,6 +18,7 @@ const images_1 = require("./images");
 const port_1 = require("./port");
 const labels_1 = require("./labels");
 const wait_1 = require("./wait");
+const retry_strategy_1 = require("./retry-strategy");
 class RealReaper {
     constructor(container, socket) {
         this.container = container;
@@ -97,28 +98,38 @@ class ReaperInstance {
             const containerId = startedContainer.getId();
             const host = startedContainer.getHost();
             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 ${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 ${containerId} closed with error`);
-                }
-                else {
-                    logger_1.log.warn(`Connection to Reaper ${containerId} closed`);
-                }
-            });
-            return new Promise((resolve) => {
-                socket.connect((0, port_1.getContainerPort)(port), host, () => {
-                    logger_1.log.debug(`Connected to Reaper ${containerId}`);
-                    socket.write(`label=${labels_1.LABEL_SESSION_ID}=${session_id_1.sessionId}\r\n`);
-                    const reaper = new RealReaper(startedContainer, socket);
-                    resolve(reaper);
+            const retryStrategy = new retry_strategy_1.IntervalRetryStrategy(1000);
+            const retryResult = yield retryStrategy.retryUntil((attempt) => {
+                return new Promise((resolve) => {
+                    logger_1.log.debug(`Connecting to Reaper (attempt ${attempt + 1}) ${containerId} on ${host}:${port}`);
+                    const socket = new net_1.Socket();
+                    socket
+                        .unref()
+                        .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 ${containerId} closed with error`);
+                        }
+                        else {
+                            logger_1.log.warn(`Connection to Reaper ${containerId} closed`);
+                        }
+                        resolve(undefined);
+                    })
+                        .connect((0, port_1.getContainerPort)(port), host, () => {
+                        logger_1.log.debug(`Connected to Reaper ${containerId}`);
+                        socket.write(`label=${labels_1.LABEL_SESSION_ID}=${session_id_1.sessionId}\r\n`);
+                        const reaper = new RealReaper(startedContainer, socket);
+                        resolve(reaper);
+                    });
                 });
-            });
+            }, (result) => result !== undefined, () => new Error(`Failed to connect to Reaper ${containerId}`), 4000);
+            if (retryResult instanceof RealReaper) {
+                return retryResult;
+            }
+            else {
+                throw retryResult;
+            }
         });
     }
 }

package/dist/retry-strategy.d.ts

@@ -12,6 +12,6 @@ declare abstract class AbstractRetryStrategy<T, U> implements RetryStrategy<T, U
 export declare class IntervalRetryStrategy<T, U> extends AbstractRetryStrategy<T, U> {
     private readonly interval;
     constructor(interval: number);
-    retryUntil(fn: () => Promise<T>, predicate: (result: T) => boolean, onTimeout: () => U, timeout: number): Promise<T | U>;
+    retryUntil(fn: (attempt: number) => Promise<T>, predicate: (result: T) => boolean, onTimeout: () => U, timeout: number): Promise<T | U>;
 }
 export {};

package/dist/retry-strategy.js

@@ -30,13 +30,14 @@ class IntervalRetryStrategy extends AbstractRetryStrategy {
     retryUntil(fn, predicate, onTimeout, timeout) {
         return __awaiter(this, void 0, void 0, function* () {
             const startTime = this.clock.getTime();
-            let result = yield fn();
+            let attemptNumber = 0;
+            let result = yield fn(attemptNumber++);
             while (!predicate(result)) {
                 if (this.hasTimedOut(timeout, startTime)) {
                     return onTimeout();
                 }
                 yield this.wait(this.interval);
-                result = yield fn();
+                result = yield fn(attemptNumber++);
             }
             return result;
         });

package/dist/startup-check-strategy.d.ts

@@ -0,0 +1,8 @@
+import { AbstractWaitStrategy } from "./wait-strategy";
+import Dockerode from "dockerode";
+import { BoundPorts } from "./bound-ports";
+export declare type StartupStatus = "PENDING" | "SUCCESS" | "FAIL";
+export declare abstract class StartupCheckStrategy extends AbstractWaitStrategy {
+    abstract checkStartupState(dockerClient: Dockerode, containerId: string): Promise<StartupStatus>;
+    waitUntilReady(container: Dockerode.Container, host: string, ports: BoundPorts): Promise<void>;
+}

package/dist/startup-check-strategy.js

@@ -0,0 +1,30 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StartupCheckStrategy = void 0;
+const wait_strategy_1 = require("./wait-strategy");
+const retry_strategy_1 = require("./retry-strategy");
+const docker_client_1 = require("./docker/docker-client");
+class StartupCheckStrategy extends wait_strategy_1.AbstractWaitStrategy {
+    waitUntilReady(container, host, ports) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { dockerode } = yield (0, docker_client_1.dockerClient)();
+            const startupStatus = yield new retry_strategy_1.IntervalRetryStrategy(1000).retryUntil(() => __awaiter(this, void 0, void 0, function* () { return yield this.checkStartupState(dockerode, container.id); }), (startupStatus) => startupStatus === "SUCCESS" || startupStatus === "FAIL", () => new Error(`Container not accessible after ${this.startupTimeout}ms for ${container.id}`), this.startupTimeout);
+            if (startupStatus instanceof Error) {
+                throw startupStatus;
+            }
+            else if (startupStatus === "FAIL") {
+                throw new Error(`Container failed to start for ${container.id}`);
+            }
+        });
+    }
+}
+exports.StartupCheckStrategy = StartupCheckStrategy;

package/dist/wait-for-container.d.ts

@@ -0,0 +1,4 @@
+import Dockerode from "dockerode";
+import { BoundPorts } from "./bound-ports";
+import { WaitStrategy } from "./wait-strategy";
+export declare const waitForContainer: (container: Dockerode.Container, waitStrategy: WaitStrategy, host: string, boundPorts: BoundPorts) => Promise<void>;

package/dist/wait-for-container.js

@@ -0,0 +1,34 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForContainer = void 0;
+const logger_1 = require("./logger");
+const stop_container_1 = require("./docker/functions/container/stop-container");
+const remove_container_1 = require("./docker/functions/container/remove-container");
+const waitForContainer = (container, waitStrategy, host, boundPorts) => __awaiter(void 0, void 0, void 0, function* () {
+    logger_1.log.debug(`Waiting for container to be ready: ${container.id}`);
+    try {
+        yield waitStrategy.waitUntilReady(container, host, 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;
+    }
+});
+exports.waitForContainer = waitForContainer;

package/dist/wait-strategy.d.ts

@@ -2,19 +2,19 @@ import { BoundPorts } from "./bound-ports";
 import { PortCheck } from "./port-check";
 import Dockerode from "dockerode";
 export interface WaitStrategy {
-    waitUntilReady(container: Dockerode.Container, boundPorts: BoundPorts): Promise<void>;
+    waitUntilReady(container: Dockerode.Container, host: string, boundPorts: BoundPorts): Promise<void>;
     withStartupTimeout(startupTimeout: number): WaitStrategy;
 }
-declare abstract class AbstractWaitStrategy implements WaitStrategy {
+export declare abstract class AbstractWaitStrategy implements WaitStrategy {
     protected startupTimeout: number;
-    abstract waitUntilReady(container: Dockerode.Container, boundPorts: BoundPorts): Promise<void>;
+    abstract waitUntilReady(container: Dockerode.Container, host: string, boundPorts: BoundPorts): Promise<void>;
     withStartupTimeout(startupTimeout: number): WaitStrategy;
 }
 export declare class HostPortWaitStrategy extends AbstractWaitStrategy {
     private readonly hostPortCheck;
     private readonly internalPortCheck;
     constructor(hostPortCheck: PortCheck, internalPortCheck: PortCheck);
-    waitUntilReady(container: Dockerode.Container, boundPorts: BoundPorts): Promise<void>;
+    waitUntilReady(container: Dockerode.Container, host: string, boundPorts: BoundPorts): Promise<void>;
     private waitForHostPorts;
     private waitForInternalPorts;
     private waitForPort;
@@ -28,4 +28,4 @@ export declare class LogWaitStrategy extends AbstractWaitStrategy {
 export declare class HealthCheckWaitStrategy extends AbstractWaitStrategy {
     waitUntilReady(container: Dockerode.Container): Promise<void>;
 }
-export {};
+export declare const defaultWaitStrategy: (host: string, container: Dockerode.Container) => HostPortWaitStrategy;

package/dist/wait-strategy.js

@@ -12,9 +12,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HealthCheckWaitStrategy = exports.LogWaitStrategy = exports.HostPortWaitStrategy = void 0;
+exports.defaultWaitStrategy = exports.HealthCheckWaitStrategy = exports.LogWaitStrategy = exports.HostPortWaitStrategy = exports.AbstractWaitStrategy = void 0;
 const byline_1 = __importDefault(require("byline"));
 const logger_1 = require("./logger");
+const port_check_1 = require("./port-check");
 const retry_strategy_1 = require("./retry-strategy");
 const container_logs_1 = require("./docker/functions/container/container-logs");
 const inspect_container_1 = require("./docker/functions/container/inspect-container");
@@ -27,13 +28,14 @@ class AbstractWaitStrategy {
         return this;
     }
 }
+exports.AbstractWaitStrategy = AbstractWaitStrategy;
 class HostPortWaitStrategy extends AbstractWaitStrategy {
     constructor(hostPortCheck, internalPortCheck) {
         super();
         this.hostPortCheck = hostPortCheck;
         this.internalPortCheck = internalPortCheck;
     }
-    waitUntilReady(container, boundPorts) {
+    waitUntilReady(container, host, boundPorts) {
         return __awaiter(this, void 0, void 0, function* () {
             yield Promise.all([this.waitForHostPorts(container, boundPorts), this.waitForInternalPorts(container, boundPorts)]);
         });
@@ -127,3 +129,5 @@ class HealthCheckWaitStrategy extends AbstractWaitStrategy {
     }
 }
 exports.HealthCheckWaitStrategy = HealthCheckWaitStrategy;
+const defaultWaitStrategy = (host, container) => new HostPortWaitStrategy(new port_check_1.HostPortCheck(host), new port_check_1.InternalPortCheck(container));
+exports.defaultWaitStrategy = defaultWaitStrategy;

package/dist/wait.d.ts

@@ -1,5 +1,7 @@
 import { Log, WaitStrategy } from "./wait-strategy";
+import { HttpWaitStrategy } from "./http-wait-strategy";
 export declare class Wait {
     static forLogMessage(message: Log | RegExp): WaitStrategy;
     static forHealthCheck(): WaitStrategy;
+    static forHttp(path: string, port: number): HttpWaitStrategy;
 }

package/dist/wait.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Wait = void 0;
 const wait_strategy_1 = require("./wait-strategy");
+const http_wait_strategy_1 = require("./http-wait-strategy");
 class Wait {
     static forLogMessage(message) {
         return new wait_strategy_1.LogWaitStrategy(message);
@@ -9,5 +10,8 @@ class Wait {
     static forHealthCheck() {
         return new wait_strategy_1.HealthCheckWaitStrategy();
     }
+    static forHttp(path, port) {
+        return new http_wait_strategy_1.HttpWaitStrategy(path, port);
+    }
 }
 exports.Wait = Wait;

package/package.json

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