webdriver 5.11.10 → 5.12.1

package/build/command.js

@@ -24,61 +24,36 @@ function _default(method, endpointUri, commandInfo) {
     isHubCommand = false
   } = commandInfo;
   return function protocolCommand(...args) {
-    let endpoint = endpointUri; // clone endpointUri in case we change it
-
+    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;
     }

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

@@ -41,7 +41,9 @@ var _chromium = _interopRequireDefault(require("../protocol/chromium.json"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
+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; }
 
@@ -52,66 +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 = _objectSpread({}, 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);
@@ -122,7 +93,7 @@ class WebDriver {
     const environmentPrototype = (0, _utils.getEnvironmentVars)(options);
     const protocolCommands = (0, _utils.getPrototype)(options);
 
-    const prototype = _objectSpread({}, protocolCommands, environmentPrototype, userPrototype);
+    const prototype = _objectSpread({}, protocolCommands, {}, environmentPrototype, {}, userPrototype);
 
     const monad = (0, _monad.default)(options, modifier, prototype);
     return monad(options.sessionId, commandWrapper);
@@ -135,10 +106,6 @@ class WebDriver {
   static get DEFAULTS() {
     return _constants.DEFAULTS;
   }
-  /**
-   * Protocols
-   */
-
 
   static get WebDriverProtocol() {
     return _webdriver.default;
@@ -161,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

@@ -66,10 +66,6 @@ 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')) {
@@ -78,21 +74,12 @@ class WebDriverRequest extends _events.default {
         '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 = {
@@ -100,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;
@@ -118,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'));
         }
@@ -136,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', {
@@ -147,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');
@@ -160,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(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;
 
@@ -414,8 +252,7 @@ function overwriteElementCommands(propertiesObject) {
     const newCommand = function (...args) {
       const element = this;
       return userDefinedCommand.apply(element, [function origCommandFunction() {
-        const context = this || element; // respect explicite context binding, use element as default
-
+        const context = this || element;
         return origCommand.apply(context, arguments);
       }, ...args]);
     };
@@ -431,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.10",
+  "version": "5.12.1",
   "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",
@@ -30,11 +30,11 @@
     "url": "https://github.com/webdriverio/webdriverio/issues"
   },
   "dependencies": {
-    "@wdio/config": "^5.11.0",
-    "@wdio/logger": "^5.11.0",
+    "@wdio/config": "^5.12.1",
+    "@wdio/logger": "^5.12.1",
     "deepmerge": "^4.0.0",
     "lodash.merge": "^4.6.1",
     "request": "^2.83.0"
   },
-  "gitHead": "644a371a294292fae1d866d14d0e42dd75156c68"
+  "gitHead": "848151e5fdcb8b694c1a273b9b69852c22875687"
 }

package/protocol/appium.json

@@ -1401,5 +1401,33 @@
         }
       }
     }
+  },
+  "/session/:sessionId/appium/execute_driver": {
+    "POST": {
+      "command": "driverScript",
+      "description": "This command allows you to define a webdriverio script in a string and send it to the Appium server to be executed locally to the server itself, thus reducing latency that might otherwise occur along with each command.",
+      "ref": "https://github.com/appium/appium/blob/master/docs/en/commands/session/execute-driver.md",
+      "parameters": [{
+        "name": "script",
+        "type": "string",
+        "description": "The script to execute. It has access to a 'driver' object which represents a webdriverio session attached to the current server.",
+        "required": true
+      }, {
+        "name": "type",
+        "type": "string",
+        "description": "The language/framework used in the script. Currently, only 'webdriverio' is supported and is the default.",
+        "required": false
+      }, {
+        "name": "timeout",
+        "type": "number",
+        "description": "The number of milliseconds the script should be allowed to run before being killed by the Appium server. Defaults to the equivalent of 1 hour.",
+        "required": false
+      }],
+      "returns": {
+        "type": "object",
+        "name": "result",
+        "description": "An object containing two fields: 'result', which is the return value of the script itself, and 'logs', which contains 3 inner fields, 'log', 'warn', and 'error', which hold an array of strings logged by console.log, console.warn, and console.error in the script's execution."
+      }
+    }
   }
 }

package/protocol/chromium.json

@@ -414,5 +414,36 @@
         "description": "The base64-encoded PNG image data comprising the screenshot of the visible region of an element’s bounding rectangle after it has been scrolled into view."
       }
     }
+  },
+  "/session/:sessionId/se/log/types": {
+    "GET": {
+      "command": "getLogTypes",
+      "description": "Get available log types.",
+      "ref": "https://github.com/SeleniumHQ/selenium/wiki/JsonWireProtocol#sessionsessionidlogtypes",
+      "parameters": [],
+      "returns": {
+        "type": "String[]",
+        "name": "logTypes",
+        "description": "The list of available log types, example: browser, driver."
+      }
+    }
+  },
+  "/session/:sessionId/se/log": {
+    "POST": {
+      "command": "getLogs",
+      "description": "Get the log for a given log type. Log buffer is reset after each request.",
+      "ref": "https://github.com/SeleniumHQ/selenium/wiki/JsonWireProtocol#sessionsessionidlog",
+      "parameters": [{
+        "name": "type",
+        "type": "string",
+        "description": "the log type",
+        "required": true
+      }],
+      "returns": {
+        "type": "Object[]",
+        "name": "logs",
+        "description": "The list of log entries."
+      }
+    }
   }
 }

package/webdriver.d.ts

@@ -79,7 +79,7 @@ declare namespace WebDriver {
         args?: string[],
         profile?: string,
         log?: FirefoxLogObject,
-        prefs: {
+        prefs?: {
             [name: string]: string | number | boolean;
         }
     }
@@ -213,6 +213,21 @@ declare namespace WebDriver {
         // wdio-sauce-service specific
         build?: string;
 
+        // Saucelabs w3c specific
+        'sauce:options'?: {
+            [name: string]: any;
+        };
+
+        // Browserstack w3c specific
+        'bstack:options'?: {
+            [name: string]: any;
+        };
+
+        // Testingbot w3c specific
+        'tb:options'?: {
+            [name: string]: any;
+        };
+
         // Appium General Capabilities
         automationName?: string;
         platformVersion?: string;
@@ -369,19 +384,69 @@ declare namespace WebDriver {
     interface ClientOptions {
         capabilities: DesiredCapabilities;
         isW3C: boolean;
+        isChrome: boolean;
         isAndroid: boolean;
         isMobile: boolean;
         isIOS: boolean;
         sessionId: string;
     }
 
+    // object with no match
+    interface ProtocolCommandResponse {
+        [key: string]: any;
+    }
+
+    // webdriver.json
+    interface SessionReturn extends DesiredCapabilities, ProtocolCommandResponse { }
+
+    interface StatusReturn extends ProtocolCommandResponse {
+        ready?: boolean,
+        message?: string,
+    }
+
+    interface WindowHandle {
+        handle: string,
+        type: string
+    }
+
+    interface RectReturn {
+        x: number,
+        y: number,
+        width: number,
+        height: number
+    }
+
+    // appium.json
+    interface StringsReturn {
+        [key:string]: string
+    }
+
+    interface SettingsReturn extends ProtocolCommandResponse {
+        shouldUseCompactResponses?: boolean,
+        elementResponseAttributes?: string,
+        ignoreUnimportantViews?: boolean,
+        allowInvisibleElements?: boolean,
+        enableNotificationListener?: boolean,
+        actionAcknowledgmentTimeout?: number,
+        keyInjectionDelay?: number,
+        scrollAcknowledgmentTimeout?: number,
+        waitForIdleTimeout?: number,
+        waitForSelectorTimeout?: number,
+        normalizeTagNames?: boolean,
+        shutdownOnPowerDisconnect?: boolean,
+        mjpegServerScreenshotQuality?: number,
+        mjpegServerFramerate?: number,
+        screenshotQuality?: number,
+        mjpegScalingFactor?: number,
+    }
+
     // generated typings
         // webdriver types
     interface Client {
-        newSession(capabilities: object): object;
+        newSession(capabilities: object): SessionReturn;
         deleteSession(): void;
-        status(): object;
-        getTimeouts(): object;
+        status(): StatusReturn;
+        getTimeouts(): Timeouts;
         setTimeouts(implicit?: number, pageLoad?: number, script?: number): void;
         getUrl(): string;
         navigateTo(url: string): string;
@@ -392,39 +457,39 @@ declare namespace WebDriver {
         getWindowHandle(): string;
         closeWindow(): void;
         switchToWindow(handle: string): void;
-        createWindow(type: string): object;
+        createWindow(type: string): WindowHandle;
         getWindowHandles(): string[];
         switchToFrame(id: (number|string|object|null)): void;
         switchToParentFrame(): void;
-        getWindowRect(): object;
-        setWindowRect(x: (number|null), y: (number|null), width: (number|null), height: (number|null)): object;
-        maximizeWindow(): object;
-        minimizeWindow(): object;
-        fullscreenWindow(): object;
+        getWindowRect(): RectReturn;
+        setWindowRect(x: (number|null), y: (number|null), width: (number|null), height: (number|null)): RectReturn;
+        maximizeWindow(): RectReturn;
+        minimizeWindow(): RectReturn;
+        fullscreenWindow(): RectReturn;
         findElement(using: string, value: string): string;
         findElements(using: string, value: string): string[];
-        findElementFromElement(using: string, value: string): string;
-        findElementsFromElement(using: string, value: string): string[];
+        findElementFromElement(elementId: string, using: string, value: string): string;
+        findElementsFromElement(elementId: string, using: string, value: string): string[];
         getActiveElement(): string;
-        isElementSelected(): boolean;
-        isElementDisplayed(): boolean;
-        getElementAttribute(name: string): string;
-        getElementProperty(name: string): string;
-        getElementCSSValue(propertyName: string): string;
-        getElementText(): string;
-        getElementTagName(): string;
-        getElementRect(): object;
-        isElementEnabled(): boolean;
-        elementClick(): void;
-        elementClear(): void;
-        elementSendKeys(text: string, value?: string[]): void;
+        isElementSelected(elementId: string): boolean;
+        isElementDisplayed(elementId: string): boolean;
+        getElementAttribute(elementId: string, name: string): string;
+        getElementProperty(elementId: string, name: string): string;
+        getElementCSSValue(elementId: string, propertyName: string): string;
+        getElementText(elementId: string): string;
+        getElementTagName(elementId: string): string;
+        getElementRect(elementId: string): RectReturn;
+        isElementEnabled(elementId: string): boolean;
+        elementClick(elementId: string): void;
+        elementClear(elementId: string): void;
+        elementSendKeys(elementId: string, text: string, value?: string[]): void;
         getPageSource(): string;
         executeScript(script: string, args?: (string|object|number|boolean|undefined)[]): any;
         executeAsyncScript(script: string, args: (string|object|number|boolean|undefined)[]): any;
         getAllCookies(): object[];
         addCookie(cookie: object): void;
         deleteAllCookies(): void;
-        getNamedCookie(name: string): object;
+        getNamedCookie(name: string): Cookie;
         deleteCookie(name: string): void;
         performActions(actions: object[]): void;
         releaseActions(): void;
@@ -433,7 +498,7 @@ declare namespace WebDriver {
         getAlertText(): string;
         sendAlertText(text: string): void;
         takeScreenshot(): string;
-        takeElementScreenshot(scroll?: boolean): string;
+        takeElementScreenshot(elementId: string, scroll?: boolean): string;
     }
 
     // appium types
@@ -479,10 +544,10 @@ declare namespace WebDriver {
         reset(): void;
         background(seconds: (number|null)): void;
         endCoverage(intent: string, path: string): void;
-        getStrings(language?: string, stringFile?: string): object;
-        setValueImmediate(value: string): void;
-        replaceValue(value: string): void;
-        getSettings(): object;
+        getStrings(language?: string, stringFile?: string): StringsReturn;
+        setValueImmediate(elementId: string, value: string): void;
+        replaceValue(elementId: string, value: string): void;
+        getSettings(): SettingsReturn;
         updateSettings(settings: object): void;
         receiveAsyncResponse(response: object): void;
         gsmCall(phoneNumber: string, action: string): void;
@@ -496,14 +561,15 @@ declare namespace WebDriver {
         getClipboard(contentType?: string): string;
         touchPerform(actions: object[]): void;
         multiTouchPerform(actions: object[]): void;
+        driverScript(script: string, type?: string, timeout?: number): ProtocolCommandResponse;
     }
 
     // jsonwp types
     interface Client {
-        status(): object;
-        newSession(desiredCapabilities: object, requiredCapabilities: object): object;
+        status(): StatusReturn;
+        newSession(desiredCapabilities: object, requiredCapabilities: object): SessionReturn;
         getSessions(): object[];
-        getSession(): object;
+        getSession(): ProtocolCommandResponse;
         deleteSession(): void;
         setTimeouts(type: string, ms: number): void;
         setAsyncTimeout(ms: number): void;
@@ -520,31 +586,31 @@ declare namespace WebDriver {
         switchToWindow(name: string): void;
         switchToFrame(id: (string|number|object|null)): void;
         switchToParentFrame(): void;
-        getWindowPosition(): object;
-        setWindowPosition(x: number, y: number): object;
-        _getWindowSize(): object;
+        getWindowPosition(): ProtocolCommandResponse;
+        setWindowPosition(x: number, y: number): ProtocolCommandResponse;
+        _getWindowSize(): ProtocolCommandResponse;
         _setWindowSize(width: number, height: number): void;
         maximizeWindow(): void;
         findElement(using: string, value: string): string;
         findElements(using: string, value: string): string[];
-        findElementFromElement(using: string, value: string): string;
-        findElementsFromElement(using: string, value: string): string[];
+        findElementFromElement(elementId: string, using: string, value: string): string;
+        findElementsFromElement(elementId: string, using: string, value: string): string[];
         getActiveElement(): string;
-        isElementSelected(): boolean;
-        isElementDisplayed(): boolean;
-        getElementAttribute(name: string): string|null;
-        getElementCSSValue(propertyName: string): string;
-        getElementText(): string;
-        getElementTagName(): string;
-        getElementLocation(): object;
-        getElementLocationInView(): object;
-        getElementSize(): object;
-        isElementEnabled(): boolean;
-        elementClick(): void;
-        elementEquals(otherElementId: string): boolean;
-        elementSubmit(): void;
-        elementClear(): void;
-        elementSendKeys(value: string[]): void;
+        isElementSelected(elementId: string): boolean;
+        isElementDisplayed(elementId: string): boolean;
+        getElementAttribute(elementId: string, name: string): string|null;
+        getElementCSSValue(elementId: string, propertyName: string): string;
+        getElementText(elementId: string): string;
+        getElementTagName(elementId: string): string;
+        getElementLocation(elementId: string): ProtocolCommandResponse;
+        getElementLocationInView(elementId: string): ProtocolCommandResponse;
+        getElementSize(elementId: string): ProtocolCommandResponse;
+        isElementEnabled(elementId: string): boolean;
+        elementClick(elementId: string): void;
+        elementEquals(elementId: string, otherElementId: string): boolean;
+        elementSubmit(elementId: string): void;
+        elementClear(elementId: string): void;
+        elementSendKeys(elementId: string, value: string[]): void;
         sendKeys(value: string[]): void;
         getPageSource(): string;
         executeScript(script: string, args?: (string|object|number|boolean|undefined)[]): any;
@@ -578,7 +644,7 @@ declare namespace WebDriver {
         touchDoubleClick(element: string): void;
         touchLongClick(element: string): void;
         touchFlick(xoffset?: number, yoffset?: number, element?: string, speed?: number, xspeed?: number, yspeed?: number): void;
-        getGeoLocation(): object;
+        getGeoLocation(): ProtocolCommandResponse;
         setGeoLocation(location: object): void;
         getLocalStorage(): string[];
         setLocalStorage(key: string, value: string): void;
@@ -616,10 +682,10 @@ declare namespace WebDriver {
         isAutoReporting(): boolean;
         setAutoReporting(enabled: boolean): object|null;
         isLoading(): boolean;
-        takeHeapSnapshot(): object;
+        takeHeapSnapshot(): ProtocolCommandResponse;
         getNetworkConnection(): number;
         setNetworkConnection(parameters: object): number;
-        getNetworkConditions(): object;
+        getNetworkConditions(): ProtocolCommandResponse;
         setNetworkConditions(network_conditions: object, network_name?: string): void;
         deleteNetworkConditions(): void;
         sendCommand(cmd: string, params: object): void;
@@ -627,18 +693,20 @@ declare namespace WebDriver {
         generateTestReport(message: string, group: string): void;
         file(file: string): string;
         launchApp(id: string): void;
-        getElementValue(): string|null;
-        elementHover(): void;
+        getElementValue(elementId: string): string|null;
+        elementHover(elementId: string): void;
         touchPinch(x: number, y: number, scale: number): void;
         freeze(): void;
         resume(): void;
         shutdown(): void;
-        takeElementScreenshot(scroll?: boolean): string;
+        takeElementScreenshot(elementId: string, scroll?: boolean): string;
+        getLogTypes(): string[];
+        getLogs(type: string): object[];
     }
 
     // saucelabs types
     interface Client {
-        getPageLogs(type: string): object;
+        getPageLogs(type: string): ProtocolCommandResponse;
         throttleNetwork(condition: (string|object)): void;
         throttleCPU(rate: number): void;
         interceptRequest(rule: object): void;
@@ -648,9 +716,9 @@ declare namespace WebDriver {
     // selenium types
     interface Client {
         file(file: string): string;
-        getHubConfig(): object;
-        gridTestSession(session: string): object;
-        gridProxyDetails(id: string): object;
+        getHubConfig(): ProtocolCommandResponse;
+        gridTestSession(session: string): ProtocolCommandResponse;
+        gridProxyDetails(id: string): ProtocolCommandResponse;
         manageSeleniumHubLifecycle(action: string): void;
     }