@eyeo/get-browser-binary 0.22.0 → 0.23.1

package/.gitlab-ci.yml

@@ -57,19 +57,16 @@ test:browsers:linux:dev:
 test:browsers:windows:
   extends: .windows
   script:
-    # Running Edge tests only on the preinstalled version
-    # https://gitlab.com/eyeo/developer-experience/get-browser-binary/-/issues/29
-    - npm test "--" --grep "edge.*latest"
+    - npm test "--" --grep "^.*edge((?!Version:.dev).)*$"
     # Chromium excluded until this is fixed: https://gitlab.com/eyeo/developer-experience/get-browser-binary/-/issues/87
     # - npm test "--" --grep "^.*chromium((?!Version:.dev).)*$"
-    # Running only a subset of Firefox tests to avoid low OS resources error
-    # https://gitlab.com/eyeo/developer-experience/get-browser-binary/-/issues/2
     # Firefox excluded until this is fixed: https://gitlab.com/eyeo/developer-experience/get-browser-binary/-/issues/87
     # - npm test "--" --grep "firefox.*installs"
 
 test:browsers:windows:dev:
   extends: .windows
   script:
+    - npm test "--" --grep "edge.*Version:.dev"
     - npm test "--" --grep "chromium.*Version:.dev"
   allow_failure: true
 
@@ -84,8 +81,7 @@ test:browsers:macos:
     - npm install
   script:
     # Only checking that latest browsers can be installed on macOS
-    # Edge excluded until this is fixed: https://gitlab.com/eyeo/developer-experience/get-browser-binary/-/issues/88
-    - npm test -- -g "(chromium|firefox).*latest.*installs"
+    - npm test -- -g ".*latest.*installs"
 
 docs:
   stage: docs

package/README.md

@@ -32,11 +32,7 @@ the right side.
 
 - Chromium >= 77 (Chromium ARM >= 92)
 - Firefox >= 68
-- Edge >= 114
-
-Note: Installing Edge is not supported on Windows. It is assumed to be installed
-because it is the default browser on that platform. On macOS, only the latest
-Edge version is supported.
+- Edge >= 114 (Linux), Edge >= latest (MacOS, Windows)
 
 ### Verbose logging
 

package/RELEASE_NOTES.md

@@ -1,5 +1,14 @@
 # Unreleased
 
+# 0.23.1
+
+- Re-enables local network access checks on Chromium v.139 (!149)
+
+# 0.23.0
+
+- Adds beta and dev channels to Edge on Windows and MacOS (#29)
+- Fixes edge driver location (!145)
+
 # 0.22.0
 
 - Adds macOS CI job (!141)

package/package.json

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

package/src/chromium.js

@@ -248,8 +248,6 @@ export class Chromium extends Browser {
       await checkExtensionPaths(extensionPaths);
       options.addArguments(`load-extension=${extensionPaths.join(",")}`);
     }
-    if (majorVersion >= 139)
-      options.addArguments("--disable-features=LocalNetworkAccessChecks");
     if (headless) {
       // https://www.selenium.dev/blog/2023/headless-is-going-away/
       if (majorVersion >= 109)

package/src/edge.js

@@ -16,7 +16,7 @@
  */
 
 import path from "path";
-import {exec} from "child_process";
+import {exec, spawn} from "child_process";
 import {promisify} from "util";
 import fs from "fs";
 
@@ -25,9 +25,8 @@ import {until, By, Builder} from "selenium-webdriver";
 import edge from "selenium-webdriver/edge.js";
 
 import {Browser} from "./browser.js";
-import {download, killDriverProcess, wait, getMajorVersion, checkVersion,
-        checkPlatform, errMsg, snapshotsBaseDir, checkExtensionPaths}
-  from "./utils.js";
+import {download, getMajorVersion, checkVersion, checkPlatform, errMsg,
+        snapshotsBaseDir, checkExtensionPaths, platformArch} from "./utils.js";
 
 let {platform} = process;
 
@@ -105,24 +104,34 @@ export class Edge extends Browser {
     return {versionNumber, channel};
   }
 
-  static #getDarwinApp(channel = "stable") {
-    const firstUppercase =
-      String(channel).charAt(0).toUpperCase() + String(channel).slice(1);
-    return channel === "stable" ? "Microsoft Edge" : `Microsoft Edge ${firstUppercase}`;
+  static #appName(channel) {
+    const channels = {stable: "", beta: " Beta", dev: " Dev"};
+
+    if (platform == "linux") {
+      return channel == "stable" ?
+        "microsoft-edge" : `microsoft-edge-${channel}`;
+    }
+    else if (platform == "darwin") {
+      return `Microsoft Edge${channels[channel]}`;
+    }
+    else if (platform == "win32") {
+      return `"Edge${channels[channel]}"`;
+    }
   }
 
   static #getBinaryPath(channel = "stable") {
     switch (platform) {
       case "win32":
-        const programFiles = process.env["ProgramFiles(x86)"] ?
-          "${Env:ProgramFiles(x86)}" : "${Env:ProgramFiles}";
-        return `${programFiles}\\Microsoft\\Edge\\Application\\msedge.exe`;
+        return path.join("C:", "\"Program Files (x86)\"", "Microsoft",
+                         Edge.#appName(channel), "Application", "msedge.exe");
       case "linux":
-        return channel == "stable" ?
-          "/usr/bin/microsoft-edge" : `/usr/bin/microsoft-edge-${channel}`;
+        return path.join("/usr", "bin", Edge.#appName(channel));
       case "darwin":
-        const darwinApp = Edge.#getDarwinApp(channel);
-        return `${process.env.HOME}/Applications/${darwinApp}.app/Contents/MacOS/${darwinApp}`;
+        // Root path may no longer be needed after switching to custom runners
+        // https://eyeo.atlassian.net/browse/DOPE-8
+        const homePath = process.env.CI === "true" ? "/" : process.env.HOME;
+        return path.join(homePath, "Applications", `${Edge.#appName(channel)}.app`,
+                         "Contents", "MacOS", Edge.#appName(channel));
       default:
         checkPlatform();
     }
@@ -141,43 +150,61 @@ export class Edge extends Browser {
    *   download failed.
    */
   static async installBrowser(version = "latest", downloadTimeout = 0) {
-    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(`${errMsg.unsupportedPlatform}: ${platform}`);
-
-    if (platform == "darwin" && !/latest|beta|dev/.test(version))
-      throw new Error(`${errMsg.unsupportedVersion}: ${version}. Only "latest", "beta" or "dev" are supported`);
-
     checkVersion(version, Edge.#MIN_VERSION, Edge.#CHANNELS);
-    let {versionNumber, channel} = await Edge.#getVersionForChannel(version);
-
-    let filename = {
-      linux: `microsoft-edge-${channel}_${versionNumber}-1_amd64.deb`,
-      darwin: `MicrosoftEdge-${versionNumber}.pkg`
-    }[platform];
+    if (!Edge.#CHANNELS.includes(version) && platform != "linux")
+      throw new Error(`${errMsg.unsupportedVersion}: ${version}. Supported versions: ${Edge.#CHANNELS.join(",")}`);
 
-    let snapshotsDir = path.join(snapshotsBaseDir, "edge");
-    let archive = path.join(snapshotsDir, "cache", filename);
+    let {versionNumber, channel} = await Edge.#getVersionForChannel(version);
     let binary = Edge.#getBinaryPath(channel);
+
+    // Patch versions differ between Debian repo and Enterprise API.
+    // We treat same-major versions as installed to avoid re-downloads.
+    // Applies to both channel builds and numeric Linux versions.
     try {
-      if (await Edge.getInstalledVersion(binary) == versionNumber)
-        return {binary, versionNumber};
+      const installedVersion = await Edge.getInstalledVersion(binary);
+      if (getMajorVersion(installedVersion) == getMajorVersion(versionNumber))
+        return {binary, versionNumber: installedVersion};
     }
     catch (e) {}
 
-    let url = `https://packages.microsoft.com/repos/edge/pool/main/m/microsoft-edge-${channel}/${filename}`;
-    try {
-      if (platform == "darwin") {
-        const caskFile = channel === "stable" ? "microsoft-edge.json" : `microsoft-edge@${channel}.json`;
-        const caskUrl = `https://formulae.brew.sh/api/cask/${caskFile}`;
-        try {
-          ({url} = await got(caskUrl).json());
-        }
-        catch (err) {
-          throw new Error(`${errMsg.browserVersionCheck}: ${caskUrl}\n${err}`);
-        }
+    const [plat, arch, ext] = {
+      "win32-ia32": ["Windows", "x86", ".msi"],
+      "win32-x64": ["Windows", "x64", ".msi"],
+      "linux-x64": ["Linux", "x64", ".deb"],
+      "darwin-x64": ["MacOS", "universal", ".pkg"],
+      "darwin-arm64": ["MacOS", "universal", ".pkg"]
+    }[platformArch];
+
+    let url;
+    let filename;
+    const downloadChannels = {latest: "Stable", beta: "Beta", dev: "Dev"};
+    if (!Edge.#CHANNELS.includes(version) && platform == "linux") {
+      filename = `microsoft-edge-${channel}_${versionNumber}-1_amd64.deb`;
+      url = `https://packages.microsoft.com/repos/edge/pool/main/m/microsoft-edge-${channel}/${filename}`;
+    }
+    else {
+      let products = await got("https://edgeupdates.microsoft.com/api/products?view=enterprise").json();
+      for (let product of products) {
+        if (product.Product != downloadChannels[version])
+          continue;
+
+        let release = product.Releases.find(
+          r => r.Platform == plat && r.Architecture == arch);
+        if (!release)
+          continue;
+
+        ({Location: url} =
+          release.Artifacts.find(a => a.Location.endsWith(ext)));
+        filename = url.split("/").pop();
+        break;
       }
+    }
+
+    if (!url)
+      throw new Error(`${errMsg.browserDownload}: Release not found for Edge ${downloadChannels[version]} on ${plat} ${arch}`);
+
+    const archive = path.join(snapshotsBaseDir, "edge", "cache", filename);
+    try {
       await download(url, archive, downloadTimeout);
     }
     catch (err) {
@@ -188,8 +215,41 @@ export class Edge extends Browser {
       await promisify(exec)(`dpkg -i ${archive}`);
     }
     else if (platform == "darwin") {
-      await fs.promises.rm(`${process.env.HOME}/Applications/${Edge.#getDarwinApp(channel)}.app`, {force: true, recursive: true});
-      await promisify(exec)(`installer -pkg ${archive} -target CurrentUserHomeDirectory`);
+      let command;
+      if (process.env.CI === "true") {
+        // For some reason installing apps on the home directory fails on macOS
+        // runners. Using the root target as a workaround
+        // This may no longer be needed after switching to custom runners
+        // https://eyeo.atlassian.net/browse/DOPE-8
+        command = `sudo installer -pkg ${archive} -target /`;
+      }
+      else {
+        await fs.promises.rm(
+          path.join(process.env.HOME, "Applications", `${Edge.#appName(channel)}.app`),
+          {force: true, recursive: true}
+        );
+        command = `installer -pkg ${archive} -target CurrentUserHomeDirectory`;
+      }
+
+      await promisify(exec)(command);
+    }
+    else if (platform == "win32") {
+      // /S strips quotes and /C executes the runnable file
+      const installProcess = spawn("cmd", [`/S /C ${archive}`], {
+        detached: true,
+        env: process.env
+      });
+
+      await new Promise((resolve, reject) => {
+        function onClose(code) {
+          if (code != 0)
+            reject(new Error(`${errMsg.browserInstall}. Exit code: ${code}`));
+
+          resolve();
+        }
+
+        installProcess.on("close", onClose);
+      });
     }
 
     return {binary, versionNumber};
@@ -212,24 +272,29 @@ export class Edge extends Browser {
 
     let binary;
     let versionNumber;
-    if (!customBrowserBinary && (platform == "linux" || platform == "darwin")) {
-      ({binary, versionNumber} =
-        await Edge.installBrowser(version, downloadTimeout));
+    if (customBrowserBinary) {
+      binary = customBrowserBinary;
+      versionNumber = await Edge.getInstalledVersion(binary);
     }
     else {
-      binary = customBrowserBinary || Edge.#getBinaryPath();
-      versionNumber =
-        await Edge.getInstalledVersion(binary);
+      ({binary, versionNumber} =
+        await Edge.installBrowser(version, downloadTimeout));
     }
 
+    if (platform == "win32")
+      // webdriver can't find the binary when subfolders are enclosed by quotes
+      binary = binary.replaceAll("\"", "");
+
     const majorVersion = getMajorVersion(versionNumber);
     const edgeOptions = {};
     // https://issues.chromium.org/issues/409441960
     if (majorVersion >= 136)
       edgeOptions.enableExtensionTargets = true;
 
-    const options = new edge.Options({"ms:edgeOptions": edgeOptions})
-      .addArguments("no-sandbox", ...extraArgs);
+    let options = new edge.Options({"ms:edgeOptions": edgeOptions})
+      .addArguments("no-sandbox", ...extraArgs)
+      .setEdgeChromiumBinaryPath(binary);
+
     if (headless) {
       if (versionNumber && majorVersion >= 114)
         options.addArguments("headless=new");
@@ -244,27 +309,19 @@ export class Edge extends Browser {
       options.addArguments("inprivate");
     if (insecure)
       options.addArguments("ignore-certificate-errors");
-    if (platform === "linux" || platform === "darwin")
-      options.setEdgeChromiumBinaryPath(binary);
 
     let builder = new Builder();
     builder.forBrowser("MicrosoftEdge");
     builder.setEdgeOptions(options);
 
     let driver;
-    // On Windows CI, occasionally a SessionNotCreatedError is thrown, likely
-    // due to low OS resources, that's why building the driver is retried
-    await wait(async() => {
-      try {
-        driver = await builder.build();
-        return true;
-      }
-      catch (err) {
-        if (err.name != "SessionNotCreatedError")
-          throw err;
-        await killDriverProcess("msedgedriver");
-      }
-    }, 30000, `${errMsg.driverStart}: msedgedriver`, 1000);
+    try {
+      process.env.SE_DRIVER_MIRROR_URL = "https://msedgedriver.microsoft.com";
+      driver = edge.Driver.createSession(options);
+    }
+    catch (err) {
+      throw new Error(`${errMsg.driverStart}: msedgedriver\n${err}`);
+    }
 
     // From Edge 134 on, developer mode needs to be enabled
     // for custom extensions to work properly

package/src/utils.js

@@ -32,6 +32,7 @@ export const errMsg = {
   driverStart: "Unable to start driver",
   extensionNotFound: "Extension not found",
   browserDownload: "Browser download failed",
+  browserInstall: "Browser installation failed",
   browserNotInstalled: "Browser is not installed",
   browserVersionCheck: "Checking the browser version failed",
   elemNotFound: "HTML element not found",

package/test/browsers.js

@@ -180,13 +180,20 @@ for (let browser of Object.keys(BROWSERS)) {
             await killDriverProcess("geckodriver");
 
           // https://gitlab.com/eyeo/developer-experience/get-browser-binary/-/issues/77
-          if (process.platform == "win32" && browser == "chromium")
+          if (process.platform == "win32" && browser == "chromium") {
             await killDriverProcess("chrome");
-          else if (process.platform == "win32" && browser == "edge")
+          }
+          else if (process.platform == "win32" && browser == "edge") {
+            await killDriverProcess("msedgedriver");
             await killDriverProcess("msedge");
+          }
         }
 
         beforeEach(function() {
+          if (browser == "edge" && process.platform != "linux" &&
+              version == "114.0.1823.82")
+            this.skip();
+
           if (failedInstall)
             this.skip();
         });
@@ -194,8 +201,8 @@ for (let browser of Object.keys(BROWSERS)) {
         afterEach(quitDriver);
 
         it("installs", async function() {
-          if (browser == "edge" && process.platform == "win32")
-            this.skip();
+          // installing browsers may take a while on the CI
+          this.timeout(150000);
 
           let binary;
           let versionNumber;
@@ -326,6 +333,10 @@ for (let browser of Object.keys(BROWSERS)) {
           if (browser == "firefox" && version == "68.0")
             this.skip();
 
+          // Skipping flaky test until solution is found, see issue #89
+          if (process.platform === "win32")
+            this.skip();
+
           let {extensionPaths, manifest} = getExtension(browser, version);
           driver = await BROWSERS[browser].getDriver(
             version, {headless: false, extensionPaths, incognito: true});
@@ -360,12 +371,8 @@ for (let browser of Object.keys(BROWSERS)) {
       });
     }
 
-
     describe("Any version", async() => {
-      it("does not install unsupported versions", async function() {
-        if (browser == "edge" && process.platform == "win32")
-          this.skip();
-
+      it("does not install unsupported versions", async() => {
         for (let unsupported of ["0.0", "invalid"]) {
           await expect(BROWSERS[browser].installBrowser(unsupported))
             .rejects.toThrow(`Unsupported browser version: ${unsupported}`);