selenium-webdriver 4.0.0-beta.2 → 4.0.0-rc-2

package/lib/input.js

@@ -20,14 +20,8 @@
 /**
  * @fileoverview Defines types related to user input with the WebDriver API.
  */
-
-const promise = require('./promise')
 const { Command, Name } = require('./command')
-const {
-  InvalidArgumentError,
-  UnknownCommandError,
-  UnsupportedOperationError,
-} = require('./error')
+const { InvalidArgumentError } = require('./error')
 
 /**
  * Enumeration of the buttons used in the advanced interactions API.
@@ -489,67 +483,6 @@ Pointer.Type = {
  * | Keyboard | pause(100)            | keyDown(SHIFT) |
  * | Mouse    | move({duration: 300}) |                |
  *
- *
- * #### Bridge Mode
- *
- * As of January 2018, only Firefox natively supports this API. For other
- * browsers, you may either use the
- * {@link ./actions.LegacyActionSequence LegacyActionSequence} class, _or_ you
- * can put the Actions class into bridge mode by passing `{bridge: true}` on
- * creation:
- *
- *     const actions = driver.actions({bridge: true});
- *     await actions.click(element).sendKeys('abc').perform();
- *
- * In bridge mode, {@link #perform perform()} will first attempt to execute the
- * configured action sequence using the W3C action protocol. If this is rejected
- * by the remote end, the sequence will be translated to and executed against
- * the legacy protocol.
- *
- * Bridge mode __is not enabled by default__ as there are several notable
- * differences between W3C-specified and legacy protocols. Care must be
- * taken to configure your action sequences to account for these differences:
- *
- * 1.  For W3C actions, the entire action sequence is executed in a single
- *     call to the remote end. For legacy sequences, multiple calls must be
- *     made for each step in the sequence. This introduces additional latency
- *     which may impact how the browser responds to the emulated user actions.
- *
- * 2.  For the legacy actions, {@linkplain #pause pauses} are handled _locally_.
- *
- * 3.  For legacy actions, a {@linkplain #keyDown keyDown()} for a
- *     _non-modifier key_ **must** be followed by a {@linkplain #keyUP keyUp()}
- *     for the same key. This will be handled for you if you use the
- *     {@linkplain #sendKeys sendKeys()} method.
- *
- * 4.  Mouse movements may not be specified relative to
- *     {@linkplain ./input.Origin.VIEWPORT Origin.VIEWPORT}.
- *     All movements must be relative to an element or the mouse's current
- *     position ({@linkplain ./input.Origin.POINTER Origin.POINTER}).
- *     The {@linkplain #move move()} method defaults to viewport relative
- *     offsets, so you must always specify an appropriate origin in bridge mode:
- *
- *         driver.actions({bridge: true})
- *             .move({x: 0, y: 0, origin: Origin.POINTER})
- *             .perform();
- *         driver.actions({bridge: true})
- *             .move({x: 0, y: 0, origin: someWebElement})
- *             .perform();
- *
- * 5.  The legacy protocol does not support specifying the duration of a
- *     {@linkplain #move mouse movement}; any specified duration _is ignored_
- *     when translating actions to the legacy protocol.
- *
- * 6.  For W3C actions, move offsets relative to a
- *     {@linkplain ./webdriver.WebElement WebElement} are interpreted relative
- *     to the center of an element's _first_ [client rect] in the viewport. For
- *     legacy actions, element offsets are relative to the top-left corner of
- *     the element's [bounding client rect]. When translating actions to the
- *     legacy protocol in bridge mode, an extra command must be inserted to
- *     translate move offsets from one frame of reference to the other. This
- *     extra command contributes to the overall latency issue outlined in
- *     point 1.
- *
  * [client rect]: https://developer.mozilla.org/en-US/docs/Web/API/Element/getClientRects
  * [bounding client rect]: https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect
  *
@@ -560,26 +493,16 @@ class Actions {
   /**
    * @param {!Executor} executor The object to execute the configured
    *     actions with.
-   * @param {{async: (boolean|undefined),
-   *          bridge: (boolean|undefined)}} options Options for this action
+   * @param {{async: (boolean|undefined)}} options Options for this action
    *     sequence (see class description for details).
    */
-  constructor(executor, { async = false, bridge = false } = {}) {
-    if (async && bridge) {
-      throw new InvalidArgumentError(
-        'Async sequences not supported with bridge mode'
-      )
-    }
-
+  constructor(executor, { async = false } = {}) {
     /** @private @const */
     this.executor_ = executor
 
     /** @private @const */
     this.sync_ = !async
 
-    /** @private @const */
-    this.bridge_ = !!bridge
-
     /** @private @const */
     this.keyboard_ = new Keyboard('default keyboard')
 
@@ -952,20 +875,9 @@ class Actions {
       return Promise.resolve()
     }
 
-    try {
-      await this.executor_.execute(
-        new Command(Name.ACTIONS).setParameter('actions', _actions)
-      )
-    } catch (ex) {
-      if (
-        this.bridge_ &&
-        (ex instanceof UnknownCommandError ||
-          ex instanceof UnsupportedOperationError)
-      ) {
-        return executeLegacy(this.executor_, this.sequences_)
-      }
-      throw ex
-    }
+    await this.executor_.execute(
+      new Command(Name.ACTIONS).setParameter('actions', _actions)
+    )
   }
 }
 
@@ -980,213 +892,6 @@ function isIdle(actions) {
   )
 }
 
-const MODIFIER_KEYS = new Set([Key.ALT, Key.CONTROL, Key.SHIFT, Key.COMMAND])
-
-/**
- * @param {!Executor} executor
- * @param {!Map<!Device, !Array<!Action>>} sequences
- * @return {!Promise<void>}
- * @suppress {deprecated} Ignore warnings about using LegacyActionSequence.
- */
-async function executeLegacy(executor, sequences) {
-  let maxLength = 0
-  sequences.forEach((seq) => (maxLength = Math.max(maxLength, seq.length)))
-
-  const actions = []
-  for (let i = 0; i < maxLength; i++) {
-    let next
-    for (const device of sequences.keys()) {
-      const seq = sequences.get(device)
-
-      if (
-        device instanceof Pointer &&
-        device.pointerType_ !== Pointer.Type.MOUSE
-      ) {
-        throw new UnsupportedOperationError(
-          `${device.pointerType_} pointer not supported in bridge mode`
-        )
-      }
-
-      const action = seq[i]
-      if (!action || (action.type === Action.Type.PAUSE && !action.duration)) {
-        continue
-      }
-
-      // -  If we've already found an action for this tick:
-      //    -  If we have two pauses, use the one with a longer duration
-      //    -  If one is a pause and the other isn't, use the non-pause
-      //    -  Otherwise, two non-pauses is an error.
-      // - Otherwise, we haven't selected an action yet.
-      if (next) {
-        if (next.type === Action.Type.PAUSE) {
-          if (action.type === Action.Type.PAUSE) {
-            next = next.duration > action.duration ? next : action
-          } else {
-            next = action
-          }
-        } else if (action.type !== Action.Type.PAUSE) {
-          throw new UnsupportedOperationError(
-            'parallel actions not supported in bridge mode'
-          )
-        }
-      } else {
-        next = action
-      }
-
-      if (action.type === Action.Type.KEY_DOWN) {
-        // If this action is a keydown for a non-modifier key, the next action
-        // must be a keyup for the same key, otherwise it cannot be translated
-        // to the legacy action API.
-        if (!MODIFIER_KEYS.has(action.value)) {
-          const nextAction = seq[i + 1]
-          if (
-            !nextAction ||
-            nextAction.type !== Action.Type.KEY_UP ||
-            nextAction.value !== action.value
-          ) {
-            throw new UnsupportedOperationError(
-              `in bridge mode, keydown for <${action.value}> must be followed` +
-                ' by a keyup for the same key'
-            )
-          }
-        }
-      } else if (
-        action.type === Action.Type.KEY_UP &&
-        !MODIFIER_KEYS.has(action.value)
-      ) {
-        next = null
-      }
-    }
-
-    if (next) {
-      actions.push(next)
-    }
-  }
-
-  for (let i = 0; i < actions.length; i++) {
-    const action = actions[i]
-    switch (action.type) {
-      case Action.Type.PAUSE: {
-        await promise.delayed(action.duration || 0)
-        break
-      }
-      case Action.Type.KEY_DOWN: {
-        const keys = [action.value]
-        if (!MODIFIER_KEYS.has(action.value)) {
-          // eslint-disable-next-line no-inner-declarations
-          function nextIsKeyDown() {
-            const next = actions[i + 1]
-            return (
-              !!next &&
-              next.type === Action.Type.KEY_DOWN &&
-              !MODIFIER_KEYS.has(next.value)
-            )
-          }
-          for (; nextIsKeyDown(); i++) {
-            keys.push(actions[i + 1].value)
-          }
-        }
-        await executor.execute(
-          new Command(Name.LEGACY_ACTION_SEND_KEYS).setParameter('value', keys)
-        )
-        break
-      }
-      case Action.Type.KEY_UP: {
-        await executor.execute(
-          new Command(Name.LEGACY_ACTION_SEND_KEYS).setParameter('value', [
-            action.value,
-          ])
-        )
-        break
-      }
-      case Action.Type.POINTER_DOWN: {
-        // eslint-disable-next-line no-inner-declarations
-        function isClick(startAt) {
-          const first = actions[startAt]
-          const second = actions[startAt + 1]
-          return (
-            !!first &&
-            !!second &&
-            first.type === Action.Type.POINTER_DOWN &&
-            second.type === Action.Type.POINTER_UP &&
-            first.button === second.button
-          )
-        }
-
-        // eslint-disable-next-line no-inner-declarations
-        function isDoubleClick(startAt) {
-          return (
-            isClick(startAt) &&
-            isClick(startAt + 2) &&
-            actions[startAt].button === actions[(startAt = 2)].button
-          )
-        }
-
-        let cmd
-        if (isDoubleClick(i)) {
-          i += 3 // Consume the pointer up/down/up.
-          cmd = Name.LEGACY_ACTION_DOUBLE_CLICK
-        } else if (isClick(i)) {
-          i++ // Consume the pointer-up.
-          cmd = Name.LEGACY_ACTION_CLICK
-        } else {
-          cmd = Name.LEGACY_ACTION_MOUSE_DOWN
-        }
-        await executor.execute(
-          new Command(cmd).setParameter('button', action.button)
-        )
-        break
-      }
-      case Action.Type.POINTER_UP: {
-        await executor.execute(
-          new Command(Name.LEGACY_ACTION_MOUSE_UP).setParameter(
-            'button',
-            action.button
-          )
-        )
-        break
-      }
-      case Action.Type.POINTER_MOVE: {
-        if (action.origin === Origin.VIEWPORT) {
-          throw new UnsupportedOperationError(
-            `pointer movements relative to ${Origin.VIEWPORT} are not` +
-              ' supported in bridge mode'
-          )
-        }
-
-        let x = action.x
-        let y = action.y
-        const cmd = new Command(Name.LEGACY_ACTION_MOUSE_MOVE)
-        if (action.origin && action.origin !== Origin.POINTER) {
-          const el = /** @type {!./webdriver.WebElement} */ (action.origin)
-
-          // Need to translate frame of reference from center of element's first
-          // client rect to the top-left of its bounding client rect. See:
-          // https://w3c.github.io/webdriver/webdriver-spec.html#dfn-center-point
-          let diff = await executor.execute(
-            new Command(Name.EXECUTE_SCRIPT)
-              .setParameter('script', INTERNAL_COMPUTE_OFFSET_SCRIPT)
-              .setParameter('args', [el])
-          )
-          x += diff[0]
-          y += diff[1]
-
-          const id = await el.getId()
-          cmd.setParameter('element', id)
-        }
-        cmd.setParameter('xoffset', x).setParameter('yoffset', y)
-        await executor.execute(cmd)
-        break
-      }
-      default: {
-        throw new UnsupportedOperationError(
-          `${action.type} actions not supported in bridge mode`
-        )
-      }
-    }
-  }
-}
-
 /**
  * Script used to compute the offset from the center of a DOM element's first
  * client rect from the top-left corner of the element's bounding client rect.

package/lib/promise.js

@@ -30,17 +30,7 @@
  * @return {boolean} Whether the value is a promise.
  */
 function isPromise(value) {
-  try {
-    // Use array notation so the Closure compiler does not obfuscate away our
-    // contract.
-    return (
-      value &&
-      (typeof value === 'object' || typeof value === 'function') &&
-      typeof value['then'] === 'function'
-    )
-  } catch (ex) {
-    return false
-  }
+  return Object.prototype.toString.call(value) === '[object Promise]'
 }
 
 /**
@@ -50,9 +40,7 @@ function isPromise(value) {
  * @return {!Promise<void>} The promise.
  */
 function delayed(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms)
-  })
+  return new Promise((resolve) => setTimeout(resolve, ms))
 }
 
 /**
@@ -199,8 +187,8 @@ async function filter(array, fn, self = undefined) {
 
   for (let i = 0; i < n; i++) {
     if (i in arr) {
-      let value = arr[i]
-      let include = await fn.call(self, value, i, arr)
+      const value = arr[i]
+      const include = await fn.call(self, value, i, arr)
       if (include) {
         values[valuesLength++] = value
       }

package/lib/until.js

@@ -137,14 +137,13 @@ exports.alertIsPresent = function alertIsPresent() {
  * @return {!Condition<boolean>} The new condition.
  */
 exports.titleIs = function titleIs(title) {
-  return new Condition(
-    'for title to be ' + JSON.stringify(title),
-    function (driver) {
-      return driver.getTitle().then(function (t) {
-        return t === title
-      })
-    }
-  )
+  return new Condition('for title to be ' + JSON.stringify(title), function (
+    driver
+  ) {
+    return driver.getTitle().then(function (t) {
+      return t === title
+    })
+  })
 }
 
 /**
@@ -189,14 +188,13 @@ exports.titleMatches = function titleMatches(regex) {
  * @return {!Condition<boolean>} The new condition.
  */
 exports.urlIs = function urlIs(url) {
-  return new Condition(
-    'for URL to be ' + JSON.stringify(url),
-    function (driver) {
-      return driver.getCurrentUrl().then(function (u) {
-        return u === url
-      })
-    }
-  )
+  return new Condition('for URL to be ' + JSON.stringify(url), function (
+    driver
+  ) {
+    return driver.getCurrentUrl().then(function (u) {
+      return u === url
+    })
+  })
 }
 
 /**

package/lib/webdriver.js

@@ -36,19 +36,21 @@ const http = require('../http/index')
 const fs = require('fs')
 const { Capabilities } = require('./capabilities')
 const path = require('path')
+const { NoSuchElementError } = require('./error')
 
 // Capability names that are defined in the W3C spec.
 const W3C_CAPABILITY_NAMES = new Set([
   'acceptInsecureCerts',
   'browserName',
   'browserVersion',
-  'platformName',
   'pageLoadStrategy',
+  'platformName',
   'proxy',
   'setWindowRect',
-  'timeouts',
   'strictFileInteractability',
+  'timeouts',
   'unhandledPromptBehavior',
+  'webSocketUrl'
 ])
 
 /**
@@ -649,7 +651,6 @@ function filterNonW3CCaps(capabilities) {
  * @implements {IWebDriver}
  */
 class WebDriver {
-
   /**
    * @param {!(./session.Session|IThenable<!./session.Session>)} session Either
    *     a known session or a promise that will be resolved to a session.
@@ -972,16 +973,46 @@ class WebDriver {
   /** @override */
   findElement(locator) {
     let id
-    locator = by.checkedLocator(locator)
+    let cmd = null
+
+    if (locator instanceof RelativeBy) {
+      cmd = new command.Command(
+        command.Name.FIND_ELEMENTS_RELATIVE
+      ).setParameter('args', locator.marshall())
+    } else {
+      locator = by.checkedLocator(locator)
+    }
+
     if (typeof locator === 'function') {
       id = this.findElementInternal_(locator, this)
-    } else {
-      let cmd = new command.Command(command.Name.FIND_ELEMENT)
+      return new WebElementPromise(this, id)
+    } else if (cmd === null) {
+      cmd = new command.Command(command.Name.FIND_ELEMENT)
         .setParameter('using', locator.using)
         .setParameter('value', locator.value)
-      id = this.execute(cmd)
     }
-    return new WebElementPromise(this, id)
+
+    id = this.execute(cmd)
+    if (locator instanceof RelativeBy) {
+      return this.normalize_(id)
+    } else {
+      return new WebElementPromise(this, id)
+    }
+  }
+
+  /**
+   * @param {!Function} webElementPromise The webElement in unresolved state
+   * @return {!Promise<!WebElement>} First single WebElement from array of resolved promises
+   */
+  async normalize_(webElementPromise) {
+    let result = await webElementPromise
+    if (result.length === 0) {
+      throw new NoSuchElementError(
+        'Cannot locate an element with provided parameters'
+      )
+    } else {
+      return result[0]
+    }
   }
 
   /**
@@ -1166,7 +1197,7 @@ class WebDriver {
       caps['map_'].get(this.VENDOR_COMMAND_PREFIX + ':chromeOptions') ||
       caps['map_'].get(this.VENDOR_CAPABILITY_PREFIX + ':edgeOptions') ||
       caps['map_'].get('moz:debuggerAddress') ||
-      new Map();
+      new Map()
     const debuggerUrl = seCdp || vendorInfo['debuggerAddress'] || vendorInfo
     this._wsUrl = await this.getWsUrl(debuggerUrl, target)
 
@@ -1199,23 +1230,25 @@ class WebDriver {
     if (target && cdpTargets.indexOf(target.toLowerCase()) === -1) {
       throw new error.InvalidArgumentError('invalid target value')
     }
-    let path
-    if (target === 'page') {
-      path = '/json'
-    } else {
-      path = '/json/version'
+
+    if (debuggerAddress.match(/\/se\/cdp/)) {
+      if (debuggerAddress.match("ws:\/\/", "http:\/\/")) {
+        return debuggerAddress.replace("ws:\/\/", "http:\/\/")
+      }
+      else if (debuggerAddress.match("wss:\/\/", "https:\/\/")) {
+        return debuggerAddress.replace("wss:\/\/", "https:\/\/")
+      }
+      else {
+        return debuggerAddress
+      }
     }
+
+    const path = '/json/version'
     let request = new http.Request('GET', path)
     let client = new http.HttpClient('http://' + debuggerAddress)
     let response = await client.send(request)
-    let url
-    if (target.toLowerCase() === 'page') {
-      url = JSON.parse(response.body)[0]['webSocketDebuggerUrl']
-    } else {
-      url = JSON.parse(response.body)['webSocketDebuggerUrl']
-    }
 
-    return url
+    return JSON.parse(response.body)['webSocketDebuggerUrl']
   }
 
   /**
@@ -1227,14 +1260,6 @@ class WebDriver {
    * @param connection CDP Connection
    */
   async register(username, password, connection) {
-    await connection.execute(
-      'Network.setCacheDisabled',
-      this.getRandomNumber(1, 10),
-      {
-        cacheDisabled: true,
-      },
-      null
-    )
 
     this._wsConnection.on('message', (message) => {
       const params = JSON.parse(message)
@@ -1273,8 +1298,69 @@ class WebDriver {
       },
       null
     )
+    await connection.execute(
+      'Network.setCacheDisabled',
+      this.getRandomNumber(1, 10),
+      {
+        cacheDisabled: true,
+      },
+      null
+    )
   }
 
+  /**
+   * Handle Network interception requests
+   * @param connection WebSocket connection to the browser
+   * @param httpResponse Object representing what we are intercepting
+   *                     as well as what should be returned.
+   * @param callback callback called when we intercept requests.
+   */
+  async onIntercept(connection, httpResponse, callback) {
+
+    this._wsConnection.on('message', (message) => {
+      const params = JSON.parse(message)
+      if (params.method === 'Fetch.requestPaused') {
+        const requestPausedParams = params['params']
+        if (requestPausedParams.request.url == httpResponse.urlToIntercept) {
+          connection.execute(
+            'Fetch.continueRequest',
+            this.getRandomNumber(1, 10),
+            {
+              requestId: requestPausedParams['requestId'],
+              url: httpResponse.urlToIntercept,
+              method: httpResponse.method,
+              headers: httpResponse.headers,
+              postData: httpResponse.body
+            }
+          )
+          callback()
+        } else {
+          connection.execute(
+            'Fetch.continueRequest',
+            this.getRandomNumber(1, 10),
+            {
+              requestId: requestPausedParams['requestId'],
+            }
+          )
+        }
+      }
+    })
+
+    await connection.execute(
+      'Fetch.enable',
+      1,
+      {},
+      null
+    )
+    await connection.execute(
+      'Network.setCacheDisabled',
+      this.getRandomNumber(1, 10),
+      {
+        cacheDisabled: true,
+      },
+      null
+    )
+  }
   /**
    *
    * @param connection
@@ -1282,12 +1368,7 @@ class WebDriver {
    * @returns {Promise<void>}
    */
   async onLogEvent(connection, callback) {
-    await connection.execute(
-      'Runtime.enable',
-      this.getRandomNumber(1, 10),
-      {},
-      null
-    )
+
 
     this._wsConnection.on('message', (message) => {
       const params = JSON.parse(message)
@@ -1303,6 +1384,12 @@ class WebDriver {
         callback(event)
       }
     })
+    await connection.execute(
+      'Runtime.enable',
+      this.getRandomNumber(1, 10),
+      {},
+      null
+    )
   }
 
   /**
@@ -1374,7 +1461,10 @@ class WebDriver {
         .toString()
     } catch {
       mutationListener = fs
-        .readFileSync(path.resolve(__dirname, './atoms/mutation-listener.js'), 'utf-8')
+        .readFileSync(
+          path.resolve(__dirname, './atoms/mutation-listener.js'),
+          'utf-8'
+        )
         .toString()
     }
 
@@ -2692,18 +2782,12 @@ class WebElement {
    * Take a screenshot of the visible region encompassed by this element's
    * bounding rectangle.
    *
-   * @param {boolean=} scroll Optional argument that indicates whether the
-   *     element should be scrolled into view before taking a screenshot.
-   *     Defaults to false.
    * @return {!Promise<string>} A promise that will be
    *     resolved to the screenshot as a base-64 encoded PNG.
    */
-  takeScreenshot(scroll = false) {
+  takeScreenshot() {
     return this.execute_(
-      new command.Command(command.Name.TAKE_ELEMENT_SCREENSHOT).setParameter(
-        'scroll',
-        scroll
-      )
+      new command.Command(command.Name.TAKE_ELEMENT_SCREENSHOT)
     )
   }
 }