@oracle/oraclejet-webdriver 10.0.8

package/lib/ScreenshotManager.ts

@@ -0,0 +1,195 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * Define an interface for objects that (like the WebDriver instance) can take screen shots
+ */
+interface ScreenshotTaker {
+  takeScreenshot(): Promise<string>;
+}
+
+/**
+ * The ScreenshotManager interface
+ */
+interface ScreenshotManager {
+  /**
+    * This function will set screenshot location based on test suite name and test name
+    * @param suiteName test case's suite name
+    * @param testName test case's name
+  */
+  beforeTest(suiteName: string, testName: string): void
+
+  /**
+     * This function will do cleanup after test execution. It will puerge screenshot for passed test and generate final state 
+     * screenshot for failed test
+     * @param passed boolean to check test state
+   */
+  afterTest(passed: boolean): void
+
+  /**
+    * This function will take screenshot and save it on the file system
+    * @param screenshotTaker an screenshotTaker instance
+    * @param name screenshot image name
+    * @return a promise
+    * @example await screenshotManager.takeAndSaveScreenShot(driver, "before_click");
+   */
+  takeAndSaveScreenShot(screenshotTaker: ScreenshotTaker, name: string): Promise<void>
+}
+
+/**
+ * This implementation of ScreenshotManager Interface will not take any screenshot
+ */
+class NoOpScreenShotManager implements ScreenshotManager {
+  beforeTest(suiteName: string, testName: string): void { }
+  afterTest(passed: boolean): void { }
+  takeAndSaveScreenShot(screenshotTaker: ScreenshotTaker, name: string): Promise<void> { return null }
+}
+
+/**
+ * This implementation of ScreenshotManager Interface will take screenshot
+ */
+class TakeScreenshotManager implements ScreenshotManager {
+
+  private _screenshotLocation:string  = "";
+  private _screenshotsDir: string
+
+  /**
+     * This function will replace all invalid characters with underscore
+     * @param name string test name may having some invalid characters
+     * @private
+     */
+  private replaceCharacters(name: string): string {
+    var output = name.replace(/[^a-z0-9]/ig, '_');
+    return output;
+  }
+
+  /**
+  * This constructor will set screenshot root directory on the file system, like <report-root>/screenshots
+  * @param screenshotRoot screenshot root directory
+  */
+  constructor(screenshotRoot: string) {
+
+    var mochawesomeReportDir = screenshotRoot;
+    try {
+      if (!fs.existsSync(mochawesomeReportDir)) fs.mkdirSync(mochawesomeReportDir);
+    } catch (err) {
+      console.error(err);
+      console.error(err.stack);
+    }
+    this._screenshotsDir = mochawesomeReportDir + path.sep + "screenshots";
+    try {
+      if (!fs.existsSync(this._screenshotsDir)) fs.mkdirSync(this._screenshotsDir);
+    } catch (err) {
+      console.error(err);
+      console.error(err.stack);
+    }
+  }
+
+  /**
+    * This function will set screenshot location based on test suite name and test name
+    * @param suiteName test case's suite name
+    * @param testName test case's name
+  */
+  beforeTest(suiteName: string, testName: string): void {
+    var suiteN = this.replaceCharacters(suiteName);
+    var testN = this.replaceCharacters(testName);
+    var suiteF = this._screenshotsDir + path.sep + suiteN;
+    var testF = suiteF + path.sep + testN;
+    this._screenshotLocation = testF;
+
+    try {
+      if (!fs.existsSync(suiteF)) fs.mkdirSync(suiteF);
+    } catch (err) {
+      console.error(err);
+      console.error(err.stack);
+    }
+    try {
+      if (!fs.existsSync(testF)) fs.mkdirSync(testF);
+    } catch (err) {
+      console.error(err);
+      console.error(err.stack);
+    }
+  }
+
+  /**
+     * This function will do cleanup after test execution. It will puerge screenshot for passed test and will generate final state 
+     * screenshot for failed test
+     * @param passed boolean to check test state
+   */
+  afterTest(passed: boolean): void {
+
+    if (passed) {
+      try {
+
+        var FOLDER_PATH = this._screenshotLocation;
+        if (fs.existsSync(FOLDER_PATH)) {
+          var files = fs.readdirSync(FOLDER_PATH);
+          files.forEach(element => {
+            fs.unlinkSync(FOLDER_PATH + path.sep + element);
+          });
+          fs.rmdirSync(FOLDER_PATH);
+        }
+      } catch (err) {
+        console.error(err);
+        console.error(err.stack);
+      }
+    }
+  }
+
+ /**
+     * This function will take screenshot and save it on the file system
+     * @param screenshotTaker a screenshotTaker instance
+     * @param name screeshot image name
+   */
+  async takeAndSaveScreenShot(screenshotTaker: ScreenshotTaker, name: string): Promise<void> {
+    var counter = 1;
+    var FOLDER_PATH = this._screenshotLocation;
+    if (fs.existsSync(FOLDER_PATH)) {
+      var files = fs.readdirSync(FOLDER_PATH);
+      files.forEach(element => {
+        if (element.includes(name)) counter++;
+      });
+    }
+    try {
+      const screenshotImg = await screenshotTaker.takeScreenshot();
+      fs.writeFileSync(this._screenshotLocation + path.sep + name + counter + ".jpg", screenshotImg, 'base64');
+
+    } catch (err) {
+      console.error(err);
+      console.error(err.stack);
+    }
+   
+    return null;
+  }
+}
+
+//Below are the top-level methods of the ScreenshotManager module
+
+var currentInstance: ScreenshotManager = new NoOpScreenShotManager();
+
+/**
+* This function will create an instance ScreenshotManager
+* @param screenshotRoot screenshot root location
+*/
+export function create(screenshotRoot: string): ScreenshotManager {
+  if (screenshotRoot) {
+    return new TakeScreenshotManager(screenshotRoot);
+  }
+  else {
+    return new NoOpScreenShotManager();
+  }
+}
+
+/**
+* This function will get an active ScreenshotManager instance
+* @return an active ScreenshotManager instance
+*/
+export function get(): ScreenshotManager { return currentInstance }
+
+/**
+* This function will set an active ScreenshotManager instance
+* @param screenshotManager an active ScreenshotManager instance
+*/
+export function set(screenshotManager: ScreenshotManager): void { currentInstance = screenshotManager }
+
+

package/lib/driver-manager.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DriverManager = void 0;
+const selenium_webdriver_1 = require("selenium-webdriver");
+const defaultConfigName = "";
+const defaultCapabilities = new selenium_webdriver_1.Capabilities({
+    autoWebview: true,
+    browserName: "chrome",
+});
+const defaultTimeouts = {
+    implicit: 0,
+    pageLoad: 30000,
+    script: 30000,
+};
+const configs = {};
+let currentInstance = {
+    configName: null,
+    driver: null,
+};
+const quitDelay = 500;
+let builder;
+let releaseTimer = setTimeout(() => true, 0);
+class DriverManager {
+    static setBuilder(b) {
+        if (builder) {
+            throw Error("DriverManager Builder instance has already been set, and cannot be set again");
+        }
+        builder = b;
+    }
+    static registerConfig(config, name) {
+        configs[name || defaultConfigName] = config;
+    }
+    static async getDriver(configName) {
+        clearTimeout(releaseTimer);
+        configName = configName || defaultConfigName;
+        if (configName === currentInstance.configName) {
+            return currentInstance.driver;
+        }
+        await quitCurrentDriver();
+        return createDriver(configName);
+    }
+    static async getCurrentDriver() {
+        return DriverManager.getDriver(currentInstance.configName);
+    }
+    static releaseDriver(driver) {
+        clearTimeout(releaseTimer);
+        releaseTimer = setTimeout(async () => {
+            await quitCurrentDriver();
+        }, quitDelay);
+    }
+}
+exports.DriverManager = DriverManager;
+DriverManager.registerConfig({ capabilities: defaultCapabilities, timeouts: defaultTimeouts });
+async function createDriver(configName) {
+    const config = configs[configName];
+    if (!config) {
+        throw Error(`No driver configuration exists for "${configName}"`);
+    }
+    const caps = new selenium_webdriver_1.Capabilities(configs[defaultConfigName].capabilities);
+    if (config.capabilities) {
+        caps.merge(config.capabilities);
+    }
+    const timeouts = Object.assign({}, configs[defaultConfigName].timeouts, config.timeouts);
+    if (!builder) {
+        builder = new selenium_webdriver_1.Builder();
+    }
+    const driver = builder.withCapabilities(caps).build();
+    currentInstance = { configName, driver };
+    await driver.manage().setTimeouts(timeouts);
+    return driver;
+}
+async function quitCurrentDriver() {
+    const driver = currentInstance.driver;
+    if (driver) {
+        try {
+            await driver.quit();
+        }
+        catch (ex) {
+            console.warn(ex);
+        }
+        finally {
+            currentInstance = {
+                configName: null,
+                driver: null,
+            };
+        }
+    }
+}
+//# sourceMappingURL=driver-manager.js.map

package/lib/driver-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"driver-manager.js","sourceRoot":"","sources":["../../../rt/src/test/webdriverjs/oraclejet-webdriver/lib/driver-manager.ts"],"names":[],"mappings":";;;AAAA,2DAI4B;AA2B5B,MAAM,iBAAiB,GAAG,EAAE,CAAC;AAC7B,MAAM,mBAAmB,GAAG,IAAI,iCAAY,CAAC;IAC3C,WAAW,EAAE,IAAI;IACjB,WAAW,EAAE,QAAQ;CACtB,CAAC,CAAC;AACH,MAAM,eAAe,GAAa;IAChC,QAAQ,EAAE,CAAC;IACX,QAAQ,EAAE,KAAK;IACf,MAAM,EAAE,KAAK;CACd,CAAC;AACF,MAAM,OAAO,GAAiD,EAAE,CAAC;AACjE,IAAI,eAAe,GAA8C;IAC/D,UAAU,EAAE,IAAI;IAChB,MAAM,EAAE,IAAI;CACb,CAAC;AAQF,MAAM,SAAS,GAAG,GAAG,CAAC;AACtB,IAAI,OAAgB,CAAC;AAKrB,IAAI,YAAY,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;AAoF7C,MAAa,aAAa;IAiBjB,MAAM,CAAC,UAAU,CAAC,CAAU;QACjC,IAAI,OAAO,EAAE;YACX,MAAM,KAAK,CAAC,8EAA8E,CAAC,CAAC;SAC7F;QACD,OAAO,GAAG,CAAC,CAAC;IACd,CAAC;IAuCM,MAAM,CAAC,cAAc,CAAC,MAAiC,EAAE,IAAa;QAC3E,OAAO,CAAC,IAAI,IAAI,iBAAiB,CAAC,GAAG,MAAM,CAAC;IAC9C,CAAC;IAgCM,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,UAAmB;QAC/C,YAAY,CAAC,YAAY,CAAC,CAAC;QAC3B,UAAU,GAAG,UAAU,IAAI,iBAAiB,CAAC;QAE7C,IAAI,UAAU,KAAK,eAAe,CAAC,UAAU,EAAE;YAC7C,OAAO,eAAe,CAAC,MAAM,CAAC;SAC/B;QAED,MAAM,iBAAiB,EAAE,CAAC;QAC1B,OAAO,YAAY,CAAC,UAAU,CAAC,CAAC;IAClC,CAAC;IASM,MAAM,CAAC,KAAK,CAAC,gBAAgB;QAClC,OAAO,aAAa,CAAC,SAAS,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;IAC7D,CAAC;IAOM,MAAM,CAAC,aAAa,CAAC,MAAiB;QAC3C,YAAY,CAAC,YAAY,CAAC,CAAC;QAI3B,YAAY,GAAG,UAAU,CAAC,KAAK,IAAI,EAAE;YACnC,MAAM,iBAAiB,EAAE,CAAC;QAC5B,CAAC,EAAE,SAAS,CAAC,CAAC;IAChB,CAAC;CACF;AApID,sCAoIC;AACD,aAAa,CAAC,cAAc,CAAC,EAAE,YAAY,EAAE,mBAAmB,EAAE,QAAQ,EAAE,eAAe,EAAE,CAAC,CAAC;AAU/F,KAAK,UAAU,YAAY,CAAC,UAAkB;IAC5C,MAAM,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IACnC,IAAI,CAAC,MAAM,EAAE;QACX,MAAM,KAAK,CAAC,uCAAuC,UAAU,GAAG,CAAC,CAAC;KACnE;IAED,MAAM,IAAI,GAAG,IAAI,iCAAY,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,YAAY,CAAC,CAAC;IACvE,IAAI,MAAM,CAAC,YAAY,EAAE;QACvB,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;KACjC;IAED,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAC,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;IACzF,IAAI,CAAC,OAAO,EAAE;QACZ,OAAO,GAAG,IAAI,4BAAO,EAAE,CAAC;KACzB;IACD,MAAM,MAAM,GAAc,OAAO,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC;IACjE,eAAe,GAAG,EAAE,UAAU,EAAE,MAAM,EAAE,CAAC;IAIzC,MAAM,MAAM,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;IAE5C,OAAO,MAAM,CAAC;AAChB,CAAC;AAKD,KAAK,UAAU,iBAAiB;IAC9B,MAAM,MAAM,GAAG,eAAe,CAAC,MAAM,CAAC;IACtC,IAAI,MAAM,EAAE;QACV,IAAI;YACF,MAAM,MAAM,CAAC,IAAI,EAAE,CAAC;SACrB;QAAC,OAAO,EAAE,EAAE;YAEX,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;SAClB;gBAAS;YACR,eAAe,GAAG;gBAChB,UAAU,EAAE,IAAI;gBAChB,MAAM,EAAE,IAAI;aACb,CAAC;SACH;KACF;AACH,CAAC"}

package/lib/driver-manager.ts

@@ -0,0 +1,330 @@
+import {
+  Builder,
+  Capabilities,
+  WebDriver,
+} from "selenium-webdriver";
+
+interface Timeouts {
+  /**
+   * The timeout value for script execution.  Default 30000
+   */
+  script?: number;
+  /**
+   * The timeout value for page loading (and to be ready).  Default 30000
+   */
+  pageLoad?: number;
+  /**
+   * The timeout value for finding an element on the page.  Default 0
+   */
+  implicit?: number;
+}
+interface CapabilitiesConfiguration {
+  /**
+   * The WebDriver Capabilties for the configuration
+   */
+  capabilities?: Capabilities;
+  /**
+   * The WebDriver timeout values for the configuration
+   */
+  timeouts?: Timeouts;
+}
+
+const defaultConfigName = "";
+const defaultCapabilities = new Capabilities({
+  autoWebview: true,
+  browserName: "chrome",
+});
+const defaultTimeouts: Timeouts = {
+  implicit: 0,
+  pageLoad: 30000,
+  script: 30000,
+};
+const configs: { [key: string]: CapabilitiesConfiguration } = {};
+let currentInstance: { configName: string, driver: WebDriver } = {
+  configName: null,
+  driver: null,
+};
+
+/**
+ * The delay, in milliseconds, that the manager will wait after the driver is
+ * release to see if there are pending requests for a driver instance.  If no
+ * requests exist, then the driver is closed, and subsequent requests will
+ * receive a new instance.
+ */
+const quitDelay = 500;
+let builder: Builder;
+// The NodeJS.Timer used to cleanup the driver instance if no subsequent test
+// asks for the driver. The type (NodeJS.Timer) cannot be defined here because
+// typedoc cannot resolve the NodeJS namespace, so we infer it by calling
+// setTimeout instead.
+let releaseTimer = setTimeout(() => true, 0);
+
+/**
+ * Manage instances of [WebDriver]
+ * (https://seleniumhq.github.io/selenium/docs/api/javascript/module/selenium-webdriver/index_exports_WebDriver.html)
+ * to be used by the tests. DriverManager
+ * allows a single place where the WebDriver instance can be configured and
+ * reused. Traditionally, tests instantiate the WebDriver instance on their own,
+ * passing configurations such as the browser to use:
+ * ```javascript
+ * let driver = new Builder().withCapabilities({
+ *   browserName: "chrome"
+ * }).build()
+ * ```
+ * This boilerplate code then has to be copied to every test. Additionally, if
+ * the capabilities need to change (say, running against a different browser),
+ * that change must be applied to all test files.
+ *
+ * DriverManager addresses this problem by centralizing the place whereby
+ * the configuration is done, and persists that configuration for all
+ * subsequent requests for the WebDriver instance. The configuration only needs
+ * to be set once in a "setup" file, and tests retrieve the configured instance
+ * without needing to define anything else.
+ *
+ * A sample <code>mocha-setup.ts</code> file which configures DriverManager
+ * ```javascript
+ * import { DriverManager } from "@oracle/oraclejet-webdriver";
+ *
+ * DriverManager.registerConfig({
+ *   capabilities: new Capabilities({
+ *     browserName: "chrome"
+ *   })
+ * })
+ * ```
+ * This setup test script should be run before any other tests.
+ * ```bash
+ * $ node node_modules/mocha/bin/mocha --require=ts-node/register mocha-setup.ts other-test.spec.ts ...
+ * ```
+ * Test files are agnostic of the driver configuration, and simply get the instance
+ * by calling <code>getDriver()</code>
+ * ```javascript
+ * import { DriverManager } from "@oracle/oraclejet-webdriver";
+ *
+ * describe("My test suite", function() {
+ *   let driver: WebDriver;
+ *
+ *   before(async function() {
+ *     driver = await DriverManager.getDriver();
+ *   })
+ *   it("open a page to test", async function() {
+ *     await driver.get("...")
+ *   })
+ *   after(async function() {
+ *     await DriverManager.releaseDriver(driver);
+ *   })
+ * })
+ * ```
+ *
+ * ## Set default timeouts for WebDriver from Mocha.
+ * When Mocha is used to start the WebDriver tests, there are two sets of timeout
+ * values--one from Mocha and one from WebDriver. This causes some confusion as
+ * the command-line argument <code>--timeout=nnn</code> is typically the only one
+ * set and assumed to be the only timeout value in play. However, WebDriver has
+ * its own set of timeout values, whose defaults are sometimes longer than what's
+ * set for Mocha. When this happens, WebDriver may be waiting on a condition to
+ * timeout, but Mocha has errored the test because its own timeout was exceeded.
+ * To ensure that WebDriver timeout conditions are properly reported to the test
+ * runner (Mocha), its timeout values must be set to a value shorter than the
+ * runner's. This is typically done in the setup test.
+ *
+ * ### Set WebDriver timeout to 5 seconds sooner than Mocha
+ * ```javascript
+ * const mochaTimeout = this.timeouts();
+ * const wdTimeout = mochaTimeout - 5000;
+ * DriverManager.registerConfig({
+ *   timeouts: {
+ *     pageLoad: wdTimeout,
+ *     script: wdTimeout,
+ *     implicit: wdTimeout
+ *   }
+ * });
+ * ```
+ *
+ */
+export class DriverManager {
+  /**
+   * Optionally set the [Builder]
+   * (https://seleniumhq.github.io/selenium/docs/api/javascript/module/selenium-webdriver/index_exports_Builder.html)
+   * instance used by DriverManager to create WebDriver.
+   * The Builder allows different settings for thigns such as the remote server,
+   * proxies, and other runtime options often needed when running in distributed
+   * environments.
+   * The instance can be preconfigured with capabilities, and any additional
+   * capabilities from [[registerConfig]] will also be applied during the
+   * creation process.  If no Builder is explicitly passed, a default one will
+   * be used.
+   * If setting a custom Builder, this function must be called before the first
+   * test calls [[getDriver]], and must only be called once per test run. If called
+   * multiple times or after [[getDriver]], an error will be thrown.
+   * @param b A builder instance
+   */
+  public static setBuilder(b: Builder) {
+    if (builder) {
+      throw Error("DriverManager Builder instance has already been set, and cannot be set again");
+    }
+    builder = b;
+  }
+  /**
+   * Register a configuration for WebDriver instances. Configurations consist of
+   * [Capabilities]
+   * (https://seleniumhq.github.io/selenium/docs/api/javascript/module/selenium-webdriver/index_exports_Capabilities.html)
+   * and/or [Timeouts]
+   * (https://seleniumhq.github.io/selenium/docs/api/javascript/module/selenium-webdriver/lib/capabilities_exports_Timeouts.html).
+   * This configuration is used by [[getDriver]] to retrieve a configured WebDriver
+   * instance.
+   * @param config The driver configuration
+   * @param name An optional name to assocaite with the config. If no name is given,
+   * the config will be the default.
+   *
+   * ### Register a default config
+   * ```javascript
+   * DriverManager.registerConfig(
+   *   {
+   *     capabilities: new Capabilities({
+   *       browserName: "chrome"
+   *     }),
+   *     timeouts: {
+   *       implicit: 5000
+   *     }
+   *   }
+   * );
+   * ```
+   * ### Register a Firefox config
+   * ```javascript
+   * DriverManager.registerConfig(
+   *   {
+   *     capabilities: new Capabilities({
+   *       browserName: "firefox",
+   *       hideAlerts: true
+   *     })
+   *   },
+   *   "firefox-no-alerts"
+   * );
+   * ```
+   */
+  public static registerConfig(config: CapabilitiesConfiguration, name?: string): void {
+    configs[name || defaultConfigName] = config;
+  }
+
+  /**
+   * Get a
+   * [WebDriver](https://seleniumhq.github.io/selenium/docs/api/javascript/module/selenium-webdriver/index_exports_WebDriver.html)
+   * instance for a given configuration. If no configName is given, the returned
+   * driver will use the default configuration.
+   * @see [[registerConfig]]
+   *
+   * ### Get driver with default capabilities
+   * ```javascript
+   * let driver = await DriverManager.getDriver();
+   * ```
+   * ### Configure and get Firefox driver
+   * ```javascript
+   * // mocha-setup.ts
+   * DriverManager.registerConfig(
+   *   {
+   *     browserName: "firefox"
+   *   },
+   *   "firefox-config");
+   * // test.spec.ts
+   * let driver = await DriverManager.getDriver("firefox-config");
+   * ```
+   * @param configName An optional configuration name, registered through
+   * [[registerConfig]], whose set will be applied to the driver instance. If no
+   * name is given, the default configuration with the "chrome" browser
+   * will be used. If the given configName doesn't exist, an error will be thrown.
+   * @return A Promise that resolves to a WebDriver instance, configured with
+   * custom capabilities for the given configName, or the default capabilities
+   * if none is specified.
+   */
+  public static async getDriver(configName?: string): Promise<WebDriver> {
+    clearTimeout(releaseTimer);
+    configName = configName || defaultConfigName;
+
+    if (configName === currentInstance.configName) {
+      return currentInstance.driver;
+    }
+
+    await quitCurrentDriver();
+    return createDriver(configName);
+  }
+
+  /**
+   * Gets the current driver instance, if one exists, otherwise create and
+   * return the default one. This method is useful for test setups which evaluate
+   * the outcome of the previous test to capture screenshots on failures. After-
+   * scripts call <code>getCurrentDriver</code> to get the instance of the driver
+   * that experienced the test failure, then capture the screenshot from it.
+   */
+  public static async getCurrentDriver(): Promise<WebDriver> {
+    return DriverManager.getDriver(currentInstance.configName);
+  }
+
+  /**
+   * Release the WebDriver instance from use.  Called when each test is done
+   * with its driver usage, typicall, in the Mocha <code>after</code> function.
+   * @param driver The WebDriver instance
+   */
+  public static releaseDriver(driver: WebDriver): void {
+    clearTimeout(releaseTimer);
+    // Wait for the delay to quit the driver. If [getDriver] was called before
+    // the timeout expired, then it will have cleared the timeout so that the
+    // instance isn't closed.
+    releaseTimer = setTimeout(async () => {
+      await quitCurrentDriver();
+    }, quitDelay);
+  }
+}
+DriverManager.registerConfig({ capabilities: defaultCapabilities, timeouts: defaultTimeouts });
+
+/**
+ * Create a WebDriver instance from the given configuration name. The config should
+ * already be registered via [registerConfig].
+ * @param configName The configuration name used to retrieve the configuration
+ * object for the driver instance
+ * @return A Promise which resolves to the configured WebDriver instance
+ * @private
+ */
+async function createDriver(configName: string) {
+  const config = configs[configName];
+  if (!config) {
+    throw Error(`No driver configuration exists for "${configName}"`);
+  }
+  // Merge default capabilities with custom ones
+  const caps = new Capabilities(configs[defaultConfigName].capabilities);
+  if (config.capabilities) {
+    caps.merge(config.capabilities);
+  }
+  // Merge default timeouts with custom ones
+  const timeouts = Object.assign({}, configs[defaultConfigName].timeouts, config.timeouts);
+  if (!builder) {
+    builder = new Builder();
+  }
+  const driver: WebDriver = builder.withCapabilities(caps).build();
+  currentInstance = { configName, driver };
+  // selenium-webdriver^3.60 has setTimeouts(),
+  // but @types/selenium-webdriver^3.0.8 (latest) has timeouts(). Need to cast
+  // here to avoid compilation failure.
+  await driver.manage().setTimeouts(timeouts);
+
+  return driver;
+}
+
+/**
+ * @private
+ */
+async function quitCurrentDriver() {
+  const driver = currentInstance.driver;
+  if (driver) {
+    try {
+      await driver.quit();
+    } catch (ex) {
+      // Driver may have already been closed
+      console.warn(ex);
+    } finally {
+      currentInstance = {
+        configName: null,
+        driver: null,
+      };
+    }
+  }
+}