@eyeo/get-browser-binary 0.3.0 → 0.5.0

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/.eslintrc.json

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

package/test/browsers.js

@@ -24,13 +24,15 @@ import {killDriverProcess} from "../src/utils.js";
 
 // Required to set the driver path on Windows
 import "chromedriver";
-import "msedgedriver";
+import "geckodriver";
 
 const VERSIONS = {
-  chromium: [void 0, "beta", "dev", "77.0.3865.0"],
-  firefox: [void 0, "beta", "68.0"],
-  edge: [void 0]
+  chromium: ["latest", "75.0.3770.0", "beta", "dev"],
+  firefox: ["latest", "60.0", "beta"],
+  edge: ["latest", "95.0.1020.53", "beta", "dev"],
+  opera: ["latest", "62.0.3331.66"]
 };
+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 +64,144 @@ 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)/
-        };
+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];
+}
 
-        driver = await BROWSERS[browser].getDriver(version);
-        await driver.navigate().to("about:blank");
+function getWindowSize(driver) {
+  return driver.executeScript(() => {
+    return {height: window.innerHeight, width: window.innerWidth};
+  });
+}
 
-        expect((await driver.getCapabilities()).getBrowserName())
-          .toEqual(expect.stringMatching(names[browser]));
-      });
+expect.extend({
+  toMeasureLessThan(small, big) {
+    let pass = small.width < big.width || small.height < big.height;
+    let message = () =>
+      `expected small sizes (w: ${small.width}, h: ${small.height}) ` +
+      `to be smaller than big sizes (w: ${big.width}, h: ${big.height})`;
+    if (pass)
+      return {message, pass: true};
+    return {message, pass: false};
+  }
+});
 
-      it("supports extra args", async() => {
-        driver = await BROWSERS[browser].getDriver(
-          version, {extraArgs: ["auto-open-devtools-for-tabs"]});
-        await driver.navigate().to("about:blank");
-      });
+for (let browser of Object.keys(BROWSERS)) {
+  describe(`Browser: ${browser}`, function() {
+    this.timeout(150000);
+
+    before(async() => {
+      try {
+        await fs.promises.rm(snapshotsBaseDir, {recursive: true});
+      }
+      catch (e) {}
+    });
 
-      it("loads an extension", async() => {
-        let headless = browser == "firefox";
+    for (let version of VERSIONS[browser]) {
+      describe(`Version: ${version}`, () => {
+        let driver = null;
+
+        async function quitDriver() {
+          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");
+        }
 
-        driver = await BROWSERS[browser].getDriver(
-          version, {headless, extensionPaths});
-        await getHandle(driver, "/index.html");
+        afterEach(quitDriver);
+
+        it("downloads", async function() {
+          if (browser == "edge" && process.platform == "win32")
+            this.skip();
+
+          let {binary, versionNumber} =
+            await BROWSERS[browser].downloadBinary(version);
+          let browserName =
+            browser == "opera" ? /(opera|Opera)/ :
+            browser == "edge" ? /(edge|Edge)/ :
+            browser;
+          expect(binary).toEqual(expect.stringMatching(browserName));
+
+          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 headless = false;
+          let extraArgs = browser == "firefox" ?
+            ["--devtools"] : ["auto-open-devtools-for-tabs"];
+
+          driver = await BROWSERS[browser].getDriver(
+            version, {headless, extraArgs});
+          await driver.navigate().to(TEST_URL);
+          let sizeDevToolsOpen = await getWindowSize(driver);
+          await quitDriver();
+
+          driver = await BROWSERS[browser].getDriver(version, {headless});
+          await driver.navigate().to(TEST_URL);
+          let sizeDevToolsClosed = await getWindowSize(driver);
+
+          expect(sizeDevToolsOpen).toMeasureLessThan(sizeDevToolsClosed);
+        });
+
+        it("loads an extension", async() => {
+          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 == "60.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");
+        });
       });
+    }
 
-      it("loads an extension in incognito mode", async function() {
-        if (browser == "firefox" && version == "68.0")
-          this.skip();
+    it("does not download unsupported versions", async function() {
+      if (browser == "edge" && process.platform == "win32")
+        this.skip();
 
-        if (process.platform == "win32")
-          this.timeout(30000);
+      const UNSUPPORTED = "0.0";
 
-        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");
-      });
+      await expect(BROWSERS[browser].downloadBinary(UNSUPPORTED))
+        .rejects.toThrow(`Unsupported browser version: ${UNSUPPORTED}`);
     });
-  }
+  });
 }

package/test/docker/Dockerfile

@@ -0,0 +1,9 @@
+FROM registry.gitlab.com/eyeo/docker/get-browser-binary:node16
+
+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