selenium-webdriver 4.9.2 → 4.11.0

package/bidi/networkTypes.js

@@ -0,0 +1,483 @@
+// 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.
+
+const { NavigationInfo } = require('./browsingContextTypes')
+
+class Header {
+  constructor(name, value, binaryValue) {
+    this._name = name
+    this._value = value
+    this._binaryValue = binaryValue
+  }
+
+  get name() {
+    return this._name
+  }
+
+  get value() {
+    return this._value
+  }
+
+  get binaryValue() {
+    return this._binaryValue
+  }
+}
+
+class Cookie {
+  constructor(
+    name,
+    value,
+    binaryValue,
+    domain,
+    path,
+    expires,
+    size,
+    httpOnly,
+    secure,
+    sameSite
+  ) {
+    this._name = name
+    this._value = value
+    this._binaryValue = binaryValue
+    this._domain = domain
+    this._path = path
+    this._expires = expires
+    this._size = size
+    this._httpOnly = httpOnly
+    this._secure = secure
+    this._sameSite = sameSite
+  }
+
+  get name() {
+    return this._name
+  }
+
+  get value() {
+    return this._value
+  }
+
+  get binaryValue() {
+    return this._binaryValue
+  }
+
+  get domain() {
+    return this._domain
+  }
+
+  get path() {
+    return this._path
+  }
+
+  get expires() {
+    return this._expires
+  }
+
+  get size() {
+    return this._size
+  }
+
+  get httpOnly() {
+    return this._httpOnly
+  }
+
+  get secure() {
+    return this._secure
+  }
+
+  get sameSite() {
+    return this._sameSite
+  }
+}
+
+// No tests written for FetchTimingInfo. Must be updated after browsers implment it and corresponding WPT test are written.
+class FetchTimingInfo {
+  constructor(
+    originTime,
+    requestTime,
+    redirectStart,
+    redirectEnd,
+    fetchStart,
+    dnsStart,
+    dnsEnd,
+    connectStart,
+    connectEnd,
+    tlsStart,
+    requestStart,
+    responseStart,
+    responseEnd
+  ) {
+    this._originTime = originTime
+    this._requestTime = requestTime
+    this._redirectStart = redirectStart
+    this._redirectEnd = redirectEnd
+    this._fetchStart = fetchStart
+    this._dnsStart = dnsStart
+    this._dnsEnd = dnsEnd
+    this._connectStart = connectStart
+    this._connectEnd = connectEnd
+    this._tlsStart = tlsStart
+    this._requestStart = requestStart
+    this._responseStart = responseStart
+    this._responseEnd = responseEnd
+  }
+
+  get originTime() {
+    return this._originTime
+  }
+
+  get requestTime() {
+    return this._requestTime
+  }
+
+  get redirectStart() {
+    return this._redirectStart
+  }
+
+  get redirectEnd() {
+    return this._redirectEnd
+  }
+
+  get fetchStart() {
+    return this._fetchStart
+  }
+
+  get dnsStart() {
+    return this._dnsStart
+  }
+
+  get dnsEnd() {
+    return this._dnsEnd
+  }
+
+  get connectStart() {
+    return this._connectStart
+  }
+
+  get connectEnd() {
+    return this._connectEnd
+  }
+
+  get tlsStart() {
+    return this._tlsStart
+  }
+
+  get requestStart() {
+    return this._requestStart
+  }
+
+  get responseStart() {
+    return this._responseStart
+  }
+
+  get responseEnd() {
+    return this._responseEnd
+  }
+}
+
+class RequestData {
+  constructor(
+    request,
+    url,
+    method,
+    headers,
+    cookies,
+    headersSize,
+    bodySize,
+    timings
+  ) {
+    this._request = request
+    this._url = url
+    this._method = method
+    this._headers = []
+    headers.forEach((header) => {
+      let name = header.name
+      let value = 'value' in header ? header.value : null
+      let binaryValue = 'binaryValue' in header ? header.binaryValue : null
+
+      this._headers.push(new Header(name, value, binaryValue))
+    })
+
+    this._cookies = []
+    cookies.forEach((cookie) => {
+      let name = cookie.name
+      let domain = cookie.domain
+      let path = cookie.path
+      let size = cookie.size
+      let httpOnly = cookie.httpOnly
+      let secure = cookie.secure
+      let sameSite = cookie.sameSite
+      let value = 'value' in cookie ? cookie.value : null
+      let binaryValue = 'binaryValue' in cookie ? cookie.binaryValue : null
+      let expires = 'expires' in cookie ? cookie.expires : null
+
+      this._cookies.push(
+        new Cookie(
+          name,
+          value,
+          binaryValue,
+          domain,
+          path,
+          expires,
+          size,
+          httpOnly,
+          secure,
+          sameSite
+        )
+      )
+    })
+    this._headersSize = headersSize
+    this._bodySize = bodySize
+    this._timings = new FetchTimingInfo(
+      timings.originTime,
+      timings.requestTime,
+      timings.redirectStart,
+      timings.redirectEnd,
+      timings.fetchStart,
+      timings.dnsStart,
+      timings.dnsEnd,
+      timings.connectStart,
+      timings.connectEnd,
+      timings.tlsStart,
+      timings.requestStart,
+      timings.responseStart,
+      timings.responseEnd
+    )
+  }
+
+  get request() {
+    return this._request
+  }
+
+  get url() {
+    return this._url
+  }
+
+  get method() {
+    return this._method
+  }
+
+  get headers() {
+    return this._headers
+  }
+
+  get cookies() {
+    return this._cookies
+  }
+
+  get headersSize() {
+    return this._headersSize
+  }
+
+  get bodySize() {
+    return this._bodySize
+  }
+
+  get timings() {
+    return this._timings
+  }
+}
+
+class BaseParameters {
+  constructor(id, navigation, redirectCount, request, timestamp) {
+    this._id = id
+    this._navigation =
+      navigation != null
+        ? new NavigationInfo(
+            navigation.context,
+            navigation.navigation,
+            navigation.timestamp,
+            navigation.url
+          )
+        : null
+    this._redirectCount = redirectCount
+    this._request = new RequestData(
+      request.request,
+      request.url,
+      request.method,
+      request.headers,
+      request.cookies,
+      request.headersSize,
+      request.bodySize,
+      request.timings
+    )
+    this._timestamp = timestamp
+  }
+
+  get id() {
+    return this._id
+  }
+
+  get navigation() {
+    return this._navigation
+  }
+
+  get redirectCount() {
+    return this._redirectCount
+  }
+
+  get request() {
+    return this._request
+  }
+
+  get timestamp() {
+    return this._timestamp
+  }
+}
+
+class Initiator {
+  constructor(type, columnNumber, lineNumber, stackTrace, request) {
+    this._type = type
+    this._columnNumber = columnNumber
+    this._lineNumber = lineNumber
+    this._stackTrace = stackTrace
+    this._request = request
+  }
+
+  get type() {
+    return this._type
+  }
+
+  get columnNumber() {
+    return this._columnNumber
+  }
+
+  get lineNumber() {
+    return this._lineNumber
+  }
+
+  get stackTrace() {
+    return this._stackTrace
+  }
+
+  get request() {
+    return this._request
+  }
+}
+
+class BeforeRequestSent extends BaseParameters {
+  constructor(id, navigation, redirectCount, request, timestamp, initiator) {
+    super(id, navigation, redirectCount, request, timestamp)
+    this._initiator = new Initiator(
+      initiator.type,
+      initiator.columnNumber,
+      initiator.lineNumber,
+      initiator.stackTrace,
+      initiator.request
+    )
+  }
+
+  get initiator() {
+    return this._initiator
+  }
+}
+
+class ResponseData {
+  constructor(
+    url,
+    protocol,
+    status,
+    statusText,
+    fromCache,
+    headers,
+    mimeType,
+    bytesReceived,
+    headersSize,
+    bodySize,
+    content
+  ) {
+    this._url = url
+    this._protocol = protocol
+    this._status = status
+    this._statusText = statusText
+    this._fromCache = fromCache
+    this._headers = headers
+    this._mimeType = mimeType
+    this._bytesReceived = bytesReceived
+    this._headersSize = headersSize
+    this._bodySize = bodySize
+    this._content = content
+  }
+
+  get url() {
+    return this._url
+  }
+
+  get protocol() {
+    return this._protocol
+  }
+
+  get status() {
+    return this._status
+  }
+
+  get statusText() {
+    return this._statusText
+  }
+
+  get fromCache() {
+    return this._fromCache
+  }
+
+  get headers() {
+    return this._headers
+  }
+
+  get mimeType() {
+    return this._mimeType
+  }
+
+  get bytesReceived() {
+    return this._bytesReceived
+  }
+
+  get headerSize() {
+    return this._headersSize
+  }
+
+  get bodySize() {
+    return this._bodySize
+  }
+
+  get content() {
+    return this._content
+  }
+}
+
+class ResponseStarted extends BaseParameters {
+  constructor(id, navigation, redirectCount, request, timestamp, response) {
+    super(id, navigation, redirectCount, request, timestamp)
+    this._response = new ResponseData(
+      response.url,
+      response.protocol,
+      response.status,
+      response.statusText,
+      response.fromCache,
+      response.headers,
+      response.mimeType,
+      response.bytesReceived,
+      response.headerSize,
+      response.bodySize,
+      response.content
+    )
+  }
+
+  get response() {
+    return this._response
+  }
+}
+
+module.exports = { BeforeRequestSent, ResponseStarted }

package/bidi/protocolValue.js

@@ -123,7 +123,7 @@ class RemoteValue {
     this.sharedId = null
 
     if ('type' in remoteValue) {
-      var typeString = remoteValue['type']
+      const typeString = remoteValue['type']
       if (PrimitiveType.findByName(typeString) != null) {
         this.type = PrimitiveType.findByName(typeString)
       } else if (NonPrimitiveType.findByName(typeString) != null) {

package/bidi/scriptManager.js

@@ -23,6 +23,7 @@ const {
 } = require('./evaluateResult')
 const { RealmInfo } = require('./realmInfo')
 const { RemoteValue } = require('./protocolValue')
+const { WebDriverError } = require('../lib/error')
 
 class ScriptManager {
   constructor(driver) {
@@ -179,6 +180,39 @@ class ScriptManager {
     return this.createEvaluateResult(response)
   }
 
+  async addPreloadScript(
+    functionDeclaration,
+    argumentValueList = [],
+    sandbox = null
+  ) {
+    const params = {
+      functionDeclaration: functionDeclaration,
+      arguments: argumentValueList,
+      sandbox: sandbox,
+    }
+
+    const command = {
+      method: 'script.addPreloadScript',
+      params,
+    }
+
+    let response = await this.bidi.send(command)
+    return response.result.script
+  }
+
+  async removePreloadScript(script) {
+    const params = { script: script }
+    const command = {
+      method: 'script.removePreloadScript',
+      params,
+    }
+    let response = await this.bidi.send(command)
+    if ('error' in response) {
+      throw new WebDriverError(response.error)
+    }
+    return response.result
+  }
+
   getCallFunctionParams(
     targetType,
     id,
@@ -251,18 +285,18 @@ class ScriptManager {
   }
 
   createEvaluateResult(response) {
-    var type = response.result.type
-    var realmId = response.result.realm
-    var evaluateResult
+    const type = response.result.type
+    const realmId = response.result.realm
+    let evaluateResult
 
     if (type === EvaluateResultType.SUCCESS) {
-      var result = response.result.result
+      const result = response.result.result
       evaluateResult = new EvaluateResultSuccess(
         realmId,
         new RemoteValue(result)
       )
     } else {
-      var exceptionDetails = response.result.exceptionDetails
+      const exceptionDetails = response.result.exceptionDetails
       evaluateResult = new EvaluateResultException(
         realmId,
         new ExceptionDetails(exceptionDetails)
@@ -272,7 +306,7 @@ class ScriptManager {
   }
 
   realmInfoMapper(realms) {
-    var realmsList = []
+    const realmsList = []
     realms.forEach((realm) => {
       realmsList.push(RealmInfo.fromJson(realm))
     })

package/chrome.js

@@ -130,14 +130,7 @@
 const io = require('./io')
 const { Browser } = require('./lib/capabilities')
 const chromium = require('./chromium')
-
-/**
- * Name of the ChromeDriver executable.
- * @type {string}
- * @const
- */
-const CHROMEDRIVER_EXE =
-  process.platform === 'win32' ? 'chromedriver.exe' : 'chromedriver'
+const CHROME_CAPABILITY_KEY = 'goog:chromeOptions'
 
 /** @type {remote.DriverService} */
 
@@ -156,8 +149,7 @@ class ServiceBuilder extends chromium.ServiceBuilder {
    *     cannot be found on the PATH.
    */
   constructor(opt_exe) {
-    let exe = opt_exe || locateSynchronously()
-    super(exe)
+    super(opt_exe)
   }
 }
 
@@ -229,7 +221,7 @@ class Driver extends chromium.Driver {
   static createSession(opt_config, opt_serviceExecutor) {
     let caps = opt_config || new Options()
     return /** @type {!Driver} */ (
-      super.createSession(caps, opt_serviceExecutor)
+      super.createSession(caps, opt_serviceExecutor, 'goog', CHROME_CAPABILITY_KEY)
     )
   }
 
@@ -242,24 +234,12 @@ class Driver extends chromium.Driver {
   }
 }
 
-/**
- * _Synchronously_ attempts to locate the chromedriver executable on the current
- * system.
- *
- * @return {?string} the located executable, or `null`.
- */
-function locateSynchronously() {
-  return io.findInPath(CHROMEDRIVER_EXE, true)
-}
-
-Options.prototype.CAPABILITY_KEY = 'goog:chromeOptions'
+Options.prototype.CAPABILITY_KEY = CHROME_CAPABILITY_KEY
 Options.prototype.BROWSER_NAME_VALUE = Browser.CHROME
-Driver.prototype.VENDOR_COMMAND_PREFIX = 'goog'
 
 // PUBLIC API
 module.exports = {
-  Driver: Driver,
+  Driver,
   Options,
   ServiceBuilder,
-  locateSynchronously,
 }

package/chromium.js

@@ -669,27 +669,38 @@ class Driver extends webdriver.WebDriver {
   /**
    * Creates a new session with the WebDriver server.
    *
-   * @param {(Capabilities|Options)=} opt_config The configuration options.
+   * @param {(Capabilities|Options)=} caps The configuration options.
    * @param {(remote.DriverService|http.Executor)=} opt_serviceExecutor Either
    *     a  DriverService to use for the remote end, or a preconfigured executor
    *     for an externally managed endpoint. If neither is provided, the
    *     {@linkplain ##getDefaultService default service} will be used by
    *     default.
+   * @param vendorPrefix Either 'goog' or 'ms'
+   * @param vendorCapabilityKey Either 'goog:chromeOptions' or 'ms:edgeOptions'
    * @return {!Driver} A new driver instance.
    */
-  static createSession(caps, opt_serviceExecutor) {
+  static createSession(caps, opt_serviceExecutor,
+    vendorPrefix = '', vendorCapabilityKey = '') {
     let executor
     let onQuit
     if (opt_serviceExecutor instanceof http.Executor) {
       executor = opt_serviceExecutor
-      configureExecutor(executor, this.VENDOR_COMMAND_PREFIX)
+      configureExecutor(executor, vendorPrefix)
     } else {
       let service = opt_serviceExecutor || this.getDefaultService()
       if (!service.getExecutable()) {
-        service.setExecutable(getPath(service, caps))
+        const {driverPath, browserPath} = getPath(caps)
+        service.setExecutable(driverPath)
+        const vendorOptions = caps.get(vendorCapabilityKey)
+        if (vendorOptions) {
+          vendorOptions['binary'] = browserPath
+          caps.set(vendorCapabilityKey, vendorOptions)
+        } else {
+          caps.set(vendorCapabilityKey, {binary: browserPath})
+        }
       }
       onQuit = () => service.kill()
-      executor = createExecutor(service.start(), this.VENDOR_COMMAND_PREFIX)
+      executor = createExecutor(service.start(), vendorPrefix)
     }
 
     // W3C spec requires noProxy value to be an array of strings, but Chromium