@eyeo/get-browser-binary 0.5.0 → 0.7.0

package/src/browsers.js

@@ -16,10 +16,9 @@
  */
 
 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";
@@ -28,31 +27,47 @@ 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";
+import Jimp from "jimp";
 
-import {download, extractTar, extractDmg, getBrowserVersion, killDriverProcess,
-        wait} from "./utils.js";
+import {download, extractTar, extractDmg, killDriverProcess, wait}
+  from "./utils.js";
 
 /**
- * Root folder where browser and webdriver binaries get downloaded.
+ * Root folder where browser and webdriver files get downloaded and extracted.
  * @type {string}
  */
 export let snapshotsBaseDir = path.join(process.cwd(), "browser-snapshots");
 
 let {until, By} = webdriver;
-let platform = `${process.platform}-${process.arch}`;
-
-function checkVersion(version, minVersion, channels) {
+let {platform, arch} = process;
+let platformArch = `${platform}-${arch}`;
+
+const UNSUPPORTED_VERSION_ERROR = "Unsupported browser version";
+const UNSUPPORTED_PLATFORM_ERROR = "Unsupported platform";
+const DRIVER_DOWNLOAD_ERROR = "Driver download failed";
+const DRIVER_START_ERROR = "Unable to start driver";
+const EXTENSION_NOT_FOUND_ERROR = "Extension not found";
+const BROWSER_DOWNLOAD_ERROR = "Browser download failed";
+const BROWSER_NOT_INSTALLED_ERROR = "Browser is not installed";
+const ELEMENT_NOT_FOUND_ERROR = "HTML element not found";
+
+function checkVersion(version, minVersion, channels = []) {
   if (channels.includes(version))
     return;
 
   let mainVersion = parseInt(version && version.split(".")[0], 10);
-  if (mainVersion < minVersion)
-    throw new Error(`Unsupported browser version: ${version}`);
+  if (isNaN(mainVersion) || mainVersion < minVersion)
+    throw new Error(`${UNSUPPORTED_VERSION_ERROR}: ${version}`);
+}
+
+function checkPlatform() {
+  if (!["win32", "linux", "darwin"].includes(platform))
+    throw new Error(`${UNSUPPORTED_PLATFORM_ERROR}: ${platform}`);
 }
 
 /**
- * Base class for browser download functionality. Please see subclasses for
- * browser specific details.
+ * Base class for browser and webdriver functionality. Please see subclasses for
+ *   browser specific details. All classes can be used statically.
  * @hideconstructor
  */
 class Browser {
@@ -64,13 +79,15 @@ class Browser {
    */
 
   /**
-   * Downloads the browser binary file.
+   * Installs the browser. The installation process is detailed on the
+   *   subclasses.
    * @param {string} version - Either full version number or channel/release.
    *   Please find examples on the subclasses.
    * @return {BrowserBinary}
-   * @throws {Error} Unsupported browser version.
+   * @throws {Error} Unsupported browser version, Unsupported platform, Browser
+   *   download failed.
    */
-  static async downloadBinary(version) {
+  static async installBrowser(version) {
     // to be implemented by the subclass
   }
 
@@ -81,7 +98,7 @@ class Browser {
    */
   static async getInstalledVersion(binary) {
     let stdout;
-    if (process.platform == "win32") {
+    if (platform == "win32") {
       ({stdout} = await promisify(exec)(
         `(Get-ItemProperty ${binary}).VersionInfo.ProductVersion`,
         {shell: "powershell.exe"})
@@ -119,7 +136,8 @@ class Browser {
    *   Please find examples on the subclasses.
    * @param {driverOptions?} options - Options to start the browser with.
    * @return {webdriver}
-   * @throws {Error} Unsupported browser version.
+   * @throws {Error} Unsupported browser version, Unsupported platform, Browser
+   *   download failed, Driver download failed, Unable to start driver.
    */
   static async getDriver(version, options = {}) {
     // to be implemented by the subclass
@@ -131,7 +149,8 @@ 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.
+   * @throws {Error} Unsupported browser version, Extension not found, HTML
+   *   element not found.
    */
   static async enableExtensionInIncognito(driver, extensionTitle) {
     // Allowing the extension in incognito mode can't happen programmatically:
@@ -139,22 +158,80 @@ class Browser {
     // https://bugzilla.mozilla.org/show_bug.cgi?id=1729315
     // That is done through the UI, to be implemented by the subclass
   }
+
+  /**
+   * @typedef {Object} Jimp
+   * @see https://github.com/oliver-moran/jimp/tree/master/packages/jimp
+   */
+
+  /**
+   * Takes a screenshot of the full page by scrolling from top to bottom.
+   * @param {webdriver} driver - The driver controlling the browser.
+   * @property {boolean} hideScrollbars=true - Hides any scrollbars before
+   *   taking the screenshot, or not.
+   * @return {Jimp} A Jimp image object containing the screenshot.
+   * @example
+   * // Getting a base-64 encoded PNG from the returned screenshot
+   * let image = await Browser.takeFullPageScreenshot(driver);
+   * let encodedPNG = await image.getBase64Async("image/png");
+   */
+  static async takeFullPageScreenshot(driver, hideScrollbars = true) {
+    // On macOS scrollbars appear and disappear overlapping the content as
+    // scrolling occurs. Hiding the scrollbars helps getting reproducible
+    // screenshots.
+    if (hideScrollbars) {
+      await driver.executeScript(() => {
+        if (!document.head)
+          return;
+
+        let style = document.createElement("style");
+        style.textContent = "html { overflow-y: scroll; }";
+        document.head.appendChild(style);
+        if (document.documentElement.clientWidth == window.innerWidth)
+          style.textContent = "html::-webkit-scrollbar { display: none; }";
+        else
+          document.head.removeChild(style);
+      });
+    }
+
+    let fullScreenshot = new Jimp(0, 0);
+    while (true) {
+      let [width, height, offset] = await driver.executeScript((...args) => {
+        window.scrollTo(0, args[0]);
+        // Math.ceil rounds up potential decimal values on window.scrollY,
+        // ensuring the loop will not hang due to never reaching enough
+        // fullScreenshot's height.
+        return [document.documentElement.clientWidth,
+                document.documentElement.scrollHeight,
+                Math.ceil(window.scrollY)];
+      }, fullScreenshot.bitmap.height);
+      let data = await driver.takeScreenshot();
+      let partialScreenshot = await Jimp.read(Buffer.from(data, "base64"));
+      let combinedScreenshot =
+        new Jimp(width, offset + partialScreenshot.bitmap.height);
+      combinedScreenshot.composite(fullScreenshot, 0, 0);
+      combinedScreenshot.composite(partialScreenshot, 0, offset);
+      fullScreenshot = combinedScreenshot;
+
+      if (fullScreenshot.bitmap.height >= height)
+        break;
+    }
+    return fullScreenshot;
+  }
 }
 
 /**
- * Download functionality for Chromium. This class can be used statically.
+ * Browser and webdriver functionality for Chromium.
  * @hideconstructor
  * @extends Browser
  */
 class Chromium extends Browser {
-  static #DRIVER = "chromedriver";
-
-  static async #getBranchBasePosition(version) {
-    let data = await got(`https://omahaproxy.appspot.com/deps.json?version=${version}`).json();
-    return data.chromium_base_position;
-  }
+  static #CHANNELS = ["latest", "beta", "dev"];
 
   static async #getVersionForChannel(channel) {
+    if (!Chromium.#CHANNELS.includes(channel))
+      return channel;
+
     if (channel == "latest")
       channel = "stable";
 
@@ -164,7 +241,7 @@ class Chromium extends Browser {
       "linux-x64": "linux",
       "darwin-x64": "mac",
       "dawrin-arm64": "mac_arm64"
-    }[platform];
+    }[platformArch];
     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} = release;
@@ -178,55 +255,67 @@ class Chromium extends Browser {
   }
 
   static #getBinaryPath(dir) {
-    switch (process.platform) {
-      case "win32":
-        return path.join(dir, "chrome-win", "chrome.exe");
-      case "linux":
-        return path.join(dir, "chrome-linux", "chrome");
-      case "darwin":
-        return path.join(dir, "chrome-mac", "Chromium.app", "Contents", "MacOS",
-                         "Chromium");
-      default:
-        throw new Error(`Unexpected platform: ${process.platform}`);
-    }
+    checkPlatform();
+    return {
+      win32: path.join(dir, "chrome-win", "chrome.exe"),
+      linux: path.join(dir, "chrome-linux", "chrome"),
+      darwin: path.join(dir, "chrome-mac", "Chromium.app", "Contents", "MacOS",
+                        "Chromium")
+    }[platform];
   }
 
-  static async #downloadChromium(chromiumRevision) {
-    const MAX_VERSION_DECREMENTS = 50;
+  /**
+   * Installs the browser. The Chromium executable gets extracted in the
+   *   {@link snapshotsBaseDir} folder, ready to go.
+   * @param {string} version - Either "latest", "beta", "dev" or a full version
+   *   number (i.e. "77.0.3865.0"). Defaults to "latest".
+   * @return {BrowserBinary}
+   * @throws {Error} Unsupported browser version, Unsupported platform, Browser
+   *   download failed.
+   */
+  static async installBrowser(version = "latest") {
+    const MIN_VERSION = 75;
+    const MAX_VERSION_DECREMENTS = 80;
 
-    let revision = parseInt(chromiumRevision, 10);
-    let startingRevision = revision;
+    checkVersion(version, MIN_VERSION, Chromium.#CHANNELS);
+    let versionNumber = await Chromium.#getVersionForChannel(version);
+
+    let {chromium_base_position: chromiumBase} =
+      await got(`https://omahaproxy.appspot.com/deps.json?version=${versionNumber}`).json();
+    let base = parseInt(chromiumBase, 10);
+    let startBase = base;
     let [platformDir, fileName] = {
       "win32-ia32": ["Win", "chrome-win.zip"],
       "win32-x64": ["Win_x64", "chrome-win.zip"],
       "linux-x64": ["Linux_x64", "chrome-linux.zip"],
       "darwin-x64": ["Mac", "chrome-mac.zip"],
       "dawrin-arm64": ["Mac_Arm", "chrome-mac.zip"]
-    }[platform];
-    let archive = null;
-    let browserDir = null;
+    }[platformArch];
+    let archive;
+    let browserDir;
     let snapshotsDir = path.join(snapshotsBaseDir, "chromium");
+    let binary;
 
     while (true) {
-      browserDir = path.join(snapshotsDir, `chromium-${platform}-${revision}`);
+      browserDir = path.join(snapshotsDir, `chromium-${platformArch}-${base}`);
+      binary = Chromium.#getBinaryPath(browserDir);
 
       try {
         await fs.promises.access(browserDir);
-        return {binary: Chromium.#getBinaryPath(browserDir), revision};
+        return {binary, versionNumber, base};
       }
       catch (e) {}
 
       await fs.promises.mkdir(path.dirname(browserDir), {recursive: true});
 
-      archive = path.join(snapshotsDir, "cache", `${revision}-${fileName}`);
-
+      archive = path.join(snapshotsDir, "cache", `${base}-${fileName}`);
       try {
         try {
           await fs.promises.access(archive);
         }
         catch (e) {
           await download(
-            `https://www.googleapis.com/download/storage/v1/b/chromium-browser-snapshots/o/${platformDir}%2F${revision}%2F${fileName}?alt=media`,
+            `https://www.googleapis.com/download/storage/v1/b/chromium-browser-snapshots/o/${platformDir}%2F${base}%2F${fileName}?alt=media`,
             archive);
         }
         break;
@@ -234,58 +323,53 @@ class Chromium extends Browser {
       catch (e) {
         // Chromium advises decrementing the branch_base_position when no
         // matching build was found. See https://www.chromium.org/getting-involved/download-chromium
-        revision--;
-        if (revision <= startingRevision - MAX_VERSION_DECREMENTS)
-          throw new Error(`No Chromium package found for ${startingRevision}`);
+        base--;
+        if (base <= startBase - MAX_VERSION_DECREMENTS)
+          throw new Error(`${BROWSER_DOWNLOAD_ERROR}: Chromium base ${startBase}`);
       }
     }
-
     await extractZip(archive, {dir: browserDir});
-    return {binary: Chromium.#getBinaryPath(browserDir), revision};
-  }
-
-  /**
-   * Downloads the browser binary file.
-   * @param {string} version - Either "latest", "beta", "dev" or a full version
-   *   number (i.e. "77.0.3865.0"). Defaults to "latest".
-   * @return {BrowserBinary}
-   */
-  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, revision};
+    return {binary, versionNumber, base};
   }
 
-  static async #installDriver(revision, version) {
-    let [dir, zip, driver] = {
+  static async #installDriver(base, versionNumber) {
+    let [dir, zip, driverBinary] = {
       "win32-ia32": ["Win", "chromedriver_win32.zip", "chromedriver.exe"],
       "win32-x64": ["Win_x64", "chromedriver_win32.zip", "chromedriver.exe"],
       "linux-x64": ["Linux_x64", "chromedriver_linux64.zip", "chromedriver"],
       "darwin-x64": ["Mac", "chromedriver_mac64.zip", "chromedriver"],
       "darwin-arm64": ["Mac_Arm", "chromedriver_mac64.zip", "chromedriver"]
-    }[platform];
+    }[platformArch];
 
-    let cacheDir = path.join(snapshotsBaseDir, "chromium", "cache", version);
-    let destinationDir = path.join(process.cwd(), "node_modules",
-                                   Chromium.#DRIVER, "lib", Chromium.#DRIVER);
-    let archive = path.join(cacheDir, `${revision}-${zip}`);
+    let cacheDir = path.join(snapshotsBaseDir, "chromium", "cache",
+                             versionNumber);
+    let archive = path.join(cacheDir, `${base}-${zip}`);
 
-    await download(`https://commondatastorage.googleapis.com/chromium-browser-snapshots/${dir}/${revision}/${zip}`,
-                   archive);
+    try {
+      await fs.promises.access(archive);
+      await extractZip(archive, {dir: cacheDir});
+    }
+    catch (e) { // zip file is either not cached or corrupted
+      let url = `https://commondatastorage.googleapis.com/chromium-browser-snapshots/${dir}/${base}/${zip}`;
+      try {
+        await download(url, archive);
+      }
+      catch (err) {
+        throw new Error(`${DRIVER_DOWNLOAD_ERROR}: ${url}\n${err}`);
+      }
+      await extractZip(archive, {dir: cacheDir});
+    }
+
+    await killDriverProcess("chromedriver");
+    let driverPath = path.join(cacheDir, zip.split(".")[0], driverBinary);
+    try {
+      await fs.promises.rm(driverPath, {recursive: true});
+    }
+    catch (e) {} // file does not exist
     await extractZip(archive, {dir: cacheDir});
-    await killDriverProcess(Chromium.#DRIVER);
-    await fs.promises.mkdir(destinationDir, {recursive: true});
-    await fs.promises.copyFile(path.join(cacheDir, zip.split(".")[0], driver),
-                               path.join(destinationDir, driver));
+
+    return driverPath;
   }
 
   /** @see Browser.getDriver */
@@ -293,10 +377,9 @@ class Chromium extends Browser {
     headless = true, extensionPaths = [], incognito = false, insecure = false,
     extraArgs = []
   } = {}) {
-    let {binary, revision, versionNumber} =
-      await Chromium.downloadBinary(version);
-    await Chromium.#installDriver(revision, versionNumber);
-
+    let {binary, versionNumber, base} = await Chromium.installBrowser(version);
+    let driverPath = await Chromium.#installDriver(base, versionNumber);
+    let serviceBuilder = new chrome.ServiceBuilder(driverPath);
     let options = new chrome.Options().addArguments("no-sandbox", ...extraArgs);
     if (extensionPaths.length > 0)
       options.addArguments(`load-extension=${extensionPaths.join(",")}`);
@@ -311,6 +394,7 @@ class Chromium extends Browser {
     let builder = new webdriver.Builder();
     builder.forBrowser("chrome");
     builder.setChromeOptions(options);
+    builder.setChromeService(serviceBuilder);
 
     return builder.build();
   }
@@ -335,106 +419,106 @@ class Chromium extends Browser {
             continue;
 
           extensionDetails = shadowRoot.getElementById("detailsButton");
+          break;
         }
-
         if (!extensionDetails)
-          reject("Extension was not found");
+          reject(`${args[1]}: ${args[0]}`);
 
         extensionDetails.click();
         setTimeout(() => resolve(enable()), 100);
       });
-    }, extensionTitle);
+    }, extensionTitle, EXTENSION_NOT_FOUND_ERROR);
   }
 }
 
 /**
- * Download functionality for Firefox. This class can be used statically.
+ * Browser and webdriver functionality for Firefox.
  * @hideconstructor
  * @extends Browser
  */
 class Firefox extends Browser {
-  static async #getVersionForChannel(branch) {
+  static #CHANNELS = ["latest", "beta"];
+
+  static async #getVersionForChannel(channel) {
+    if (!Firefox.#CHANNELS.includes(channel))
+      return channel;
+
     let data = await got("https://product-details.mozilla.org/1.0/firefox_versions.json").json();
-    return branch == "beta" ?
+    return channel == "beta" ?
       data.LATEST_FIREFOX_DEVEL_VERSION : data.LATEST_FIREFOX_VERSION;
   }
 
   static #getBinaryPath(dir) {
-    switch (process.platform) {
-      case "win32":
-        return path.join(dir, "core", "firefox.exe");
-      case "linux":
-        return path.join(dir, "firefox", "firefox");
-      case "darwin":
-        return path.join(dir, "Firefox.app", "Contents", "MacOS", "firefox");
-      default:
-        throw new Error(`Unexpected platform: ${process.platform}`);
-    }
+    checkPlatform();
+    return {
+      win32: path.join(dir, "core", "firefox.exe"),
+      linux: path.join(dir, "firefox", "firefox"),
+      darwin: path.join(dir, "Firefox.app", "Contents", "MacOS", "firefox")
+    }[platform];
   }
 
   static #extractFirefoxArchive(archive, dir) {
-    switch (process.platform) {
+    switch (platform) {
       case "win32":
-        // 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":
         return extractDmg(archive, dir);
       default:
-        throw new Error(`Unexpected platform: ${process.platform}`);
+        checkPlatform();
     }
   }
 
-  static async #downloadFirefox(version) {
+  /**
+   * Installs the browser. The Firefox executable gets extracted in the
+   *   {@link snapshotsBaseDir} folder, ready to go.
+   * @param {string} version - Either "latest", "beta" or a full version
+   *   number (i.e. "68.0"). Defaults to "latest".
+   * @return {BrowserBinary}
+   * @throws {Error} Unsupported browser version, Unsupported platform, Browser
+   *   download failed.
+   */
+  static async installBrowser(version = "latest") {
+    const MIN_VERSION = 60;
+
+    checkVersion(version, MIN_VERSION, Firefox.#CHANNELS);
+    let versionNumber = await Firefox.#getVersionForChannel(version);
+
     let [buildPlatform, fileName] = {
-      "win32-ia32": ["win32", `Firefox Setup ${version}.exe`],
-      "win32-x64": ["win64", `Firefox Setup ${version}.exe`],
-      "linux-x64": ["linux-x86_64", `firefox-${version}.tar.bz2`],
-      "darwin-x64": ["mac", `Firefox ${version}.dmg`],
-      "darwin-arm64": ["mac", `Firefox ${version}.dmg`]
-    }[platform];
+      "win32-ia32": ["win32", `Firefox Setup ${versionNumber}.exe`],
+      "win32-x64": ["win64", `Firefox Setup ${versionNumber}.exe`],
+      "linux-x64": ["linux-x86_64", `firefox-${versionNumber}.tar.bz2`],
+      "darwin-x64": ["mac", `Firefox ${versionNumber}.dmg`],
+      "darwin-arm64": ["mac", `Firefox ${versionNumber}.dmg`]
+    }[platformArch];
 
     let snapshotsDir = path.join(snapshotsBaseDir, "firefox");
-    let browserDir = path.join(snapshotsDir, `firefox-${platform}-${version}`);
-    let archive = path.join(snapshotsDir, "cache", fileName);
-
+    let browserDir = path.join(snapshotsDir,
+                               `firefox-${platformArch}-${versionNumber}`);
+    let binary = Firefox.#getBinaryPath(browserDir);
     try {
       await fs.promises.access(browserDir);
-      return Firefox.#getBinaryPath(browserDir);
+      return {binary, versionNumber};
     }
     catch (e) {}
 
+    let archive = path.join(snapshotsDir, "cache", fileName);
     await fs.promises.mkdir(path.dirname(browserDir), {recursive: true});
     try {
       await fs.promises.access(archive);
     }
     catch (e) {
-      let url = `https://archive.mozilla.org/pub/firefox/releases/${version}/${buildPlatform}/en-US/${fileName}`;
-      await download(url, archive);
+      let url = `https://archive.mozilla.org/pub/firefox/releases/${versionNumber}/${buildPlatform}/en-US/${fileName}`;
+      try {
+        await download(url, archive);
+      }
+      catch (err) {
+        throw new Error(`${BROWSER_DOWNLOAD_ERROR}: ${url}\n${err}`);
+      }
     }
-
     await Firefox.#extractFirefoxArchive(archive, browserDir);
-    return Firefox.#getBinaryPath(browserDir);
-  }
-
-  /**
-   * Downloads the browser binary file
-   * @param {string} version - Either "latest", "beta" or a full version
-   *   number (i.e. "68.0"). Defaults to "latest".
-   * @return {BrowserBinary}
-   */
-  static async downloadBinary(version = "latest") {
-    const MIN_VERSION = 60;
-    const CHANNELS = ["latest", "beta"];
-
-    checkVersion(version, MIN_VERSION, CHANNELS);
 
-    let versionNumber = CHANNELS.includes(version) ?
-      await Firefox.#getVersionForChannel(version) : version;
-
-    let binary = await Firefox.#downloadFirefox(versionNumber);
     return {binary, versionNumber};
   }
 
@@ -443,7 +527,7 @@ class Firefox extends Browser {
     headless = true, extensionPaths = [], incognito = false, insecure = false,
     extraArgs = []
   } = {}) {
-    let {binary} = await Firefox.downloadBinary(version);
+    let {binary} = await Firefox.installBrowser(version);
 
     let options = new firefox.Options();
     if (headless)
@@ -472,7 +556,7 @@ class Firefox extends Browser {
           throw err;
         await killDriverProcess("geckodriver");
       }
-    }, 30000, "geckodriver didn't start, likely due to low OS resources", 1000);
+    }, 30000, `${DRIVER_START_ERROR}: geckodriver`, 1000);
 
     for (let extensionPath of extensionPaths) {
       await driver.execute(
@@ -486,10 +570,9 @@ class Firefox extends Browser {
 
   /** @see Browser.enableExtensionInIncognito */
   static async enableExtensionInIncognito(driver, extensionTitle) {
-    let version = await getBrowserVersion(driver);
-    if (version < 87)
-      // The UI workaround assumes web elements only present on Firefox >= 87
-      throw new Error(`Only supported on Firefox >= 87. Current version: ${version}`);
+    let version = (await driver.getCapabilities()).getBrowserVersion();
+    // The UI workaround assumes web elements only present on Firefox >= 87
+    checkVersion(version, 87);
 
     await driver.navigate().to("about:addons");
     await driver.wait(until.elementLocated(By.name("extension")), 1000).click();
@@ -502,33 +585,50 @@ class Firefox extends Browser {
       await elem.click();
       return await driver.findElement(By.name("private-browsing")).click();
     }
-    throw new Error(`Extension "${extensionTitle}" not found`);
+    throw new Error(`${EXTENSION_NOT_FOUND_ERROR}: ${extensionTitle}`);
   }
 }
 
 /**
- * Download functionality for Edge. This class can be used statically.
+ * Browser and webdriver functionality for Edge.
  * @hideconstructor
  * @extends Browser
  */
 class Edge extends Browser {
-  static #DRIVER = "msedgedriver";
+  static #CHANNELS = ["latest", "beta", "dev"];
 
   static async #getVersionForChannel(version) {
-    if (!["latest", "beta", "dev"].includes(version))
-      return {versionNumber: version, channel: "stable"};
+    let channel = "stable";
+    if (Edge.#CHANNELS.includes(version) && version != "latest")
+      channel = version;
 
-    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];
+    let versionNumber;
+    if (Edge.#CHANNELS.includes(version)) {
+      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;
+      versionNumber = versionNumbers.sort(compareVersions)[0];
+    }
+    else {
+      let split = version.split(".");
+      let minorVersion = split.length == 4 ? parseInt(split.pop(), 10) : -1;
+      let majorVersion = split.join(".");
+      let found;
+      while (!found && minorVersion >= 0) {
+        versionNumber = `${majorVersion}.${minorVersion}`;
+        found = body.includes(versionNumber);
+        minorVersion--;
+      }
+      if (!found)
+        throw new Error(`${UNSUPPORTED_VERSION_ERROR}: ${version}`);
+    }
 
     return {versionNumber, channel};
   }
@@ -540,10 +640,11 @@ class Edge extends Browser {
   }
 
   static #getBinaryPath(channel = "stable") {
-    switch (process.platform) {
+    switch (platform) {
       case "win32":
-        return "${Env:ProgramFiles(x86)}\\Microsoft\\Edge\\Application\\" +
-          "msedge.exe";
+        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}`;
@@ -551,26 +652,28 @@ class Edge extends Browser {
         let appName = Edge.#getDarwinAppName(channel);
         return `${process.env.HOME}/Applications/${appName}.app/Contents/MacOS/${appName}`;
       default:
-        throw new Error(`Unexpected platform: ${process.platform}`);
+        checkPlatform();
     }
   }
 
   /**
-   * Downloads the browser binary file.
+   * Installs the browser. On Linux, Edge is installed as a system package,
+   *   which requires root permissions. On MacOS, Edge is installed as a user
+   *   app (not as a system app). Installing Edge on Windows is not supported.
    * @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.
+   *   number (i.e. "95.0.1020.40"). Defaults to "latest".
    * @return {BrowserBinary}
+   * @throws {Error} Unsupported browser version, Unsupported platform, Browser
+   *   download failed.
    */
-  static async downloadBinary(version = "latest") {
-    if (process.platform == "win32")
+  static async installBrowser(version = "latest") {
+    if (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");
+      throw new Error(`${UNSUPPORTED_PLATFORM_ERROR}: ${platform}`);
 
     const MIN_VERSION = 95;
-    const CHANNELS = ["latest", "beta", "dev"];
-    checkVersion(version, MIN_VERSION, CHANNELS);
+    checkVersion(version, MIN_VERSION, Edge.#CHANNELS);
     let {versionNumber, channel} = await Edge.#getVersionForChannel(version);
 
     let darwinName = {
@@ -581,14 +684,14 @@ class Edge extends Browser {
     let filename = {
       linux: `microsoft-edge-${channel}_${versionNumber}-1_amd64.deb`,
       darwin: `${darwinName}-${versionNumber}.pkg`
-    }[process.platform];
+    }[platform];
     let darwinArch = process.arch == "arm64" ?
       "03adf619-38c6-4249-95ff-4a01c0ffc962" :
       "C1297A47-86C4-4C1F-97FA-950631F94777";
-    let downloadUrl = {
+    let url = {
       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];
+    }[platform];
 
     let snapshotsDir = path.join(snapshotsBaseDir, "edge");
     let archive = path.join(snapshotsDir, "cache", filename);
@@ -600,16 +703,16 @@ class Edge extends Browser {
     catch (e) {}
 
     try {
-      await download(downloadUrl, archive);
+      await download(url, archive);
     }
     catch (err) {
-      throw new Error(`Edge download failed: ${err}`);
+      throw new Error(`${BROWSER_DOWNLOAD_ERROR}: ${url}\n${err}`);
     }
 
-    if (process.platform == "linux") {
+    if (platform == "linux") {
       await promisify(exec)(`dpkg -i ${archive}`);
     }
-    else if (process.platform == "darwin") {
+    else if (platform == "darwin") {
       let appName = Edge.#getDarwinAppName(channel);
       try {
         await fs.promises.rm(`${process.env.HOME}/Applications/${appName}.app`, {recursive: true});
@@ -629,47 +732,55 @@ class Edge extends Browser {
   }
 
   static async #installDriver() {
+    async function extractEdgeZip(archive, cacheDir, driverPath) {
+      await killDriverProcess("msedgedriver");
+      try {
+        await fs.promises.rm(driverPath, {recursive: true});
+      }
+      catch (e) {} // file does not exist
+      await extractZip(archive, {dir: cacheDir});
+    }
+
     let binary = Edge.#getBinaryPath();
     let versionNumber = await Edge.#getInstalledVersionNumber(binary);
     if (!versionNumber)
-      throw new Error("Edge is not installed");
+      throw new Error(`${BROWSER_NOT_INSTALLED_ERROR}: Edge`);
 
-    let [zip, driver] = {
+    let [zip, driverBinary] = {
       "win32-ia32": ["edgedriver_win32.zip", "msedgedriver.exe"],
       "win32-x64": ["edgedriver_win64.zip", "msedgedriver.exe"],
       "linux-x64": ["edgedriver_linux64.zip", "msedgedriver"],
       "darwin-x64": ["edgedriver_mac64.zip", "msedgedriver"],
       "darwin-arm64": ["edgedriver_arm64.zip", "msedgedriver"]
-    }[platform];
+    }[platformArch];
     let cacheDir = path.join(snapshotsBaseDir, "edge", "cache",
                              `edgedriver-${versionNumber}`);
     let archive = path.join(cacheDir, `${versionNumber}-${zip}`);
+    let driverPath = path.join(cacheDir, driverBinary);
 
-    let vSplit = versionNumber.split(".");
-    let lastNum = parseInt(vSplit[3], 10);
-    while (lastNum >= 0) {
-      try {
-        let attempt = `${vSplit[0]}.${vSplit[1]}.${vSplit[2]}.${lastNum}`;
-        await download(`https://msedgedriver.azureedge.net/${attempt}/${zip}`,
-                       archive);
-        break;
-      }
-      catch (e) {
-        lastNum--;
-      }
-    }
-
-    if (lastNum < 0)
-      throw new Error(`msedgedriver was not found for Edge ${versionNumber}`);
-
-    await killDriverProcess(Edge.#DRIVER);
-    let driverPath = path.join(cacheDir, driver);
     try {
-      await fs.promises.rm(driverPath, {recursive: true});
+      await fs.promises.access(archive);
+      await extractEdgeZip(archive, cacheDir, driverPath);
     }
-    catch (e) {} // file does not exist
-    await extractZip(archive, {dir: cacheDir});
+    catch (e) { // zip file is either not cached or corrupted
+      let vSplit = versionNumber.split(".");
+      let lastNum = parseInt(vSplit[3], 10);
+      while (lastNum >= 0) {
+        try {
+          let attempt = `${vSplit[0]}.${vSplit[1]}.${vSplit[2]}.${lastNum}`;
+          await download(`https://msedgedriver.azureedge.net/${attempt}/${zip}`,
+                         archive);
+          break;
+        }
+        catch (e2) {
+          lastNum--;
+        }
+      }
+      if (lastNum < 0)
+        throw new Error(`${DRIVER_DOWNLOAD_ERROR}: Edge ${versionNumber}`);
 
+      await extractEdgeZip(archive, cacheDir, driverPath);
+    }
     return driverPath;
   }
 
@@ -678,8 +789,8 @@ class Edge extends Browser {
     headless = true, extensionPaths = [], incognito = false, insecure = false,
     extraArgs = []
   } = {}) {
-    if (process.platform == "linux" || process.platform == "darwin")
-      await Edge.downloadBinary(version);
+    if (platform == "linux" || platform == "darwin")
+      await Edge.installBrowser(version);
 
     let driverPath = await Edge.#installDriver();
     let serviceBuilder = new edge.ServiceBuilder(driverPath);
@@ -718,257 +829,22 @@ class Edge extends Browser {
         await button.click();
         return await driver.findElement(By.id("itemAllowIncognito")).click();
       }
-      throw new Error("Details button not found");
-    }
-    throw new Error(`Extension "${extensionTitle}" not found`);
-  }
-}
-
-/**
- * Download functionality for Opera. This class can be used statically.
- * @hideconstructor
- * @extends Browser
- */
-class Opera extends Browser {
-  static async #getVersionForChannel(version, platformDir) {
-    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;
-    while (matches.length > 0) {
-      let result = regex.exec(matches.pop());
-      if (!result)
-        continue;
-
-      versionNumber = result[1];
-      try {
-        await got(`https://ftp.opera.com/pub/${channelPath}/${versionNumber}/${platformDir}`);
-        break;
-      }
-      catch (e) {}
-    }
-
-    return {versionNumber, channelPath, filePrefix};
-  }
-
-  static #getBinaryPath(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().includes("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") {
-    const MIN_VERSION = 62;
-    const CHANNELS = ["latest"];
-
-    checkVersion(version, MIN_VERSION, CHANNELS);
-
-    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 {versionNumber, channelPath, filePrefix} =
-      await Opera.#getVersionForChannel(version, platformDir);
-
-    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.#getBinaryPath(browserDir);
-    try {
-      if (process.platform == "linux" &&
-          await Opera.getInstalledVersion("opera") == versionNumber)
-        return {binary, versionNumber};
-
-      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) {
-      let url = `https://ftp.opera.com/pub/${channelPath}/${versionNumber}/${platformDir}/${filename}`;
-      try {
-        await download(url, archive);
-      }
-      catch (err) {
-        throw new Error(`Browser download unavailable at ${url}\n${err}`);
-      }
-    }
-
-    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",
-                             `operadriver-${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);
+      throw new Error(`${ELEMENT_NOT_FOUND_ERROR}: Details button`);
     }
-    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);
+    throw new Error(`${EXTENSION_NOT_FOUND_ERROR}: ${extensionTitle}`);
   }
 }
 
 /**
  * @type {Object}
- * @property {Chromium} chromium - Download functionality for Chromium.
- * @property {Firefox} firefox - Download functionality for Firefox.
- * @property {Edge} edge - Download functionality for Edge.
+ * @property {Chromium} chromium - Browser and webdriver functionality for
+ *   Chromium.
+ * @property {Firefox} firefox - Browser and webdriver functionality for
+ *   Firefox.
+ * @property {Edge} edge - Browser and webdriver functionality for Edge.
  */
 export const BROWSERS = {
   chromium: Chromium,
   firefox: Firefox,
-  edge: Edge,
-  opera: Opera
+  edge: Edge
 };