@eyeo/get-browser-binary 0.3.0 → 0.4.0

package/.dockerignore

@@ -0,0 +1,3 @@
+node_modules/
+browser-snapshots/
+docs/

package/.gitlab-ci.yml

@@ -1,5 +1,5 @@
 default:
-  image: registry.gitlab.com/eyeo/docker/adblockplus-ci:node16-no-python
+  image: node:16-bullseye-slim
   interruptible: true
 
 stages:
@@ -29,18 +29,15 @@ test:basic:
 
 test:browsers:linux:
   stage: test
+  image: docker:20.10.16
+  services:
+    - docker:20.10.16-dind
+  variables:
+    DOCKER_DRIVER: overlay2
   before_script:
-    - apt-get update && apt-get install -y procps
-    - npm install
-    # https://www.how2shout.com/linux/install-microsoft-edge-on-linux/
-    - wget https://packages.microsoft.com/keys/microsoft.asc
-    - cat microsoft.asc | gpg --dearmor > microsoft.gpg
-    - install -o root -g root -m 644 microsoft.gpg /etc/apt/trusted.gpg.d/
-    - echo "deb [arch=amd64] https://packages.microsoft.com/repos/edge stable main" > /etc/apt/sources.list.d/microsoft-edge-dev.list
-    - rm microsoft.*
-    - apt-get update && apt-get install -y microsoft-edge-stable
+    - docker build -f test/docker/Dockerfile -t browsers .
   script:
-    - xvfb-run -a npm test -- --grep "Browser"
+    - docker run browsers
 
 test:browsers:windows:
   stage: test
@@ -54,10 +51,19 @@ 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:
-    - npm test -- --grep "chromium"
-    - npm test -- --grep "edge"
+    # Running only a subset of Firefox and Opera 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""""
+    - $full_tests = '(chromium|edge.*latest)'
+    - npm test -- --grep """"$full_tests""""
   tags:
     - shared-windows
     - windows

package/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+code-of-conduct@eyeo.com.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available
+at [https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

package/README.md

@@ -1,11 +1,12 @@
 # get-browser-binary
 
-Download specific browser versions for Chromium, Firefox and Edge, and their
-matching [selenium webdriver](https://www.selenium.dev/selenium/docs/api/javascript/index.html).
+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 not implemented, and it is assumed to be already
-installed on the running system. In that case, the matching `msedgedriver`
-will be downloaded accordingly.
+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.
 
 ## Getting started
 
@@ -69,11 +70,34 @@ npm test
 The `grep` option filters the tests to run with a regular expression. Example:
 
 ```shell
-npm test -- --grep "chromium latest"
+npm test -- --grep "chromium.*latest"
 ```
 
+### Running tests on Docker
+
+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
+```
+
+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
+```
+
+Note: For a full automated run, `opera` tests should not use the interactive
+tty `-it` flag.
+
 ## Building the documentation
 
 ```shell
 npm run docs
 ```
+
+## Code of Conduct
+
+All contributors to this project are required to read and follow our
+[code of conduct](./CODE_OF_CONDUCT.md).

package/RELEASE_NOTES.md

@@ -1,3 +1,9 @@
+# 0.4.0
+
+- Adds Opera as a supported browser (#7)
+- Enables Edge binary downloads on Linux (!18)
+- Adds a code of conduct (#15)
+
 # 0.3.0
 
 - Adds incognito mode support to all browsers (#5)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eyeo/get-browser-binary",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Download browser binaries and matching webdrivers",
   "repository": {
     "type": "git",

package/src/browsers.js

@@ -16,9 +16,10 @@
  */
 
 import path from "path";
-import {exec, execFile} from "child_process";
+import {exec, execFile, spawn} 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";
@@ -27,8 +28,8 @@ import firefox from "selenium-webdriver/firefox.js";
 import command from "selenium-webdriver/lib/command.js";
 import extractZip from "extract-zip";
 
-import {download, extractTar, extractDmg, runWinInstaller, getBrowserVersion,
-        killDriverProcess} from "./utils.js";
+import {download, extractTar, extractDmg, getBrowserVersion, killDriverProcess,
+        wait} from "./utils.js";
 
 /**
  * Root folder where browser and webdriver binaries get downloaded.
@@ -49,7 +50,9 @@ let platform = `${process.platform}-${process.arch}`;
 class Browser {
   /**
    * @typedef {Object} BrowserBinary
-   * @property {string} binary - The path to the Chromium binary.
+   * @property {string} binary - The path to the browser binary.
+   * @property {string} versionNumber - The version number of the browser
+   *   binary.
    */
 
   /**
@@ -62,6 +65,25 @@ class Browser {
     throw new Error(ERROR_DOWNLOAD_NOT_SUPPORTED);
   }
 
+  /**
+   * Gets the installed version returned by the browser binary.
+   * @param {string} binary - The path to the browser binary.
+   * @return {string} Installed browser version.
+   */
+  static async getInstalledVersion(binary) {
+    let stdout;
+    if (process.platform == "win32") {
+      ({stdout} = await promisify(exec)(
+        `(Get-ItemProperty ${binary}).VersionInfo.ProductVersion`,
+        {shell: "powershell.exe"})
+      );
+    }
+    else {
+      ({stdout} = await promisify(execFile)(binary, ["--version"]));
+    }
+    return stdout;
+  }
+
   /**
    * @typedef {Object} webdriver
    * @see https://www.selenium.dev/selenium/docs/api/javascript/index.html
@@ -225,7 +247,7 @@ class Chromium extends Browser {
       ({version, base} = await Chromium.#getLatestVersion(version));
 
     let {binary, revision} = await Chromium.#downloadChromium(base);
-    return {binary, downloadedVersion: version, revision};
+    return {binary, versionNumber: version, revision};
   }
 
   static async #installDriver(revision, version) {
@@ -245,7 +267,6 @@ class Chromium extends Browser {
     await download(`https://commondatastorage.googleapis.com/chromium-browser-snapshots/${dir}/${revision}/${zip}`,
                    archive);
     await extractZip(archive, {dir: cacheDir});
-    // avoid driver copy failing if the file would be locked
     await killDriverProcess(Chromium.#DRIVER);
     await fs.promises.mkdir(destinationDir, {recursive: true});
     await fs.promises.copyFile(path.join(cacheDir, zip.split(".")[0], driver),
@@ -256,9 +277,9 @@ class Chromium extends Browser {
   static async getDriver(version, {headless = true, extensionPaths = [],
                                    incognito = false, insecure = false,
                                    extraArgs = []} = {}) {
-    let {binary, revision, downloadedVersion} =
+    let {binary, revision, versionNumber} =
       await Chromium.downloadBinary(version);
-    await Chromium.#installDriver(revision, downloadedVersion);
+    await Chromium.#installDriver(revision, versionNumber);
 
     let options = new chrome.Options().addArguments("no-sandbox", ...extraArgs);
     if (extensionPaths.length > 0)
@@ -281,7 +302,8 @@ class Chromium extends Browser {
   /** @see Browser.enableExtensionInIncognito */
   static async enableExtensionInIncognito(driver, extensionTitle) {
     let version = await getBrowserVersion(driver);
-    if (version < 75)
+    // 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}`);
 
@@ -319,7 +341,7 @@ class Chromium extends Browser {
  * @hideconstructor
  * @extends Browser
  */
-class Firefox {
+class Firefox extends Browser {
   static async #getLatestVersion(branch) {
     let data = await got("https://product-details.mozilla.org/1.0/firefox_versions.json").json();
     return branch == "beta" ?
@@ -342,7 +364,9 @@ class Firefox {
   static #extractFirefoxArchive(archive, dir) {
     switch (process.platform) {
       case "win32":
-        return runWinInstaller(archive, dir);
+        // Procedure inspired from mozinstall:
+        // https://hg.mozilla.org/mozilla-central/file/tip/testing/mozbase/mozinstall/mozinstall/mozinstall.py
+        return promisify(exec)(`"${archive}" /extractdir=${dir}`);
       case "linux":
         return extractTar(archive, dir);
       case "darwin":
@@ -395,7 +419,7 @@ class Firefox {
       version = await Firefox.#getLatestVersion(version);
 
     let binary = await Firefox.#downloadFirefox(version);
-    return {binary};
+    return {binary, versionNumber: version};
   }
 
   /** @see Browser.getDriver */
@@ -415,10 +439,23 @@ class Firefox {
       options.addArguments(...extraArgs);
     options.setBinary(binary);
 
-    let driver = await new webdriver.Builder()
-      .forBrowser("firefox")
-      .setFirefoxOptions(options)
-      .build();
+    let driver;
+    // The OS may be low on resources, that's why building the driver is retried
+    // https://github.com/mozilla/geckodriver/issues/1560
+    await wait(async() => {
+      try {
+        driver = await new webdriver.Builder()
+          .forBrowser("firefox")
+          .setFirefoxOptions(options)
+          .build();
+        return true;
+      }
+      catch (err) {
+        if (err.message != "Failed to decode response from marionette")
+          throw err;
+        await killDriverProcess("geckodriver");
+      }
+    }, 30000, "geckodriver didn't start, likely due to low OS resources", 1000);
 
     for (let extensionPath of extensionPaths) {
       await driver.execute(
@@ -457,32 +494,87 @@ class Firefox {
  * @hideconstructor
  * @extends Browser
  */
-class Edge {
+class Edge extends Browser {
   static #DRIVER = "msedgedriver";
 
-  static async #installDriver() {
-    let stdout;
-    if (process.platform == "win32") {
-      let cmd = "(Get-ItemProperty ${Env:ProgramFiles(x86)}\\Microsoft\\" +
-                "Edge\\Application\\msedge.exe).VersionInfo.ProductVersion";
-      ({stdout} = await promisify(exec)(cmd, {shell: "powershell.exe"}));
+  static async #getVersionForChannel(version) {
+    if (!["latest", "beta", "dev"].includes(version))
+      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 regex = /href="microsoft-edge-(stable|beta|dev)_(.*?)-1_/gm;
+    let matches;
+    let versionNumbers = [];
+    while ((matches = regex.exec(body)) !== null)
+      versionNumbers.push(matches[2]);
+
+    let compareVersions = (v1, v2) =>
+      parseInt(v1.split(".")[0], 10) < parseInt(v2.split(".")[0], 10) ? 1 : -1;
+    let versionNumber = versionNumbers.sort(compareVersions)[0];
+
+    return {versionNumber, channel};
+  }
+
+  /**
+   * Downloads the browser binary file.
+   * @param {string} version - Either "latest", "beta", "dev" or a full version
+   *   number (i.e. "95.0.1020.53"). Defaults to "latest". This is only
+   *   available on Linux.
+   * @return {BrowserBinary}
+   */
+  static async downloadBinary(version = "latest") {
+    if (process.platform != "linux")
+      throw new Error("Edge download is only supported on Linux");
+
+    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"
+    }[channel];
+
+    try {
+      if (await Edge.#getInstalledVersionNumber(binary) == versionNumber)
+        return {binary, versionNumber};
     }
-    else if (process.platform == "darwin") {
-      ({stdout} = await promisify(execFile)(
-        "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
-        ["--version"]
-      ));
+    catch (e) {}
+
+    try {
+      await download(
+        `https://packages.microsoft.com/repos/edge/pool/main/m/microsoft-edge-${channel}/${filename}`,
+        archive
+      );
     }
-    else if (process.platform == "linux") {
-      ({stdout} = await promisify(execFile)("microsoft-edge", ["--version"]));
+    catch (err) {
+      throw new Error(`Edge download failed: ${err}`);
     }
+    await promisify(exec)(`dpkg -i ${archive}`);
+
+    return {binary, versionNumber};
+  }
 
-    let version = stdout.trim().replace(/.*\s/, "");
+  static async #getInstalledVersionNumber(binary) {
+    let installedVersion = await Edge.getInstalledVersion(binary);
+    return installedVersion.replace("beta", "").replace("dev", "")
+      .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)
       throw new Error("Edge is not installed");
 
-    // Based on "node_modules/msedgedriver/install.js", adding a fallback
-    // mechanism when msedgedriver doesn't exist for the latest Edge version.
     let [zip, driver] = {
       "win32-ia32": ["edgedriver_win32.zip", "msedgedriver.exe"],
       "win32-x64": ["edgedriver_win64.zip", "msedgedriver.exe"],
@@ -515,7 +607,6 @@ class Edge {
       throw new Error(`msedgedriver was not found for Edge ${version}`);
 
     await extractZip(archive, {dir: cacheDir});
-    // avoid driver copy failing if the file would be locked
     await killDriverProcess(Edge.#DRIVER);
     for (let destinationDir of [driverBinDir, driverLibDir]) {
       await fs.promises.mkdir(destinationDir, {recursive: true});
@@ -528,6 +619,9 @@ class Edge {
   static async getDriver(version, {headless = true, extensionPaths = [],
                                    incognito = false, insecure = false,
                                    extraArgs = []} = {}) {
+    if (process.platform == "linux")
+      await Edge.downloadBinary(version);
+
     await Edge.#installDriver();
 
     let args = ["no-sandbox", ...extraArgs];
@@ -577,6 +671,217 @@ class Edge {
   }
 }
 
+/**
+ * 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}
@@ -587,5 +892,6 @@ class Edge {
 export const BROWSERS = {
   chromium: Chromium,
   firefox: Firefox,
-  edge: Edge
+  edge: Edge,
+  opera: Opera
 };

package/src/utils.js

@@ -56,7 +56,7 @@ export async function download(url, destFile) {
 
 export async function extractTar(archive, dir) {
   await fs.promises.mkdir(dir);
-  await promisify(exec)(["tar", "-jxf", archive, "-C", dir].join(" "));
+  await promisify(exec)(`tar -jxf ${archive} -C ${dir}`);
 }
 
 export async function extractDmg(archive, dir) {
@@ -78,17 +78,12 @@ export async function extractDmg(archive, dir) {
   }
 }
 
-export async function runWinInstaller(archive, dir) {
-  // Procedure inspired from mozinstall. Uninstaller will also need to be run.
-  // https://hg.mozilla.org/mozilla-central/file/tip/testing/mozbase/mozinstall/mozinstall/mozinstall.py
-  await promisify(exec)(`"${archive}" /extractdir=${dir}`);
-}
-
 export async function getBrowserVersion(driver) {
   let version = (await driver.getCapabilities()).getBrowserVersion();
-  return parseInt(version.split(".")[0], 10);
+  return version ? parseInt(version.split(".")[0], 10) : null;
 }
 
+// Useful to unlock the driver file before replacing it or executing it
 export async function killDriverProcess(driverName) {
   let cmd = `kill $(pgrep ${driverName})`;
   let shell;
@@ -106,3 +101,51 @@ export async function killDriverProcess(driverName) {
       throw err;
   }
 }
+
+export function wait(condition, timeout = 0, message, pollTimeout = 100) {
+  if (typeof condition !== "function")
+    throw TypeError("Wait condition must be a function");
+
+  function evaluateCondition() {
+    return new Promise((resolve, reject) => {
+      try {
+        resolve(condition(this));
+      }
+      catch (ex) {
+        reject(ex);
+      }
+    });
+  }
+
+  let result = new Promise((resolve, reject) => {
+    let startTime = Date.now();
+    let pollCondition = async() => {
+      evaluateCondition().then(value => {
+        let elapsed = Date.now() - startTime;
+        if (value) {
+          resolve(value);
+        }
+        else if (timeout && elapsed >= timeout) {
+          try {
+            let timeoutMessage = message ?
+              `${typeof message === "function" ? message() : message}\n` : "";
+            reject(
+              new Error(`${timeoutMessage}Wait timed out after ${elapsed}ms`)
+            );
+          }
+          catch (ex) {
+            reject(
+              new Error(`${ex.message}\nWait timed out after ${elapsed}ms`)
+            );
+          }
+        }
+        else {
+          setTimeout(pollCondition, pollTimeout);
+        }
+      }, reject);
+    };
+    pollCondition();
+  });
+
+  return result;
+}

package/test/browsers.js

@@ -24,13 +24,16 @@ 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, "beta", "dev", "77.0.3865.0"],
-  firefox: [void 0, "beta", "68.0"],
-  edge: [void 0]
+  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"]
 };
+const TEST_URL = "https://gitlab.com/eyeo/developer-experience/get-browser-binary";
 let extensionPaths = [path.resolve(process.cwd(), "test", "extension")];
 
 async function switchToHandle(driver, testFn) {
@@ -62,85 +65,99 @@ async function getHandle(driver, page) {
   return handle;
 }
 
-for (let browser of Object.keys(BROWSERS)) {
-  for (let version of VERSIONS[browser]) {
-    describe(`Browser: ${browser} ${version || "latest"}`, function() {
-      this.timeout(20000);
-
-      before(async() => {
-        try {
-          await fs.promises.rm(snapshotsBaseDir, {recursive: true});
-        }
-        catch (e) {}
-      });
-
-      let driver = null;
-      afterEach(async() => {
-        if (!driver)
-          return;
-
-        await driver.quit();
-        driver = null;
-        // Some platforms don't immediately kill the chromedriver process
-        if (browser == "chromium")
-          await killDriverProcess("chromedriver");
-      });
-
-      it("downloads", async function() {
-        if (browser == "edge")
-          // Edge download is not implemented. It is assumed to be installed.
-          this.skip();
-
-        this.timeout(40000);
-        let {binary} = await BROWSERS[browser].downloadBinary(version);
-
-        await fs.promises.access(binary);
-        expect(binary).toEqual(
-          expect.stringContaining(path.join(snapshotsBaseDir, browser)));
-      });
-
-      it("runs", async() => {
-        let names = {
-          chromium: "chrome",
-          firefox: "firefox",
-          edge: /(MicrosoftEdge|msedge)/
-        };
-
-        driver = await BROWSERS[browser].getDriver(version);
-        await driver.navigate().to("about:blank");
-
-        expect((await driver.getCapabilities()).getBrowserName())
-          .toEqual(expect.stringMatching(names[browser]));
-      });
-
-      it("supports extra args", async() => {
-        driver = await BROWSERS[browser].getDriver(
-          version, {extraArgs: ["auto-open-devtools-for-tabs"]});
-        await driver.navigate().to("about:blank");
-      });
-
-      it("loads an extension", async() => {
-        let headless = browser == "firefox";
-
-        driver = await BROWSERS[browser].getDriver(
-          version, {headless, extensionPaths});
-        await getHandle(driver, "/index.html");
-      });
-
-      it("loads an extension in incognito mode", async function() {
-        if (browser == "firefox" && version == "68.0")
-          this.skip();
+function normalize(version) {
+  // Discards any numbers after the third dot. For example, "103.0.5060.134"
+  // will return "103.0.5060", and "68.0" will return "68.0"
+  let normalized = version.split(".").slice(0, 3).join(".");
+  // On Windows, Firefox beta versions look like "103.0b9", but the installed
+  // version returned by the browser is actually "103.0"
+  return normalized.split("b")[0];
+}
 
-        if (process.platform == "win32")
-          this.timeout(30000);
+for (let browser of Object.keys(BROWSERS)) {
+  describe(`Browser: ${browser}`, function() {
+    this.timeout(40000);
+
+    before(async() => {
+      try {
+        await fs.promises.rm(snapshotsBaseDir, {recursive: true});
+      }
+      catch (e) {}
+    });
 
-        driver = await BROWSERS[browser].getDriver(
-          version, {headless: false, extensionPaths, incognito: true});
-        await BROWSERS[browser].enableExtensionInIncognito(
-          driver, "Browser download test extension"
-        );
-        await getHandle(driver, "/index.html");
+    for (let version of VERSIONS[browser]) {
+      describe(`Version: ${version || "latest"}`, () => {
+        let driver = null;
+        afterEach(async() => {
+          if (!driver)
+            return;
+
+          await driver.quit();
+          driver = null;
+          // Some platforms don't immediately kill the driver process
+          if (browser == "chromium")
+            await killDriverProcess("chromedriver");
+          else if (browser == "firefox")
+            await killDriverProcess("geckodriver");
+        });
+
+        it("downloads", async function() {
+          if (browser == "edge" && process.platform != "linux")
+            this.skip();
+
+          let {binary, versionNumber} =
+            await BROWSERS[browser].downloadBinary(version);
+          let browserDir = browser == "opera" ? /(opera|Opera)/ : browser;
+          expect(binary).toEqual(expect.stringMatching(browserDir));
+
+          let installedVersion =
+            await BROWSERS[browser].getInstalledVersion(binary);
+          expect(installedVersion).toEqual(
+            expect.stringContaining(normalize(versionNumber)));
+        });
+
+        it("runs", async() => {
+          let names = {
+            chromium: "chrome",
+            firefox: "firefox",
+            edge: /(MicrosoftEdge|msedge)/,
+            opera: /(opera|chrome)/
+          };
+
+          driver = await BROWSERS[browser].getDriver(version);
+          await driver.navigate().to(TEST_URL);
+
+          expect((await driver.getCapabilities()).getBrowserName())
+            .toEqual(expect.stringMatching(names[browser]));
+        });
+
+        it("supports extra args", async() => {
+          let extraArgs = browser == "firefox" ?
+            ["--devtools"] : ["auto-open-devtools-for-tabs"];
+          driver = await BROWSERS[browser].getDriver(version, {extraArgs});
+          await driver.navigate().to(TEST_URL);
+        });
+
+        it("loads an extension", async() => {
+          let headless = browser == "firefox";
+
+          driver = await BROWSERS[browser].getDriver(
+            version, {headless, extensionPaths});
+          await getHandle(driver, "/index.html");
+        });
+
+        it("loads an extension in incognito mode", async function() {
+          if (browser == "firefox" && version == "68.0")
+            this.skip();
+
+          driver = await BROWSERS[browser].getDriver(
+            version, {headless: false, extensionPaths, incognito: true});
+          await BROWSERS[browser].enableExtensionInIncognito(
+            driver, "Browser download test extension"
+          );
+          await getHandle(driver, "/index.html");
+        });
       });
-    });
-  }
+    }
+  });
 }

package/test/docker/Dockerfile

@@ -0,0 +1,20 @@
+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
+
+COPY package*.json get-browser-binary/
+RUN cd get-browser-binary && npm install
+
+COPY . get-browser-binary/
+
+ENV TEST_ARGS="--grep Browser"
+ENTRYPOINT get-browser-binary/test/docker/entrypoint.sh

package/test/docker/entrypoint.sh

@@ -0,0 +1,4 @@
+#! /bin/bash
+
+cd get-browser-binary
+xvfb-run -a npm test -- $TEST_ARGS