Refactor + add tests

Author: cristianrgreco

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

@@ -1,8 +1,8 @@
 import archiver from "archiver";
 import AsyncLock from "async-lock";
-import { Container, ContainerCreateOptions, ContainerInspectInfo, HostConfig } from "dockerode";
+import { Container, ContainerCreateOptions, HostConfig } from "dockerode";
 import { Readable } from "stream";
-import { containerLog, hash, IntervalRetry, log, toNanos } from "../common";
+import { containerLog, hash, log, toNanos } from "../common";
 import { ContainerRuntimeClient, getContainerRuntimeClient, ImageName } from "../container-runtime";
 import { CONTAINER_STATUSES } from "../container-runtime/clients/container/types";
 import { StartedNetwork } from "../network/network";
@@ -33,6 +33,7 @@ import { Wait } from "../wait-strategies/wait";
 import { waitForContainer } from "../wait-strategies/wait-for-container";
 import { WaitStrategy } from "../wait-strategies/wait-strategy";
 import { GenericContainerBuilder } from "./generic-container-builder";
+import { inspectContainerUntilPortsExposed } from "./inspect-container-util-ports-exposed";
 import { StartedGenericContainer } from "./started-generic-container";
 
 const reusableContainerCreationLock = new AsyncLock();
@@ -141,7 +142,13 @@ export class GenericContainer implements TestContainer {
     if (!inspectResult.State.Running) {
       log.debug("Reused container is not running, attempting to start it");
       await client.container.start(container);
-      inspectResult = (await this.inspectContainer(client, container)).inspectResult;
+      inspectResult = (
+        await inspectContainerUntilPortsExposed(
+          () => client.container.inspect(container),
+          this.exposedPorts,
+          container.id
+        )
+      ).inspectResult;
     }
 
     const mappedInspectResult = mapInspectResult(inspectResult);
@@ -195,7 +202,11 @@ export class GenericContainer implements TestContainer {
     await client.container.start(container);
     log.info(`Started container for image "${this.createOpts.Image}"`, { containerId: container.id });
 
-    const { inspectResult, mappedInspectResult } = await this.inspectContainer(client, container);
+    const { inspectResult, mappedInspectResult } = await inspectContainerUntilPortsExposed(
+      () => client.container.inspect(container),
+      this.exposedPorts,
+      container.id
+    );
     const boundPorts = BoundPorts.fromInspectResult(client.info.containerRuntime.hostIps, mappedInspectResult).filter(
       this.exposedPorts
     );
@@ -239,48 +250,6 @@ export class GenericContainer implements TestContainer {
     return startedContainer;
   }
 
-  private async inspectContainer(
-    client: ContainerRuntimeClient,
-    container: Container
-  ): Promise<{
-    inspectResult: ContainerInspectInfo;
-    mappedInspectResult: InspectResult;
-  }> {
-    const containerInspectRetry = await new IntervalRetry<
-      {
-        inspectResult: ContainerInspectInfo;
-        mappedInspectResult: InspectResult;
-      },
-      Error
-    >(100).retryUntil(
-      async () => {
-        const inspectResult = await client.container.inspect(container);
-        const mappedInspectResult = mapInspectResult(inspectResult);
-        return { inspectResult, mappedInspectResult };
-      },
-      ({ mappedInspectResult }) =>
-        this.exposedPorts
-          .map((exposedPort) => getContainerPort(exposedPort))
-          .every(
-            (exposedPort) =>
-              mappedInspectResult.ports[exposedPort].length > 0 &&
-              mappedInspectResult.ports[exposedPort].every(({ hostPort }) => hostPort !== undefined)
-          ),
-      () => {
-        const message = `Container did not expose all ports after starting`;
-        log.error(message, { containerId: container.id });
-        return new Error(message);
-      },
-      3000
-    );
-
-    if (containerInspectRetry instanceof Error) {
-      throw containerInspectRetry;
-    }
-
-    return containerInspectRetry;
-  }
-
   private async connectContainerToPortForwarder(client: ContainerRuntimeClient, container: Container) {
     const portForwarder = await PortForwarderInstance.getInstance();
     const portForwarderNetworkId = portForwarder.getNetworkId();

packages/testcontainers/src/generic-container/inspect-container-util-ports-exposed.test.ts

@@ -0,0 +1,91 @@
+import { ContainerInspectInfo } from "dockerode";
+import { InspectResult } from "../types";
+import { mapInspectResult } from "../utils/map-inspect-result";
+import { inspectContainerUntilPortsExposed } from "./inspect-container-util-ports-exposed";
+
+function mockExposed(): { inspectResult: ContainerInspectInfo; mappedInspectResult: InspectResult } {
+  const date = new Date();
+
+  const inspectResult: ContainerInspectInfo = {
+    Name: "container-id",
+    Config: {
+      Hostname: "hostname",
+      Labels: {},
+    },
+    State: {
+      Health: {
+        Status: "healthy",
+      },
+      Status: "running",
+      Running: true,
+      StartedAt: date.toISOString(),
+      FinishedAt: date.toISOString(),
+    },
+    NetworkSettings: {
+      Ports: { "8080/tcp": [{ HostIp: "0.0.0.0", HostPort: "45000" }] },
+      Networks: {},
+    },
+  } as unknown as ContainerInspectInfo;
+
+  return { inspectResult, mappedInspectResult: mapInspectResult(inspectResult) };
+}
+
+function mockNotExposed(): { inspectResult: ContainerInspectInfo; mappedInspectResult: InspectResult } {
+  const date = new Date();
+
+  const inspectResult: ContainerInspectInfo = {
+    Name: "container-id",
+    Config: {
+      Hostname: "hostname",
+      Labels: {},
+    },
+    State: {
+      Health: {
+        Status: "healthy",
+      },
+      Status: "running",
+      Running: true,
+      StartedAt: date.toISOString(),
+      FinishedAt: date.toISOString(),
+    },
+    NetworkSettings: {
+      Ports: { "8080/tcp": [] },
+      Networks: {},
+    },
+  } as unknown as ContainerInspectInfo;
+
+  return { inspectResult, mappedInspectResult: mapInspectResult(inspectResult) };
+}
+
+test("returns the inspect results when all ports are exposed", async () => {
+  const data = mockExposed();
+  const inspectFn = vi.fn().mockResolvedValueOnce(data.inspectResult);
+
+  const result = await inspectContainerUntilPortsExposed(inspectFn, [8080], "container-id");
+
+  expect(result).toEqual(data);
+});
+
+test("retries the inspect if ports are not yet exposed", async () => {
+  const data1 = mockNotExposed();
+  const data2 = mockExposed();
+  const inspectFn = vi
+    .fn()
+    .mockResolvedValueOnce(data1.inspectResult)
+    .mockResolvedValueOnce(data1.inspectResult)
+    .mockResolvedValueOnce(data2.inspectResult);
+
+  const result = await inspectContainerUntilPortsExposed(inspectFn, [8080], "container-id");
+
+  expect(result).toEqual(data2);
+  expect(inspectFn).toHaveBeenCalledTimes(3);
+});
+
+test("throws an error ", async () => {
+  const data = mockNotExposed();
+  const inspectFn = vi.fn().mockResolvedValue(data.inspectResult);
+
+  await expect(inspectContainerUntilPortsExposed(inspectFn, [8080], "container-id", 0)).rejects.toThrow(
+    "Container did not expose all ports after starting"
+  );
+});

packages/testcontainers/src/generic-container/inspect-container-util-ports-exposed.ts

@@ -0,0 +1,45 @@
+import { ContainerInspectInfo } from "dockerode";
+import { IntervalRetry, log } from "../common";
+import { InspectResult } from "../types";
+import { mapInspectResult } from "../utils/map-inspect-result";
+import { getContainerPort, PortWithOptionalBinding } from "../utils/port";
+
+type Result = {
+  inspectResult: ContainerInspectInfo;
+  mappedInspectResult: InspectResult;
+};
+
+export async function inspectContainerUntilPortsExposed(
+  inspectFn: () => Promise<ContainerInspectInfo>,
+  ports: PortWithOptionalBinding[],
+  containerId: string,
+  timeout = 5000
+): Promise<Result> {
+  const result = await new IntervalRetry<Result, Error>(100).retryUntil(
+    async () => {
+      const inspectResult = await inspectFn();
+      const mappedInspectResult = mapInspectResult(inspectResult);
+      return { inspectResult, mappedInspectResult };
+    },
+    ({ mappedInspectResult }) =>
+      ports
+        .map((exposedPort) => getContainerPort(exposedPort))
+        .every(
+          (exposedPort) =>
+            mappedInspectResult.ports[exposedPort].length > 0 &&
+            mappedInspectResult.ports[exposedPort].every(({ hostPort }) => hostPort !== undefined)
+        ),
+    () => {
+      const message = `Container did not expose all ports after starting`;
+      log.error(message, { containerId });
+      return new Error(message);
+    },
+    timeout
+  );
+
+  if (result instanceof Error) {
+    throw result;
+  }
+
+  return result;
+}