Add support for abortOnContainerExit to HTTP wait strategy (#693)

Author: NuShoSinkuPomogliTebeTvoiSankcii

docs/features/wait-strategies.md

@@ -120,6 +120,16 @@ const container = await new GenericContainer("redis")
   .start();
 ```
 
+Stop waiting after container exited if waiting for container restart not needed.
+
+```javascript
+const { GenericContainer, Wait } = require("testcontainers");
+
+const container = await new GenericContainer("redis")
+  .withWaitStrategy(Wait.forHttp("/health", 8080, { abortOnContainerExit: true }))
+  .start();
+```
+
 ### For status code
 
 ```javascript

packages/modules/couchbase/src/couchbase-container.ts

@@ -7,7 +7,6 @@ import {
   Wait,
 } from "testcontainers";
 import { WaitStrategy } from "testcontainers/src/wait-strategies/wait-strategy";
-import { HttpWaitStrategy } from "testcontainers/src/wait-strategies/http-wait-strategy";
 import { BoundPorts } from "testcontainers/src/utils/bound-ports";
 import { ContainerRuntimeClient, getContainerRuntimeClient } from "testcontainers/src/container-runtime";
 import { CouchbaseService } from "./couchbase-service";
@@ -129,7 +128,7 @@ export class CouchbaseContainer extends GenericContainer {
     const waitStrategies: WaitStrategy[] = [];
 
     waitStrategies.push(
-      new HttpWaitStrategy("/pools/default", PORTS.MGMT_PORT)
+      Wait.forHttp("/pools/default", PORTS.MGMT_PORT)
         .withBasicCredentials(this.username, this.password)
         .forStatusCode(200)
         .forResponsePredicate((response) => {
@@ -145,23 +144,23 @@ export class CouchbaseContainer extends GenericContainer {
 
     if (this.enabledServices.has(CouchbaseService.QUERY)) {
       waitStrategies.push(
-        new HttpWaitStrategy("/admin/ping", PORTS.QUERY_PORT)
+        Wait.forHttp("/admin/ping", PORTS.QUERY_PORT)
           .withBasicCredentials(this.username, this.password)
           .forStatusCode(200)
       );
     }
 
     if (this.enabledServices.has(CouchbaseService.ANALYTICS)) {
       waitStrategies.push(
-        new HttpWaitStrategy("/admin/ping", PORTS.ANALYTICS_PORT)
+        Wait.forHttp("/admin/ping", PORTS.ANALYTICS_PORT)
           .withBasicCredentials(this.username, this.password)
           .forStatusCode(200)
       );
     }
 
     if (this.enabledServices.has(CouchbaseService.EVENTING)) {
       waitStrategies.push(
-        new HttpWaitStrategy("/api/v1/config", PORTS.EVENTING_PORT)
+        Wait.forHttp("/api/v1/config", PORTS.EVENTING_PORT)
           .withBasicCredentials(this.username, this.password)
           .forStatusCode(200)
       );
@@ -174,7 +173,7 @@ export class CouchbaseContainer extends GenericContainer {
     inspectResult: InspectResult,
     startedTestContainer: StartedTestContainer
   ) {
-    return new HttpWaitStrategy("/pools", PORTS.MGMT_PORT)
+    return Wait.forHttp("/pools", PORTS.MGMT_PORT)
       .forStatusCode(200)
       .waitUntilReady(
         client.container.getById(startedTestContainer.getId()),
@@ -386,7 +385,7 @@ export class CouchbaseContainer extends GenericContainer {
 
       await this.checkResponse(response, `Could not create bucket ${bucket.getName()}`);
 
-      await new HttpWaitStrategy(`/pools/default/b/${bucket.getName()}`, PORTS.MGMT_PORT)
+      await Wait.forHttp(`/pools/default/b/${bucket.getName()}`, PORTS.MGMT_PORT)
         .withBasicCredentials(this.username, this.password)
         .forStatusCode(200)
         .forResponsePredicate((response) => {

packages/testcontainers/src/container-runtime/clients/container/docker-container-client.ts

@@ -162,6 +162,7 @@ export class DockerContainerClient implements ContainerClient {
         follow: true,
         stdout: true,
         stderr: true,
+        tail: opts?.tail ?? -1,
         since: opts?.since ?? 0,
       })) as IncomingMessage;
       stream.socket.unref();

packages/testcontainers/src/generic-container/abstract-started-container.ts

@@ -83,7 +83,7 @@ export class AbstractStartedContainer implements StartedTestContainer {
     return this.startedTestContainer.exec(command, opts);
   }
 
-  public logs(opts?: { since?: number }): Promise<Readable> {
+  public logs(opts?: { since?: number; tail?: number }): Promise<Readable> {
     return this.startedTestContainer.logs(opts);
   }
 }

packages/testcontainers/src/generic-container/started-generic-container.ts

@@ -181,7 +181,7 @@ export class StartedGenericContainer implements StartedTestContainer {
     return output;
   }
 
-  public async logs(opts?: { since?: number }): Promise<Readable> {
+  public async logs(opts?: { since?: number; tail?: number }): Promise<Readable> {
     const client = await getContainerRuntimeClient();
 
     return client.container.logs(this.container, opts);

packages/testcontainers/src/index.ts

@@ -19,6 +19,7 @@ export { DownedDockerComposeEnvironment } from "./docker-compose-environment/dow
 export { Network, StartedNetwork, StoppedNetwork } from "./network/network";
 
 export { Wait } from "./wait-strategies/wait";
+export { HttpWaitStrategyOptions } from "./wait-strategies/http-wait-strategy";
 export { StartupCheckStrategy, StartupStatus } from "./wait-strategies/startup-check-strategy";
 export { PullPolicy, ImagePullPolicy } from "./utils/pull-policy";
 export { InspectResult, Content, ExecOptions, ExecResult } from "./types";

packages/testcontainers/src/test-container.ts

@@ -75,7 +75,7 @@ export interface StartedTestContainer {
   copyFilesToContainer(filesToCopy: FileToCopy[]): Promise<void>;
   copyContentToContainer(contentsToCopy: ContentToCopy[]): Promise<void>;
   exec(command: string | string[], opts?: Partial<ExecOptions>): Promise<ExecResult>;
-  logs(opts?: { since?: number }): Promise<Readable>;
+  logs(opts?: { since?: number; tail?: number }): Promise<Readable>;
 }
 
 export interface StoppedTestContainer {

packages/testcontainers/src/utils/test-helper.ts

@@ -5,6 +5,8 @@ import { StartedTestContainer } from "../test-container";
 import https from "https";
 import { GetEventsOptions } from "dockerode";
 import { getContainerRuntimeClient } from "../container-runtime";
+import { GenericContainer } from "../generic-container/generic-container";
+import { IntervalRetry } from "../common";
 
 export const checkContainerIsHealthy = async (container: StartedTestContainer): Promise<void> => {
   const url = `http://${container.getHost()}:${container.getMappedPort(8080)}`;
@@ -103,3 +105,25 @@ export async function deleteImageByName(imageName: string): Promise<void> {
   const dockerode = (await getContainerRuntimeClient()).container.dockerode;
   await dockerode.getImage(imageName).remove();
 }
+
+export async function stopStartingContainer(container: GenericContainer, name: string) {
+  const client = await getContainerRuntimeClient();
+  const containerStartPromise = container.start();
+
+  const status = await new IntervalRetry<boolean, boolean>(500).retryUntil(
+    () =>
+      client.container
+        .getById(name)
+        .inspect()
+        .then((i) => i.State.Running)
+        .catch(() => false),
+    (status) => status,
+    () => false,
+    10000
+  );
+
+  if (!status) throw Error("failed start container");
+
+  await client.container.getById(name).stop();
+  await containerStartPromise;
+}

packages/testcontainers/src/wait-strategies/http-wait-strategy.test.ts

@@ -1,6 +1,6 @@
 import { GenericContainer } from "../generic-container/generic-container";
 import { Wait } from "./wait";
-import { checkContainerIsHealthy, checkContainerIsHealthyTls } from "../utils/test-helper";
+import { checkContainerIsHealthy, checkContainerIsHealthyTls, stopStartingContainer } from "../utils/test-helper";
 
 jest.setTimeout(180_000);
 
@@ -85,6 +85,44 @@ describe("HttpWaitStrategy", () => {
     ).rejects.toThrowError("URL /hello-world not accessible after 3000ms");
   });
 
+  describe("when options.abortOnContainerExit is true", () => {
+    it("should fail if container exited before waiting pass", async () => {
+      const name = "container-name";
+      const data = [1, 2, 3];
+      const tail = 50;
+      const echoCmd = data.map((i) => `echo ${i}`).join(" && ");
+      const lastLogs = data.join("\n");
+      const container = new GenericContainer("cristianrgreco/testcontainer:1.1.14")
+        .withExposedPorts(8080)
+        .withStartupTimeout(20000)
+        .withEntrypoint(["/bin/sh", "-c", `${echoCmd} && sleep infinity`])
+        .withWaitStrategy(Wait.forHttp("/hello-world", 8080, { abortOnContainerExit: true }))
+        .withName(name);
+
+      await expect(stopStartingContainer(container, name)).rejects.toThrowError(
+        new Error(`Container exited during HTTP healthCheck, last ${tail} logs: ${lastLogs}`)
+      );
+    });
+
+    it("should log only $tail logs if container exited before waiting pass", async () => {
+      const name = "container-name";
+      const tail = 50;
+      const data = [...Array(tail + 5).keys()];
+      const echoCmd = data.map((i) => `echo ${i}`).join(" && ");
+      const lastLogs = data.slice(tail * -1).join("\n");
+      const container = new GenericContainer("cristianrgreco/testcontainer:1.1.14")
+        .withExposedPorts(8080)
+        .withStartupTimeout(20000)
+        .withEntrypoint(["/bin/sh", "-c", `${echoCmd} && sleep infinity`])
+        .withWaitStrategy(Wait.forHttp("/hello-world", 8080, { abortOnContainerExit: true }))
+        .withName(name);
+
+      await expect(stopStartingContainer(container, name)).rejects.toThrowError(
+        new Error(`Container exited during HTTP healthCheck, last ${tail} logs: ${lastLogs}`)
+      );
+    });
+  });
+
   it("should set method", async () => {
     const container = await new GenericContainer("cristianrgreco/testcontainer:1.1.14")
       .withExposedPorts(8080)

packages/testcontainers/src/wait-strategies/http-wait-strategy.ts

@@ -6,6 +6,10 @@ import { BoundPorts } from "../utils/bound-ports";
 import { IntervalRetry, log } from "../common";
 import { getContainerRuntimeClient } from "../container-runtime";
 
+export interface HttpWaitStrategyOptions {
+  abortOnContainerExit?: boolean;
+}
+
 export class HttpWaitStrategy extends AbstractWaitStrategy {
   private protocol = "http";
   private method = "GET";
@@ -14,7 +18,11 @@ export class HttpWaitStrategy extends AbstractWaitStrategy {
   private _allowInsecure = false;
   private readTimeout = 1000;
 
-  constructor(private readonly path: string, private readonly port: number) {
+  constructor(
+    private readonly path: string,
+    private readonly port: number,
+    private readonly options: HttpWaitStrategyOptions
+  ) {
     super();
   }
 
@@ -66,14 +74,29 @@ export class HttpWaitStrategy extends AbstractWaitStrategy {
 
   public async waitUntilReady(container: Dockerode.Container, boundPorts: BoundPorts): Promise<void> {
     log.debug(`Waiting for HTTP...`, { containerId: container.id });
+
+    const exitStatus = "exited";
+    let containerExited = false;
     const client = await getContainerRuntimeClient();
+    const { abortOnContainerExit } = this.options;
 
     await new IntervalRetry<Response | undefined, Error>(this.readTimeout).retryUntil(
       async () => {
         try {
           const url = `${this.protocol}://${client.info.containerRuntime.host}:${boundPorts.getBinding(this.port)}${
             this.path
           }`;
+
+          if (abortOnContainerExit) {
+            const containerStatus = (await client.container.inspect(container)).State.Status;
+
+            if (containerStatus === exitStatus) {
+              containerExited = true;
+
+              return;
+            }
+          }
+
           return await fetch(url, {
             method: this.method,
             timeout: this.readTimeout,
@@ -85,6 +108,10 @@ export class HttpWaitStrategy extends AbstractWaitStrategy {
         }
       },
       async (response) => {
+        if (abortOnContainerExit && containerExited) {
+          return true;
+        }
+
         if (response === undefined) {
           return false;
         } else if (!this.predicates.length) {
@@ -107,9 +134,36 @@ export class HttpWaitStrategy extends AbstractWaitStrategy {
       this.startupTimeout
     );
 
+    if (abortOnContainerExit && containerExited) {
+      return this.handleContainerExit(container);
+    }
+
     log.debug(`HTTP wait strategy complete`, { containerId: container.id });
   }
 
+  private async handleContainerExit(container: Dockerode.Container) {
+    const tail = 50;
+    const lastLogs: string[] = [];
+    const client = await getContainerRuntimeClient();
+    let message: string;
+
+    try {
+      const stream = await client.container.logs(container, { tail });
+
+      await new Promise((res) => {
+        stream.on("data", (d) => lastLogs.push(d.trim())).on("end", res);
+      });
+
+      message = `Container exited during HTTP healthCheck, last ${tail} logs: ${lastLogs.join("\n")}`;
+    } catch (err) {
+      message = "Container exited during HTTP healthCheck, failed to get last logs";
+    }
+
+    log.error(message, { containerId: container.id });
+
+    throw new Error(message);
+  }
+
   private getAgent(): Agent | undefined {
     if (this._allowInsecure) {
       return new https.Agent({