webdriver 5.11.0 → 5.11.12

package/build/command.js

@@ -23,62 +23,37 @@ function _default(method, endpointUri, commandInfo) {
     variables = [],
     isHubCommand = false
   } = commandInfo;
-  return function (...args) {
-    let endpoint = endpointUri; // clone endpointUri in case we change it
-
+  return function protocolCommand(...args) {
+    let endpoint = endpointUri;
     const commandParams = [...variables.map(v => Object.assign(v, {
-      /**
-       * url variables are:
-       */
       required: true,
-      // always required as they are part of the endpoint
-      type: 'string' // have to be always type of string
-
+      type: 'string'
     })), ...parameters];
     const commandUsage = `${command}(${commandParams.map(p => p.name).join(', ')})`;
     const moreInfo = `\n\nFor more info see ${ref}\n`;
     const body = {};
-    /**
-     * parameter check
-     */
-
     const minAllowedParams = commandParams.filter(param => param.required).length;
 
     if (args.length < minAllowedParams || args.length > commandParams.length) {
       const parameterDescription = commandParams.length ? `\n\nProperty Description:\n${commandParams.map(p => `  "${p.name}" (${p.type}): ${p.description}`).join('\n')}` : '';
       throw new Error(`Wrong parameters applied for ${command}\n` + `Usage: ${commandUsage}` + parameterDescription + moreInfo);
     }
-    /**
-     * parameter type check
-     */
-
 
     for (const [i, arg] of Object.entries(args)) {
       const commandParam = commandParams[i];
 
       if (!(0, _utils.isValidParameter)(arg, commandParam.type)) {
-        /**
-         * ignore if argument is not required
-         */
         if (typeof arg === 'undefined' && !commandParam.required) {
           continue;
         }
 
         throw new Error(`Malformed type for "${commandParam.name}" parameter of command ${command}\n` + `Expected: ${commandParam.type}\n` + `Actual: ${(0, _utils.getArgumentType)(arg)}` + moreInfo);
       }
-      /**
-       * inject url variables
-       */
-
 
       if (i < variables.length) {
-        endpoint = endpoint.replace(`:${commandParams[i].name}`, arg);
+        endpoint = endpoint.replace(`:${commandParams[i].name}`, encodeURIComponent(encodeURIComponent(arg)));
         continue;
       }
-      /**
-       * rest of args are part of body payload
-       */
-
 
       body[commandParams[i].name] = arg;
     }
@@ -92,7 +67,7 @@ function _default(method, endpointUri, commandInfo) {
     log.info('COMMAND', (0, _utils.commandCallStructure)(command, args));
     return request.makeRequest(this.options, this.sessionId).then(result => {
       if (result.value != null) {
-        log.info('RESULT', command.toLowerCase().includes('screenshot') && typeof result.value === 'string' && result.value.length > 64 ? `${result.value.substr(0, 61)}...` : result.value);
+        log.info('RESULT', /screenshot|recording/i.test(command) && typeof result.value === 'string' && result.value.length > 64 ? `${result.value.substr(0, 61)}...` : result.value);
       }
 
       this.emit('result', {

package/build/constants.js

@@ -5,103 +5,52 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.DEFAULTS = void 0;
 const DEFAULTS = {
-  /**
-   * protocol of automation driver
-   */
   protocol: {
     type: 'string',
     default: 'http',
     match: /(http|https)/
   },
-
-  /**
-   * hostname of automation driver
-   */
   hostname: {
     type: 'string',
     default: 'localhost'
   },
-
-  /**
-   * port of automation driver
-   */
   port: {
     type: 'number',
     default: 4444
   },
-
-  /**
-   * path to WebDriver endpoints
-   */
   path: {
     type: 'string',
     default: '/wd/hub'
   },
-
-  /**
-   * A key-value store of query parameters to be added to every selenium request
-   */
   queryParams: {
     type: 'object'
   },
-
-  /**
-   * capability of WebDriver session
-   */
   capabilities: {
     type: 'object',
     required: true
   },
-
-  /**
-   * Level of logging verbosity
-   */
   logLevel: {
     type: 'string',
     default: 'info',
     match: /(trace|debug|info|warn|error|silent)/
   },
-
-  /**
-   * Timeout for any request to the Selenium server
-   */
   connectionRetryTimeout: {
     type: 'number',
     default: 90000
   },
-
-  /**
-   * Count of request retries to the Selenium server
-   */
   connectionRetryCount: {
     type: 'number',
     default: 3
   },
-
-  /**
-   * cloud user if applicable
-   */
   user: {
     type: 'string'
   },
-
-  /**
-   * access key to user
-   */
   key: {
     type: 'string'
   },
-
-  /**
-   * Override default agent
-   */
   agent: {
     type: 'object'
   },
-
-  /**
-   * Pass custom headers
-   */
   headers: {
     type: 'object'
   }

package/build/index.js

@@ -19,8 +19,6 @@ exports.default = void 0;
 
 var _logger = _interopRequireDefault(require("@wdio/logger"));
 
-var _lodash = _interopRequireDefault(require("lodash.merge"));
-
 var _config = require("@wdio/config");
 
 var _monad = _interopRequireDefault(require("./monad"));
@@ -43,6 +41,12 @@ var _chromium = _interopRequireDefault(require("../protocol/chromium.json"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
 class WebDriver {
   static async newSession(options = {}, modifier, userPrototype = {}, commandWrapper) {
     const params = (0, _config.validateConfig)(_constants.DEFAULTS, options);
@@ -50,64 +54,35 @@ class WebDriver {
     if (!options.logLevels || !options.logLevels['webdriver']) {
       _logger.default.setLevel('webdriver', params.logLevel);
     }
-    /**
-     * the user could have passed in either w3c style or jsonwp style caps
-     * and we want to pass both styles to the server, which means we need
-     * to check what style the user sent in so we know how to construct the
-     * object for the other style
-     */
-
-
-    const [w3cCaps, jsonwpCaps] = params.capabilities && params.capabilities.alwaysMatch
-    /**
-     * in case W3C compliant capabilities are provided
-     */
-    ? [params.capabilities, params.capabilities.alwaysMatch]
-    /**
-     * otherwise assume they passed in jsonwp-style caps (flat object)
-     */
-    : [{
+
+    const [w3cCaps, jsonwpCaps] = params.capabilities && params.capabilities.alwaysMatch ? [params.capabilities, params.capabilities.alwaysMatch] : [{
       alwaysMatch: params.capabilities,
       firstMatch: [{}]
     }, params.capabilities];
     const sessionRequest = new _request.default('POST', '/session', {
       capabilities: w3cCaps,
-      // W3C compliant
-      desiredCapabilities: jsonwpCaps // JSONWP compliant
-
+      desiredCapabilities: jsonwpCaps
     });
     const response = await sessionRequest.makeRequest(params);
-    /**
-     * save original set of capabilities to allow to request the same session again
-     * (e.g. for reloadSession command in WebdriverIO)
-     */
-
     params.requestedCapabilities = {
       w3cCaps,
       jsonwpCaps
-      /**
-       * save actual receveived session details
-       */
-
     };
     params.capabilities = response.value.capabilities || response.value;
     const environment = (0, _utils.environmentDetector)(params);
     const environmentPrototype = (0, _utils.getEnvironmentVars)(environment);
     const protocolCommands = (0, _utils.getPrototype)(environment);
-    const prototype = (0, _lodash.default)(protocolCommands, environmentPrototype, userPrototype);
+
+    const prototype = _objectSpread({}, protocolCommands, {}, environmentPrototype, {}, userPrototype);
+
     const monad = (0, _monad.default)(params, modifier, prototype);
     return monad(response.value.sessionId || response.sessionId, commandWrapper);
   }
-  /**
-   * allows user to attach to existing sessions
-   */
-
 
   static attachToSession(options = {}, modifier, userPrototype = {}, commandWrapper) {
     if (typeof options.sessionId !== 'string') {
       throw new Error('sessionId is required to attach to existing session');
-    } // logLevel can be undefined in watch mode when SIGINT is called
-
+    }
 
     if (options.logLevel !== undefined) {
       _logger.default.setLevel('webdriver', options.logLevel);
@@ -117,7 +92,9 @@ class WebDriver {
     options.isW3C = options.isW3C === false ? false : true;
     const environmentPrototype = (0, _utils.getEnvironmentVars)(options);
     const protocolCommands = (0, _utils.getPrototype)(options);
-    const prototype = (0, _lodash.default)(protocolCommands, environmentPrototype, userPrototype);
+
+    const prototype = _objectSpread({}, protocolCommands, {}, environmentPrototype, {}, userPrototype);
+
     const monad = (0, _monad.default)(options, modifier, prototype);
     return monad(options.sessionId, commandWrapper);
   }
@@ -129,10 +106,6 @@ class WebDriver {
   static get DEFAULTS() {
     return _constants.DEFAULTS;
   }
-  /**
-   * Protocols
-   */
-
 
   static get WebDriverProtocol() {
     return _webdriver.default;
@@ -155,9 +128,5 @@ class WebDriver {
   }
 
 }
-/**
- * Helper methods consumed by webdriverio package
- */
-
 
 exports.default = WebDriver;

package/build/monad.js

@@ -14,29 +14,17 @@ var _utils = require("./utils");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 const SCOPE_TYPES = {
-  'browser':
-  /* istanbul ignore next */
-  function Browser() {},
-  'element':
-  /* istanbul ignore next */
-  function Element() {}
+  'browser': function Browser() {},
+  'element': function Element() {}
 };
 
 function WebDriver(options, modifier, propertiesObject = {}) {
-  /**
-   * In order to allow named scopes for elements we have to propagate that
-   * info within the `propertiesObject` object. This doesn't have any functional
-   * advantages just provides better description of objects when debugging them
-   */
   const scopeType = SCOPE_TYPES[propertiesObject.scope] || SCOPE_TYPES['browser'];
   delete propertiesObject.scope;
   const prototype = Object.create(scopeType.prototype);
   const log = (0, _logger.default)('webdriver');
   const eventHandler = new _events.EventEmitter();
   const EVENTHANDLER_FUNCTIONS = Object.getPrototypeOf(eventHandler);
-  /**
-   * WebDriver monad
-   */
 
   function unit(sessionId, commandWrapper) {
     propertiesObject.commandList = {
@@ -44,11 +32,6 @@ function WebDriver(options, modifier, propertiesObject = {}) {
     };
     propertiesObject.options = {
       value: options
-      /**
-       * allow to wrap commands if necessary
-       * e.g. in wdio-cli to make them synchronous
-       */
-
     };
 
     if (typeof commandWrapper === 'function') {
@@ -63,25 +46,14 @@ function WebDriver(options, modifier, propertiesObject = {}) {
         propertiesObject[commandName].configurable = true;
       }
     }
-    /**
-     * overwrite native element commands with user defined
-     */
-
 
     _utils.overwriteElementCommands.call(this, propertiesObject);
-    /**
-     * assign propertiesObject to itself so the client can be recreated
-     */
-
 
     propertiesObject['__propertiesObject__'] = {
       value: propertiesObject
     };
     let client = Object.create(prototype, propertiesObject);
     client.sessionId = sessionId;
-    /**
-     * register capabilities only to browser scope
-     */
 
     if (scopeType.name === 'Browser') {
       client.capabilities = options.capabilities;
@@ -95,9 +67,6 @@ function WebDriver(options, modifier, propertiesObject = {}) {
       const customCommand = typeof commandWrapper === 'function' ? commandWrapper(name, func) : func;
 
       if (attachToElement) {
-        /**
-         * add command to every multiremote instance
-         */
         if (instances) {
           Object.values(instances).forEach(instance => {
             instance.__propertiesObject__[name] = {
@@ -113,32 +82,16 @@ function WebDriver(options, modifier, propertiesObject = {}) {
         unit.lift(name, customCommand, proto);
       }
     };
-    /**
-     * overwriteCommand
-     * @param  {String}   name              command name to be overwritten
-     * @param  {Function} func              function to replace original command with;
-     *                                      takes original function as first argument.
-     * @param  {boolean=} attachToElement   overwrite browser command (false) or element command (true)
-     * @param  {Object=}  proto             prototype to add function to (optional)
-     * @param  {Object=}  instances         multiremote instances
-     */
-
 
     client.overwriteCommand = function (name, func, attachToElement = false, proto, instances) {
       let customCommand = typeof commandWrapper === 'function' ? commandWrapper(name, func) : func;
 
       if (attachToElement) {
         if (instances) {
-          /**
-           * add command to every multiremote instance
-           */
           Object.values(instances).forEach(instance => {
             instance.__propertiesObject__.__elementOverrides__.value[name] = customCommand;
           });
         } else {
-          /**
-           * regular mode
-           */
           this.__propertiesObject__.__elementOverrides__.value[name] = customCommand;
         }
       } else if (client[name]) {
@@ -152,32 +105,15 @@ function WebDriver(options, modifier, propertiesObject = {}) {
 
     return client;
   }
-  /**
-   * Enhance monad prototype with function
-   * @param  {String}   name          name of function to attach to prototype
-   * @param  {Function} func          function to be added to prototype
-   * @param  {Object}   proto         prototype to add function to (optional)
-   * @param  {Function} origCommand   original command to be passed to custom command as first argument
-   */
-
 
   unit.lift = function (name, func, proto, origCommand) {
     (proto || prototype)[name] = function next(...args) {
       log.info('COMMAND', (0, _utils.commandCallStructure)(name, args));
-      /**
-       * set name of function for better error stack
-       */
-
       Object.defineProperty(func, 'name', {
         value: name,
         writable: false
       });
       const result = func.apply(this, origCommand ? [origCommand, ...args] : args);
-      /**
-       * always transform result into promise as we don't know whether or not
-       * the user is running tests with wdio-sync or not
-       */
-
       Promise.resolve(result).then(res => {
         log.info('RESULT', res);
         this.emit('result', {
@@ -188,10 +124,6 @@ function WebDriver(options, modifier, propertiesObject = {}) {
       return result;
     };
   };
-  /**
-   * register event emitter
-   */
-
 
   for (let eventCommand in EVENTHANDLER_FUNCTIONS) {
     prototype[eventCommand] = function (...args) {

package/build/request.js

@@ -13,8 +13,6 @@ var _path = _interopRequireDefault(require("path"));
 
 var _https = _interopRequireDefault(require("https"));
 
-var _lodash = _interopRequireDefault(require("lodash.merge"));
-
 var _request = _interopRequireDefault(require("request"));
 
 var _events = _interopRequireDefault(require("events"));
@@ -58,7 +56,7 @@ class WebDriverRequest extends _events.default {
   }
 
   makeRequest(options, sessionId) {
-    const fullRequestOptions = (0, _lodash.default)({}, this.defaultOptions, this._createOptions(options, sessionId));
+    const fullRequestOptions = Object.assign({}, this.defaultOptions, this._createOptions(options, sessionId));
     this.emit('request', fullRequestOptions);
     return this._request(fullRequestOptions, options.connectionRetryCount);
   }
@@ -68,33 +66,20 @@ class WebDriverRequest extends _events.default {
       agent: options.agent || agents[options.protocol],
       headers: typeof options.headers === 'object' ? options.headers : {},
       qs: typeof options.queryParams === 'object' ? options.queryParams : {}
-      /**
-       * only apply body property if existing
-       */
-
     };
 
     if (this.body && (Object.keys(this.body).length || this.method === 'POST')) {
       requestOptions.body = this.body;
-      requestOptions.headers = (0, _lodash.default)({}, requestOptions.headers, {
+      requestOptions.headers = Object.assign({}, requestOptions.headers, {
         'Content-Length': Buffer.byteLength(JSON.stringify(requestOptions.body), 'UTF-8')
       });
     }
-    /**
-     * if we don't have a session id we set it here, unless we call commands that don't require session ids, for
-     * example /sessions. The call to /sessions is not connected to a session itself and it therefore doesn't
-     * require it
-     */
-
 
     if (this.requiresSessionId && !sessionId) {
       throw new Error('A sessionId is required for this command');
     }
 
     requestOptions.uri = _url.default.parse(`${options.protocol}://` + `${options.hostname}:${options.port}` + (this.isHubCommand ? this.endpoint : _path.default.join(options.path, this.endpoint.replace(':sessionId', sessionId))));
-    /**
-     * send authentication credentials only when creating new session
-     */
 
     if (this.endpoint === '/session' && options.user && options.key) {
       requestOptions.auth = {
@@ -102,10 +87,6 @@ class WebDriverRequest extends _events.default {
         pass: options.key
       };
     }
-    /**
-     * if the environment variable "STRICT_SSL" is defined as "false", it doesn't require SSL certificates to be valid.
-     */
-
 
     requestOptions.strictSSL = !(process.env.STRICT_SSL === 'false' || process.env.strict_ssl === 'false');
     return requestOptions;
@@ -120,16 +101,8 @@ class WebDriverRequest extends _events.default {
 
     return new Promise((resolve, reject) => (0, _request.default)(fullRequestOptions, (err, response, body) => {
       const error = err || (0, _utils.getErrorFromResponseBody)(body);
-      /**
-       * hub commands don't follow standard response formats
-       * and can have empty bodies
-       */
 
       if (this.isHubCommand) {
-        /**
-         * if body contains HTML the command was called on a node
-         * directly without using a hub, therefor throw
-         */
         if (typeof body === 'string' && body.startsWith('<!DOCTYPE html>')) {
           return reject(new Error('Command can only be called to a Selenium Hub'));
         }
@@ -138,10 +111,6 @@ class WebDriverRequest extends _events.default {
           value: body || null
         };
       }
-      /**
-       * Resolve only if successful response
-       */
-
 
       if (!err && (0, _utils.isSuccessfulResponse)(response.statusCode, body)) {
         this.emit('response', {
@@ -149,11 +118,6 @@ class WebDriverRequest extends _events.default {
         });
         return resolve(body);
       }
-      /**
-       *  stop retrying as this will never be successful.
-       *  we will handle this at the elementErrorHandler
-       */
-
 
       if (error.name === 'stale element reference') {
         log.warn('Request encountered a stale element - terminating request');
@@ -162,11 +126,6 @@ class WebDriverRequest extends _events.default {
         });
         return reject(error);
       }
-      /**
-       * stop retrying if totalRetryCount was exceeded or there is no reason to
-       * retry, e.g. if sessionId is invalid
-       */
-
 
       if (retryCount >= totalRetryCount || error.message.includes('invalid session id')) {
         log.error('Request failed due to', error);

package/build/utils.js

@@ -44,35 +44,16 @@ var _selenium = _interopRequireDefault(require("../protocol/selenium.json"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 const log = (0, _logger.default)('webdriver');
-/**
- * check if WebDriver requests was successful
- * @param  {Object}  body  body payload of response
- * @return {Boolean}       true if request was successful
- */
 
 function isSuccessfulResponse(statusCode, body) {
-  /**
-   * response contains a body
-   */
   if (!body || typeof body.value === 'undefined') {
     log.debug('request failed due to missing body');
     return false;
   }
-  /**
-   * ignore failing element request to enable lazy loading capability
-   */
 
-
-  if (body.status === 7 && body.value && body.value.message && (body.value.message.toLowerCase().startsWith('no such element') || // Appium
-  body.value.message === 'An element could not be located on the page using the given search parameters.' || // Internet Explorter
-  body.value.message.toLowerCase().startsWith('unable to find element'))) {
+  if (body.status === 7 && body.value && body.value.message && (body.value.message.toLowerCase().startsWith('no such element') || body.value.message === 'An element could not be located on the page using the given search parameters.' || body.value.message.toLowerCase().startsWith('unable to find element'))) {
     return true;
   }
-  /**
-   * if it has a status property, it should be 0
-   * (just here to stay backwards compatible to the jsonwire protocol)
-   */
-
 
   if (body.status && body.status !== 0) {
     log.debug(`request failed due to status ${body.status}`);
@@ -80,26 +61,14 @@ function isSuccessfulResponse(statusCode, body) {
   }
 
   const hasErrorResponse = body.value && (body.value.error || body.value.stackTrace || body.value.stacktrace);
-  /**
-   * check status code
-   */
 
   if (statusCode === 200 && !hasErrorResponse) {
     return true;
   }
-  /**
-   * if an element was not found we don't flag it as failed request because
-   * we lazy load it
-   */
-
 
   if (statusCode === 404 && body.value && body.value.error === 'no such element') {
     return true;
   }
-  /**
-   * that has no error property (Appium only)
-   */
-
 
   if (hasErrorResponse) {
     log.debug('request failed due to response error:', body.value.error);
@@ -108,14 +77,6 @@ function isSuccessfulResponse(statusCode, body) {
 
   return true;
 }
-/**
- * checks if command argument is valid according to specificiation
- *
- * @param  {*}       arg           command argument
- * @param  {Object}  expectedType  parameter type (e.g. `number`, `string[]` or `(number|string)`)
- * @return {Boolean}               true if argument is valid
- */
-
 
 function isValidParameter(arg, expectedType) {
   let shouldBeArray = false;
@@ -124,19 +85,12 @@ function isValidParameter(arg, expectedType) {
     expectedType = expectedType.slice(0, -2);
     shouldBeArray = true;
   }
-  /**
-   * check type of each individual array element
-   */
-
 
   if (shouldBeArray) {
     if (!Array.isArray(arg)) {
       return false;
     }
   } else {
-    /**
-     * transform to array to have a unified check
-     */
     arg = [arg];
   }
 
@@ -150,18 +104,10 @@ function isValidParameter(arg, expectedType) {
 
   return true;
 }
-/**
- * get type of command argument
- */
-
 
 function getArgumentType(arg) {
   return arg === null ? 'null' : typeof arg;
 }
-/**
- * creates the base prototype for the webdriver monad
- */
-
 
 function getPrototype({
   isW3C,
@@ -171,30 +117,7 @@ function getPrototype({
   isSeleniumStandalone
 }) {
   const prototype = {};
-  const ProtocolCommands = (0, _lodash.default)(
-  /**
-   * if mobile apply JSONWire and WebDriver protocol because
-   * some legacy JSONWire commands are still used in Appium
-   * (e.g. set/get geolocation)
-   */
-  isMobile ? (0, _lodash.default)({}, _jsonwp.default, _webdriver.default) : isW3C ? _webdriver.default : _jsonwp.default,
-  /**
-   * only apply mobile protocol if session is actually for mobile
-   */
-  isMobile ? (0, _lodash.default)({}, _mjsonwp.default, _appium.default) : {},
-  /**
-   * only apply special Chrome commands if session is using Chrome
-   */
-  isChrome ? _chromium.default : {},
-  /**
-   * only Sauce Labs specific vendor commands
-   */
-  isSauce ? _saucelabs.default : {},
-  /**
-   * only apply special commands when running tests using
-   * Selenium Grid or Selenium Standalone server
-   */
-  isSeleniumStandalone ? _selenium.default : {});
+  const ProtocolCommands = (0, _lodash.default)(isMobile ? (0, _lodash.default)({}, _jsonwp.default, _webdriver.default) : isW3C ? _webdriver.default : _jsonwp.default, isMobile ? (0, _lodash.default)({}, _mjsonwp.default, _appium.default) : {}, isChrome ? _chromium.default : {}, isSauce ? _saucelabs.default : {}, isSeleniumStandalone ? _selenium.default : {});
 
   for (const [endpoint, methods] of Object.entries(ProtocolCommands)) {
     for (const [method, commandData] of Object.entries(methods)) {
@@ -206,11 +129,6 @@ function getPrototype({
 
   return prototype;
 }
-/**
- * get command call structure
- * (for logging purposes)
- */
-
 
 function commandCallStructure(commandName, args) {
   const callArgs = args.map(arg => {
@@ -230,108 +148,40 @@ function commandCallStructure(commandName, args) {
   }).join(', ');
   return `${commandName}(${callArgs})`;
 }
-/**
- * check if session is based on W3C protocol based on the /session response
- * @param  {Object}  capabilities  caps of session response
- * @return {Boolean}               true if W3C (browser)
- */
-
 
 function isW3C(capabilities) {
-  /**
-   * JSONWire protocol doesn't return a property `capabilities`.
-   * Also check for Appium response as it is using JSONWire protocol for most of the part.
-   */
   if (!capabilities) {
     return false;
   }
-  /**
-   * assume session to be a WebDriver session when
-   * - capabilities are returned
-   *   (https://w3c.github.io/webdriver/#dfn-new-sessions)
-   * - it is an Appium session (since Appium is full W3C compliant)
-   */
-
 
   const isAppium = capabilities.automationName || capabilities.deviceName;
-  const hasW3CCaps = capabilities.platformName && capabilities.browserVersion && (
-  /**
-   * local safari and BrowserStack don't provide platformVersion therefor
-   * check also if setWindowRect is provided
-   */
-  capabilities.platformVersion || Object.prototype.hasOwnProperty.call(capabilities, 'setWindowRect'));
+  const hasW3CCaps = capabilities.platformName && capabilities.browserVersion && (capabilities.platformVersion || Object.prototype.hasOwnProperty.call(capabilities, 'setWindowRect'));
   return Boolean(hasW3CCaps || isAppium);
 }
-/**
- * check if session is run by Chromedriver
- * @param  {Object}  capabilities  caps of session response
- * @return {Boolean}               true if run by Chromedriver
- */
-
 
 function isChrome(caps) {
   return Boolean(caps.chrome) || Boolean(caps['goog:chromeOptions']);
 }
-/**
- * check if current platform is mobile device
- *
- * @param  {Object}  caps  capabilities
- * @return {Boolean}       true if platform is mobile device
- */
-
 
 function isMobile(caps) {
-  return Boolean(typeof caps['appium-version'] !== 'undefined' || typeof caps['device-type'] !== 'undefined' || typeof caps['deviceType'] !== 'undefined' || typeof caps['device-orientation'] !== 'undefined' || typeof caps['deviceOrientation'] !== 'undefined' || typeof caps.deviceName !== 'undefined' || // Check browserName for specific values
-  caps.browserName === '' || caps.browserName !== undefined && (caps.browserName.toLowerCase() === 'ipad' || caps.browserName.toLowerCase() === 'iphone' || caps.browserName.toLowerCase() === 'android'));
+  return Boolean(typeof caps['appium-version'] !== 'undefined' || typeof caps['device-type'] !== 'undefined' || typeof caps['deviceType'] !== 'undefined' || typeof caps['device-orientation'] !== 'undefined' || typeof caps['deviceOrientation'] !== 'undefined' || typeof caps.deviceName !== 'undefined' || caps.browserName === '' || caps.browserName !== undefined && (caps.browserName.toLowerCase() === 'ipad' || caps.browserName.toLowerCase() === 'iphone' || caps.browserName.toLowerCase() === 'android'));
 }
-/**
- * check if session is run on iOS device
- * @param  {Object}  capabilities  caps of session response
- * @return {Boolean}               true if run on iOS device
- */
-
 
 function isIOS(caps) {
   return Boolean(caps.platformName && caps.platformName.match(/iOS/i) || caps.deviceName && caps.deviceName.match(/(iPad|iPhone)/i));
 }
-/**
- * check if session is run on Android device
- * @param  {Object}  capabilities  caps of session response
- * @return {Boolean}               true if run on Android device
- */
-
 
 function isAndroid(caps) {
   return Boolean(caps.platformName && caps.platformName.match(/Android/i) || caps.browserName && caps.browserName.match(/Android/i));
 }
-/**
- * detects if session is run on Sauce with extended debugging enabled
- * @param  {string}  hostname     hostname of session request
- * @param  {object}  capabilities session capabilities
- * @return {Boolean}              true if session is running on Sauce with extended debugging enabled
- */
-
 
 function isSauce(hostname, caps) {
-  return Boolean(hostname && hostname.includes('saucelabs') && (caps.extendedDebugging || caps['sauce:options'] && caps['sauce:options'].extendedDebugging));
+  return Boolean(caps.extendedDebugging || caps['sauce:options'] && caps['sauce:options'].extendedDebugging);
 }
-/**
- * detects if session is run using Selenium Standalone server
- * @param  {object}  capabilities session capabilities
- * @return {Boolean}              true if session is run with Selenium Standalone Server
- */
-
 
 function isSeleniumStandalone(caps) {
   return Boolean(caps['webdriver.remote.sessionid']);
 }
-/**
- * returns information about the environment
- * @param  {Object}  hostname      name of the host to run the session against
- * @param  {Object}  capabilities  caps of session response
- * @return {Object}                object with environment flags
- */
-
 
 function environmentDetector({
   hostname,
@@ -348,12 +198,6 @@ function environmentDetector({
     isSeleniumStandalone: isSeleniumStandalone(capabilities)
   };
 }
-/**
- * helper method to determine the error from webdriver response
- * @param  {Object} body body object
- * @return {Object} error
- */
-
 
 function getErrorFromResponseBody(body) {
   if (!body) {
@@ -369,8 +213,7 @@ function getErrorFromResponseBody(body) {
   }
 
   return new CustomRequestError(body);
-} //Exporting for testability
-
+}
 
 class CustomRequestError extends Error {
   constructor(body) {
@@ -384,11 +227,6 @@ class CustomRequestError extends Error {
   }
 
 }
-/**
- * overwrite native element commands with user defined
- * @param {object} propertiesObject propertiesObject
- */
-
 
 exports.CustomRequestError = CustomRequestError;
 
@@ -412,7 +250,11 @@ function overwriteElementCommands(propertiesObject) {
     delete propertiesObject[commandName];
 
     const newCommand = function (...args) {
-      return userDefinedCommand.apply(this, [origCommand.bind(this), ...args]);
+      const element = this;
+      return userDefinedCommand.apply(element, [function origCommandFunction() {
+        const context = this || element;
+        return origCommand.apply(context, arguments);
+      }, ...args]);
     };
 
     propertiesObject[commandName] = {
@@ -426,13 +268,6 @@ function overwriteElementCommands(propertiesObject) {
     value: {}
   };
 }
-/**
- * return all supported flags and return them in a format so we can attach them
- * to the instance protocol
- * @param  {Object} options   driver instance or option object containing these flags
- * @return {Object}           prototype object
- */
-
 
 function getEnvironmentVars({
   isW3C,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webdriver",
-  "version": "5.11.0",
+  "version": "5.11.12",
   "description": "A Node.js bindings implementation for the W3C WebDriver and Mobile JSONWire Protocol",
   "author": "Christian Bromann <christian@saucelabs.com>",
   "homepage": "https://github.com/webdriverio/webdriverio/tree/master/packages/webdriver",
@@ -36,5 +36,5 @@
     "lodash.merge": "^4.6.1",
     "request": "^2.83.0"
   },
-  "gitHead": "f235de6d9876a1a81bc1007430346d493ba7f579"
+  "gitHead": "32d9805f8dee10f0665e31eed14f774aaa48c914"
 }

package/protocol/saucelabs.json

@@ -81,7 +81,7 @@
       }
     }
   },
-  "/session/:sessionId/sauce/ondemand/throttle": {
+  "/session/:sessionId/sauce/ondemand/throttle/network": {
     "POST": {
       "command": "throttleNetwork",
       "description": "With network conditioning you can test your site on a variety of network connections, including Edge, 3G, and even offline. You can throttle the data throughput, including the maximum download and upload throughput, and use latency manipulation to enforce a minimum delay in connection round-trip time (RTT).",
@@ -108,6 +108,29 @@
       }]
     }
   },
+  "/session/:sessionId/sauce/ondemand/throttle/cpu": {
+    "POST": {
+      "command": "throttleCPU",
+      "description": "You can throttle the CPU in DevTools to understand how your page performs under that constraint.",
+      "ref": "https://wiki.saucelabs.com/display/DOCS/Custom+Sauce+Labs+WebDriver+Extensions+for+Network+and+Log+Commands#CustomSauceLabsWebDriverExtensionsforNetworkandLogCommands-ThrottleCPUCapabilities",
+      "examples": [
+        [
+          "// throttle CPU and make it run 4x slower",
+          "browser.throttleCPU(4)"
+        ],
+        [
+          "// reset CPU throttling",
+          "browser.throttleCPU(0)"
+        ]
+      ],
+      "parameters": [{
+        "name": "rate",
+        "type": "number",
+        "description": "Rate on how much the CPU should get throttled.",
+        "required": true
+      }]
+    }
+  },
   "/session/:sessionId/sauce/ondemand/intercept": {
     "POST": {
       "command": "interceptRequest",

package/webdriver.d.ts

@@ -66,6 +66,7 @@ declare namespace WebDriver {
         perfLoggingPrefs?: {
             [name: string]: any;
         };
+        prefs?: string[];
         windowTypes?: string[];
     }
 
@@ -78,7 +79,7 @@ declare namespace WebDriver {
         args?: string[],
         profile?: string,
         log?: FirefoxLogObject,
-        prefs: {
+        prefs?: {
             [name: string]: string | number | boolean;
         }
     }
@@ -368,6 +369,7 @@ declare namespace WebDriver {
     interface ClientOptions {
         capabilities: DesiredCapabilities;
         isW3C: boolean;
+        isChrome: boolean;
         isAndroid: boolean;
         isMobile: boolean;
         isIOS: boolean;
@@ -639,6 +641,7 @@ declare namespace WebDriver {
     interface Client {
         getPageLogs(type: string): object;
         throttleNetwork(condition: (string|object)): void;
+        throttleCPU(rate: number): void;
         interceptRequest(rule: object): void;
         assertPerformance(name: string, metrics?: string[]): boolean;
     }