@eyeo/get-browser-binary 0.16.0 → 0.18.0

package/.gitlab-ci.yml

@@ -27,42 +27,52 @@ test:basic:
     - npm run lint
     - npm test -- --grep "Utils"
 
-test:browsers:linux:
+.linux:
   stage: test
   image: docker:24.0.5
   services:
     - docker:24.0.5-dind
   before_script:
     - docker build -f test/docker/Dockerfile -t browsers .
+
+test:browsers:linux:
+  extends: .linux
   script:
-    - docker run --shm-size=512m -t browsers
+    - docker run --shm-size=512m -t -e TEST_ARGS="--grep ^.*Browser((?!Version:.dev).)*\$" browsers
 
-test:browsers:windows:
+test:browsers:linux:dev:
+  extends: .linux
+  script:
+    - docker run --shm-size=512m -t -e TEST_ARGS="--grep Version:.dev" browsers
+  allow_failure: true
+
+.windows:
   stage: test
-  variables:
-    CI_PROJECT_ID_MAINSTREAM: 36688302
   before_script:
-    - Invoke-WebRequest
-        -Uri "${Env:CI_API_V4_URL}/projects/${Env:CI_PROJECT_ID_MAINSTREAM}/packages/generic/microsoft-edge/79.0.309/MicrosoftEdgeEnterpriseX64.msi"
-        -Headers @{'JOB-TOKEN' = $Env:CI_JOB_TOKEN}
-        -OutFile 'MicrosoftEdgeEnterpriseX64.msi'
-    - Start-Process msiexec
-        -ArgumentList "/i MicrosoftEdgeEnterpriseX64.msi /norestart /qn" -Wait
-    - choco upgrade -y --no-progress nodejs --version 18.17.1
+    - choco install -y microsoft-edge
     - npm install
+  tags:
+    - eyeo-windows
+  cache: {}
+  # Retrying to mitigate Edge install issues
+  retry: 1
+
+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 "chromium"
+    - 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
     - npm test -- --grep "firefox.*installs"
-  tags:
-    - shared-windows
-    - windows
-    - windows-1809
-  cache: {}
+
+test:browsers:windows:dev:
+  extends: .windows
+  script:
+    - npm test -- --grep "chromium.*Version:.dev"
+  allow_failure: true
 
 docs:
   stage: docs

package/README.md

@@ -32,7 +32,7 @@ the right side.
 
 - Chromium >= 77 (Chromium ARM >= 92)
 - Firefox >= 68
-- Edge >= 95 (Windows Edge >= 79)
+- 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
@@ -43,6 +43,22 @@ Edge version is supported.
 Set the `VERBOSE` environment variable to `"true"` to get verbose logging on
 download requests.
 
+### Offline execution
+
+It is possible to run browsers offline as long as they have been previously
+installed. Example:
+
+```javascript
+// Online
+let {binary} = await BROWSERS[browser].installBrowser(version);
+console.log(binary); // keep the browser binary location to use it offline
+let driver = await BROWSERS[browser].getDriver(version); // let the driver binary download
+
+// Offline
+let customBrowserBinary = "<browser binary location>";
+let driver = await BROWSERS[browser].getDriver(version, {customBrowserBinary});
+```
+
 ## Development
 
 ### Prerequisites

package/RELEASE_NOTES.md

@@ -1,6 +1,29 @@
+# Unreleased 
+
+# 0.18.0
+
+- Adds support for Firefox dev channel (!116)
+- Drops support for old Edge versions (#79)
+- Fixes `enableExtensionInIncognito()` to keep working with Chromium +131 (!117)
+
+## Testing
+
+- Changes the way test extensions load internal pages. With Chromium +133,
+`driver.getAllWindowHandles()` can't see tabs opened by an extension if the url
+option opens an extension page. Please check the example provided by !119 in
+order to workaround that issue.
+
+# 0.17.0
+
+- Stops calling `driver.close()` in `enableExtensionInIncognito()`
+on non-Windows platforms (!114)
+- Add instructions for offline execution (!110)
+- Adds option to setup proxy through PAC file for Firefox (!115)
+
 # 0.16.0
 
-- Starts using selenium's automated driver management (#67)
+- Starts using selenium's automated driver management. That means additional
+`chromedriver` and `msedgedriver` packages are no longer needed (#67)
 - Loads the extension in Firefox by local path instead of being copied to a
 temporary folder (!104)
 - Checks if extensions can be loaded beforehand, by ensuring they contain a
@@ -18,7 +41,9 @@ include parenthesis (#69)
 ### Notes for integrators
 
 - Please make sure that your selenium-webdriver package version is at least
-4.15.0 (the one used in this release) (#67)
+4.15.0 (the one used in this release). Also make sure that you are not using the
+`chromedriver` nor `msedgedriver` packages, otherwise the automated driver
+management may not work as expected (#67)
 - If you experience chromedriver issues, try deleting the `/browser-snapshots`
 cache folder.
 

package/package.json

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

package/src/browser.js

@@ -95,6 +95,8 @@ export class Browser {
    *   certificates, or not.
    * @property {Array.<string>} [extraArgs=[]] Additional arguments to start
    *   the browser with.
+   * @property {string} [proxy] Only for Firefox, path to network
+   *   proxy autoconfig url (PAC file).
    * @property {string} [customBrowserBinary] Path to the browser binary to be
    *   used, instead of the browser installed by installBrowser(). This option
    *   overrides the version parameter in getDriver().

package/src/chromium.js

@@ -229,46 +229,59 @@ export class Chromium extends Browser {
 
   /** @see Browser.enableExtensionInIncognito */
   static async enableExtensionInIncognito(driver, extensionTitle) {
-    let handle = await driver.getWindowHandle();
+    const currentHandle = await driver.getWindowHandle();
 
-    let version = getMajorVersion(
-      (await driver.getCapabilities()).getBrowserVersion());
-    if (version >= 115)
+    const browserVersion =
+      getMajorVersion((await driver.getCapabilities()).getBrowserVersion());
+    if (browserVersion >= 115)
       // On Chromium 115 opening chrome://extensions on the default tab causes
       // WebDriverError: disconnected. Switching to a new window as a workaround
       await driver.switchTo().newWindow("window");
 
     await driver.navigate().to("chrome://extensions");
-    await driver.executeScript((...args) => {
-      let enable = () => document.querySelector("extensions-manager").shadowRoot
+
+    await driver.executeScript((title, errorMsg) => {
+      const enableIncognitoMode = () => document
+        .querySelector("extensions-manager").shadowRoot
         .querySelector("extensions-detail-view").shadowRoot
         .getElementById("allow-incognito").shadowRoot
         .getElementById("crToggle").click();
 
-      let extensions = document.querySelector("extensions-manager").shadowRoot
-        .getElementById("items-list").shadowRoot
-        .querySelectorAll("extensions-item");
+      const getExtensionDetailsButton = () => {
+        const extensions = document
+          .querySelector("extensions-manager").shadowRoot
+          .getElementById("items-list").shadowRoot
+          .querySelectorAll("extensions-item");
 
-      return new Promise((resolve, reject) => {
-        let extensionDetails;
+        let detailsButton;
         for (let {shadowRoot} of extensions) {
-          if (shadowRoot.getElementById("name").innerHTML != args[0])
+          const extensionName = shadowRoot.getElementById("name").innerHTML;
+          if (!extensionName.includes(title))
             continue;
 
-          extensionDetails = shadowRoot.getElementById("detailsButton");
+          detailsButton = shadowRoot.getElementById("detailsButton");
           break;
         }
-        if (!extensionDetails)
-          reject(`${args[1]}: ${args[0]}`);
 
-        extensionDetails.click();
-        setTimeout(() => resolve(enable()), 100);
+        return detailsButton;
+      };
+
+      return new Promise((resolve, reject) => {
+        const detailsButton = getExtensionDetailsButton();
+
+        if (!detailsButton)
+          reject(`${errorMsg}: ${title}`);
+
+        detailsButton.click();
+        setTimeout(() => resolve(enableIncognitoMode()), 100);
       });
     }, extensionTitle, errMsg.extensionNotFound);
-    if (version >= 115)
-      // Closing the previously opened new window
+
+    if (browserVersion >= 115 && process.platform == "win32")
+      // Closing the previously opened new window. Needed on Windows to avoid a
+      // further `WebDriverError: disconnected` error
       await driver.close();
 
-    await driver.switchTo().window(handle);
+    await driver.switchTo().window(currentHandle);
   }
 }

package/src/edge.js

@@ -23,7 +23,6 @@ import fs from "fs";
 import got from "got";
 import webdriver from "selenium-webdriver";
 import edge from "selenium-webdriver/edge.js";
-import extractZip from "extract-zip";
 
 import {Browser} from "./browser.js";
 import {download, killDriverProcess, wait, getMajorVersion, checkVersion,
@@ -40,6 +39,7 @@ let {platform} = process;
  */
 export class Edge extends Browser {
   static #CHANNELS = ["latest", "beta", "dev"];
+  static #MIN_VERSION = 114;
 
   static async #getVersionForChannel(version) {
     let channel = "stable";
@@ -106,7 +106,7 @@ export class Edge extends Browser {
    *   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=latest] Either "latest", "beta", "dev" or a full
-   *   version number (i.e. "95.0.1020.40").
+   *   version number (i.e. "114.0.1823.82").
    * @param {number} [downloadTimeout=0] Allowed time in ms for the download of
    *   install files to complete. When set to 0 there is no time limit.
    * @return {BrowserBinary}
@@ -123,8 +123,7 @@ export class Edge extends Browser {
       // Only latest Edge is supported on macOS
       throw new Error(`${errMsg.unsupportedVersion}: ${version}. Only "latest" is supported`);
 
-    const MIN_VERSION = 95;
-    checkVersion(version, MIN_VERSION, Edge.#CHANNELS);
+    checkVersion(version, Edge.#MIN_VERSION, Edge.#CHANNELS);
     let {versionNumber, channel} = await Edge.#getVersionForChannel(version);
 
     let filename = {
@@ -179,53 +178,13 @@ export class Edge extends Browser {
     return installedVersion.trim().replace(/.*\s/, "");
   }
 
-  static async #installOldWindowsDriver(binary) {
-    async function extractEdgeZip(archive, cacheDir, driverPath) {
-      await killDriverProcess("msedgedriver");
-      await fs.promises.rm(driverPath, {force: true});
-      await extractZip(archive, {dir: cacheDir});
-    }
-
-    let binaryPath = binary || Edge.#getBinaryPath();
-    let versionNumber = await Edge.#getInstalledVersionNumber(binaryPath);
-    let cacheDir = path.join(snapshotsBaseDir, "edge", "cache",
-                             `edgedriver-${versionNumber}`);
-    let zip = process.arch == "ia32" ?
-      "edgedriver_win32.zip" : "edgedriver_win64.zip";
-    let archive = path.join(cacheDir, `${versionNumber}-${zip}`);
-    let driverPath = path.join(cacheDir, "msedgedriver.exe");
-
-    try {
-      await fs.promises.access(archive);
-      await extractEdgeZip(archive, cacheDir, driverPath);
-    }
-    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(`${errMsg.driverDownload}: Edge ${versionNumber}`);
-
-      await extractEdgeZip(archive, cacheDir, driverPath);
-    }
-    return driverPath;
-  }
-
   /** @see Browser.getDriver */
   static async getDriver(version = "latest", {
     headless = true, extensionPaths = [], incognito = false, insecure = false,
     extraArgs = [], customBrowserBinary
   } = {}, downloadTimeout = 0) {
+    checkVersion(version, Edge.#MIN_VERSION, Edge.#CHANNELS);
+
     let binary;
     let versionNumber;
     if (!customBrowserBinary && (platform == "linux" || platform == "darwin")) {
@@ -260,15 +219,6 @@ export class Edge extends Browser {
     builder.forBrowser("MicrosoftEdge");
     builder.setEdgeOptions(options);
 
-    if (getMajorVersion(versionNumber) < 95) {
-      // Selenium's automated driver download doesn't work on old Edge versions.
-      // Support to installing old drivers is only needed by Windows CI jobs.
-      // https://gitlab.com/eyeo/developer-experience/get-browser-binary/-/issues/2#note_1189235804
-      let driverPath = await Edge.#installOldWindowsDriver(binary);
-      let serviceBuilder = new edge.ServiceBuilder(driverPath);
-      builder.setEdgeService(serviceBuilder);
-    }
-
     let driver;
     // On Windows CI, occasionally a SessionNotCreatedError is thrown, likely
     // due to low OS resources, that's why building the driver is retried

package/src/firefox.js

@@ -38,12 +38,13 @@ let {until, By} = webdriver;
  * @extends Browser
  */
 export class Firefox extends Browser {
-  static #CHANNELS = ["latest", "beta"];
+  static #CHANNELS = ["latest", "beta", "dev"];
 
   static async #getVersionForChannel(channel) {
     if (!Firefox.#CHANNELS.includes(channel))
       return channel;
 
+    // https://wiki.mozilla.org/Release_Management/Product_details#firefox_versions.json
     let url = "https://product-details.mozilla.org/1.0/firefox_versions.json";
     let data;
     try {
@@ -52,17 +53,44 @@ export class Firefox extends Browser {
     catch (err) {
       throw new Error(`${errMsg.browserVersionCheck}: ${url}\n${err}`);
     }
-    return channel == "beta" ?
-      data.LATEST_FIREFOX_DEVEL_VERSION : data.LATEST_FIREFOX_VERSION;
+
+    if (channel === "beta") {
+      // The validated latest Firefox Beta built, exposed for downloading
+      return data.LATEST_FIREFOX_RELEASED_DEVEL_VERSION;
+    }
+    else if (channel === "dev") {
+      // Firefox Developer Edition
+      return data.FIREFOX_DEVEDITION;
+    }
+
+    // The Firefox Version shipped on the release channel
+    return data.LATEST_FIREFOX_VERSION;
+  }
+
+  static #getAppDir(dir) {
+    const appDirRegexes = {
+      win32: /^core$/,
+      linux: /^firefox$/,
+      darwin: /^Firefox.*\.app$/
+    };
+
+    const contents = fs.readdirSync(dir);
+    const appDir = contents.find(candidateDir =>
+      appDirRegexes[process.platform].test(candidateDir));
+
+    return path.join(dir, appDir);
   }
 
   static #getBinaryPath(dir) {
     checkPlatform();
-    return {
-      win32: path.join(dir, "core", "firefox.exe"),
-      linux: path.join(dir, "firefox", "firefox"),
-      darwin: path.join(dir, "Firefox.app", "Contents", "MacOS", "firefox")
-    }[process.platform];
+
+    const defaultBinaries = {
+      win32: path.join(Firefox.#getAppDir(dir), "firefox.exe"),
+      linux: path.join(Firefox.#getAppDir(dir), "firefox"),
+      darwin: path.join(Firefox.#getAppDir(dir), "Contents", "MacOS", "firefox")
+    };
+
+    return defaultBinaries[process.platform];
   }
 
   static #extractFirefoxArchive(archive, dir) {
@@ -113,12 +141,16 @@ export class Firefox extends Browser {
     let snapshotsDir = path.join(snapshotsBaseDir, "firefox");
     let browserDir = path.join(snapshotsDir,
                                `firefox-${platformArch}-${versionNumber}`);
-    let binary = Firefox.#getBinaryPath(browserDir);
+
+    let binary;
     try {
       await fs.promises.access(browserDir);
+      binary = Firefox.#getBinaryPath(browserDir);
       return {binary, versionNumber};
     }
-    catch (e) {}
+    catch (e) {
+      // The binary was not already downloaded
+    }
 
     let archive = path.join(snapshotsDir, "cache", fileName);
     await fs.promises.mkdir(path.dirname(browserDir), {recursive: true});
@@ -126,7 +158,9 @@ export class Firefox extends Browser {
       await fs.promises.access(archive);
     }
     catch (e) {
-      let url = `https://archive.mozilla.org/pub/firefox/releases/${versionNumber}/${buildPlatform}/en-US/${fileName}`;
+      const baseUrl = "https://archive.mozilla.org/pub";
+      const channel = version === "dev" ? "devedition" : "firefox";
+      let url = `${baseUrl}/${channel}/releases/${versionNumber}/${buildPlatform}/en-US/${fileName}`;
       try {
         await download(url, archive, downloadTimeout);
       }
@@ -135,14 +169,20 @@ export class Firefox extends Browser {
       }
     }
     await Firefox.#extractFirefoxArchive(archive, browserDir);
+    binary = Firefox.#getBinaryPath(browserDir);
 
     return {binary, versionNumber};
   }
 
   /** @see Browser.getDriver */
+  /** In Firefox you can define url to proxy autoconfig file.
+  * Proxy Autoconfig file determine whether web requests should go through
+  * a proxy server or connect directly. This allow to use localhost mapped
+  * to any url (f.ex testpages.adblockplus.org)
+  */
   static async getDriver(version = "latest", {
     headless = true, extensionPaths = [], incognito = false, insecure = false,
-    extraArgs = [], customBrowserBinary
+    extraArgs = [], customBrowserBinary, proxy
   } = {}, downloadTimeout = 0) {
     let binary;
     let versionNumber;
@@ -163,6 +203,10 @@ export class Firefox extends Browser {
     // Enabled by default on Firefox > 68
     if (versionNumber && getMajorVersion(versionNumber) == 68)
       options.setPreference("dom.promise_rejection_events.enabled", true);
+    if (proxy) {
+      options.setPreference("network.proxy.type", 2);
+      options.setPreference("network.proxy.autoconfig_url", proxy);
+    }
 
     options.setBinary(customBrowserBinary || binary);
 

package/test/browsers.js

@@ -27,10 +27,11 @@ import {TEST_SERVER_URL} from "./test-server.js";
 
 const VERSIONS = {
   chromium: ["latest", "77.0.3865.0", "beta", "dev"],
-  firefox: ["latest", "68.0", "beta"],
-  edge: ["latest", "95.0.1020.40", "beta", "dev"]
+  firefox: ["latest", "68.0", "beta", "dev"],
+  edge: ["latest", "114.0.1823.82", "beta", "dev"]
 };
 const TEST_URL_BASIC = `${TEST_SERVER_URL}/basic.html`;
+const PROXY_URL_BASIC = "http://testpages.adblockplus.org/basic.html";
 const TEST_URL_LONG = `${TEST_SERVER_URL}/long.html`;
 
 async function switchToHandle(driver, testFn) {
@@ -106,7 +107,8 @@ function getExtension(browser, version) {
 
 async function getInstallFileCTime(browser) {
   // Browsers installed at OS level are not tested
-  if (browser == "edge" && process.platform == "win32")
+  if (browser == "edge" && (process.platform == "win32" ||
+                            process.platform == "darwin"))
     return null;
 
   const installTypes = [".zip", ".dmg", ".bz2", ".deb", ".exe"];
@@ -141,6 +143,14 @@ function addVersionToTitle(ctx, version) {
   ctx.test.title = `${ctx.test.title} [v${version}]`;
 }
 
+function isOldHeadlessMode(browser, version) {
+  // Chromium's old headless mode doesn't support loading extensions
+  return browser != "firefox" && (
+    !["latest", "beta", "dev"].includes(version) ||
+    // Edge on the Windows CI is v79, that is old headless
+    (browser == "edge" && process.platform == "win32"));
+}
+
 for (let browser of Object.keys(BROWSERS)) {
   describe(`Browser: ${browser}`, () => {
     before(async() => {
@@ -168,6 +178,12 @@ for (let browser of Object.keys(BROWSERS)) {
             await killDriverProcess("chromedriver");
           else if (browser == "firefox")
             await killDriverProcess("geckodriver");
+
+          // https://gitlab.com/eyeo/developer-experience/get-browser-binary/-/issues/77
+          if (process.platform == "win32" && browser == "chromium")
+            await killDriverProcess("chrome");
+          else if (process.platform == "win32" && browser == "edge")
+            await killDriverProcess("msedge");
         }
 
         beforeEach(function() {
@@ -258,6 +274,22 @@ for (let browser of Object.keys(BROWSERS)) {
           expect(sizeSmall).toMeasureLessThan(sizeDefault);
         });
 
+        it("supports proxy", async function() {
+          if (browser != "firefox")
+            this.skip();
+
+          let headless = true;
+          let proxy = "http://localhost:3000/proxy-config.pac";
+          let extraArgs = [];
+          driver = await BROWSERS[browser].getDriver(
+            version, {headless, extraArgs, proxy});
+          await driver.navigate().to(PROXY_URL_BASIC);
+
+          let text = await driver.findElement(By.id("basic")).getText();
+          expect(text).toEqual("Test server basic page");
+          await quitDriver();
+        });
+
         it("takes a full page screenshot", async() => {
           driver = await BROWSERS[browser].getDriver(version);
           await driver.navigate().to(TEST_URL_LONG);
@@ -277,9 +309,7 @@ for (let browser of Object.keys(BROWSERS)) {
         // Selenium's automated driver download should be able to manage it.
         // https://gitlab.com/eyeo/developer-experience/get-browser-binary/-/issues/44
         it("loads an extension", async() => {
-          // Chromium's old headless mode doesn't support loading extensions
-          let headless = browser == "firefox" || (browser == "chromium" &&
-            ["latest", "beta", "dev"].includes(version));
+          let headless = !isOldHeadlessMode(browser, version);
           let {extensionPaths} = getExtension(browser, version);
 
           driver = await BROWSERS[browser].getDriver(
@@ -299,24 +329,50 @@ for (let browser of Object.keys(BROWSERS)) {
           );
           await getHandle(driver, "/index.html");
         });
+
+        it("updates an extension", async() => {
+          let headless = !isOldHeadlessMode(browser, version);
+          let {extensionPaths, manifest} = getExtension(browser, version);
+
+          let tmpExtensionDir = path.join(snapshotsBaseDir, "extension");
+          await fs.promises.rm(tmpExtensionDir, {recursive: true, force: true});
+          await fs.promises.cp(extensionPaths[0], tmpExtensionDir,
+                               {recursive: true});
+
+          driver = await BROWSERS[browser].getDriver(
+            version, {headless, extensionPaths: [tmpExtensionDir]});
+          await getHandle(driver, "/index.html");
+          let text = await driver.findElement(By.id("title")).getText();
+          expect(text).toEqual(`Browser test extension - ${manifest}`);
+
+          // The page is modified and reloaded to emulate an extension update
+          await fs.promises.cp(path.join(tmpExtensionDir, "update.html"),
+                               path.join(tmpExtensionDir, "index.html"));
+          await driver.navigate().refresh();
+          text = await driver.findElement(By.id("title")).getText();
+          expect(text).toEqual(`Updated test extension - ${manifest}`);
+        });
       });
     }
 
-    it("does not install unsupported versions", async function() {
-      if (browser == "edge" && process.platform == "win32")
-        this.skip();
 
-      for (let unsupported of ["0.0", "invalid"]) {
-        await expect(BROWSERS[browser].installBrowser(unsupported))
-          .rejects.toThrow(`Unsupported browser version: ${unsupported}`);
-      }
-    });
+    describe("Any version", async() => {
+      it("does not install unsupported versions", async function() {
+        if (browser == "edge" && process.platform == "win32")
+          this.skip();
 
-    it("does not load an invalid extension", async() => {
-      let extensionPaths = [process.cwd()];
+        for (let unsupported of ["0.0", "invalid"]) {
+          await expect(BROWSERS[browser].installBrowser(unsupported))
+            .rejects.toThrow(`Unsupported browser version: ${unsupported}`);
+        }
+      });
 
-      await expect(BROWSERS[browser].getDriver("latest", {extensionPaths}))
-        .rejects.toThrow(`Extension manifest file not found: ${extensionPaths[0]}`);
+      it("does not load an invalid extension", async() => {
+        let extensionPaths = [process.cwd()];
+
+        await expect(BROWSERS[browser].getDriver("latest", {extensionPaths}))
+          .rejects.toThrow(`Extension manifest file not found: ${extensionPaths[0]}`);
+      });
     });
   });
 }

package/test/extension/mv2/index.html

@@ -1 +1 @@
-<h1>Browser test extension - mv2</h1>
+<h1 id="title">Browser test extension - mv2</h1>

package/test/extension/mv2/update.html

@@ -0,0 +1 @@
+<h1 id="title">Updated test extension - mv2</h1>

package/test/extension/mv3/background.js

@@ -1,3 +1,16 @@
 "use strict";
 
-chrome.tabs.create({url: "index.html"});
+// There's an issue with Chrome +133 and selenium webdriver where
+// getAllWindowHandles() can't see tabs opened by an extension if the url option
+// opens an extension page. Example: chrome.tabs.create({url: "index.html"});
+//
+// Workaround: Create the tab with empty options, which allows
+// getAllWindowHandles() to see it, and afterwards update the tab with the
+// intended url.
+
+// This timeout must be higher than driver.geAllWindowHandles() polling interval
+const timeout = 1000;
+
+chrome.tabs.create({}, ({tabId}) => {
+  setTimeout(() => chrome.tabs.update(tabId, {url: "index.html"}), timeout);
+});

package/test/extension/mv3/index.html

@@ -1 +1 @@
-<h1>Browser test extension - mv3</h1>
+<h1 id="title">Browser test extension - mv3</h1>

package/test/extension/mv3/update.html

@@ -0,0 +1 @@
+<h1 id="title">Updated test extension - mv3</h1>

package/test/pages/proxy-config.pac

@@ -0,0 +1,7 @@
+
+function FindProxyForURL(url, host) {
+  if (host === "testpages.adblockplus.org")
+    return "PROXY http://localhost:3000";
+
+  return "DIRECT";
+}