Docker and Testcontainers

// build.gradle: testImplementation "org.testcontainers:selenium:1.21.0", "org.testcontainers:junit-jupiter:1.21.0"
import org.testcontainers.containers.BrowserWebDriverContainer;
import org.testcontainers.containers.VncRecordingContainer.VncRecordingFormat;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;

@Testcontainers
class CheckoutIT {

  @Container
  static BrowserWebDriverContainer<?> browser = new BrowserWebDriverContainer<>("selenium/standalone-chrome:4.48.0")
      .withCapabilities(new ChromeOptions())
      .withRecordingMode(BrowserWebDriverContainer.VncRecordingMode.RECORD_FAILING,
                         new File("target/videos"), VncRecordingFormat.MP4)
      .withSharedMemorySize(2L * 1024 * 1024 * 1024);

  private RemoteWebDriver driver;

  @BeforeEach
  void setUp() {
      driver = new RemoteWebDriver(browser.getSeleniumAddress(), new ChromeOptions());
      driver.setFileDetector(new LocalFileDetector());
  }

  @AfterEach
  void tearDown() { driver.quit(); }

  @Test
  void placesOrder() {
      // The app under test must be reachable from inside the container:
      // use host.testcontainers.internal instead of localhost
      driver.get("http://host.testcontainers.internal:3000/checkout");
      // ...
  }
}

# pip install testcontainers[selenium]
import pytest
from testcontainers.selenium import BrowserWebDriverContainer
from selenium.webdriver import ChromeOptions

@pytest.fixture(scope="session")
def browser_container():
  with BrowserWebDriverContainer(ChromeOptions(), image="selenium/standalone-chrome:4.48.0") as container:
      yield container

@pytest.fixture
def driver(browser_container):
  d = browser_container.get_driver()          # a RemoteWebDriver pointed at the container
  yield d
  d.quit()

def test_places_order(driver):
  # Reach the host from inside Docker
  driver.get("http://host.docker.internal:3000/checkout")
  ...

// npm i -D testcontainers
const { GenericContainer, Wait } = require('testcontainers');
const { Builder } = require('selenium-webdriver');

describe('checkout', function () {
this.timeout(120000);
let container, driver;

before(async () => {
  container = await new GenericContainer('selenium/standalone-chrome:4.48.0')
    .withExposedPorts(4444)
    .withSharedMemorySize(2 * 1024 * 1024 * 1024)
    .withWaitStrategy(Wait.forHttp('/status', 4444).forResponsePredicate((b) => b.includes('"ready": true')))
    .start();
});
after(async () => { await container.stop(); });

beforeEach(async () => {
  const url = `http://${container.getHost()}:${container.getMappedPort(4444)}`;
  driver = await new Builder().usingServer(url).forBrowser('chrome').build();
});
afterEach(async () => { await driver.quit(); });

it('places an order', async () => {
  await driver.get('http://host.docker.internal:3000/checkout');
});
});

// NuGet: Testcontainers
using DotNet.Testcontainers.Builders;
using DotNet.Testcontainers.Containers;

[TestFixture]
public class CheckoutTests
{
  private IContainer _container = null!;
  private IWebDriver _driver = null!;

  [OneTimeSetUp]
  public async Task StartBrowser()
  {
      _container = new ContainerBuilder()
          .WithImage("selenium/standalone-chrome:4.48.0")
          .WithPortBinding(4444, true)
          .WithEnvironment("SE_NODE_MAX_SESSIONS", "2")
          .WithWaitStrategy(Wait.ForUnixContainer().UntilHttpRequestIsSucceeded(r => r.ForPort(4444).ForPath("/status")))
          .Build();
      await _container.StartAsync();
  }

  [OneTimeTearDown]
  public async Task StopBrowser() => await _container.DisposeAsync();

  [SetUp]
  public void SetUp()
  {
      var url = new Uri($"http://{_container.Hostname}:{_container.GetMappedPublicPort(4444)}");
      _driver = new RemoteWebDriver(url, new ChromeOptions());
  }

  [TearDown]
  public void TearDown() => _driver.Quit();

  [Test]
  public void PlacesOrder() => _driver.Navigate().GoToUrl("http://host.docker.internal:3000/checkout");
}