Selenium support user-provided network

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

@@ -1,6 +1,6 @@
 import path from "path";
 import { Browser, Builder } from "selenium-webdriver";
-import { GenericContainer } from "testcontainers";
+import { GenericContainer, Network } from "testcontainers";
 import tmp from "tmp";
 import { getImage } from "../../../testcontainers/src/utils/test-helper";
 import { SELENIUM_VIDEO_IMAGE, SeleniumContainer } from "./selenium-container";
@@ -45,4 +45,19 @@ describe.for(browsers)("SeleniumContainer", { timeout: 240_000 }, ([browser, ima
     expect(exitCode).toBe(0);
     // }
   });
+
+  it(`should use provided network when recording for ${browser}`, async () => {
+    await using network = await new Network().start();
+
+    await using _webServer = await new GenericContainer("cristianrgreco/testcontainer:1.1.14")
+      .withNetwork(network)
+      .withNetworkAliases("webserver")
+      .withExposedPorts(8080)
+      .start();
+
+    await using container = await new SeleniumContainer(image).withRecording().withNetwork(network).start();
+
+    const { exitCode } = await container.exec(["getent", "hosts", "webserver"]);
+    expect(exitCode).toBe(0);
+  });
 });

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

@@ -77,36 +77,46 @@ export class SeleniumRecordingContainer extends SeleniumContainer {
     super(image);
   }
 
-  public override async start(): Promise<StartedSeleniumRecordingContainer> {
+  private async createNetworkIfNeeded(): Promise<StartedNetwork | undefined> {
+    if (this.networkMode) {
+      return undefined;
+    }
     const network = await new Network().start();
     this.withNetwork(network);
+    return network;
+  }
+
+  public override async start(): Promise<StartedSeleniumRecordingContainer> {
+    const internalNetwork = await this.createNetworkIfNeeded();
     this.withNetworkAliases(SELENIUM_NETWORK_ALIAS);
 
     const startedSeleniumContainer = await super.start();
 
     const startedFfmpegContainer = await new GenericContainer(SELENIUM_VIDEO_IMAGE)
-      .withNetwork(network)
+      .withNetworkMode(this.networkMode!)
       .withEnvironment({ DISPLAY_CONTAINER_NAME: SELENIUM_NETWORK_ALIAS })
       .withWaitStrategy(Wait.forLogMessage(/.*video-recording entered RUNNING state.*/))
       .start();
 
-    return new StartedSeleniumRecordingContainer(startedSeleniumContainer, startedFfmpegContainer, network);
+    return new StartedSeleniumRecordingContainer(startedSeleniumContainer, startedFfmpegContainer, internalNetwork);
   }
 }
 
 export class StartedSeleniumRecordingContainer extends StartedSeleniumContainer {
   constructor(
     startedSeleniumContainer: StartedTestContainer,
     private readonly startedFfmpegContainer: StartedTestContainer,
-    private readonly network: StartedNetwork
+    private readonly internalNetwork?: StartedNetwork
   ) {
     super(startedSeleniumContainer);
   }
 
   override async stop(options?: Partial<StopOptions>): Promise<StoppedSeleniumRecordingContainer> {
     const stoppedSeleniumContainer = await super.stop(options);
     const stoppedFfmpegContainer = await this.startedFfmpegContainer.stop({ remove: false, timeout: 60_000 });
-    await this.network.stop();
+    if (this.internalNetwork) {
+      await this.internalNetwork.stop();
+    }
     return new StoppedSeleniumRecordingContainer(stoppedSeleniumContainer, stoppedFfmpegContainer);
   }
 }