Abort timers when log wait strategy completes

Author: cristianrgreco

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

@@ -55,20 +55,23 @@ describe("LogWaitStrategy", { timeout: 180_000 }, () => {
     expect(await getRunningContainerNames()).not.toContain(containerName);
   });
 
-  it("should throw an error if the message is never received", async () => {
+  it("should throw an error if the log stream ends and the message is not received", async () => {
     const containerName = `container-${new RandomUuid().nextUuid()}`;
 
     await expect(
       new GenericContainer("cristianrgreco/testcontainer:1.1.14")
         .withName(containerName)
-        .withCommand("/bin/sh", "-c", 'echo "Ready"')
+        .withCommand(["/bin/sh", "-c", 'echo "Ready"'])
         .withWaitStrategy(Wait.forLogMessage("unexpected"))
         .start()
     ).rejects.toThrowError(`Log stream ended and message "unexpected" was not received`);
 
     expect(await getRunningContainerNames()).not.toContain(containerName);
   });
 
+  // TODO
+  it.skip("should throw an error if the log stream is open and the strategy times out", async () => {});
+
   it("does not matter if container does not send all content in a single line", async () => {
     const container = await new GenericContainer("cristianrgreco/testcontainer:1.1.14")
       .withCommand([

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

@@ -9,6 +9,8 @@ import { AbstractWaitStrategy } from "./wait-strategy";
 export type Log = string;
 
 export class LogWaitStrategy extends AbstractWaitStrategy {
+  private abortController!: AbortController;
+
   constructor(
     private readonly message: Log | RegExp,
     private readonly times: number
@@ -17,12 +19,20 @@ export class LogWaitStrategy extends AbstractWaitStrategy {
   }
 
   public async waitUntilReady(container: Dockerode.Container, boundPorts: BoundPorts, startTime?: Date): Promise<void> {
+    this.abortController = new AbortController();
     await Promise.race([this.handleTimeout(container.id), this.handleLogs(container, startTime)]);
   }
 
   async handleTimeout(containerId: string): Promise<void> {
-    await setTimeout(this.startupTimeout);
+    try {
+      await setTimeout(this.startupTimeout, undefined, { signal: this.abortController.signal });
+    } catch (err) {
+      if (!(err instanceof Error && err.name === "AbortError")) {
+        throw err;
+      }
+    }
     this.throwError(containerId, `Log message "${this.message}" not received after ${this.startupTimeout}ms`);
+    this.abortController.abort();
   }
 
   async handleLogs(container: Dockerode.Container, startTime?: Date): Promise<void> {
@@ -32,21 +42,26 @@ export class LogWaitStrategy extends AbstractWaitStrategy {
 
     let matches = 0;
     for await (const line of byline(stream)) {
+      if (this.abortController.signal.aborted) {
+        break;
+      }
       if (this.matches(line)) {
         if (++matches === this.times) {
-          return log.debug(`Log wait strategy complete`, { containerId: container.id });
+          log.debug(`Log wait strategy complete`, { containerId: container.id });
+          this.abortController.abort();
+          return;
         }
       }
     }
 
     this.throwError(container.id, `Log stream ended and message "${this.message}" was not received`);
   }
 
-  matches(line: string): boolean {
+  private matches(line: string): boolean {
     return this.message instanceof RegExp ? this.message.test(line) : line.includes(this.message);
   }
 
-  throwError(containerId: string, message: string): void {
+  private throwError(containerId: string, message: string): void {
     log.error(message, { containerId });
     throw new Error(message);
   }