@eyeo/get-browser-binary 0.4.0 → 0.6.0

package/.eslintrc.json

@@ -5,7 +5,8 @@
   "root": true,
   "env": {
     "es2022": true,
-    "node": true
+    "node": true,
+    "browser": true
   },
   "rules": {
     "brace-style": ["error", "stroustrup"],

package/.gitlab-ci.yml

@@ -1,5 +1,5 @@
 default:
-  image: node:16-bullseye-slim
+  image: registry.gitlab.com/eyeo/docker/get-browser-binary:node16
   interruptible: true
 
 stages:
@@ -37,7 +37,7 @@ test:browsers:linux:
   before_script:
     - docker build -f test/docker/Dockerfile -t browsers .
   script:
-    - docker run browsers
+    - docker run --shm-size=256m browsers
 
 test:browsers:windows:
   stage: test
@@ -51,17 +51,14 @@ test:browsers:windows:
     - Start-Process msiexec
         -ArgumentList "/i MicrosoftEdgeEnterpriseX64.msi /norestart /qn" -Wait
     - choco upgrade -y nodejs --version 16.10.0
-    - npm install -g npm
     - npm install
   script:
-    # Running only a subset of Firefox and Opera tests to avoid low OS resources error
+    # Running only a subset of Firefox tests to avoid low OS resources error
     # https://gitlab.com/eyeo/developer-experience/get-browser-binary/-/issues/2
-    # Regarding grep, running npm v8 on powershell has issues when the grep
-    # value contains the pipe (|) literal. Storing that string as a verbatim
-    # string (single quotes) and then sorrounding it with four double quotes
-    # does the trick.
-    - $subset_tests = '(firefox|opera).*latest.*downloads'
-    - npm test -- --grep """"$subset_tests""""
+    - npm test -- --grep "firefox.*latest.*downloads"
+    # Running npm v8 on powershell has issues when the grep value contains the
+    # pipe (|) literal. Storing that string as a verbatim string (single quotes)
+    # and then sorrounding it with four double quotes does the trick.
     - $full_tests = '(chromium|edge.*latest)'
     - npm test -- --grep """"$full_tests""""
   tags:

package/README.md

@@ -1,12 +1,7 @@
 # get-browser-binary
 
-Download specific browser versions for Chromium, Firefox, Edge and Opera, and
-their matching [selenium webdriver](https://www.selenium.dev/selenium/docs/api/javascript/index.html).
-
-Note: Edge download is only supported on Linux. On other platforms it is assumed
-to be already installed.
-
-Note: Using the `operadriver` on Windows is not supported.
+Download specific browser versions for Chromium, Firefox and Edge, and their
+matching [selenium webdriver](https://www.selenium.dev/selenium/docs/api/javascript/index.html).
 
 ## Getting started
 
@@ -17,12 +12,10 @@ selenium webdriver:
 import {BROWSERS} from "@eyeo/get-browser-binary";
 
 (async function example() {
-  let {chromium} = BROWSERS;
-
-  let {binary} = await chromium.downloadBinary();
+  let {binary} = await BROWSERS.chromium.downloadBinary("latest");
   console.log(`Chromium binary downloaded to ${binary}`);
 
-  let driver = await chromium.getDriver();
+  let driver = await BROWSERS.chromium.getDriver("latest");
   await driver.navigate().to("https://example.com/");
   await driver.quit();
 })();
@@ -35,6 +28,15 @@ For more information, please refer to the [API documention](https://gitlab.com/e
 If you are already on the documentation page, you may find the API contents on
 the right side.
 
+### Supported browser versions
+
+- Chromium >= 75
+- Firefox >= 60
+- Edge >= 95
+
+Note: Edge download is not supported on Windows. It is assumed to be installed
+because it is the default browser on that platform.
+
 ## Development
 
 ### Prerequisites
@@ -79,18 +81,15 @@ Useful to reproduce the CI environment of the `test:browsers:linux` job:
 
 ```shell
 docker build -f test/docker/Dockerfile -t browsers .
-docker run -it browsers
+docker run --shm-size=256m -it browsers
 ```
 
 The `grep` option can also be used on Docker via the `TEST_ARGS` parameter:
 
 ```shell
-docker run -e TEST_ARGS="--grep chromium.*latest" -it browsers
+docker run --shm-size=256m -e TEST_ARGS="--grep chromium.*latest" -it browsers
 ```
 
-Note: For a full automated run, `opera` tests should not use the interactive
-tty `-it` flag.
-
 ## Building the documentation
 
 ```shell

package/RELEASE_NOTES.md

@@ -1,3 +1,18 @@
+# 0.6.0
+
+- Removes Opera support (#26)
+- Improves error handling when the downloaded browser version doesn't match
+known channels (#25)
+- Fixes an Edge running issue on Windows (32-bit) (#23)
+
+# 0.5.0
+
+- Enables Edge binary downloads on MacOS (!25)
+- Sets unsupported browser versions (#16)
+- Fixes the Edge repo url (!27)
+- Fixes an issue when downloading Opera (#21)
+- Fixes redundant Opera installations on Linux (!24)
+
 # 0.4.0
 
 - Adds Opera as a supported browser (#7)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eyeo/get-browser-binary",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Download browser binaries and matching webdrivers",
   "repository": {
     "type": "git",
@@ -18,11 +18,9 @@
     "chromedriver": "^90.0.1",
     "dmg": "^0.1.0",
     "extract-zip": "^2.0.1",
-    "fs-extra": "^10.0.0",
     "geckodriver": "^3.0.2",
     "got": "^11.8.2",
-    "msedgedriver": "^91.0.0",
-    "selenium-webdriver": "^4.2.0"
+    "selenium-webdriver": "^4.6.1"
   },
   "devDependencies": {
     "eslint": "^8.17.0",

package/src/browsers.js

@@ -16,15 +16,15 @@
  */
 
 import path from "path";
-import {exec, execFile, spawn} from "child_process";
+import {exec, execFile} from "child_process";
 import {promisify} from "util";
 import fs from "fs";
-import fsExtra from "fs-extra";
 
 import got from "got";
 import webdriver from "selenium-webdriver";
 import chrome from "selenium-webdriver/chrome.js";
 import firefox from "selenium-webdriver/firefox.js";
+import edge from "selenium-webdriver/edge.js";
 import command from "selenium-webdriver/lib/command.js";
 import extractZip from "extract-zip";
 
@@ -38,10 +38,17 @@ import {download, extractTar, extractDmg, getBrowserVersion, killDriverProcess,
 export let snapshotsBaseDir = path.join(process.cwd(), "browser-snapshots");
 
 let {until, By} = webdriver;
-const ERROR_DOWNLOAD_NOT_SUPPORTED =
-  "Downloading this browser is not supported";
 let platform = `${process.platform}-${process.arch}`;
 
+function checkVersion(version, minVersion, channels) {
+  if (channels.includes(version))
+    return;
+
+  let mainVersion = parseInt(version && version.split(".")[0], 10);
+  if (isNaN(mainVersion) || mainVersion < minVersion)
+    throw new Error(`Unsupported browser version: ${version}`);
+}
+
 /**
  * Base class for browser download functionality. Please see subclasses for
  * browser specific details.
@@ -60,9 +67,10 @@ class Browser {
    * @param {string} version - Either full version number or channel/release.
    *   Please find examples on the subclasses.
    * @return {BrowserBinary}
+   * @throws {Error} Unsupported browser version.
    */
   static async downloadBinary(version) {
-    throw new Error(ERROR_DOWNLOAD_NOT_SUPPORTED);
+    // to be implemented by the subclass
   }
 
   /**
@@ -81,7 +89,7 @@ class Browser {
     else {
       ({stdout} = await promisify(execFile)(binary, ["--version"]));
     }
-    return stdout;
+    return stdout.trim();
   }
 
   /**
@@ -107,11 +115,10 @@ class Browser {
    * Installs the webdriver matching the browser version and runs the
    * browser. If needed, the browser binary is also installed.
    * @param {string} version - Either full version number or channel/release.
-   *   Please find examples on the subclasses. On Edge this parameter has
-   *   no effect.
+   *   Please find examples on the subclasses.
    * @param {driverOptions?} options - Options to start the browser with.
    * @return {webdriver}
-   * @throws {Error} Unsupported webdriver version.
+   * @throws {Error} Unsupported browser version.
    */
   static async getDriver(version, options = {}) {
     // to be implemented by the subclass
@@ -123,6 +130,7 @@ class Browser {
    * @param {webdriver} driver - The driver controlling the browser.
    * @param {string} extensionTitle - Title of the extebsion to be enabled.
    * @return {webdriver}
+   * @throws {Error} Unsupported browser version.
    */
   static async enableExtensionInIncognito(driver, extensionTitle) {
     // Allowing the extension in incognito mode can't happen programmatically:
@@ -145,28 +153,30 @@ class Chromium extends Browser {
     return data.chromium_base_position;
   }
 
-  static async #getLatestVersion(channel = "stable") {
-    let os = process.platform;
-    if (os == "win32")
-      os = process.arch == "x64" ? "win64" : "win";
-    else if (os == "darwin")
-      os = process.arch == "arm64" ? "mac_arm64" : "mac";
+  static async #getVersionForChannel(channel) {
+    if (channel == "latest")
+      channel = "stable";
 
+    let os = {
+      "win32-ia32": "win",
+      "win32-x64": "win64",
+      "linux-x64": "linux",
+      "darwin-x64": "mac",
+      "dawrin-arm64": "mac_arm64"
+    }[platform];
     let data = await got(`https://omahaproxy.appspot.com/all.json?os=${os}`).json();
     let release = data[0].versions.find(ver => ver.channel == channel);
-    let {current_version: version, branch_base_position: base} = release;
+    let {current_version: version} = release;
 
-    if (release.true_branch && release.true_branch.includes("_")) {
+    if (release.true_branch && release.true_branch.includes("_"))
       // A wrong base may be caused by a mini-branch (patched) release
       // In that case, the base is taken from the unpatched version
       version = [...version.split(".").slice(0, 3), "0"].join(".");
-      base = await Chromium.#getBranchBasePosition(version);
-    }
 
-    return {version, base};
+    return version;
   }
 
-  static #getChromiumBinary(dir) {
+  static #getBinaryPath(dir) {
     switch (process.platform) {
       case "win32":
         return path.join(dir, "chrome-win", "chrome.exe");
@@ -201,7 +211,7 @@ class Chromium extends Browser {
 
       try {
         await fs.promises.access(browserDir);
-        return {binary: Chromium.#getChromiumBinary(browserDir), revision};
+        return {binary: Chromium.#getBinaryPath(browserDir), revision};
       }
       catch (e) {}
 
@@ -230,7 +240,7 @@ class Chromium extends Browser {
     }
 
     await extractZip(archive, {dir: browserDir});
-    return {binary: Chromium.#getChromiumBinary(browserDir), revision};
+    return {binary: Chromium.#getBinaryPath(browserDir), revision};
   }
 
   /**
@@ -239,15 +249,19 @@ class Chromium extends Browser {
    *   number (i.e. "77.0.3865.0"). Defaults to "latest".
    * @return {BrowserBinary}
    */
-  static async downloadBinary(version) {
-    let base;
-    if (version && !(version == "beta" || version == "dev"))
-      base = await Chromium.#getBranchBasePosition(version);
-    else
-      ({version, base} = await Chromium.#getLatestVersion(version));
+  static async downloadBinary(version = "latest") {
+    const MIN_VERSION = 75;
+    const CHANNELS = ["latest", "beta", "dev"];
+
+    checkVersion(version, MIN_VERSION, CHANNELS);
+
+    let versionNumber = CHANNELS.includes(version) ?
+      await Chromium.#getVersionForChannel(version) : version;
+
+    let base = await Chromium.#getBranchBasePosition(versionNumber);
 
     let {binary, revision} = await Chromium.#downloadChromium(base);
-    return {binary, versionNumber: version, revision};
+    return {binary, versionNumber, revision};
   }
 
   static async #installDriver(revision, version) {
@@ -274,9 +288,10 @@ class Chromium extends Browser {
   }
 
   /** @see Browser.getDriver */
-  static async getDriver(version, {headless = true, extensionPaths = [],
-                                   incognito = false, insecure = false,
-                                   extraArgs = []} = {}) {
+  static async getDriver(version = "latest", {
+    headless = true, extensionPaths = [], incognito = false, insecure = false,
+    extraArgs = []
+  } = {}) {
     let {binary, revision, versionNumber} =
       await Chromium.downloadBinary(version);
     await Chromium.#installDriver(revision, versionNumber);
@@ -301,14 +316,8 @@ class Chromium extends Browser {
 
   /** @see Browser.enableExtensionInIncognito */
   static async enableExtensionInIncognito(driver, extensionTitle) {
-    let version = await getBrowserVersion(driver);
-    // Webdriver capabilities don't include a browser version for Opera
-    if (version && version < 75)
-      // The UI workaround needs a chromedriver >= 75
-      throw new Error(`Only supported on Chromium >= 75. Current version: ${version}`);
-
     await driver.navigate().to("chrome://extensions");
-    await driver.executeScript(`
+    await driver.executeScript((...args) => {
       let enable = () => document.querySelector("extensions-manager").shadowRoot
         .querySelector("extensions-detail-view").shadowRoot
         .getElementById("allow-incognito").shadowRoot
@@ -321,7 +330,7 @@ class Chromium extends Browser {
       return new Promise((resolve, reject) => {
         let extensionDetails;
         for (let {shadowRoot} of extensions) {
-          if (shadowRoot.getElementById("name").innerHTML != arguments[0])
+          if (shadowRoot.getElementById("name").innerHTML != args[0])
             continue;
 
           extensionDetails = shadowRoot.getElementById("detailsButton");
@@ -332,7 +341,8 @@ class Chromium extends Browser {
 
         extensionDetails.click();
         setTimeout(() => resolve(enable()), 100);
-      });`, extensionTitle);
+      });
+    }, extensionTitle);
   }
 }
 
@@ -342,13 +352,13 @@ class Chromium extends Browser {
  * @extends Browser
  */
 class Firefox extends Browser {
-  static async #getLatestVersion(branch) {
+  static async #getVersionForChannel(branch) {
     let data = await got("https://product-details.mozilla.org/1.0/firefox_versions.json").json();
     return branch == "beta" ?
       data.LATEST_FIREFOX_DEVEL_VERSION : data.LATEST_FIREFOX_VERSION;
   }
 
-  static #getFirefoxBinary(dir) {
+  static #getBinaryPath(dir) {
     switch (process.platform) {
       case "win32":
         return path.join(dir, "core", "firefox.exe");
@@ -391,7 +401,7 @@ class Firefox extends Browser {
 
     try {
       await fs.promises.access(browserDir);
-      return Firefox.#getFirefoxBinary(browserDir);
+      return Firefox.#getBinaryPath(browserDir);
     }
     catch (e) {}
 
@@ -405,7 +415,7 @@ class Firefox extends Browser {
     }
 
     await Firefox.#extractFirefoxArchive(archive, browserDir);
-    return Firefox.#getFirefoxBinary(browserDir);
+    return Firefox.#getBinaryPath(browserDir);
   }
 
   /**
@@ -414,18 +424,24 @@ class Firefox extends Browser {
    *   number (i.e. "68.0"). Defaults to "latest".
    * @return {BrowserBinary}
    */
-  static async downloadBinary(version) {
-    if (!version || version == "beta")
-      version = await Firefox.#getLatestVersion(version);
+  static async downloadBinary(version = "latest") {
+    const MIN_VERSION = 60;
+    const CHANNELS = ["latest", "beta"];
+
+    checkVersion(version, MIN_VERSION, CHANNELS);
 
-    let binary = await Firefox.#downloadFirefox(version);
-    return {binary, versionNumber: version};
+    let versionNumber = CHANNELS.includes(version) ?
+      await Firefox.#getVersionForChannel(version) : version;
+
+    let binary = await Firefox.#downloadFirefox(versionNumber);
+    return {binary, versionNumber};
   }
 
   /** @see Browser.getDriver */
-  static async getDriver(version, {headless = true, extensionPaths = [],
-                                   incognito = false, insecure = false,
-                                   extraArgs = []} = {}) {
+  static async getDriver(version = "latest", {
+    headless = true, extensionPaths = [], incognito = false, insecure = false,
+    extraArgs = []
+  } = {}) {
     let {binary} = await Firefox.downloadBinary(version);
 
     let options = new firefox.Options();
@@ -502,7 +518,7 @@ class Edge extends Browser {
       return {versionNumber: version, channel: "stable"};
 
     let channel = version == "latest" ? "stable" : version;
-    let {body} = await got(`https://packages.microsoft.com/repos/edge/pool/main/m/microsoft-edge-${channel}`);
+    let {body} = await got(`https://packages.microsoft.com/repos/edge/pool/main/m/microsoft-edge-${channel}/`);
     let regex = /href="microsoft-edge-(stable|beta|dev)_(.*?)-1_/gm;
     let matches;
     let versionNumbers = [];
@@ -516,6 +532,29 @@ class Edge extends Browser {
     return {versionNumber, channel};
   }
 
+  static #getDarwinAppName(channel) {
+    let extra = channel == "stable" ?
+      "" : " " + channel.charAt(0).toUpperCase() + channel.slice(1);
+    return `Microsoft Edge${extra}`;
+  }
+
+  static #getBinaryPath(channel = "stable") {
+    switch (process.platform) {
+      case "win32":
+        let programFiles = process.env["ProgramFiles(x86)"] ?
+          "${Env:ProgramFiles(x86)}" : "${Env:ProgramFiles}";
+        return `${programFiles}\\Microsoft\\Edge\\Application\\msedge.exe`;
+      case "linux":
+        return channel == "stable" ?
+          "microsoft-edge" : `microsoft-edge-${channel}`;
+      case "darwin":
+        let appName = Edge.#getDarwinAppName(channel);
+        return `${process.env.HOME}/Applications/${appName}.app/Contents/MacOS/${appName}`;
+      default:
+        throw new Error(`Unexpected platform: ${process.platform}`);
+    }
+  }
+
   /**
    * Downloads the browser binary file.
    * @param {string} version - Either "latest", "beta", "dev" or a full version
@@ -524,20 +563,36 @@ class Edge extends Browser {
    * @return {BrowserBinary}
    */
   static async downloadBinary(version = "latest") {
-    if (process.platform != "linux")
-      throw new Error("Edge download is only supported on Linux");
-
+    if (process.platform == "win32")
+      // Edge is mandatory on Windows, can't be uninstalled or downgraded
+      // https://support.microsoft.com/en-us/microsoft-edge/why-can-t-i-uninstall-microsoft-edge-ee150b3b-7d7a-9984-6d83-eb36683d526d
+      throw new Error("Edge download is not supported in Windows");
+
+    const MIN_VERSION = 95;
+    const CHANNELS = ["latest", "beta", "dev"];
+    checkVersion(version, MIN_VERSION, CHANNELS);
     let {versionNumber, channel} = await Edge.#getVersionForChannel(version);
 
-    let snapshotsDir = path.join(snapshotsBaseDir, "edge");
-    let filename = `microsoft-edge-${channel}_${versionNumber}-1_amd64.deb`;
-    let archive = path.join(snapshotsDir, "cache", filename);
-    let binary = {
-      stable: "microsoft-edge",
-      beta: "microsoft-edge-beta",
-      dev: "microsoft-edge-dev"
+    let darwinName = {
+      stable: "MicrosoftEdge",
+      beta: "MicrosoftEdgeBeta",
+      dev: "MicrosoftEdgeDev"
     }[channel];
+    let filename = {
+      linux: `microsoft-edge-${channel}_${versionNumber}-1_amd64.deb`,
+      darwin: `${darwinName}-${versionNumber}.pkg`
+    }[process.platform];
+    let darwinArch = process.arch == "arm64" ?
+      "03adf619-38c6-4249-95ff-4a01c0ffc962" :
+      "C1297A47-86C4-4C1F-97FA-950631F94777";
+    let downloadUrl = {
+      linux: `https://packages.microsoft.com/repos/edge/pool/main/m/microsoft-edge-${channel}/${filename}`,
+      darwin: `https://officecdnmac.microsoft.com/pr/${darwinArch}/MacAutoupdate/${filename}`
+    }[process.platform];
 
+    let snapshotsDir = path.join(snapshotsBaseDir, "edge");
+    let archive = path.join(snapshotsDir, "cache", filename);
+    let binary = Edge.#getBinaryPath(channel);
     try {
       if (await Edge.#getInstalledVersionNumber(binary) == versionNumber)
         return {binary, versionNumber};
@@ -545,34 +600,38 @@ class Edge extends Browser {
     catch (e) {}
 
     try {
-      await download(
-        `https://packages.microsoft.com/repos/edge/pool/main/m/microsoft-edge-${channel}/${filename}`,
-        archive
-      );
+      await download(downloadUrl, archive);
     }
     catch (err) {
-      throw new Error(`Edge download failed: ${err}`);
+      throw new Error(`Edge download failed at ${downloadUrl}\n${err}`);
+    }
+
+    if (process.platform == "linux") {
+      await promisify(exec)(`dpkg -i ${archive}`);
+    }
+    else if (process.platform == "darwin") {
+      let appName = Edge.#getDarwinAppName(channel);
+      try {
+        await fs.promises.rm(`${process.env.HOME}/Applications/${appName}.app`, {recursive: true});
+      }
+      catch (e) {}
+      await promisify(exec)(`installer -pkg ${archive} -target CurrentUserHomeDirectory`);
     }
-    await promisify(exec)(`dpkg -i ${archive}`);
 
     return {binary, versionNumber};
   }
 
   static async #getInstalledVersionNumber(binary) {
     let installedVersion = await Edge.getInstalledVersion(binary);
-    return installedVersion.replace("beta", "").replace("dev", "")
-      .trim().replace(/.*\s/, "");
+    for (let word of ["beta", "dev", "Beta", "Dev"])
+      installedVersion = installedVersion.replace(word, "");
+    return installedVersion.trim().replace(/.*\s/, "");
   }
 
   static async #installDriver() {
-    let binary = {
-      win32:
-        "${Env:ProgramFiles(x86)}\\Microsoft\\Edge\\Application\\msedge.exe",
-      darwin: "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
-      linux: "microsoft-edge"
-    }[process.platform];
-    let version = await Edge.#getInstalledVersionNumber(binary);
-    if (!version)
+    let binary = Edge.#getBinaryPath();
+    let versionNumber = await Edge.#getInstalledVersionNumber(binary);
+    if (!versionNumber)
       throw new Error("Edge is not installed");
 
     let [zip, driver] = {
@@ -582,14 +641,11 @@ class Edge extends Browser {
       "darwin-x64": ["edgedriver_mac64.zip", "msedgedriver"],
       "darwin-arm64": ["edgedriver_arm64.zip", "msedgedriver"]
     }[platform];
-    let cacheDir = path.join(snapshotsBaseDir, "edge", "cache");
-    let driverBinDir = path.join(process.cwd(), "node_modules", Edge.#DRIVER,
-                                 "bin");
-    let driverLibDir = path.join(process.cwd(), "node_modules", Edge.#DRIVER,
-                                 "lib", Edge.#DRIVER);
-    let archive = path.join(cacheDir, `${version}-${zip}`);
-
-    let vSplit = version.split(".");
+    let cacheDir = path.join(snapshotsBaseDir, "edge", "cache",
+                             `edgedriver-${versionNumber}`);
+    let archive = path.join(cacheDir, `${versionNumber}-${zip}`);
+
+    let vSplit = versionNumber.split(".");
     let lastNum = parseInt(vSplit[3], 10);
     while (lastNum >= 0) {
       try {
@@ -604,53 +660,50 @@ class Edge extends Browser {
     }
 
     if (lastNum < 0)
-      throw new Error(`msedgedriver was not found for Edge ${version}`);
+      throw new Error(`msedgedriver was not found for Edge ${versionNumber}`);
 
-    await extractZip(archive, {dir: cacheDir});
     await killDriverProcess(Edge.#DRIVER);
-    for (let destinationDir of [driverBinDir, driverLibDir]) {
-      await fs.promises.mkdir(destinationDir, {recursive: true});
-      await fs.promises.copyFile(path.join(cacheDir, driver),
-                                 path.join(destinationDir, driver));
+    let driverPath = path.join(cacheDir, driver);
+    try {
+      await fs.promises.rm(driverPath, {recursive: true});
     }
+    catch (e) {} // file does not exist
+    await extractZip(archive, {dir: cacheDir});
+
+    return driverPath;
   }
 
   /** @see Browser.getDriver */
-  static async getDriver(version, {headless = true, extensionPaths = [],
-                                   incognito = false, insecure = false,
-                                   extraArgs = []} = {}) {
-    if (process.platform == "linux")
+  static async getDriver(version = "latest", {
+    headless = true, extensionPaths = [], incognito = false, insecure = false,
+    extraArgs = []
+  } = {}) {
+    if (process.platform == "linux" || process.platform == "darwin")
       await Edge.downloadBinary(version);
 
-    await Edge.#installDriver();
+    let driverPath = await Edge.#installDriver();
+    let serviceBuilder = new edge.ServiceBuilder(driverPath);
 
-    let args = ["no-sandbox", ...extraArgs];
+    let options = new edge.Options().addArguments("no-sandbox", ...extraArgs);
     if (headless)
-      args.push("headless");
+      options.headless();
     if (extensionPaths.length > 0)
-      args.push(`load-extension=${extensionPaths.join(",")}`);
+      options.addArguments(`load-extension=${extensionPaths.join(",")}`);
     if (incognito)
-      args.push("incognito");
+      options.addArguments("incognito");
+    if (insecure)
+      options.addArguments("ignore-certificate-errors");
 
     let builder = new webdriver.Builder();
     builder.forBrowser("MicrosoftEdge");
-    builder.withCapabilities({
-      "browserName": "MicrosoftEdge",
-      "ms:edgeChromium": true,
-      "ms:edgeOptions": {args},
-      "acceptInsecureCerts": insecure
-    });
+    builder.setEdgeOptions(options);
+    builder.setEdgeService(serviceBuilder);
 
     return builder.build();
   }
 
   /** @see Browser.enableExtensionInIncognito */
   static async enableExtensionInIncognito(driver, extensionTitle) {
-    let version = await getBrowserVersion(driver);
-    if (version < 79)
-      // The UI workaround needs a chromium based msedgedriver
-      throw new Error(`Only supported on Edge >= 79. Current version: ${version}`);
-
     await driver.navigate().to("edge://extensions/");
     for (let elem of await driver.findElements(By.css("[role=listitem]"))) {
       let text = await elem.getAttribute("innerHTML");
@@ -671,218 +724,6 @@ class Edge extends Browser {
   }
 }
 
-/**
- * Download functionality for Opera. This class can be used statically.
- * @hideconstructor
- * @extends Browser
- */
-class Opera extends Browser {
-  static async #getVersionForChannel(version) {
-    let channelPath = "opera/desktop";
-    let filePrefix = "Opera";
-    if (version != "latest")
-      return {versionNumber: version, channelPath, filePrefix};
-
-    let {body} = await got(`https://ftp.opera.com/pub/${channelPath}`);
-    let regex = /href="(\d.*)\/"/gm;
-    let matches = body.match(regex);
-    let versionNumber = regex.exec(matches[matches.length - 1])[1];
-
-    return {versionNumber, channelPath, filePrefix};
-  }
-
-  static #getOperaBinary(dir) {
-    switch (process.platform) {
-      case "win32":
-        return path.join(dir, "launcher.exe");
-      case "linux":
-        return path.join("/", "usr", "bin", "opera");
-      case "darwin":
-        return path.join(dir, "Opera.app", "Contents", "MacOS", "Opera");
-      default:
-        throw new Error(`Unexpected platform: ${process.platform}`);
-    }
-  }
-
-  static async #extractDeb(archive) {
-    let child = spawn("dpkg", ["-i", archive]);
-
-    child.stdout.on("data", data => {
-      if (data.toString().startsWith("Do you want to update Opera")) {
-        process.stdin.pipe(child.stdin);
-        child.stdin.write("no\r\n");
-      }
-    });
-
-    child.stderr.on("data", data => {
-      let expectedWarnings = [
-        "debconf: unable to initialize frontend",
-        "dpkg: warning: downgrading opera-stable",
-        "update-alternatives",
-        "using /usr/bin/opera",
-        "skip creation of",
-        "\r\n"
-      ];
-      if (!expectedWarnings.find(err => data.toString().includes(err.trim())))
-        console.error(`stderr: ${data.toString()}`);
-    });
-
-    await new Promise((resolve, reject) => child.on("close", code => {
-      if (code != 0)
-        reject(`dpkg process exited with code ${code}`);
-
-      resolve();
-    }));
-  }
-
-  static async #installOnWindows(archive, dir, filename) {
-    let archiveCopy = path.join(dir, filename);
-    await fsExtra.copy(archive, archiveCopy);
-    await promisify(exec)(`"${archiveCopy}"`);
-  }
-
-  static #extractOperaArchive(archive, dir, filename) {
-    switch (process.platform) {
-      case "win32":
-        return Opera.#installOnWindows(archive, dir, filename);
-      case "linux":
-        return Opera.#extractDeb(archive, dir);
-      case "darwin":
-        return extractTar(archive, dir);
-      default:
-        throw new Error(`Unexpected platform: ${process.platform}`);
-    }
-  }
-
-  /**
-   * Downloads the browser binary file.
-   * @param {string} version - Either "latest" or a full version number
-   *   (i.e. "64.0.3417.92"). Defaults to "latest".
-   * @return {BrowserBinary}
-   */
-  static async downloadBinary(version = "latest") {
-    let {versionNumber, channelPath, filePrefix} =
-      await Opera.#getVersionForChannel(version);
-
-    let [platformDir, fileSuffix] = {
-      "win32-ia32": ["win", "Autoupdate.exe"],
-      "win32-x64": ["win", "Autoupdate_x64.exe"],
-      "linux-x64": ["linux", "amd64.deb"],
-      "darwin-x64": ["mac", "Autoupdate.tar.xz"],
-      "dawrin-arm64": ["mac", "Autoupdate_arm64.tar.xz"]
-    }[platform];
-
-    let snapshotsDir = path.join(snapshotsBaseDir, "opera");
-    let browserDir = path.join(snapshotsDir, `opera-${platform}-${versionNumber}`);
-    let filename = `${filePrefix}_${versionNumber}_${fileSuffix}`;
-    let archive = path.join(snapshotsDir, "cache", filename);
-
-    let binary = Opera.#getOperaBinary(browserDir);
-    try {
-      await fs.promises.access(browserDir);
-      return {binary, versionNumber};
-    }
-    catch (e) {}
-
-    await fs.promises.mkdir(path.dirname(browserDir), {recursive: true});
-    try {
-      await fs.promises.access(archive);
-    }
-    catch (e) {
-      await download(
-        `https://ftp.opera.com/pub/${channelPath}/${versionNumber}/${platformDir}/${filename}`,
-        archive
-      );
-    }
-
-    await Opera.#extractOperaArchive(archive, browserDir, filename);
-    return {binary, versionNumber};
-  }
-
-  static async #installDriver(version, originalVersion) {
-    let [zip, driver] = {
-      "win32-ia32": ["operadriver_win32.zip", "operadriver.exe"],
-      "win32-x64": ["operadriver_win64.zip", "operadriver.exe"],
-      "linux-x64": ["operadriver_linux64.zip", "operadriver"],
-      "darwin-x64": ["operadriver_mac64.zip", "operadriver"],
-      "darwin-arm64": ["operadriver_mac64.zip", "operadriver"]
-    }[platform];
-
-    let {versionNumber} = await Opera.#getVersionForChannel(version);
-    versionNumber = versionNumber.split(".")[0];
-
-    let cacheDir = path.join(snapshotsBaseDir, "opera", "cache",
-                             `driver-for-opera-${versionNumber}`);
-    let archive = path.join(cacheDir, zip);
-
-    let {body} = await got(`https://github.com/operasoftware/operachromiumdriver/releases?q=Opera+${versionNumber}&expanded=true`);
-    let regex = /release-card[\s\S]*Link--primary.*>(.*)<\/a/gm;
-    let matches = body.match(regex);
-    if (!matches || matches.length == 0)
-      throw new Error(`Driver for Opera ${version} was not found`);
-    let driverVersion = regex.exec(matches[matches.length - 1])[1];
-
-    try {
-      await download(`https://github.com/operasoftware/operachromiumdriver/releases/download/v.${driverVersion}/${zip}`,
-                     archive);
-    }
-    catch (err) {
-      throw new Error(`Downloading operadriver failed: ${err}`);
-    }
-
-    await killDriverProcess("operadriver");
-    let driverPath = path.join(cacheDir, zip.split(".")[0], driver);
-    try {
-      await fs.promises.rm(driverPath, {recursive: true});
-    }
-    catch (e) {} // file does not exist
-    await extractZip(archive, {dir: cacheDir});
-    await fs.promises.chmod(driverPath, 577);
-
-    return driverPath;
-  }
-
-  /** @see Browser.getDriver */
-  static async getDriver(version = "latest", {
-    headless = true, extensionPaths = [], incognito = false, insecure = false,
-    extraArgs = []
-  } = {}) {
-    let {binary, versionNumber} = await Opera.downloadBinary(version);
-    let driverPath = await Opera.#installDriver(versionNumber, version);
-    // operadriver uses chrome as a service builder:
-    // https://github.com/operasoftware/operachromiumdriver/blob/master/docs/desktop.md
-    let serviceBuilder = new chrome.ServiceBuilder(driverPath);
-    let service = serviceBuilder.build();
-    await service.start();
-
-    let options = new chrome.Options().addArguments("no-sandbox", ...extraArgs);
-    if (extensionPaths.length > 0)
-      options.addArguments(`load-extension=${extensionPaths.join(",")}`);
-    if (headless)
-      options.headless();
-    if (insecure)
-      options.addArguments("ignore-certificate-errors");
-    if (incognito)
-      options.addArguments("incognito");
-    options.setChromeBinaryPath(binary);
-    // https://github.com/operasoftware/operachromiumdriver/issues/61#issuecomment-579331657
-    options.addArguments("remote-debugging-port=9222");
-
-    let builder = new webdriver.Builder();
-    builder.forBrowser("chrome");
-    builder.setChromeOptions(options);
-    builder.setChromeService(serviceBuilder);
-
-    return builder.build();
-  }
-
-  /** @see Browser.enableExtensionInIncognito */
-  static async enableExtensionInIncognito(driver, extensionTitle) {
-    // Extensions page in Opera has the same web elements as Chromium
-    await Chromium.enableExtensionInIncognito(driver, extensionTitle);
-  }
-}
-
 /**
  * @type {Object}
  * @property {Chromium} chromium - Download functionality for Chromium.
@@ -892,6 +733,5 @@ class Opera extends Browser {
 export const BROWSERS = {
   chromium: Chromium,
   firefox: Firefox,
-  edge: Edge,
-  opera: Opera
+  edge: Edge
 };

package/src/utils.js

@@ -22,7 +22,6 @@ import {promisify} from "util";
 import {exec} from "child_process";
 
 import got from "got";
-import fsExtra from "fs-extra";
 import dmg from "dmg";
 
 /**
@@ -66,7 +65,7 @@ export async function extractDmg(archive, dir) {
   let source = path.join(mpath, target);
   await fs.promises.mkdir(dir);
   try {
-    await fsExtra.copy(source, path.join(dir, target));
+    await fs.promises.cp(source, path.join(dir, target), {recursive: true});
   }
   finally {
     try {

package/test/.eslintrc.json

@@ -1,5 +1,6 @@
 {
   "env": {
-    "mocha": true
+    "mocha": true,
+    "browser": true
   }
 }

package/test/browsers.js

@@ -25,13 +25,11 @@ import {killDriverProcess} from "../src/utils.js";
 // Required to set the driver path on Windows
 import "chromedriver";
 import "geckodriver";
-import "msedgedriver";
 
 const VERSIONS = {
-  chromium: [void 0, "77.0.3865.0", "beta", "dev"],
-  firefox: [void 0, "68.0", "beta"],
-  edge: [void 0, "95.0.1020.53", "beta", "dev"],
-  opera: [void 0, "64.0.3417.92"]
+  chromium: ["latest", "75.0.3770.0", "beta", "dev"],
+  firefox: ["latest", "60.0", "beta"],
+  edge: ["latest", "95.0.1020.40", "beta", "dev"]
 };
 const TEST_URL = "https://gitlab.com/eyeo/developer-experience/get-browser-binary";
 let extensionPaths = [path.resolve(process.cwd(), "test", "extension")];
@@ -74,9 +72,27 @@ function normalize(version) {
   return normalized.split("b")[0];
 }
 
+function getWindowSize(driver) {
+  return driver.executeScript(() => {
+    return {height: window.innerHeight, width: window.innerWidth};
+  });
+}
+
+expect.extend({
+  toMeasureLessThan(small, big) {
+    let pass = small.width < big.width || small.height < big.height;
+    let message = () =>
+      `expected small sizes (w: ${small.width}, h: ${small.height}) ` +
+      `to be smaller than big sizes (w: ${big.width}, h: ${big.height})`;
+    if (pass)
+      return {message, pass: true};
+    return {message, pass: false};
+  }
+});
+
 for (let browser of Object.keys(BROWSERS)) {
   describe(`Browser: ${browser}`, function() {
-    this.timeout(40000);
+    this.timeout(150000);
 
     before(async() => {
       try {
@@ -86,9 +102,10 @@ for (let browser of Object.keys(BROWSERS)) {
     });
 
     for (let version of VERSIONS[browser]) {
-      describe(`Version: ${version || "latest"}`, () => {
+      describe(`Version: ${version}`, () => {
         let driver = null;
-        afterEach(async() => {
+
+        async function quitDriver() {
           if (!driver)
             return;
 
@@ -99,16 +116,18 @@ for (let browser of Object.keys(BROWSERS)) {
             await killDriverProcess("chromedriver");
           else if (browser == "firefox")
             await killDriverProcess("geckodriver");
-        });
+        }
+
+        afterEach(quitDriver);
 
         it("downloads", async function() {
-          if (browser == "edge" && process.platform != "linux")
+          if (browser == "edge" && process.platform == "win32")
             this.skip();
 
           let {binary, versionNumber} =
             await BROWSERS[browser].downloadBinary(version);
-          let browserDir = browser == "opera" ? /(opera|Opera)/ : browser;
-          expect(binary).toEqual(expect.stringMatching(browserDir));
+          let browserName = browser == "edge" ? /(edge|Edge)/ : browser;
+          expect(binary).toEqual(expect.stringMatching(browserName));
 
           let installedVersion =
             await BROWSERS[browser].getInstalledVersion(binary);
@@ -120,8 +139,7 @@ for (let browser of Object.keys(BROWSERS)) {
           let names = {
             chromium: "chrome",
             firefox: "firefox",
-            edge: /(MicrosoftEdge|msedge)/,
-            opera: /(opera|chrome)/
+            edge: /(MicrosoftEdge|msedge)/
           };
 
           driver = await BROWSERS[browser].getDriver(version);
@@ -132,10 +150,21 @@ for (let browser of Object.keys(BROWSERS)) {
         });
 
         it("supports extra args", async() => {
+          let headless = false;
           let extraArgs = browser == "firefox" ?
             ["--devtools"] : ["auto-open-devtools-for-tabs"];
-          driver = await BROWSERS[browser].getDriver(version, {extraArgs});
+
+          driver = await BROWSERS[browser].getDriver(
+            version, {headless, extraArgs});
+          await driver.navigate().to(TEST_URL);
+          let sizeDevToolsOpen = await getWindowSize(driver);
+          await quitDriver();
+
+          driver = await BROWSERS[browser].getDriver(version, {headless});
           await driver.navigate().to(TEST_URL);
+          let sizeDevToolsClosed = await getWindowSize(driver);
+
+          expect(sizeDevToolsOpen).toMeasureLessThan(sizeDevToolsClosed);
         });
 
         it("loads an extension", async() => {
@@ -147,7 +176,7 @@ for (let browser of Object.keys(BROWSERS)) {
         });
 
         it("loads an extension in incognito mode", async function() {
-          if (browser == "firefox" && version == "68.0")
+          if (browser == "firefox" && version == "60.0")
             this.skip();
 
           driver = await BROWSERS[browser].getDriver(
@@ -159,5 +188,15 @@ for (let browser of Object.keys(BROWSERS)) {
         });
       });
     }
+
+    it("does not download unsupported versions", async function() {
+      if (browser == "edge" && process.platform == "win32")
+        this.skip();
+
+      for (let unsupported of ["0.0", "invalid"]) {
+        await expect(BROWSERS[browser].downloadBinary(unsupported))
+          .rejects.toThrow(`Unsupported browser version: ${unsupported}`);
+      }
+    });
   });
 }

package/test/docker/Dockerfile

@@ -1,15 +1,4 @@
-FROM node:16-bullseye-slim
-
-# General packages
-RUN apt-get update && apt-get install -y git procps wget unzip bzip2 gnupg
-# xvfb (headful browser run)
-RUN apt-get install -y libgtk-3-0 libxt6 xvfb libnss3 libxss1
-# General browser dependencies
-RUN apt-get install -y libgconf-2-4 libasound2 libgbm1
-# Edge dependencies
-RUN apt-get install -y fonts-liberation libatomic1 xdg-utils
-# Opera dependencies
-RUN apt-get install -y libcurl4 libgdk-pixbuf2.0-0
+FROM registry.gitlab.com/eyeo/docker/get-browser-binary:node16
 
 COPY package*.json get-browser-binary/
 RUN cd get-browser-binary && npm install