selenium-webdriver 4.1.1 → 4.3.0

package/lib/virtual_authenticator.js

@@ -0,0 +1,230 @@
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+'use strict'
+
+/**
+ * Options for the creation of virtual authenticators.
+ * @see http://w3c.github.io/webauthn/#sctn-automation
+ */
+class VirtualAuthenticatorOptions {
+
+  static Protocol = {
+    "CTAP2": 'ctap2',
+    "U2F": 'ctap1/u2f',
+  }
+
+  static Transport = {
+    "BLE": 'ble',
+    "USB": 'usb',
+    "NFC": 'nfc',
+    "INTERNAL": 'internal',
+  }
+
+  /**
+   * Constructor to initialise VirtualAuthenticatorOptions object.
+   */
+  constructor() {
+    this._protocol = VirtualAuthenticatorOptions.Protocol["CTAP2"]
+    this._transport = VirtualAuthenticatorOptions.Transport["USB"]
+    this._hasResidentKey = false
+    this._hasUserVerification = false
+    this._isUserConsenting = true
+    this._isUserVerified = false
+  }
+
+  getProtocol() {
+    return this._protocol
+  }
+
+  setProtocol(protocol) {
+    this._protocol = protocol
+  }
+
+  getTransport() {
+    return this._transport
+  }
+
+  setTransport(transport) {
+    this._transport = transport
+  }
+
+  getHasResidentKey() {
+    return this._hasResidentKey
+  }
+
+  setHasResidentKey(value) {
+    this._hasResidentKey = value
+  }
+
+  getHasUserVerification() {
+    return this._hasUserVerification
+  }
+
+  setHasUserVerification(value) {
+    this._hasUserVerification = value
+  }
+
+  getIsUserConsenting() {
+    return this._isUserConsenting
+  }
+
+  setIsUserConsenting(value) {
+    this._isUserConsenting = value
+  }
+
+  getIsUserVerified() {
+    return this._isUserVerified
+  }
+
+  setIsUserVerified(value) {
+    this._isUserVerified = value
+  }
+
+  toDict() {
+    return {
+      "protocol": this.getProtocol(),
+      "transport": this.getTransport(),
+      "hasResidentKey": this.getHasResidentKey(),
+      "hasUserVerification": this.getHasUserVerification(),
+      "isUserConsenting": this.getIsUserConsenting(),
+      "isUserVerified": this.getIsUserVerified(),
+
+    }
+  }
+}
+
+/**
+ * A credential stored in a virtual authenticator.
+ * @see https://w3c.github.io/webauthn/#credential-parameters
+ */
+class Credential {
+  constructor(
+    credentialId,
+    isResidentCredential,
+    rpId,
+    userHandle,
+    privateKey,
+    signCount
+  ) {
+    this._id = credentialId
+    this._isResidentCredential = isResidentCredential
+    this._rpId = rpId
+    this._userHandle = userHandle
+    this._privateKey = privateKey
+    this._signCount = signCount
+  }
+
+  id() {
+    return this._id
+  }
+
+  isResidentCredential() {
+    return this._isResidentCredential
+  }
+
+  rpId() {
+    return this._rpId
+  }
+
+  userHandle() {
+    if (this._userHandle != null) {
+      return this._userHandle
+    }
+    return null
+  }
+
+  privateKey() {
+    return this._privateKey
+  }
+
+  signCount() {
+    return this._signCount
+  }
+
+  /**
+   * Creates a resident (i.e. stateless) credential.
+   * @param id Unique base64 encoded string.
+   * @param rpId Relying party identifier.
+   * @param userHandle userHandle associated to the credential. Must be Base64 encoded string.
+   * @param privateKey Base64 encoded PKCS
+   * @param signCount initial value for a signature counter.
+   * @returns A resident credential
+   */
+  createResidentCredential(id, rpId, userHandle, privateKey, signCount) {
+    return new Credential(id, true, rpId, userHandle, privateKey, signCount)
+  }
+
+  /**
+   * Creates a non-resident (i.e. stateless) credential.
+   * @param id Unique base64 encoded string.
+   * @param rpId Relying party identifier.
+   * @param privateKey Base64 encoded PKCS
+   * @param signCount initial value for a signature counter.
+   * @returns A non-resident credential
+   */
+  createNonResidentCredential(id, rpId, privateKey, signCount) {
+    return new Credential(id, false, rpId, null, privateKey, signCount)
+  }
+
+  toDict() {
+    let credentialData = {
+      'credentialId': Buffer.from(this._id).toString('base64url'),
+      'isResidentCredential': this._isResidentCredential,
+      'rpId': this._rpId,
+      'privateKey': Buffer.from(this._privateKey, 'binary').toString('base64url'),
+      'signCount': this._signCount,
+    }
+
+    if (this.userHandle() != null) {
+      credentialData['userHandle'] = Buffer.from(this._userHandle).toString('base64url')
+    }
+
+    return credentialData
+  }
+
+  /**
+   * Creates a credential from a map.
+   */
+  fromDict(data) {
+    let id = new Uint8Array(Buffer.from(data['credentialId'], 'base64url'))
+    let isResidentCredential = data['isResidentCredential']
+    let rpId = data['rpId']
+    let privateKey = Buffer.from(data['privateKey'], 'base64url').toString('binary')
+    let signCount = data['signCount']
+    let userHandle
+
+    if ('userHandle' in data) {
+      userHandle = new Uint8Array(Buffer.from(data['userHandle'], 'base64url'))
+    } else {
+      userHandle = null
+    }
+    return new Credential(
+      id,
+      isResidentCredential,
+      rpId,
+      userHandle,
+      privateKey,
+      signCount
+    )
+  }
+}
+
+module.exports = {
+  Credential,
+  VirtualAuthenticatorOptions,
+}

package/lib/webdriver.js

@@ -37,6 +37,7 @@ const { Capabilities } = require('./capabilities')
 const path = require('path')
 const { NoSuchElementError } = require('./error')
 const cdpTargets = ['page', 'browser']
+const Credential = require('./virtual_authenticator').Credential
 
 // Capability names that are defined in the W3C spec.
 const W3C_CAPABILITY_NAMES = new Set([
@@ -679,6 +680,9 @@ class WebDriver {
 
     /** @private @const {(function(this: void): ?|undefined)} */
     this.onQuit_ = onQuit
+
+    /** @private {./virtual_authenticator}*/
+    this.authenticatorId_ = null
   }
 
   /**
@@ -730,6 +734,7 @@ class WebDriver {
   /** @override */
   async execute(command) {
     command.setParameter('sessionId', this.session_)
+
     let parameters = await toWireValue(command.getParameters())
     command.setParameters(parameters)
     let value = await this.executor_.execute(command)
@@ -1197,14 +1202,25 @@ class WebDriver {
    * @return {!Promise<resolved>} A new CDP instance.
    */
   async createCDPConnection(target) {
+    let debuggerUrl = null
+
     const caps = await this.getCapabilities()
-    const seCdp = caps['map_'].get('se:cdp')
-    const vendorInfo =
-      caps['map_'].get(this.VENDOR_COMMAND_PREFIX + ':chromeOptions') ||
-      caps['map_'].get(this.VENDOR_CAPABILITY_PREFIX + ':edgeOptions') ||
-      caps['map_'].get('moz:debuggerAddress') ||
-      new Map()
-    const debuggerUrl = seCdp || vendorInfo['debuggerAddress'] || vendorInfo
+
+    if (process.env.SELENIUM_REMOTE_URL) {
+      const host = new URL(process.env.SELENIUM_REMOTE_URL).host
+      const sessionId = await this.getSession().then((session) =>
+        session.getId()
+      )
+      debuggerUrl = `ws://${host}/session/${sessionId}/se/cdp`
+    } else {
+      const seCdp = caps['map_'].get('se:cdp')
+      const vendorInfo =
+        caps['map_'].get(this.VENDOR_COMMAND_PREFIX + ':chromeOptions') ||
+        caps['map_'].get(this.VENDOR_CAPABILITY_PREFIX + ':edgeOptions') ||
+        caps['map_'].get('moz:debuggerAddress') ||
+        new Map()
+      debuggerUrl = seCdp || vendorInfo['debuggerAddress'] || vendorInfo
+    }
     this._wsUrl = await this.getWsUrl(debuggerUrl, target, caps)
     return new Promise((resolve, reject) => {
       try {
@@ -1352,12 +1368,11 @@ class WebDriver {
       if (params.method === 'Fetch.requestPaused') {
         const requestPausedParams = params['params']
         if (requestPausedParams.request.url == httpResponse.urlToIntercept) {
-          connection.execute('Fetch.continueRequest', {
+          connection.execute('Fetch.fulfillRequest', {
             requestId: requestPausedParams['requestId'],
-            url: httpResponse.urlToIntercept,
-            method: httpResponse.method,
-            headers: httpResponse.headers,
-            postData: httpResponse.body,
+            responseCode: 200,
+            responseHeaders: httpResponse.headers,
+            body: httpResponse.body,
           })
           callback()
         } else {
@@ -1504,6 +1519,110 @@ class WebDriver {
       }
     })
   }
+
+  /**
+   *
+   * @returns The value of authenticator ID added
+   */
+  virtualAuthenticatorId() {
+    return this.authenticatorId_
+  }
+
+  /**
+   * Adds a virtual authenticator with the given options.
+   * @param options VirtualAuthenticatorOptions object to set authenticator optons.
+   */
+  async addVirtualAuthenticator(options) {
+    this.authenticatorId_ = await this.execute(
+      new command.Command(command.Name.ADD_VIRTUAL_AUTHENTICATOR).setParameters(
+        options.toDict()
+      )
+    )
+  }
+
+  /**
+   * Removes a previously added virtual authenticator. The authenticator is no
+   * longer valid after removal, so no methods may be called.
+   */
+  async removeVirtualAuthenticator() {
+    await this.execute(
+      new command.Command(
+        command.Name.REMOVE_VIRTUAL_AUTHENTICATOR
+      ).setParameter('authenticatorId', this.authenticatorId_)
+    )
+    this.authenticatorId_ = null
+  }
+
+  /**
+   * Injects a credential into the authenticator.
+   * @param credential Credential to be added
+   */
+  async addCredential(credential) {
+    credential = credential.toDict()
+    credential['authenticatorId'] = this.authenticatorId_
+    await this.execute(
+      new command.Command(command.Name.ADD_CREDENTIAL).setParameters(credential)
+    )
+  }
+
+  /**
+   *
+   * @returns The list of credentials owned by the authenticator.
+   */
+  async getCredentials() {
+    let credential_data = await this.execute(
+      new command.Command(command.Name.GET_CREDENTIALS).setParameter(
+        'authenticatorId',
+        this.virtualAuthenticatorId()
+      )
+    )
+    var credential_list = []
+    for (var i = 0; i < credential_data.length; i++) {
+      credential_list.push(new Credential().fromDict(credential_data[i]))
+    }
+    return credential_list
+  }
+
+  /**
+   * Removes a credential from the authenticator.
+   * @param credential_id The ID of the credential to be removed.
+   */
+  async removeCredential(credential_id) {
+    // If credential_id is not a base64url, then convert it to base64url.
+    if (Array.isArray(credential_id)) {
+      credential_id = Buffer.from(credential_id).toString('base64url')
+    }
+
+    await this.execute(
+      new command.Command(command.Name.REMOVE_CREDENTIAL)
+        .setParameter('credentialId', credential_id)
+        .setParameter('authenticatorId', this.authenticatorId_)
+    )
+  }
+
+  /**
+   * Removes all the credentials from the authenticator.
+   */
+  async removeAllCredentials() {
+    await this.execute(
+      new command.Command(command.Name.REMOVE_ALL_CREDENTIALS).setParameter(
+        'authenticatorId',
+        this.authenticatorId_
+      )
+    )
+  }
+
+  /**
+   * Sets whether the authenticator will simulate success or fail on user verification.
+   * @param verified true if the authenticator will pass user verification, false otherwise.
+   */
+  async setUserVerified(verified) {
+    await this.execute(
+      new command.Command(command.Name.SET_USER_VERIFIED)
+        .setParameter('authenticatorId', this.authenticatorId_)
+        .setParameter('isUserVerified', verified)
+    )
+  }
 }
 
 /**
@@ -1945,14 +2064,10 @@ class Window {
    * @return {!Promise<{x: number, y: number, width: number, height: number}>}
    *     A promise that will resolve to the window rect of the current window.
    */
-  async getRect() {
-    try {
-      return await this.driver_.execute(
-        new command.Command(command.Name.GET_WINDOW_RECT)
-      )
-    } catch (ex) {
-      throw ex
-    }
+  getRect() {
+    return this.driver_.execute(
+      new command.Command(command.Name.GET_WINDOW_RECT)
+    )
   }
 
   /**
@@ -1969,19 +2084,15 @@ class Window {
    *     A promise that will resolve to the current window's updated window
    *     rect.
    */
-  async setRect({ x, y, width, height }) {
-    try {
-      return await this.driver_.execute(
-        new command.Command(command.Name.SET_WINDOW_RECT).setParameters({
-          x,
-          y,
-          width,
-          height,
-        })
-      )
-    } catch (ex) {
-      throw ex
-    }
+  setRect({ x, y, width, height }) {
+    return this.driver_.execute(
+      new command.Command(command.Name.SET_WINDOW_RECT).setParameters({
+        x,
+        y,
+        width,
+        height,
+      })
+    )
   }
 
   /**
@@ -2159,13 +2270,23 @@ class TargetLocator {
    * If the specified frame can not be found, the returned promise will be
    * rejected with a {@linkplain error.NoSuchFrameError}.
    *
-   * @param {(number|WebElement|null)} id The frame locator.
+   * @param {(number|string|WebElement|null)} id The frame locator.
    * @return {!Promise<void>} A promise that will be resolved
    *     when the driver has changed focus to the specified frame.
    */
   frame(id) {
+    let frameReference = id
+    if (typeof id === 'string') {
+      frameReference = this.driver_
+        .findElement({ id })
+        .catch((_) => this.driver_.findElement({ name: id }))
+    }
+
     return this.driver_.execute(
-      new command.Command(command.Name.SWITCH_TO_FRAME).setParameter('id', id)
+      new command.Command(command.Name.SWITCH_TO_FRAME).setParameter(
+        'id',
+        frameReference
+      )
     )
   }
 
@@ -2522,12 +2643,12 @@ class WebElement {
       if (type === 'number') {
         key = String(key)
       } else if (type !== 'string') {
-        throw TypeError('each key must be a number of string; got ' + type)
+        throw TypeError('each key must be a number or string; got ' + type)
       }
 
       // The W3C protocol requires keys to be specified as an array where
       // each element is a single key.
-      keys.push(...key.split(''))
+      keys.push(...key)
     })
 
     if (!this.driver_.fileDetector_) {
@@ -2544,7 +2665,10 @@ class WebElement {
         keys.join('')
       )
     } catch (ex) {
-      console.log('Error trying parse string as a file with file detector; sending keys instead' + ex)
+      console.log(
+        'Error trying parse string as a file with file detector; sending keys instead' +
+          ex
+      )
     }
 
     return this.execute_(
@@ -2715,14 +2839,8 @@ class WebElement {
    * @return {!Promise<{width: number, height: number, x: number, y: number}>}
    *     A promise that will resolve with the element's rect.
    */
-  async getRect() {
-    try {
-      return await this.execute_(
-        new command.Command(command.Name.GET_ELEMENT_RECT)
-      )
-    } catch (err) {
-        throw err;
-    }
+  getRect() {
+    return this.execute_(new command.Command(command.Name.GET_ELEMENT_RECT))
   }
 
   /**
@@ -2755,13 +2873,18 @@ class WebElement {
    *     when the form has been submitted.
    */
   submit() {
-    const form = this.findElement({ xpath: './ancestor-or-self::form' })
-    this.driver_.executeScript(
-      "var e = arguments[0].ownerDocument.createEvent('Event');" +
-        "e.initEvent('submit', true, true);" +
-        'if (arguments[0].dispatchEvent(e)) { arguments[0].submit() }',
-      form
-    )
+    const script =
+      'var form = arguments[0];\n' +
+      'while (form.nodeName != "FORM" && form.parentNode) {\n' +
+      '  form = form.parentNode;\n' +
+      '}\n' +
+      "if (!form) { throw Error('Unable to find containing form element'); }\n" +
+      "if (!form.ownerDocument) { throw Error('Unable to find owning document'); }\n" +
+      "var e = form.ownerDocument.createEvent('Event');\n" +
+      "e.initEvent('submit', true, true);\n" +
+      'if (form.dispatchEvent(e)) { HTMLFormElement.prototype.submit.call(form) }\n'
+
+    this.driver_.executeScript(script, this)
   }
 
   /**

package/net/index.js

@@ -48,7 +48,10 @@ function getIPAddress(loopback, family) {
     }
 
     for (let ipAddress of interfaces[key]) {
-      if (ipAddress.family === family && ipAddress.internal === loopback) {
+      if (
+        (ipAddress.family === family || `IPv${ipAddress.family}` === family) &&
+        ipAddress.internal === loopback
+      ) {
         return ipAddress.address
       }
     }
@@ -73,7 +76,11 @@ function getAddress(family = 'IPv4') {
  * @return {(string|undefined)} The IP address or undefined if not available.
  */
 function getLoopbackAddress(family = 'IPv4') {
-  return getIPAddress(true, family)
+  let address = getIPAddress(true, family)
+  if (address === '127.0.0.1') {
+    address = 'localhost'
+  }
+  return address
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "selenium-webdriver",
-  "version": "4.1.1",
+  "version": "4.3.0",
   "description": "The official WebDriver JavaScript bindings from the Selenium project",
   "license": "Apache-2.0",
   "keywords": [
@@ -23,26 +23,26 @@
     "node": ">= 10.15.0"
   },
   "dependencies": {
-    "jszip": "^3.6.0",
+    "jszip": "^3.10.0",
     "tmp": "^0.2.1",
-    "ws": ">=7.4.6"
+    "ws": ">=8.7.0"
   },
   "devDependencies": {
-    "eslint": "^7.26.0",
-    "eslint-config-prettier": "^8.3.0",
+    "eslint": "^8.16.0",
+    "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-no-only-tests": "^2.6.0",
     "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-prettier": "^3.4.0",
+    "eslint-plugin-prettier": "^4.0.0",
     "express": "^4.17.1",
     "jasmine": "^3.8.0",
-    "mocha": "^8.1.0",
-    "multer": "^1.4.2",
-    "prettier": "^2.3.0",
+    "mocha": "^10.0.0",
+    "multer": "^1.4.5-lts.1",
+    "prettier": "^2.6.1",
     "serve-index": "^1.9.1",
     "sinon": "^10.0.0"
   },
   "scripts": {
-    "lint": "eslint --ignore-pattern node_modules --ignore-pattern generator --ext js lib/http.js \"**/*.js\"",
+    "lint": "eslint --ignore-pattern node_modules --ignore-pattern generator --fix --ext js lib/http.js \"**/*.js\"",
     "test": "npm run lint && mocha -t 600000 --recursive test",
     "test-jasmine": "jasmine JASMINE_CONFIG_PATH=jasmine.json"
   },

package/testing/index.js

@@ -39,8 +39,7 @@ const firefox = require('../firefox')
 const ie = require('../ie')
 const remote = require('../remote')
 const safari = require('../safari')
-const opera = require('../opera')
-const { Browser, Capabilities } = require('../lib/capabilities')
+const { Browser } = require('../lib/capabilities')
 const { Builder } = require('../index')
 
 /**
@@ -123,7 +122,6 @@ function getAvailableBrowsers() {
     [firefox.locateSynchronously, Browser.FIREFOX],
     [ie.locateSynchronously, Browser.INTERNET_EXPLORER],
     [safari.locateSynchronously, Browser.SAFARI],
-    [opera.locateSynchronously, Browser.OPERA],
   ]
 
   let availableBrowsers = []
@@ -236,7 +234,8 @@ function init(force = false) {
 }
 
 const TARGET_MAP = /** !WeakMap<!Environment, !TargetBrowser> */ new WeakMap()
-const URL_MAP = /** !WeakMap<!Environment, ?(string|remote.SeleniumServer)> */ new WeakMap()
+const URL_MAP =
+  /** !WeakMap<!Environment, ?(string|remote.SeleniumServer)> */ new WeakMap()
 
 /**
  * Defines the environment a {@linkplain suite test suite} is running against.
@@ -249,9 +248,9 @@ class Environment {
    *     Selenium server to test against.
    */
   constructor(browser, url = undefined) {
-    browser = /** @type {!TargetBrowser} */ (Object.seal(
-      Object.assign({}, browser)
-    ))
+    browser = /** @type {!TargetBrowser} */ (
+      Object.seal(Object.assign({}, browser))
+    )
 
     TARGET_MAP.set(this, browser)
     URL_MAP.set(this, url || null)
@@ -286,19 +285,16 @@ class Environment {
     const builder = new Builder()
     builder.disableEnvironmentOverrides()
 
-
-
     const realBuild = builder.build
     builder.build = function () {
-      builder.forBrowser(browser.name, browser.version, browser.platform);
-
+      builder.forBrowser(browser.name, browser.version, browser.platform)
 
       if (browser.capabilities) {
-        builder.getCapabilities().merge(browser.capabilities);
+        builder.getCapabilities().merge(browser.capabilities)
       }
 
-      if(browser.name === 'firefox') {
-        builder.setCapability('moz:debuggerAddress', true);
+      if (browser.name === 'firefox') {
+        builder.setCapability('moz:debuggerAddress', true)
       }
 
       if (typeof urlOrServer === 'string') {
@@ -444,7 +440,7 @@ function suite(fn, options = undefined) {
  * @param {function(): boolean} predicateFn A predicate to call to determine
  *     if the test should be suppressed. This function MUST be synchronous.
  * @return {{describe: !Function, it: !Function}} an object with wrapped
- *     versions of the `describe` and `it` wtest functions.
+ *     versions of the `describe` and `it` test functions.
  */
 function ignore(predicateFn) {
   const isJasmine = global.jasmine && typeof global.jasmine === 'object'