@eyeo/get-browser-binary 0.13.0 → 0.14.0

package/.gitlab-ci.yml

@@ -1,5 +1,5 @@
 default:
-  image: registry.gitlab.com/eyeo/docker/get-browser-binary:node16
+  image: registry.gitlab.com/eyeo/docker/get-browser-binary:node18
   interruptible: true
 
 stages:
@@ -48,7 +48,7 @@ test:browsers:windows:
         -OutFile 'MicrosoftEdgeEnterpriseX64.msi'
     - Start-Process msiexec
         -ArgumentList "/i MicrosoftEdgeEnterpriseX64.msi /norestart /qn" -Wait
-    - choco upgrade -y nodejs --version 16.10.0
+    - choco upgrade -y --no-progress nodejs --version 18.17.1
     - npm install
   script:
     # Running Edge tests only on the preinstalled version

package/README.md

@@ -30,20 +30,25 @@ the right side.
 
 ### Supported browser versions
 
-- Chromium >= 75
-- Firefox >= 60
+- Chromium >= 77 (Chromium ARM >= 92)
+- Firefox >= 68
 - Edge >= 95
 
 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.
 
+### Verbose logging
+
+Set the `VERBOSE` environment variable to `"true"` to get verbose logging on
+download requests.
+
 ## Development
 
 ### Prerequisites
 
-- Node >= 16.10.0
-- npm >= 7
+- Node >= 18
+- npm >= 9
 
 ### Installing/Updating dependencies
 
@@ -70,6 +75,8 @@ Running all tests:
 npm test
 ```
 
+### Options
+
 The `grep` option filters the tests to run with a regular expression. Example:
 
 ```shell
@@ -91,6 +98,21 @@ variable to `true`. Example:
 TEST_KEEP_SNAPSHOTS=true npm test
 ```
 
+### Test server
+
+Tests use a local http server, which is managed by the `npm test` command. If
+needed, the test server can also run independently:
+
+```shell
+npm run test-server
+```
+
+Then tests may be executed on a separate session. Example:
+
+```shell
+npm run test-suite -- --grep "chromium.*latest"
+```
+
 ### Running tests on Docker
 
 Useful to reproduce the CI environment of the `test:browsers:linux` job.
@@ -111,22 +133,22 @@ docker run --shm-size=512m -e TEST_ARGS="--grep chromium.*latest --timeout 10000
 
 #### ARM architecture (M1/M2 Apple Silicon)
 
-Chromium (ARM native):
-
 ```shell
 docker build -f test/docker/arm64.Dockerfile -t browsers-arm .
-docker run --shm-size=512m -e TEST_ARGS="--grep chromium.*latest" -it browsers-arm
+docker run --shm-size=512m -e TEST_ARGS="--grep (chromium|firefox).*latest" -it browsers-arm
 ```
 
-Firefox (AMD emulation):
+Only latest Chromium and latest Firefox ESR versions are supported. Edge is not
+supported.
+
+Regarding Firefox, it may be possible to run other versions using AMD emulation
+(unstable results):
 
 ```shell
 docker build -f test/docker/Dockerfile -t browsers-amd .
-docker run --platform linux/amd64 --shm-size=512m -e TEST_ARGS="--grep firefox.*latest" -it browsers-amd
+docker run --platform linux/amd64 --shm-size=512m -e TEST_ARGS="--grep firefox.*68.0" -it browsers-amd
 ```
 
-Edge: Not supported
-
 ## Building the documentation
 
 ```shell

package/RELEASE_NOTES.md

@@ -1,3 +1,29 @@
+# 0.14.0
+
+- Increases minimum supported browser versions (#64)
+- Sets a minimum supported version for Chromium ARM (#54)
+- Upgrades minimum node version to node 18 (#63)
+- Fixes an occasional issue where the latest Edge on Windows could not find its
+version on Chromium Dash (#61)
+- Enables `dom.promise_rejection_events.enabled` for Firefox 68 (#49)
+- Adds optional verbose logging on download requests (!79)
+- Refactors `src/browsers.js` file (#65)
+
+### Testing
+
+- Adds a local http server for tests (#50)
+- Allows running Firefox ARM in the Docker ARM image (!84)
+- Skip other browser tests when install fails (#58)
+- Fixes an issue where Linux Edge tests would fail when not following a very
+specific order (#57)
+- Reduces the size of the Windows CI log (#62)
+
+### Notes for integrators
+
+- The minimum broser versions are now Chromium >= 77 (Chromium ARM >= 92) and
+Firefox >= 68. Edge keeps the same version (>= 95)
+- The minimum required node version is now 18
+
 # 0.13.0
 
 - Fixes an issue that prevented the webdriver from locating the Edge binary on

package/index.js

@@ -15,5 +15,22 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-export * from "./src/browsers.js";
-export {download, takeFullPageScreenshot} from "./src/utils.js";
+import {Chromium} from "./src/chromium.js";
+import {Firefox} from "./src/firefox.js";
+import {Edge} from "./src/edge.js";
+
+export {download, takeFullPageScreenshot, snapshotsBaseDir}
+  from "./src/utils.js";
+
+/**
+ * @type {Object}
+ * @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
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eyeo/get-browser-binary",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Install browser binaries and matching webdrivers",
   "repository": {
     "type": "git",
@@ -9,8 +9,8 @@
   "author": "eyeo GmbH",
   "license": "GPL-3.0",
   "engines": {
-    "node": ">=16.10.0",
-    "npm": ">=7"
+    "node": ">=18",
+    "npm": ">=9"
   },
   "type": "module",
   "main": "index.js",
@@ -39,12 +39,15 @@
     "eslint": "^8.33.0",
     "eslint-config-eyeo": "^3.2.0",
     "expect": "^29.4.2",
+    "express": "^4.18.2",
     "jsdoc": "^4.0.0",
     "mocha": "^10.2.0"
   },
   "scripts": {
     "docs": "jsdoc --readme README.md --destination docs src/*.js",
     "lint": "eslint --ext js .",
-    "test": "mocha test/*.js --"
+    "test": "node test/runner.js --",
+    "test-suite": "mocha --exclude test/start-server.js --exclude test/test-server.js --exclude test/runner.js --",
+    "test-server": "node test/start-server.js"
   }
 }

package/src/browser.js

@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2006-present eyeo GmbH
+ *
+ * This module is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import {exec, execFile} from "child_process";
+import {promisify} from "util";
+
+import {errMsg} from "./utils.js";
+
+/**
+ * Base class for browser and webdriver functionality. Please see subclasses for
+ *   browser specific details. All classes can be used statically.
+ * @hideconstructor
+ */
+export class Browser {
+  /**
+   * @typedef {Object} BrowserBinary
+   * @property {string} binary The path to the browser binary.
+   * @property {string} versionNumber The version number of the browser binary.
+   */
+
+  /**
+   * Installs the browser. The installation process is detailed on the
+   *   subclasses.
+   * @param {string} [version=latest] Either full version number or
+   *   channel/release. Please find examples on the subclasses.
+   * @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}
+   * @throws {Error} Unsupported browser version, Unsupported platform, Browser
+   *   download failed.
+   */
+  static async installBrowser(version, downloadTimeout = 0) {
+    // to be implemented by the subclass
+  }
+
+  /**
+   * Gets the installed version returned by the browser binary.
+   * @param {string} binary The path to the browser binary.
+   * @return {string} Installed browser version.
+   * @throws {Error} Browser is not installed.
+   */
+  static async getInstalledVersion(binary) {
+    try {
+      let stdout;
+      let stderr;
+      if (process.platform == "win32") {
+        ({stdout, stderr} = await promisify(exec)(
+          `(Get-ItemProperty ${binary}).VersionInfo.ProductVersion`,
+          {shell: "powershell.exe"})
+        );
+      }
+      else {
+        ({stdout, stderr} = await promisify(execFile)(binary, ["--version"]));
+      }
+      if (stderr)
+        throw new Error(stderr);
+
+      return stdout.trim();
+    }
+    catch (err) {
+      throw new Error(`${errMsg.browserNotInstalled}.\nBinary path: ${binary}\n${err}`);
+    }
+  }
+
+  /**
+   * @typedef {Object} webdriver
+   * @see https://www.selenium.dev/selenium/docs/api/javascript/index.html
+   */
+
+  /**
+   * @typedef {Object} driverOptions
+   * @property {boolean} [headless=true] Run the browser in headless mode,
+   *   or not. In Chromium >= 111, the
+   *   {@link https://developer.chrome.com/articles/new-headless/ new headless mode}
+   *   is used.
+   * @property {Array.<string>} [extensionPaths=[]] Loads extensions to the
+   *   browser.
+   * @property {boolean} [incognito=false] Runs the browser in incognito mode,
+   *   or not.
+   * @property {boolean} [insecure=false] Forces the browser to accept insecure
+   *   certificates, or not.
+   * @property {Array.<string>} [extraArgs=[]] Additional arguments to start
+   *   the browser with.
+   * @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().
+   */
+
+  /**
+   * Installs the webdriver matching the browser version and runs the
+   * browser. If needed, the browser binary is also installed.
+   * @param {string} [version=latest] Either full version number or
+   *   channel/release. Please find examples on the subclasses.
+   * @param {driverOptions} [options={}] Options to start the browser with.
+   * @param {number} [downloadTimeout=0] Allowed time in ms for the download of
+   *   browser install files to complete. When set to 0 there is no time limit.
+   * @return {webdriver}
+   * @throws {Error} Unsupported browser version, Unsupported platform, Browser
+   *   download failed, Driver download failed, Unable to start driver.
+   */
+  static async getDriver(version, options = {}, downloadTimeout = 0) {
+    // to be implemented by the subclass
+  }
+
+  /**
+   * By default, extensions are disabled in incognito mode. This function
+   * enables the extension when loaded in incognito.
+   * @param {webdriver} driver The driver controlling the browser.
+   * @param {string} extensionTitle Title of the extension to be enabled.
+   * @return {webdriver}
+   * @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:
+    // https://stackoverflow.com/questions/57419654
+    // https://bugzilla.mozilla.org/show_bug.cgi?id=1729315
+    // That is done through the UI, to be implemented by the subclass
+  }
+}

package/src/chromium.js

@@ -0,0 +1,336 @@
+/*
+ * Copyright (c) 2006-present eyeo GmbH
+ *
+ * This module is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import path from "path";
+import fs from "fs";
+
+import got from "got";
+import webdriver from "selenium-webdriver";
+import chrome from "selenium-webdriver/chrome.js";
+import extractZip from "extract-zip";
+
+import {Browser} from "./browser.js";
+import {download, killDriverProcess, getMajorVersion, checkVersion,
+        checkPlatform, errMsg, snapshotsBaseDir, platformArch}
+  from "./utils.js";
+
+/**
+ * Browser and webdriver functionality for Chromium.
+ * @hideconstructor
+ * @extends Browser
+ */
+export class Chromium extends Browser {
+  static #CHANNELS = ["latest", "beta", "dev"];
+  static #MAX_VERSION_DECREMENTS = 200;
+
+  static async #getVersionForChannel(channel) {
+    if (!Chromium.#CHANNELS.includes(channel))
+      return channel;
+
+    if (channel == "latest")
+      channel = "stable";
+
+    let os = {
+      "win32-ia32": "win",
+      "win32-x64": "win64",
+      "linux-x64": "linux",
+      "darwin-x64": "mac",
+      "darwin-arm64": "mac_arm64"
+    }[platformArch];
+    let url = `https://versionhistory.googleapis.com/v1/chrome/platforms/${os}/channels/${channel}/versions/all/releases`;
+
+    let data;
+    try {
+      data = await got(url).json();
+    }
+    catch (err) {
+      throw new Error(`${errMsg.browserVersionCheck}: ${url}\n${err}`);
+    }
+    let version;
+    let fraction;
+    for ({version, fraction} of data.releases) {
+      // Versions having small fractions may not appear on Chromium Dash
+      if (fraction > 0.0025)
+        break;
+    }
+
+    return version;
+  }
+
+  static #getBinaryPath(dir) {
+    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")
+    }[process.platform];
+  }
+
+  static async #getBase(chromiumVersion) {
+    let url;
+    let chromiumBase;
+    try {
+      // https://gitlab.com/eyeo/developer-experience/get-browser-binary/-/issues/55
+      if (getMajorVersion(chromiumVersion) < 91) {
+        url = `https://omahaproxy.appspot.com/deps.json?version=${chromiumVersion}`;
+        ({chromium_base_position: chromiumBase} = await got(url).json());
+      }
+      else {
+        url = `https://chromiumdash.appspot.com/fetch_version?version=${chromiumVersion}`;
+        ({chromium_main_branch_position: chromiumBase} = await got(url).json());
+      }
+    }
+    catch (err) {
+      throw new Error(`${errMsg.browserVersionCheck}: ${url}\n${err}`);
+    }
+    return parseInt(chromiumBase, 10);
+  }
+
+  static async #getInstalledBrowserInfo(binary) {
+    let installedVersion = await Chromium.getInstalledVersion(binary);
+    // Linux example: "Chromium 112.0.5615.49 built on Debian 11.6"
+    // Windows example: "114.0.5735.0"
+    let versionNumber = installedVersion.split(" ")[1] || installedVersion;
+    let base = await Chromium.#getBase(versionNumber);
+    return {binary, versionNumber, base};
+  }
+
+  /**
+   * Installs the browser. The Chromium executable gets extracted in the
+   *   {@link snapshotsBaseDir} folder, ready to go.
+   * @param {string} [version=latest] Either "latest", "beta", "dev" or a full
+   *   version number (i.e. "77.0.3865.0").
+   * @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}
+   * @throws {Error} Unsupported browser version, Unsupported platform, Browser
+   *   download failed.
+   */
+  static async installBrowser(version = "latest", downloadTimeout = 0) {
+    const MIN_VERSION = process.arch == "arm64" ? 92 : 77;
+
+    let binary;
+    let versionNumber;
+    let base;
+
+    // https://gitlab.com/eyeo/developer-experience/get-browser-binary/-/issues/46
+    if (platformArch == "linux-arm64")
+      return await Chromium.#getInstalledBrowserInfo("/usr/bin/chromium");
+
+    checkVersion(version, MIN_VERSION, Chromium.#CHANNELS);
+    versionNumber = await Chromium.#getVersionForChannel(version);
+
+    base = await Chromium.#getBase(versionNumber);
+    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"],
+      "darwin-arm64": ["Mac_Arm", "chrome-mac.zip"]
+    }[platformArch];
+    let archive;
+    let browserDir;
+    let snapshotsDir = path.join(snapshotsBaseDir, "chromium");
+
+    while (true) {
+      browserDir = path.join(snapshotsDir, `chromium-${platformArch}-${base}`);
+      binary = Chromium.#getBinaryPath(browserDir);
+
+      try {
+        await fs.promises.access(browserDir);
+        return {binary, versionNumber, base};
+      }
+      catch (e) {}
+
+      await fs.promises.mkdir(path.dirname(browserDir), {recursive: true});
+
+      archive = path.join(snapshotsDir, "cache", `${base}-${fileName}`);
+      let url = `https://www.googleapis.com/download/storage/v1/b/chromium-browser-snapshots/o/${platformDir}%2F${base}%2F${fileName}?alt=media`;
+      try {
+        try {
+          await fs.promises.access(archive);
+        }
+        catch (e) {
+          await download(url, archive, downloadTimeout);
+        }
+        break;
+      }
+      catch (err) {
+        if (err.name == "HTTPError") {
+          // Chromium advises decrementing the branch_base_position when no
+          // matching build was found. See https://www.chromium.org/getting-involved/download-chromium
+          base--;
+          if (base <= startBase - Chromium.#MAX_VERSION_DECREMENTS)
+            throw new Error(`${errMsg.browserDownload}: Chromium base ${startBase}`);
+        }
+        else {
+          throw new Error(`${errMsg.browserDownload}: ${url}\n${err}`);
+        }
+      }
+    }
+    await extractZip(archive, {dir: browserDir});
+
+    return {binary, versionNumber, base};
+  }
+
+  static async #installDriver(startBase) {
+    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"],
+      "linux-arm64": ["", "", "chromedriver"],
+      "darwin-x64": ["Mac", "chromedriver_mac64.zip", "chromedriver"],
+      "darwin-arm64": ["Mac_Arm", "chromedriver_mac64.zip", "chromedriver"]
+    }[platformArch];
+
+    let cacheDir = path.join(snapshotsBaseDir, "chromium", "cache",
+                             "chromedriver");
+    let archive = path.join(cacheDir, `${startBase}-${zip}`);
+    try {
+      await fs.promises.access(archive);
+      await extractZip(archive, {dir: cacheDir});
+    }
+    catch (e) { // zip file is either not cached or corrupted
+      if (platformArch == "linux-arm64") {
+        // https://gitlab.com/eyeo/developer-experience/get-browser-binary/-/issues/46
+        // It's unclear how electron releases match Chromium versions. Once that
+        // is figured out, the link below will depend on the Chromium version.
+        // https://stackoverflow.com/questions/38732822/compile-chromedriver-on-arm
+        let url = "https://github.com/electron/electron/releases/download/v26.2.0/chromedriver-v26.2.0-linux-arm64.zip";
+        try {
+          await download(url, archive);
+        }
+        catch (err) {
+          throw new Error(`${errMsg.driverDownload}: ${url}\n${err}`);
+        }
+      }
+      else {
+        let base = startBase;
+        while (true) {
+          let url = `https://commondatastorage.googleapis.com/chromium-browser-snapshots/${dir}/${base}/${zip}`;
+          try {
+            await download(url, archive);
+            break;
+          }
+          catch (err) {
+            if (err.name == "HTTPError") {
+              base--;
+              archive = path.join(cacheDir, `${base}-${zip}`);
+              if (base <= startBase - Chromium.#MAX_VERSION_DECREMENTS)
+                throw new Error(`${errMsg.driverDownload}: Chromium base ${startBase}`);
+            }
+            else {
+              throw new Error(`${errMsg.driverDownload}: ${url}\n${err}`);
+            }
+          }
+        }
+      }
+      await extractZip(archive, {dir: cacheDir});
+    }
+
+    await killDriverProcess("chromedriver");
+    let driverPath = path.join(cacheDir, zip.split(".")[0], driverBinary);
+    if (platformArch == "linux-arm64")
+      driverPath = path.join(cacheDir, driverBinary);
+    await fs.promises.rm(driverPath, {force: true});
+    await extractZip(archive, {dir: cacheDir});
+
+    return driverPath;
+  }
+
+  /** @see Browser.getDriver */
+  static async getDriver(version = "latest", {
+    headless = true, extensionPaths = [], incognito = false, insecure = false,
+    extraArgs = [], customBrowserBinary
+  } = {}, downloadTimeout = 0) {
+    let {binary, versionNumber, base} = customBrowserBinary ?
+      await Chromium.#getInstalledBrowserInfo(customBrowserBinary) :
+      await Chromium.installBrowser(version, downloadTimeout);
+    let driverPath = await Chromium.#installDriver(base);
+    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(",")}`);
+    if (headless) {
+      // New headless mode introduced in Chrome 111
+      // https://developer.chrome.com/articles/new-headless/
+      if (getMajorVersion(versionNumber) >= 111)
+        options.addArguments("headless=new");
+      else
+        options.headless();
+    }
+    if (insecure)
+      options.addArguments("ignore-certificate-errors");
+    if (incognito)
+      options.addArguments("incognito");
+    options.setChromeBinaryPath(binary);
+
+    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) {
+    let handle = await driver.getWindowHandle();
+
+    let version = getMajorVersion(
+      (await driver.getCapabilities()).getBrowserVersion());
+    if (version >= 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
+        .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");
+
+      return new Promise((resolve, reject) => {
+        let extensionDetails;
+        for (let {shadowRoot} of extensions) {
+          if (shadowRoot.getElementById("name").innerHTML != args[0])
+            continue;
+
+          extensionDetails = shadowRoot.getElementById("detailsButton");
+          break;
+        }
+        if (!extensionDetails)
+          reject(`${args[1]}: ${args[0]}`);
+
+        extensionDetails.click();
+        setTimeout(() => resolve(enable()), 100);
+      });
+    }, extensionTitle, errMsg.extensionNotFound);
+    if (version >= 115)
+      // Closing the previously opened new window
+      await driver.close();
+
+    await driver.switchTo().window(handle);
+  }
+}