selenium-webdriver 4.2.0 → 4.4.0

package/lib/http.js

@@ -347,6 +347,44 @@ const W3C_COMMAND_MAP = new Map([
 
   // Server Extensions
   [cmd.Name.UPLOAD_FILE, post('/session/:sessionId/se/file')],
+
+  // Virtual Authenticator
+  [
+    cmd.Name.ADD_VIRTUAL_AUTHENTICATOR,
+    post('/session/:sessionId/webauthn/authenticator'),
+  ],
+  [
+    cmd.Name.REMOVE_VIRTUAL_AUTHENTICATOR,
+    del('/session/:sessionId/webauthn/authenticator/:authenticatorId'),
+  ],
+  [
+    cmd.Name.ADD_CREDENTIAL,
+    post(
+      '/session/:sessionId/webauthn/authenticator/:authenticatorId/credential'
+    ),
+  ],
+  [
+    cmd.Name.GET_CREDENTIALS,
+    get(
+      '/session/:sessionId/webauthn/authenticator/:authenticatorId/credentials'
+    ),
+  ],
+  [
+    cmd.Name.REMOVE_CREDENTIAL,
+    del(
+      '/session/:sessionId/webauthn/authenticator/:authenticatorId/credentials/:credentialId'
+    ),
+  ],
+  [
+    cmd.Name.REMOVE_ALL_CREDENTIALS,
+    del(
+      '/session/:sessionId/webauthn/authenticator/:authenticatorId/credentials'
+    ),
+  ],
+  [
+    cmd.Name.SET_USER_VERIFIED,
+    post('/session/:sessionId/webauthn/authenticator/:authenticatorId/uv'),
+  ],
 ])
 
 /**
@@ -472,6 +510,7 @@ class Executor {
     this.log_.finer(() => `>>>\n${request}\n<<<\n${response}`)
 
     let httpResponse = /** @type {!Response} */ (response)
+
     let { isW3C, value } = parseHttpResponse(command, httpResponse)
 
     if (command.getName() === cmd.Name.NEW_SESSION) {
@@ -530,6 +569,7 @@ function parseHttpResponse(command, httpResponse) {
   }
 
   let parsed = tryParse(httpResponse.body)
+
   if (parsed && typeof parsed === 'object') {
     let value = parsed.value
     let isW3C =

package/lib/input.js

@@ -346,16 +346,42 @@ class Pointer extends Device {
 
   /**
    * @param {!Button=} button The button to press.
+   * @param width
+   * @param height
+   * @param pressure
+   * @param tangentialPressure
+   * @param tiltX
+   * @param tiltY
+   * @param twist
+   * @param altitudeAngle
+   * @param azimuthAngle
    * @return {!Action} An action to press the specified button with this device.
    * @package
    */
-  press(button = Button.LEFT, width = 0, height = 0, pressure = 0,
-    tangentialPressure = 0, tiltX = 0, tiltY = 0, twist = 0,
-    altitudeAngle = 0, azimuthAngle = 0) {
+  press(
+    button = Button.LEFT,
+    width = 0,
+    height = 0,
+    pressure = 0,
+    tangentialPressure = 0,
+    tiltX = 0,
+    tiltY = 0,
+    twist = 0,
+    altitudeAngle = 0,
+    azimuthAngle = 0
+  ) {
     return {
-      type: Action.Type.POINTER_DOWN, button, width, height,
-      pressure, tangentialPressure, tiltX, tiltY, twist,
-      altitudeAngle, azimuthAngle
+      type: Action.Type.POINTER_DOWN,
+      button,
+      width,
+      height,
+      pressure,
+      tangentialPressure,
+      tiltX,
+      tiltY,
+      twist,
+      altitudeAngle,
+      azimuthAngle,
     }
   }
 
@@ -385,15 +411,36 @@ class Pointer extends Device {
    * @return {!Action} The new action.
    * @package
    */
-  move({ x = 0, y = 0, duration = 100, origin = Origin.VIEWPORT,
-    width = 0, height = 0, pressure = 0,
-    tangentialPressure = 0, tiltX = 0, tiltY = 0, twist = 0,
-    altitudeAngle = 0, azimuthAngle = 0
+  move({
+    x = 0,
+    y = 0,
+    duration = 100,
+    origin = Origin.VIEWPORT,
+    width = 0,
+    height = 0,
+    pressure = 0,
+    tangentialPressure = 0,
+    tiltX = 0,
+    tiltY = 0,
+    twist = 0,
+    altitudeAngle = 0,
+    azimuthAngle = 0,
   }) {
     return {
-      type: Action.Type.POINTER_MOVE, origin, duration, x, y,
-      width, height, pressure, tangentialPressure, tiltX, tiltY, twist,
-      altitudeAngle, azimuthAngle
+      type: Action.Type.POINTER_MOVE,
+      origin,
+      duration,
+      x,
+      y,
+      width,
+      height,
+      pressure,
+      tangentialPressure,
+      tiltX,
+      tiltY,
+      twist,
+      altitudeAngle,
+      azimuthAngle,
     }
   }
 }
@@ -410,10 +457,9 @@ Pointer.Type = {
 
 class Wheel extends Device {
   /**
-   * @param {string} id the device ID.
-   * @param {Pointer.Type} type the pointer type.
+   * @param {string} id the device ID..
    */
-  constructor(id, type) {
+  constructor(id) {
     super(Device.Type.WHEEL, id)
   }
 
@@ -423,15 +469,19 @@ class Wheel extends Device {
    * @param {number} y starting y coordinate
    * @param {number} deltaX Delta X to scroll to target
    * @param {number} deltaY Delta Y to scroll to target
+   * @param {WebElement} origin element origin
    * @param {number} duration duration ratio be the ratio of time delta and duration
    * @returns {!Action} An action to scroll with this device.
    */
   scroll(x, y, deltaX, deltaY, origin, duration) {
     return {
       type: Action.Type.SCROLL,
-      duration: duration, x: x, y: y,
-      deltaX: deltaX, deltaY: deltaY,
-      origin: origin
+      duration: duration,
+      x: x,
+      y: y,
+      deltaX: deltaX,
+      deltaY: deltaY,
+      origin: origin,
     }
   }
 }
@@ -795,18 +845,21 @@ class Actions {
    * @param {number} deltax delta x to scroll to target
    * @param {number} deltay delta y to scroll to target
    * @param {number} duration duration ratio be the ratio of time delta and duration
-   * @returns {!Action} An action to scroll with this device.
+   * @returns {!Actions} An action to scroll with this device.
    */
   scroll(x, y, targetDeltaX, targetDeltaY, origin, duration) {
-    return this.insert(this.wheel_, this.wheel_.scroll(x, y, targetDeltaX, targetDeltaY, origin, duration))
+    return this.insert(
+      this.wheel_,
+      this.wheel_.scroll(x, y, targetDeltaX, targetDeltaY, origin, duration)
+    )
   }
 
   /**
    * Inserts an action for moving the mouse `x` and `y` pixels relative to the
    * specified `origin`. The `origin` may be defined as the mouse's
-   * {@linkplain ./input.Origin.POINTER current position}, the
+   * {@linkplain ./input.Origin.POINTER current position}, the top-left corner of the
    * {@linkplain ./input.Origin.VIEWPORT viewport}, or the center of a specific
-   * {@linkplain ./webdriver.WebElement WebElement}.
+   * {@linkplain ./webdriver.WebElement WebElement}. Default is top left corner of the view-port if origin is not specified
    *
    * You may adjust how long the remote end should take, in milliseconds, to
    * perform the move using the `duration` parameter (defaults to 100 ms).

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)
@@ -1363,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 {
@@ -1515,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)
+    )
+  }
 }
 
 /**
@@ -2765,17 +2873,18 @@ class WebElement {
    *     when the form has been submitted.
    */
   submit() {
-    const script = "var form = arguments[0];\n" +
-      "while (form.nodeName != \"FORM\" && form.parentNode) {\n" +
-      "  form = form.parentNode;\n" +
-      "}\n" +
+    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";
+      'if (form.dispatchEvent(e)) { HTMLFormElement.prototype.submit.call(form) }\n'
 
-    this.driver_.executeScript(script, this);
+    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 || `IPv${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.2.0",
+  "version": "4.4.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": "^9.2.2",
-    "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"
   },