Selenium: Drivers, Browsers & Options

import static org.junit.jupiter.api.Assertions.*;

import java.time.Duration;
import org.junit.jupiter.api.Test;
import org.openqa.selenium.PageLoadStrategy;
import org.openqa.selenium.Proxy;
import org.openqa.selenium.UnexpectedAlertBehaviour;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;
import org.openqa.selenium.remote.CapabilityType;

class OptionsTest {
  @Test
  void sharedOptionsBecomeSessionCapabilities() {
    ChromeOptions options = new ChromeOptions();
    options.addArguments("--headless=new");
    options.setPageLoadStrategy(PageLoadStrategy.EAGER);
    options.setAcceptInsecureCerts(true);
    options.setScriptTimeout(Duration.ofSeconds(5));
    options.setPageLoadTimeout(Duration.ofSeconds(20));
    options.setImplicitWaitTimeout(Duration.ZERO);
    options.setUnhandledPromptBehaviour(UnexpectedAlertBehaviour.DISMISS_AND_NOTIFY);
    options.setCapability(CapabilityType.STRICT_FILE_INTERACTABILITY, true);

    // What the client would send: the W3C capabilities plus the goog:chromeOptions extension.
    System.out.println("asMap: " + options.asMap());

    WebDriver driver = new ChromeDriver(options);
    try {
      var caps = ((ChromeDriver) driver).getCapabilities();
      System.out.println("browserName=" + caps.getBrowserName() + " platformName=" + caps.getPlatformName()
          + " pageLoadStrategy=" + caps.getCapability("pageLoadStrategy")
          + " timeouts=" + caps.getCapability("timeouts"));
      assertEquals("chrome", caps.getBrowserName());
      assertEquals("eager", caps.getCapability("pageLoadStrategy"));
      // setWindowRect is reported by the driver; it is not accepted as an input capability.
      assertEquals(true, caps.getCapability(CapabilityType.SET_WINDOW_RECT));
      assertEquals(true, caps.getCapability("acceptInsecureCerts"));
      assertEquals(Duration.ofSeconds(5), driver.manage().timeouts().getScriptTimeout());
      assertEquals(Duration.ofSeconds(20), driver.manage().timeouts().getPageLoadTimeout());
      assertEquals(Duration.ZERO, driver.manage().timeouts().getImplicitWaitTimeout());
    } finally {
      driver.quit();
    }
  }

  @Test
  void proxyIsAStandardCapability() {
    Proxy proxy = new Proxy();
    proxy.setHttpProxy("proxy.example.test:8080");
    proxy.setNoProxy("localhost");
    ChromeOptions options = new ChromeOptions();
    options.setCapability("proxy", proxy);
    System.out.println("proxy capability: " + options.asMap().get("proxy"));
    assertEquals("proxy.example.test:8080", ((Proxy) options.getCapability("proxy")).getHttpProxy());
  }
}

def test_shared_options_become_session_capabilities():
    options = webdriver.ChromeOptions()
    options.add_argument("--headless=new")
    options.page_load_strategy = "eager"
    options.accept_insecure_certs = True
    options.timeouts = {"script": 5000, "pageLoad": 20000, "implicit": 0}
    options.unhandled_prompt_behavior = "dismiss and notify"
    options.strict_file_interactability = True

    # What the client would send: the W3C capabilities plus the goog:chromeOptions extension.
    print("to_capabilities:", json.dumps(options.to_capabilities(), sort_keys=True))

    driver = webdriver.Chrome(options=options)
    try:
        caps = driver.capabilities
        print("browserName=%s platformName=%s pageLoadStrategy=%s timeouts=%s" % (
            caps["browserName"], caps["platformName"], caps["pageLoadStrategy"], caps["timeouts"]))
        assert caps["browserName"] == "chrome"
        assert caps["pageLoadStrategy"] == "eager"
        assert caps["acceptInsecureCerts"] is True
        # setWindowRect is reported by the driver; it is not accepted as an input capability.
        assert caps["setWindowRect"] is True
        assert driver.timeouts.script == 5
        assert driver.timeouts.page_load == 20
        assert driver.timeouts.implicit_wait == 0
        driver.get(BASE_URL + "/books")
    finally:
        driver.quit()


def test_proxy_is_a_standard_capability():
    options = webdriver.ChromeOptions()
    options.proxy = Proxy({"proxyType": ProxyType.MANUAL, "httpProxy": "proxy.example.test:8080", "noProxy": "localhost"})
    caps = options.to_capabilities()
    print("proxy capability:", caps["proxy"])
    assert caps["proxy"]["httpProxy"] == "proxy.example.test:8080"

asMap: {acceptInsecureCerts=true, browserName=chrome, goog:chromeOptions={args=[--headless=new], extensions=[]}, pageLoadStrategy=eager, strictFileInteractability=true, timeouts={implicit=0, pageLoad=20000, script=5000}, unhandledPromptBehavior=dismiss and notify}
browserName=chrome platformName=mac pageLoadStrategy=eager timeouts={implicit=0, pageLoad=20000, script=5000}
proxy capability: Proxy(manual, http=proxy.example.test:8080)

@Test
void uploadsNeedALocalFileDetector() throws Exception {
  ChromeOptions options = new ChromeOptions();
  options.addArguments("--headless=new");
  driver = new RemoteWebDriver(Env.url(Env.CHROME_GRID), options);
  driver.get(Fixture.FROM_DOCKER + "/upload");

  Path file = Files.createTempFile("cover-", ".txt");
  Files.writeString(file, "not really a cover");
  ((RemoteWebDriver) driver).setFileDetector(new LocalFileDetector());
  driver.findElement(By.id("file")).sendKeys(file.toAbsolutePath().toString());

  assertEquals(file.getFileName().toString(), driver.findElement(By.id("uploaded")).getText());
}

def test_uploads_use_a_local_file_detector_by_default(fixture_server, tmp_path):
    driver = webdriver.Remote(command_executor=CHROME_GRID, options=chrome_options())
    try:
        driver.get(fixture_server + "/upload")
        file = tmp_path / "cover.txt"
        file.write_text("not really a cover")
        driver.find_element(By.ID, "file").send_keys(str(file))
        assert driver.find_element(By.ID, "uploaded").text == "cover.txt"
    finally:
        driver.quit()

@Test
void managedDownloadsBringFilesBackToTheClient() throws Exception {
  ChromeOptions options = new ChromeOptions();
  options.addArguments("--headless=new");
  options.setEnableDownloads(true); // se:downloadsEnabled
  driver = new RemoteWebDriver(Env.url(Env.CHROME_GRID), options);

  driver.get(Fixture.FROM_DOCKER + "/download/hello.txt");
  new WebDriverWait(driver, Duration.ofSeconds(10))
      .until(d -> ((HasDownloads) d).getDownloadableFiles().contains("hello.txt"));

  List<String> names = ((HasDownloads) driver).getDownloadableFiles();
  System.out.println("downloadable files: " + names);

  Path target = Files.createTempDirectory("download");
  ((HasDownloads) driver).downloadFile("hello.txt", target);
  assertEquals("Hello, World!", Files.readString(target.resolve("hello.txt")));

  ((HasDownloads) driver).deleteDownloadableFiles();
  assertTrue(((HasDownloads) driver).getDownloadableFiles().isEmpty());
}

def test_managed_downloads_bring_files_back_to_the_client(fixture_server, tmp_path):
    options = chrome_options()
    options.enable_downloads = True  # se:downloadsEnabled
    driver = webdriver.Remote(command_executor=CHROME_GRID, options=options)
    try:
        driver.get(fixture_server + "/download/hello.txt")
        WebDriverWait(driver, 10).until(lambda d: "hello.txt" in d.get_downloadable_files())
        print("downloadable files:", driver.get_downloadable_files())

        driver.download_file("hello.txt", str(tmp_path))
        assert (tmp_path / "hello.txt").read_text() == "Hello, World!"

        driver.delete_downloadable_files()
        assert driver.get_downloadable_files() == []
    finally:
        driver.quit()

@Test
void augmenterAddsTheSameInterfacesToAPlainRemoteDriver() {
  ChromeOptions options = new ChromeOptions();
  options.addArguments("--headless=new");
  driver = new RemoteWebDriver(Env.url(Env.CHROME_GRID), options);
  assertFalse(driver instanceof HasCasting);

  driver = new Augmenter().augment(driver);
  assertTrue(driver instanceof HasCasting);
}

import com.sun.net.httpserver.HttpServer;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.Executors;

/** A tiny HTTP server for the two things Bookshelf does not have: a file download and a file upload form. */
final class Fixture {
  static final int PORT = Integer.getInteger("fixture.port", 4519);
  static final String FROM_DOCKER = "http://host.docker.internal:" + PORT;
  private final HttpServer server;

  Fixture() throws IOException {
    server = HttpServer.create(new InetSocketAddress(PORT), 0);
    server.setExecutor(Executors.newCachedThreadPool());
    server.createContext("/download/hello.txt", ex -> {
      byte[] body = "Hello, World!".getBytes(StandardCharsets.UTF_8);
      ex.getResponseHeaders().add("Content-Type", "text/plain");
      ex.getResponseHeaders().add("Content-Disposition", "attachment; filename=\"hello.txt\"");
      ex.sendResponseHeaders(200, body.length);
      ex.getResponseBody().write(body);
      ex.close();
    });
    server.createContext("/upload", ex -> {
      byte[] body = ("<html><body><input type=file id=file>"
          + "<p id=uploaded></p>"
          + "<script>file.onchange = () => uploaded.textContent = file.files[0].name;</script>"
          + "</body></html>").getBytes(StandardCharsets.UTF_8);
      ex.getResponseHeaders().add("Content-Type", "text/html");
      ex.sendResponseHeaders(200, body.length);
      ex.getResponseBody().write(body);
      ex.close();
    });
    server.start();
  }

  void stop() { server.stop(0); }
}

@Test
@DisabledOnOs(OS.WINDOWS)
void installUnpackedExtensionOverBiDi() {
  ChromeOptions options = new ChromeOptions();
  options.addArguments("--headless=new");
  options.enableBiDi();
  options.addArguments("--remote-debugging-pipe", "--enable-unsafe-extension-debugging");
  ChromeDriver driver = new ChromeDriver(options);
  try {
    Path dir = Path.of("src/test/resources/extensions/bookshelf-banner-chrome").toAbsolutePath();
    new WebExtension(driver).install(new InstallExtensionParameters(new ExtensionPath(dir.toString())));

    driver.get(Env.BASE_URL + "/books");
    assertEquals("Injected by the bookshelf-banner add-on", driver.findElement(By.id("bookshelf-banner")).getText());
  } finally {
    driver.quit();
  }
}

def test_install_unpacked_extension_over_bidi():
    options = webdriver.ChromeOptions()
    options.add_argument("--headless=new")
    options.enable_bidi = True
    options.add_argument("--remote-debugging-pipe")
    options.add_argument("--enable-unsafe-extension-debugging")
    driver = webdriver.Chrome(options=options)
    try:
        driver.webextension.install(path=EXTENSION_DIR)

        driver.get(BASE_URL + "/books")
        assert driver.find_element(By.ID, "bookshelf-banner").text == "Injected by the bookshelf-banner add-on"
    finally:
        driver.quit()

ChromeDriver driver;

@BeforeEach
void start() {
  ChromeOptions options = new ChromeOptions();
  options.addArguments("--headless=new", "--window-size=1280,800");
  // Keep the driver's log buffers: the browser console and Chrome's performance (CDP) events.
  LoggingPreferences prefs = new LoggingPreferences();
  prefs.enable(LogType.BROWSER, Level.ALL);
  prefs.enable(LogType.PERFORMANCE, Level.ALL);
  options.setCapability(ChromeOptions.LOGGING_PREFS, prefs);
  driver = new ChromeDriver(options);
}

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

@pytest.fixture
def driver():
    options = webdriver.ChromeOptions()
    options.add_argument("--headless=new")
    options.add_argument("--window-size=1280,800")
    # Keep the driver's log buffers: the browser console and Chrome's performance (CDP) events.
    options.set_capability("goog:loggingPrefs", {"browser": "ALL", "performance": "ALL"})
    d = webdriver.Chrome(options=options)
    yield d
    d.quit()

@Test
void networkConditionsSlowTheBrowserDown() {
  ChromiumNetworkConditions slow = new ChromiumNetworkConditions();
  slow.setOffline(false);
  slow.setLatency(Duration.ofMillis(400));
  slow.setDownloadThroughput(500 * 1024 / 8); // 500 kbps
  slow.setUploadThroughput(500 * 1024 / 8);
  driver.setNetworkConditions(slow);
  assertEquals(Duration.ofMillis(400), driver.getNetworkConditions().getLatency());

  long start = System.nanoTime();
  driver.get(Env.BASE_URL + "/books");
  long slowMs = (System.nanoTime() - start) / 1_000_000;

  driver.deleteNetworkConditions();
  start = System.nanoTime();
  driver.get(Env.BASE_URL + "/books");
  long fastMs = (System.nanoTime() - start) / 1_000_000;
  System.out.printf("with latency 400 ms: %d ms, without: %d ms%n", slowMs, fastMs);
  assertTrue(slowMs > fastMs + 300);
}

@Test
void offlineMakesNavigationFail() {
  ChromiumNetworkConditions offline = new ChromiumNetworkConditions();
  offline.setOffline(true);
  offline.setLatency(Duration.ZERO);
  offline.setDownloadThroughput(-1); // -1 means no throttling
  offline.setUploadThroughput(-1);
  driver.setNetworkConditions(offline);
  WebDriverException e = assertThrows(WebDriverException.class, () -> driver.get(Env.BASE_URL + "/books"));
  System.out.println(e.getMessage().lines().findFirst().orElse(""));
  assertTrue(e.getMessage().contains("ERR_INTERNET_DISCONNECTED"));
}

def test_network_conditions_slow_the_browser_down(driver):
    driver.set_network_conditions(offline=False, latency=400, download_throughput=500 * 1024 // 8,
                                  upload_throughput=500 * 1024 // 8)
    assert driver.get_network_conditions()["latency"] == 400

    start = time.monotonic()
    driver.get(BASE_URL + "/books")
    slow_ms = round((time.monotonic() - start) * 1000)

    driver.delete_network_conditions()
    start = time.monotonic()
    driver.get(BASE_URL + "/books")
    fast_ms = round((time.monotonic() - start) * 1000)
    print(f"with latency 400 ms: {slow_ms} ms, without: {fast_ms} ms")
    assert slow_ms > fast_ms + 300


def test_offline_makes_navigation_fail(driver):
    driver.set_network_conditions(offline=True, latency=0, download_throughput=-1, upload_throughput=-1)
    with pytest.raises(WebDriverException) as error:
        driver.get(BASE_URL + "/books")
    print(error.value.msg.splitlines()[0])
    assert "ERR_INTERNET_DISCONNECTED" in error.value.msg

with latency 400 ms: 1185 ms, without: 24 ms
unknown error: net::ERR_INTERNET_DISCONNECTED

@Test
void browserConsoleAndPerformanceLogs() {
  driver.get(Env.BASE_URL + "/");
  driver.executeScript("console.error('bookshelf test message')");

  LogEntries console = driver.manage().logs().get(LogType.BROWSER);
  console.forEach(e -> System.out.println(e.getLevel() + " " + e.getMessage()));
  assertTrue(console.getAll().stream().anyMatch(e -> e.getMessage().contains("bookshelf test message")));

  LogEntries performance = driver.manage().logs().get(LogType.PERFORMANCE);
  assertFalse(performance.getAll().isEmpty());
  System.out.println("available log types: " + driver.manage().logs().getAvailableLogTypes());
}

def test_browser_console_and_performance_logs(driver):
    driver.get(BASE_URL + "/")
    driver.execute_script("console.error('bookshelf test message')")

    console = driver.get_log("browser")
    for entry in console:
        print(entry["level"], entry["message"])
    assert any("bookshelf test message" in entry["message"] for entry in console)

    assert driver.get_log("performance")
    print("available log types:", driver.log_types)

@Test
void permissions() {
  driver.get(Env.BASE_URL + "/");
  driver.setPermission("camera", "denied");
  Object state = driver.executeAsyncScript(
      "const done = arguments[arguments.length - 1];"
          + "navigator.permissions.query({name: 'camera'}).then(s => done(s.state));");
  assertEquals("denied", state);
}

def test_permissions(driver):
    driver.get(BASE_URL + "/")
    driver.set_permissions("camera", "denied")
    state = driver.execute_async_script(
        "const done = arguments[arguments.length - 1];"
        "navigator.permissions.query({name: 'camera'}).then(s => done(s.state));")
    assert state == "denied"

@Test
void castingNeedsACastDevice() {
  List<Map<String, String>> sinks = driver.getCastSinks();
  System.out.println("cast sinks: " + sinks);
  if (!sinks.isEmpty()) {
    String name = sinks.get(0).get("name");
    driver.startTabMirroring(name);
    driver.stopCasting(name);
  }
}

def test_casting_needs_a_cast_device(driver):
    sinks = driver.get_sinks()
    print("cast sinks:", sinks)
    if sinks:
        name = sinks[0]["name"]
        driver.start_tab_mirroring(name)
        driver.stop_casting(name)

private WebDriver start() {
  FirefoxOptions options = new FirefoxOptions();
  options.addArguments("-headless");
  options.addPreference("intl.accept_languages", "en-US");
  return RemoteWebDriver.builder().address(Env.url(Env.FIREFOX_GRID)).oneOf(options).build();
}

@Test
void headlessFirefox() {
  driver = start();
  driver.get(Env.BASE_URL_FROM_DOCKER + "/books");
  var caps = ((RemoteWebDriver) driver).getCapabilities();
  System.out.println(caps.getBrowserName() + " " + caps.getBrowserVersion());
  assertEquals("firefox", caps.getBrowserName());
  assertEquals("Catalogue - Bookshelf", driver.getTitle());
}

def test_headless_firefox_in_a_container():
    options = webdriver.FirefoxOptions()
    options.add_argument("-headless")
    options.set_preference("intl.accept_languages", "en-US")
    driver = webdriver.Remote(command_executor=FIREFOX_GRID, options=options)
    try:
        driver.get(BASE_URL_FROM_DOCKER + "/books")
        caps = driver.capabilities
        print(caps["browserName"], caps["browserVersion"])
        assert caps["browserName"] == "firefox"
        assert driver.title == "Catalogue - Bookshelf"
    finally:
        driver.quit()

@Test
void temporaryUnsignedAddon() {
  driver = start();
  Path dir = Path.of("src/test/resources/extensions/bookshelf-banner");
  String id = ((HasExtensions) driver).installExtension(dir, true);
  System.out.println("add-on id: " + id);

  driver.get(Env.BASE_URL_FROM_DOCKER + "/books");
  String text = new WebDriverWait(driver, Duration.ofSeconds(10))
      .until(d -> d.findElement(By.id("bookshelf-banner"))).getText();
  assertEquals("Injected by the bookshelf-banner add-on", text);

  ((HasExtensions) driver).uninstallExtension(id);
  driver.navigate().refresh();
  assertTrue(driver.findElements(By.id("bookshelf-banner")).isEmpty());
}

driver = webdriver.Firefox(options=options)
addon_id = driver.install_addon("/path/to/bookshelf-banner", temporary=True)
driver.get(f"{BASE_URL}/books")
assert driver.find_element(By.ID, "bookshelf-banner").text == "Injected by the bookshelf-banner add-on"
driver.uninstall_addon(addon_id)

@Test
void fullPageScreenshot() throws Exception {
  driver = start();
  driver.get(Env.BASE_URL_FROM_DOCKER + "/books");
  byte[] png = ((HasFullPageScreenshot) driver).getFullPageScreenshotAs(OutputType.BYTES);
  Path out = Files.createTempFile("full-page-", ".png");
  Files.write(out, png);
  System.out.println("full page screenshot: " + png.length + " bytes");
  assertTrue(png.length > 1000);
}

@Test
void contentContextIsTheDefaultAndChromeNeedsSystemAccess() {
  driver = start();
  HasContext withContext = (HasContext) driver;
  assertEquals(FirefoxCommandContext.CONTENT, withContext.getContext());

  // Firefox 138+ refuses the CHROME context unless geckodriver was started with --allow-system-access.
  var e = assertThrows(Exception.class, () -> withContext.setContext(FirefoxCommandContext.CHROME));
  System.out.println(e.getClass().getSimpleName() + ": " + e.getMessage().lines().findFirst().orElse(""));
}

UnsupportedCommandException: System access is required. Start Firefox with "-remote-allow-system-access" to enable it.

SafariOptions options = new SafariOptions();
options.setUseTechnologyPreview(true);
WebDriver driver = new SafariDriver(options);

options = webdriver.SafariOptions()
options.use_technology_preview = True
service = webdriver.SafariService(
    executable_path="/Applications/Safari Technology Preview.app/Contents/MacOS/safaridriver")
driver = webdriver.Safari(options=options, service=service)

InternetExplorerOptions options = new InternetExplorerOptions();
options.attachToEdgeChrome();
options.withEdgeExecutablePath(System.getenv("EDGE_BIN"));
WebDriver driver = new InternetExplorerDriver(options);

options = webdriver.IeOptions()
options.attach_to_edge_chrome = True
options.edge_executable_path = os.environ["EDGE_BIN"]
driver = webdriver.Ie(options=options)

var options = new InternetExplorerOptions();   // Windows 11: nothing else is needed
var driver = new InternetExplorerDriver(options);