Replace ESM-only archive and port dependencies

Author: cristianrgreco

package-lock.json

@@ -1,11 +1,4 @@
-import {
-  AbstractStartedContainer,
-  GenericContainer,
-  PortGenerator,
-  RandomPortGenerator,
-  StartedTestContainer,
-  Wait,
-} from "testcontainers";
+import { AbstractStartedContainer, GenericContainer, StartedTestContainer, Wait, getRandomPort } from "testcontainers";
 
 type Protocol = "http" | "https";
 
@@ -21,11 +14,9 @@ export class AzureCosmosDbEmulatorContainer extends GenericContainer {
   private protocol: Protocol = DEFAULT_PROTOCOL;
   private telemetryEnabled = DEFAULT_TELEMETRY_ENABLED;
   private explorerEnabled = DEFAULT_EXPLORER_ENABLED;
-  private portGenerator: PortGenerator;
 
   constructor(image: string) {
     super(image);
-    this.portGenerator = new RandomPortGenerator();
     this.withWaitStrategy(Wait.forLogMessage(COSMOS_READY_LOG_MESSAGE));
   }
 
@@ -40,7 +31,7 @@ export class AzureCosmosDbEmulatorContainer extends GenericContainer {
   }
 
   public override async start(): Promise<StartedAzureCosmosDbEmulatorContainer> {
-    const port = await this.portGenerator.generatePort();
+    const port = await getRandomPort();
     this.withExposedPorts({
       host: port,
       container: port,

packages/modules/azurecosmosdb/src/azure-cosmosdb-emulator-container.ts

@@ -3,7 +3,7 @@ import { BlobServiceClient, StorageSharedKeyCredential } from "@azure/storage-bl
 import { QueueServiceClient } from "@azure/storage-queue";
 import fs from "node:fs";
 import path from "node:path";
-import { RandomPortGenerator } from "testcontainers";
+import { getRandomPort } from "testcontainers";
 import { getImage } from "../../../testcontainers/src/utils/test-helper";
 import { AzuriteContainer } from "./azurite-container";
 import { createOAuthToken, createTokenCredential, getTlsPipelineOptions } from "./azurite-test-utils";
@@ -99,10 +99,9 @@ describe("AzuriteContainer", { timeout: 240_000 }, () => {
 
   it("should be able to specify custom ports", async () => {
     // customPorts {
-    const portGenerator = new RandomPortGenerator();
-    const blobPort = await portGenerator.generatePort();
-    const queuePort = await portGenerator.generatePort();
-    const tablePort = await portGenerator.generatePort();
+    const blobPort = await getRandomPort();
+    const queuePort = await getRandomPort();
+    const tablePort = await getRandomPort();
 
     await using container = await new AzuriteContainer(IMAGE)
       .withSkipApiVersionCheck()

packages/modules/azurite/src/azurite-container.test.ts

@@ -32,7 +32,6 @@
     "testcontainers": "^12.0.2"
   },
   "devDependencies": {
-    "couchbase": "^4.7.0",
-    "get-port": "^7.2.0"
+    "couchbase": "^4.7.0"
   }
 }

packages/modules/couchbase/package.json

@@ -1,5 +1,5 @@
 import couchbase, { Bucket, Cluster } from "couchbase";
-import getPort from "get-port";
+import { getRandomPort } from "testcontainers";
 import { getImage } from "../../../testcontainers/src/utils/test-helper";
 import { BucketDefinition } from "./bucket-definition";
 import { CouchbaseContainer } from "./couchbase-container";
@@ -118,7 +118,7 @@ describe("CouchbaseContainer", { timeout: 180_000 }, () => {
   });
 
   it("should preserve fixed host port binding", async () => {
-    const hostPort = await getPort();
+    const hostPort = await getRandomPort();
     await using container = await new CouchbaseContainer(COMMUNITY_IMAGE)
       .withEnabledServices(CouchbaseService.KV)
       .withExposedPorts({ container: PORTS.MGMT_PORT, host: hostPort })

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

@@ -32,28 +32,27 @@
   "dependencies": {
     "@balena/dockerignore": "^1.0.2",
     "@types/dockerode": "^4.0.1",
-    "archiver": "^8.0.0",
     "async-lock": "^1.4.1",
     "byline": "^5.0.0",
     "debug": "^4.4.3",
     "docker-compose": "^1.4.2",
     "dockerode": "^5.0.0",
-    "get-port": "^7.2.0",
     "proper-lockfile": "^4.1.2",
     "properties-reader": "^3.0.1",
     "ssh-remote-port-forward": "^1.0.4",
     "tar-fs": "^3.1.2",
+    "tar-stream": "^3.2.0",
     "tmp": "^0.2.7",
     "undici": "^8.3.0"
   },
   "devDependencies": {
-    "@types/archiver": "^8.0.0",
     "@types/async-lock": "^1.4.2",
     "@types/byline": "^4.2.36",
     "@types/debug": "^4.1.13",
     "@types/proper-lockfile": "^4.1.4",
     "@types/properties-reader": "^2.1.3",
     "@types/tar-fs": "^2.0.4",
+    "@types/tar-stream": "^3.1.4",
     "@types/tmp": "^0.2.6"
   }
 }

packages/testcontainers/package.json

@@ -1,8 +1,8 @@
-import { TarArchive, type EntryData } from "archiver";
-import getPort from "get-port";
 import path from "path";
+import * as tarStream from "tar-stream";
 import { RandomUuid } from "../common";
 import { getContainerRuntimeClient } from "../container-runtime";
+import { getRandomPort } from "../utils/port-generator";
 import { PullPolicy } from "../utils/pull-policy";
 import {
   checkContainerIsHealthy,
@@ -38,7 +38,7 @@ describe("GenericContainer", { timeout: 180_000 }, () => {
   });
 
   it("should bind to specified host port", async () => {
-    const hostPort = await getPort();
+    const hostPort = await getRandomPort();
     await using container = await new GenericContainer("cristianrgreco/testcontainer:1.1.14")
       .withExposedPorts({
         container: 8080,
@@ -51,7 +51,7 @@ describe("GenericContainer", { timeout: 180_000 }, () => {
   });
 
   it("should bind to specified host port with a different protocol", async () => {
-    const hostPort = await getPort();
+    const hostPort = await getRandomPort();
     await using container = await new GenericContainer("mendhak/udp-listener")
       .withWaitStrategy(Wait.forLogMessage("Listening on UDP port 5005"))
       .withExposedPorts({
@@ -473,6 +473,19 @@ describe("GenericContainer", { timeout: 180_000 }, () => {
     expect((await container.exec("cat /tmp/test.txt")).output).toEqual(expect.stringContaining("hello world"));
   });
 
+  it("should copy directory to started container with permissions", async () => {
+    const source = path.resolve(fixtures, "docker");
+    const target = "/tmp/started-newdir";
+    const mode = parseInt("0777", 8);
+    await using container = await new GenericContainer("cristianrgreco/testcontainer:1.1.14")
+      .withExposedPorts(8080)
+      .start();
+
+    await container.copyDirectoriesToContainer([{ source, target, mode }]);
+
+    expect((await container.exec(`stat -c "%a %n" /tmp/started-newdir/test.txt`)).output).toContain("777");
+  });
+
   it("should copy content to container", async () => {
     const content = "hello world";
     const target = "/tmp/test.txt";
@@ -521,9 +534,7 @@ describe("GenericContainer", { timeout: 180_000 }, () => {
         .withExposedPorts(8080)
         .start();
 
-      const tar = new TarArchive();
-      tar.append("hello world", { name: targetWithCopyOwnership.slice(1), uid, gid } as EntryData);
-      tar.finalize();
+      const tar = createArchiveWithOwnership(targetWithCopyOwnership, uid, gid);
 
       await container.copyArchiveToContainer(tar, "/", { copyUIDGID: true });
 
@@ -536,9 +547,7 @@ describe("GenericContainer", { timeout: 180_000 }, () => {
       const uid = 4242;
       const gid = 4343;
       const targetWithCopyOwnership = "/tmp/with-copy-archives-copyuidgid.txt";
-      const tar = new TarArchive();
-      tar.append("hello world", { name: targetWithCopyOwnership.slice(1), uid, gid } as EntryData);
-      tar.finalize();
+      const tar = createArchiveWithOwnership(targetWithCopyOwnership, uid, gid);
 
       await using containerWithCopyOwnership = await new GenericContainer("cristianrgreco/testcontainer:1.1.14")
         .withCopyArchivesToContainer([
@@ -672,3 +681,27 @@ describe("GenericContainer", { timeout: 180_000 }, () => {
     await GenericContainer.fromDockerfile(context).withTarget("invalid").build();
   });
 });
+
+const createArchiveWithOwnership = (target: string, uid: number, gid: number) => {
+  const content = "hello world";
+  const tar = tarStream.pack();
+
+  tar.entry(
+    {
+      name: target.slice(1),
+      uid,
+      gid,
+      size: Buffer.byteLength(content),
+    },
+    content,
+    (err) => {
+      if (err) {
+        tar.destroy(err);
+      } else {
+        tar.finalize();
+      }
+    }
+  );
+
+  return tar;
+};

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

@@ -1,7 +1,5 @@
-import { TarArchive, type Archiver } from "archiver";
 import AsyncLock from "async-lock";
 import { Container, ContainerCreateOptions, ContainerInspectInfo, HostConfig } from "dockerode";
-import { promises as fs } from "fs";
 import { Readable } from "stream";
 import { containerLog, hash, log, toNanos } from "../common";
 import { ContainerRuntimeClient, getContainerRuntimeClient, ImageName } from "../container-runtime";
@@ -31,6 +29,7 @@ import { createLabels, LABEL_TESTCONTAINERS_CONTAINER_HASH, LABEL_TESTCONTAINERS
 import { mapInspectResult } from "../utils/map-inspect-result";
 import { getContainerPort, getProtocol, hasHostBinding, PortWithOptionalBinding } from "../utils/port";
 import { ImagePullPolicy, PullPolicy } from "../utils/pull-policy";
+import { createTarArchive } from "../utils/tar-archive";
 import { selectWaitStrategy } from "../wait-strategies/utils/wait-strategy-selector";
 import { waitForContainer } from "../wait-strategies/wait-for-container";
 import { WaitStrategy } from "../wait-strategies/wait-strategy";
@@ -198,8 +197,11 @@ export class GenericContainer implements TestContainer {
     }
 
     if (this.filesToCopy.length > 0 || this.directoriesToCopy.length > 0 || this.contentsToCopy.length > 0) {
-      const archive = await this.createArchiveToCopyToContainer();
-      archive.finalize();
+      const archive = await createTarArchive({
+        filesToCopy: this.filesToCopy,
+        directoriesToCopy: this.directoriesToCopy,
+        contentsToCopy: this.contentsToCopy,
+      });
       await client.container.putArchive(container, archive, "/", this.copyToContainerOptions);
     }
 
@@ -275,28 +277,6 @@ export class GenericContainer implements TestContainer {
     }
   }
 
-  private async createArchiveToCopyToContainer(): Promise<Archiver> {
-    const tar = new TarArchive();
-    const filesToCopyWithStats = await Promise.all(
-      this.filesToCopy.map(async (fileToCopy) => ({
-        ...fileToCopy,
-        stats: await fs.stat(fileToCopy.source),
-      }))
-    );
-
-    for (const { source, target, mode, stats } of filesToCopyWithStats) {
-      tar.file(source, { name: target, mode, stats });
-    }
-    for (const { source, target, mode } of this.directoriesToCopy) {
-      tar.directory(source, target, { mode });
-    }
-    for (const { content, target, mode } of this.contentsToCopy) {
-      tar.append(content, { name: target, mode });
-    }
-
-    return tar;
-  }
-
   protected containerStarted?(
     container: StartedTestContainer,
     inspectResult: InspectResult,

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

@@ -1,7 +1,5 @@
-import { TarArchive } from "archiver";
 import AsyncLock from "async-lock";
 import Dockerode, { ContainerInspectInfo } from "dockerode";
-import { promises as fs } from "fs";
 import { Readable } from "stream";
 import { containerLog, log } from "../common";
 import { ContainerRuntimeClient, getContainerRuntimeClient } from "../container-runtime";
@@ -21,6 +19,7 @@ import { BoundPorts } from "../utils/bound-ports";
 import { LABEL_TESTCONTAINERS_SESSION_ID } from "../utils/labels";
 import { mapInspectResult } from "../utils/map-inspect-result";
 import { PortWithOptionalBinding } from "../utils/port";
+import { createTarArchive } from "../utils/tar-archive";
 import { waitForContainer } from "../wait-strategies/wait-for-container";
 import { WaitStrategy } from "../wait-strategies/wait-strategy";
 import { inspectContainerUntilPortsExposed } from "./inspect-container-util-ports-exposed";
@@ -192,35 +191,23 @@ export class StartedGenericContainer implements StartedTestContainer {
   public async copyFilesToContainer(filesToCopy: FileToCopy[]): Promise<void> {
     log.debug(`Copying files to container...`, { containerId: this.container.id });
     const client = await getContainerRuntimeClient();
-    const tar = new TarArchive();
-    const filesToCopyWithStats = await Promise.all(
-      filesToCopy.map(async (fileToCopy) => ({
-        ...fileToCopy,
-        stats: await fs.stat(fileToCopy.source),
-      }))
-    );
-    filesToCopyWithStats.forEach(({ source, target, mode, stats }) => tar.file(source, { name: target, mode, stats }));
-    tar.finalize();
+    const tar = await createTarArchive({ filesToCopy });
     await client.container.putArchive(this.container, tar, "/");
     log.debug(`Copied files to container`, { containerId: this.container.id });
   }
 
   public async copyDirectoriesToContainer(directoriesToCopy: DirectoryToCopy[]): Promise<void> {
     log.debug(`Copying directories to container...`, { containerId: this.container.id });
     const client = await getContainerRuntimeClient();
-    const tar = new TarArchive();
-    directoriesToCopy.forEach(({ source, target }) => tar.directory(source, target));
-    tar.finalize();
+    const tar = await createTarArchive({ directoriesToCopy });
     await client.container.putArchive(this.container, tar, "/");
     log.debug(`Copied directories to container`, { containerId: this.container.id });
   }
 
   public async copyContentToContainer(contentsToCopy: ContentToCopy[]): Promise<void> {
     log.debug(`Copying content to container...`, { containerId: this.container.id });
     const client = await getContainerRuntimeClient();
-    const tar = new TarArchive();
-    contentsToCopy.forEach(({ content, target, mode }) => tar.append(content, { name: target, mode: mode }));
-    tar.finalize();
+    const tar = await createTarArchive({ contentsToCopy });
     await client.container.putArchive(this.container, tar, "/");
     log.debug(`Copied content to container`, { containerId: this.container.id });
   }

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

@@ -23,7 +23,7 @@ export { CommitOptions, Content, CopyToContainerOptions, ExecOptions, ExecResult
 export { BoundPorts } from "./utils/bound-ports";
 export { LABEL_TESTCONTAINERS_SESSION_ID } from "./utils/labels";
 export { PortWithBinding, PortWithOptionalBinding, getContainerPort, hasHostBinding } from "./utils/port";
-export { PortGenerator, RandomPortGenerator } from "./utils/port-generator";
+export { PortGenerator, RandomPortGenerator, getRandomPort } from "./utils/port-generator";
 export { ImagePullPolicy, PullPolicy } from "./utils/pull-policy";
 export { HttpWaitStrategyOptions } from "./wait-strategies/http-wait-strategy";
 export { StartupCheckStrategy, StartupStatus } from "./wait-strategies/startup-check-strategy";