Run tests concurrently

docs/modules/cassandra.md

@@ -21,7 +21,7 @@ npm install @testcontainers/cassandra --save-dev
 <!--/codeinclude-->
 
 <!--codeinclude-->
-[With custom datacenter / rack](../../packages/modules/cassandra/src/cassandra-container.test.ts) inside_block:customDataSenterAndRack
+[With custom datacenter / rack](../../packages/modules/cassandra/src/cassandra-container.test.ts) inside_block:customDataCenterAndRack
 <!--/codeinclude-->
 
 <!--codeinclude-->

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

@@ -5,7 +5,7 @@ import { CassandraContainer } from "./cassandra-container";
 
 const IMAGE = getImage(__dirname);
 
-describe("Cassandra", { timeout: 240_000 }, () => {
+describe.sequential("Cassandra", { timeout: 240_000 }, () => {
   // connectWithDefaultCredentials {
   it("should connect and execute a query with default credentials", async () => {
     const container = await new CassandraContainer(IMAGE).start();
@@ -50,7 +50,7 @@ describe("Cassandra", { timeout: 240_000 }, () => {
   });
   // }
 
-  // customDataSenterAndRack {
+  // customDataCenterAndRack {
   it("should set datacenter and rack", async () => {
     const customDataCenter = "customDC";
     const customRack = "customRack";

packages/modules/gcloud/src/cloudstorage-emulator-container.test.ts

@@ -30,7 +30,7 @@ async function getRequestBodyFromReadableStream(stream: ReadableStream<Uint8Arra
   return fullString;
 }
 
-describe("CloudStorageEmulatorContainer", { timeout: 240_000 }, () => {
+describe.sequential("CloudStorageEmulatorContainer", { timeout: 240_000 }, () => {
   const server = setupServer();
 
   beforeAll(() => {

packages/modules/gcloud/src/firestore-emulator-container.test.ts

@@ -1,14 +1,11 @@
 import admin from "firebase-admin";
+import { randomUuid } from "testcontainers";
 import { getImage } from "../../../testcontainers/src/utils/test-helper";
 import { FirestoreEmulatorContainer, StartedFirestoreEmulatorContainer } from "./firestore-emulator-container";
 
 const IMAGE = getImage(__dirname);
 
 describe("FirestoreEmulatorContainer", { timeout: 240_000 }, () => {
-  afterEach(async () => {
-    await admin.app().delete();
-  });
-
   // firestore4 {
   it("should work using default version", async () => {
     const firestoreEmulatorContainer = await new FirestoreEmulatorContainer(IMAGE).start();
@@ -35,10 +32,11 @@ describe("FirestoreEmulatorContainer", { timeout: 240_000 }, () => {
   async function checkFirestore(firestoreEmulatorContainer: StartedFirestoreEmulatorContainer) {
     expect(firestoreEmulatorContainer).toBeDefined();
     const testProjectId = "test-project";
+    const testAppName = `test-app-${randomUuid()}`;
     const testCollection = "test-collection";
     const testDocument = "test-doc";
     const firebaseConfig = { projectId: testProjectId };
-    const firestore = admin.initializeApp(firebaseConfig).firestore();
+    const firestore = admin.initializeApp(firebaseConfig, testAppName).firestore();
     firestore.settings({ host: firestoreEmulatorContainer.getEmulatorEndpoint(), ssl: false });
 
     const docRef = firestore.collection(testCollection).doc(testDocument);

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

@@ -4,7 +4,7 @@ import { KurrentDbContainer } from "./kurrentdb-container";
 
 const IMAGE = getImage(__dirname);
 
-describe("KurrentDbContainer", { timeout: 240_000 }, () => {
+describe.sequential("KurrentDbContainer", { timeout: 240_000 }, () => {
   // startContainer {
   it("should execute write and read", async () => {
     const container = await new KurrentDbContainer(IMAGE).start();
@@ -42,6 +42,7 @@ describe("KurrentDbContainer", { timeout: 240_000 }, () => {
     ]);
 
     await container.stop();
+    await client.dispose();
   });
   // }
 
@@ -86,6 +87,7 @@ describe("KurrentDbContainer", { timeout: 240_000 }, () => {
     );
     await stream.unsubscribe();
     await container.stop();
+    await client.dispose();
   });
   // }
 });

packages/testcontainers/src/common/index.ts

@@ -5,4 +5,4 @@ export { IntervalRetry, Retry } from "./retry";
 export { streamToString } from "./streams";
 export * from "./time";
 export * from "./type-guards";
-export { RandomUuid, Uuid } from "./uuid";
+export { RandomUuid, Uuid, randomUuid } from "./uuid";

packages/testcontainers/src/container-runtime/auth/cred-helpers.ts

@@ -7,7 +7,7 @@ export class CredHelpers extends CredentialProvider {
   }
 
   public getCredentialProviderName(registry: string, dockerConfig: ContainerRuntimeConfig): string | undefined {
-    if (dockerConfig.credHelpers !== undefined && dockerConfig.credHelpers[registry] !== undefined) {
+    if (dockerConfig.credHelpers?.[registry] !== undefined) {
       return dockerConfig.credHelpers[registry];
     }
   }

packages/testcontainers/src/container-runtime/auth/credential-provider.test.ts

@@ -11,7 +11,7 @@ vi.mock("child_process", () => ({
   spawn: (...args: unknown[]) => mockSpawn(...args),
 }));
 
-describe("CredentialProvider", () => {
+describe.sequential("CredentialProvider", () => {
   let credentialProvider: CredentialProvider;
   let containerRuntimeConfig: ContainerRuntimeConfig;
 

packages/testcontainers/src/container-runtime/auth/get-auth-config.test.ts

@@ -1,6 +1,6 @@
-import { Mock } from "vitest";
+import type { Mock } from "vitest";
 
-describe("get auth config", () => {
+describe.sequential("get auth config", () => {
   let mockExistsSync: Mock;
   let mockReadFile: Mock;
 

packages/testcontainers/src/container-runtime/image-name.test.ts

@@ -1,6 +1,6 @@
 import { ImageName } from "./image-name";
 
-describe("ContainerImage", () => {
+describe.sequential("ContainerImage", () => {
   it("should return whether two image names are equal", () => {
     const imageName = new ImageName("registry", "image", "tag");
 
@@ -10,7 +10,7 @@ describe("ContainerImage", () => {
     expect(imageName.equals(new ImageName("anotherRegistry", "image", "tag"))).toBe(false);
   });
 
-  describe("string", () => {
+  describe.sequential("string", () => {
     it("should work with registry", () => {
       const imageName = new ImageName("registry", "image", "tag");
       expect(imageName.string).toBe("registry/image:tag");
@@ -67,7 +67,7 @@ describe("ContainerImage", () => {
     );
   });
 
-  describe("fromString", () => {
+  describe.sequential("fromString", () => {
     it("should work", () => {
       const imageName = ImageName.fromString("image:latest");
 
@@ -154,7 +154,7 @@ describe("ContainerImage", () => {
     });
   });
 
-  describe.each([
+  describe.sequential.each([
     { customRegistry: "custom.com/registry", expectedRegistry: "custom.com", expectedImagePrefix: "registry/" },
     { customRegistry: "custom.com/registry/", expectedRegistry: "custom.com", expectedImagePrefix: "registry/" },
     { customRegistry: "custom.com", expectedRegistry: "custom.com", expectedImagePrefix: "" },

packages/testcontainers/src/container-runtime/strategies/configuration-strategy.test.ts

@@ -8,7 +8,7 @@ vi.mock("fs/promises");
 const mockGetContainerRuntimeConfig = vi.mocked(getContainerRuntimeConfig);
 const mockReadFile = vi.mocked(readFile);
 
-describe("ConfigurationStrategy", () => {
+describe.sequential("ConfigurationStrategy", () => {
   it("should return undefined if no docker host is set", async () => {
     mockGetContainerRuntimeConfig.mockResolvedValueOnce({ dockerHost: undefined });
 

packages/testcontainers/src/container-runtime/strategies/rootless-unix-socket-strategy.test.ts

@@ -5,7 +5,7 @@ import { RootlessUnixSocketStrategy } from "./rootless-unix-socket-strategy";
 
 vi.mock("fs", () => ({ existsSync: vi.fn() }));
 
-describe("RootlessUnixSocketStrategy", () => {
+describe.sequential("RootlessUnixSocketStrategy", () => {
   const mockExistsSync = vi.mocked(existsSync);
 
   it("should return undefined for non-linux and non-darwin platforms", async () => {

packages/testcontainers/src/container-runtime/strategies/testcontainers-host-strategy.test.ts

@@ -5,7 +5,7 @@ vi.mock("./utils/config", () => ({
   getContainerRuntimeConfig: () => mockGetContainerRuntimeConfig(),
 }));
 
-describe("TestcontainersHostStrategy", () => {
+describe.sequential("TestcontainersHostStrategy", () => {
   it("should return undefined when tc.host property is not set", async () => {
     mockGetContainerRuntimeConfig.mockResolvedValue({});
 

packages/testcontainers/src/container-runtime/strategies/unix-socket-strategy.test.ts

@@ -4,7 +4,7 @@ import { UnixSocketStrategy } from "./unix-socket-strategy";
 vi.mock("fs");
 const mockExistsSync = vi.mocked(existsSync);
 
-describe("UnixSocketStrategy", () => {
+describe.sequential("UnixSocketStrategy", () => {
   beforeEach(() => {
     mockExistsSync.mockReturnValue(true);
   });

packages/testcontainers/src/container-runtime/strategies/utils/config.test.ts

@@ -5,122 +5,124 @@ vi.mock("fs", () => ({ existsSync: mockExistsSync }));
 const mockReadFile = vi.fn();
 vi.mock("fs/promises", () => ({ readFile: mockReadFile }));
 
-let getContainerRuntimeConfig: GetContainerRuntimeConfig;
+describe.sequential("Config", () => {
+  let getContainerRuntimeConfig: GetContainerRuntimeConfig;
 
-beforeEach(async () => {
-  getContainerRuntimeConfig = (await import("./config")).getContainerRuntimeConfig;
-});
-
-afterEach(() => {
-  vi.resetModules();
-});
-
-test("should not set anything", async () => {
-  const dockerClientConfig = await getContainerRuntimeConfig({});
-
-  expect(dockerClientConfig.dockerHost).toBeUndefined();
-  expect(dockerClientConfig.dockerTlsVerify).toBeUndefined();
-  expect(dockerClientConfig.dockerCertPath).toBeUndefined();
-});
+  beforeEach(async () => {
+    getContainerRuntimeConfig = (await import("./config")).getContainerRuntimeConfig;
+  });
 
-describe("environment", () => {
-  beforeEach(() => {
-    mockExistsSync.mockReturnValue(false);
+  afterEach(() => {
+    vi.resetModules();
   });
 
-  test("should set the host", async () => {
-    const dockerClientConfig = await getContainerRuntimeConfig({
-      DOCKER_HOST: "tcp://my.docker.host:1234",
-    });
+  it("should not set anything", async () => {
+    const dockerClientConfig = await getContainerRuntimeConfig({});
 
-    expect(dockerClientConfig.dockerHost).toBe("tcp://my.docker.host:1234");
+    expect(dockerClientConfig.dockerHost).toBeUndefined();
     expect(dockerClientConfig.dockerTlsVerify).toBeUndefined();
     expect(dockerClientConfig.dockerCertPath).toBeUndefined();
   });
 
-  test("should set TLS verify", async () => {
-    const dockerClientConfig = await getContainerRuntimeConfig({
-      DOCKER_HOST: "tcp://my.docker.host:1234",
-      DOCKER_TLS_VERIFY: "1",
+  describe("environment", () => {
+    beforeEach(() => {
+      mockExistsSync.mockReturnValue(false);
     });
 
-    expect(dockerClientConfig.dockerHost).toBe("tcp://my.docker.host:1234");
-    expect(dockerClientConfig.dockerTlsVerify).toBe("1");
-    expect(dockerClientConfig.dockerCertPath).toBeUndefined();
-  });
+    it("should set the host", async () => {
+      const dockerClientConfig = await getContainerRuntimeConfig({
+        DOCKER_HOST: "tcp://my.docker.host:1234",
+      });
 
-  test("should set the cert path", async () => {
-    const dockerClientConfig = await getContainerRuntimeConfig({
-      DOCKER_HOST: "tcp://my.docker.host:1234",
-      DOCKER_TLS_VERIFY: "1",
-      DOCKER_CERT_PATH: "/some/path",
+      expect(dockerClientConfig.dockerHost).toBe("tcp://my.docker.host:1234");
+      expect(dockerClientConfig.dockerTlsVerify).toBeUndefined();
+      expect(dockerClientConfig.dockerCertPath).toBeUndefined();
     });
 
-    expect(dockerClientConfig.dockerHost).toBe("tcp://my.docker.host:1234");
-    expect(dockerClientConfig.dockerTlsVerify).toBe("1");
-    expect(dockerClientConfig.dockerCertPath).toBe("/some/path");
-  });
-});
+    it("should set TLS verify", async () => {
+      const dockerClientConfig = await getContainerRuntimeConfig({
+        DOCKER_HOST: "tcp://my.docker.host:1234",
+        DOCKER_TLS_VERIFY: "1",
+      });
 
-describe("testcontainers.properties file", () => {
-  beforeEach(() => {
-    mockExistsSync.mockReturnValue(true);
+      expect(dockerClientConfig.dockerHost).toBe("tcp://my.docker.host:1234");
+      expect(dockerClientConfig.dockerTlsVerify).toBe("1");
+      expect(dockerClientConfig.dockerCertPath).toBeUndefined();
+    });
+
+    it("should set the cert path", async () => {
+      const dockerClientConfig = await getContainerRuntimeConfig({
+        DOCKER_HOST: "tcp://my.docker.host:1234",
+        DOCKER_TLS_VERIFY: "1",
+        DOCKER_CERT_PATH: "/some/path",
+      });
+
+      expect(dockerClientConfig.dockerHost).toBe("tcp://my.docker.host:1234");
+      expect(dockerClientConfig.dockerTlsVerify).toBe("1");
+      expect(dockerClientConfig.dockerCertPath).toBe("/some/path");
+    });
   });
 
-  test("should set the tc host", async () => {
-    mockReadFile.mockResolvedValueOnce("tc.host=tcp://my.docker.host:1234");
+  describe("testcontainers.properties file", () => {
+    beforeEach(() => {
+      mockExistsSync.mockReturnValue(true);
+    });
 
-    const dockerClientConfig = await getContainerRuntimeConfig({});
+    it("should set the tc host", async () => {
+      mockReadFile.mockResolvedValueOnce("tc.host=tcp://my.docker.host:1234");
 
-    expect(dockerClientConfig.tcHost).toBe("tcp://my.docker.host:1234");
-  });
+      const dockerClientConfig = await getContainerRuntimeConfig({});
 
-  test("should set the host", async () => {
-    mockReadFile.mockResolvedValueOnce("docker.host=tcp://my.docker.host:1234");
+      expect(dockerClientConfig.tcHost).toBe("tcp://my.docker.host:1234");
+    });
 
-    const dockerClientConfig = await getContainerRuntimeConfig({});
+    it("should set the host", async () => {
+      mockReadFile.mockResolvedValueOnce("docker.host=tcp://my.docker.host:1234");
 
-    expect(dockerClientConfig.dockerHost).toBe("tcp://my.docker.host:1234");
-    expect(dockerClientConfig.dockerTlsVerify).toBeUndefined();
-    expect(dockerClientConfig.dockerCertPath).toBeUndefined();
-  });
+      const dockerClientConfig = await getContainerRuntimeConfig({});
+
+      expect(dockerClientConfig.dockerHost).toBe("tcp://my.docker.host:1234");
+      expect(dockerClientConfig.dockerTlsVerify).toBeUndefined();
+      expect(dockerClientConfig.dockerCertPath).toBeUndefined();
+    });
 
-  test("should set TLS verify", async () => {
-    mockReadFile.mockResolvedValueOnce(`
+    it("should set TLS verify", async () => {
+      mockReadFile.mockResolvedValueOnce(`
         docker.host=tcp://my.docker.host:1234
         docker.tls.verify=1
       `);
 
-    const dockerClientConfig = await getContainerRuntimeConfig({});
+      const dockerClientConfig = await getContainerRuntimeConfig({});
 
-    expect(dockerClientConfig.dockerHost).toBe("tcp://my.docker.host:1234");
-    expect(dockerClientConfig.dockerTlsVerify).toBe("1");
-    expect(dockerClientConfig.dockerCertPath).toBeUndefined();
-  });
+      expect(dockerClientConfig.dockerHost).toBe("tcp://my.docker.host:1234");
+      expect(dockerClientConfig.dockerTlsVerify).toBe("1");
+      expect(dockerClientConfig.dockerCertPath).toBeUndefined();
+    });
 
-  test("should set the cert path", async () => {
-    mockReadFile.mockResolvedValueOnce(`
+    it("should set the cert path", async () => {
+      mockReadFile.mockResolvedValueOnce(`
         docker.host=tcp://my.docker.host:1234
         docker.tls.verify=1
         docker.cert.path=/some/path
       `);
 
-    const dockerClientConfig = await getContainerRuntimeConfig({});
+      const dockerClientConfig = await getContainerRuntimeConfig({});
 
-    expect(dockerClientConfig.dockerHost).toBe("tcp://my.docker.host:1234");
-    expect(dockerClientConfig.dockerTlsVerify).toBe("1");
-    expect(dockerClientConfig.dockerCertPath).toBe("/some/path");
+      expect(dockerClientConfig.dockerHost).toBe("tcp://my.docker.host:1234");
+      expect(dockerClientConfig.dockerTlsVerify).toBe("1");
+      expect(dockerClientConfig.dockerCertPath).toBe("/some/path");
+    });
   });
-});
 
-test("should cache the result", async () => {
-  mockExistsSync.mockReturnValue(true);
-  mockReadFile.mockResolvedValueOnce("tc.host=tcp://my.docker.host:1234");
+  it("should cache the result", async () => {
+    mockExistsSync.mockReturnValue(true);
+    mockReadFile.mockResolvedValueOnce("tc.host=tcp://my.docker.host:1234");
 
-  await getContainerRuntimeConfig({});
-  const dockerClientConfig = await getContainerRuntimeConfig({});
+    await getContainerRuntimeConfig({});
+    const dockerClientConfig = await getContainerRuntimeConfig({});
 
-  expect(dockerClientConfig.tcHost).toBe("tcp://my.docker.host:1234");
-  expect(mockExistsSync).toHaveBeenCalledTimes(1);
-  expect(mockReadFile).toHaveBeenCalledTimes(1);
+    expect(dockerClientConfig.tcHost).toBe("tcp://my.docker.host:1234");
+    expect(mockExistsSync).toHaveBeenCalledTimes(1);
+    expect(mockReadFile).toHaveBeenCalledTimes(1);
+  });
 });