Workaround for WinAppDriver

Author: licanhua

README.md

@@ -0,0 +1,100 @@
+WebDriver
+=========
+
+> A lightweight, non-opinionated implementation of the [WebDriver specification](https://w3c.github.io/webdriver/webdriver-spec.html) including mobile commands supported by [Appium](http://appium.io/)
+
+There are [tons](https://github.com/christian-bromann/awesome-selenium#javascript) of Selenium and WebDriver binding implementations in the Node.js world. Every one of them have an opinionated API and recommended way to use. This binding is the most non-opinionated you will find as it just represents the [WebDriver specification](https://w3c.github.io/webdriver/webdriver-spec.html) and doesn't come with any extra or higher level abstraction. It is lightweight and comes with support for the [WebDriver specification](https://w3c.github.io/webdriver/webdriver-spec.html) and Appiums [Mobile JSONWire Protocol](https://github.com/appium/appium-base-driver/blob/master/docs/mjsonwp/protocol-methods.md).
+
+## Example
+
+The following example demonstrates a simple Google Search scenario:
+
+```js
+import WebDriver from 'webdriver'
+
+;(async () => {
+    const client = await WebDriver.newSession({
+        path: '/',
+        capabilities: { browserName: 'firefox' }
+    })
+
+    await client.navigateTo('https://www.google.com/ncr')
+
+    const searchInput = await client.findElement('css selector', '#lst-ib')
+    await client.elementSendKeys(searchInput['element-6066-11e4-a52e-4f735466cecf'], 'WebDriver')
+
+    const searchBtn = await client.findElement('css selector', 'input[value="Google Search"]')
+    await client.elementClick(searchBtn['element-6066-11e4-a52e-4f735466cecf'])
+
+    console.log(await client.getTitle()) // outputs "WebDriver - Google Search"
+
+    await client.deleteSession()
+})()
+```
+
+# Configuration
+
+To create a WebDriver session call the `newSession` method on the `WebDriver` class and pass in your configurations:
+
+```js
+import WebDriver from 'webdriver'
+const client = await WebDriver.newSession(options)
+```
+
+The following options are available:
+
+### capabilities
+Defines the [capabilities](https://w3c.github.io/webdriver/webdriver-spec.html#capabilities) you want to run in your Selenium session.
+
+Type: `Object`<br>
+Required: `true`
+
+### logLevel
+Level of logging verbosity.
+
+Type: `String`<br>
+Default: *info*<br>
+Options: *trace* | *debug* | *info* | *warn* | *error* | *silent*
+
+### protocol
+Protocol to use when communicating with the Selenium standalone server (or driver).
+
+Type: `String`<br>
+Default: *http*
+Options: *http* | *https*
+
+### hostname
+Host of your WebDriver server.
+
+Type: `String`<br>
+Default: *localhost*
+
+### port
+Port your WebDriver server is on.
+
+Type: `Number`<br>
+Default: *4444*
+
+### path
+Path to WebDriver server.
+
+Type: `String`<br>
+Default: */wd/hub*
+
+### baseUrl
+Shorten `url` command calls by setting a base url.
+
+Type: `String`<br>
+Default: *null*
+
+### connectionRetryTimeout
+Timeout for any request to the Selenium server.
+
+Type: `Number`<br>
+Default: *90000*
+
+### connectionRetryCount
+Count of request retries to the Selenium server.
+
+Type: `Number`<br>
+Default: *2*

build/command.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+var _logger = _interopRequireDefault(require("@wdio/logger"));
+
+var _request = _interopRequireDefault(require("./request"));
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const log = (0, _logger.default)('webdriver');
+
+function _default(method, endpointUri, commandInfo) {
+  const {
+    command,
+    ref,
+    parameters,
+    variables = [],
+    isHubCommand = false
+  } = commandInfo;
+  return function protocolCommand(...args) {
+    let endpoint = endpointUri;
+    const commandParams = [...variables.map(v => Object.assign(v, {
+      required: true,
+      type: 'string'
+    })), ...parameters];
+    const commandUsage = `${command}(${commandParams.map(p => p.name).join(', ')})`;
+    const moreInfo = `\n\nFor more info see ${ref}\n`;
+    const body = {};
+    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);
+    }
+
+    for (const [i, arg] of Object.entries(args)) {
+      const commandParam = commandParams[i];
+
+      if (!(0, _utils.isValidParameter)(arg, commandParam.type)) {
+        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);
+      }
+
+      if (i < variables.length) {
+        endpoint = endpoint.replace(`:${commandParams[i].name}`, encodeURIComponent(encodeURIComponent(arg)));
+        continue;
+      }
+
+      body[commandParams[i].name] = arg;
+    }
+
+    const request = new _request.default(method, endpoint, body, isHubCommand);
+    this.emit('command', {
+      method,
+      endpoint,
+      body
+    });
+    log.info('COMMAND', (0, _utils.commandCallStructure)(command, args));
+    return request.makeRequest(this.options, this.sessionId).then(result => {
+      if (result.value != null) {
+        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', {
+        method,
+        endpoint,
+        body,
+        result
+      });
+      return result.value;
+    });
+  };
+}

build/constants.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DEFAULTS = void 0;
+const DEFAULTS = {
+  protocol: {
+    type: 'string',
+    default: 'http',
+    match: /(http|https)/
+  },
+  hostname: {
+    type: 'string',
+    default: 'localhost'
+  },
+  port: {
+    type: 'number',
+    default: 4444
+  },
+  path: {
+    type: 'string',
+    default: '/wd/hub'
+  },
+  queryParams: {
+    type: 'object'
+  },
+  capabilities: {
+    type: 'object',
+    required: true
+  },
+  logLevel: {
+    type: 'string',
+    default: 'info',
+    match: /(trace|debug|info|warn|error|silent)/
+  },
+  connectionRetryTimeout: {
+    type: 'number',
+    default: 90000
+  },
+  connectionRetryCount: {
+    type: 'number',
+    default: 3
+  },
+  user: {
+    type: 'string'
+  },
+  key: {
+    type: 'string'
+  },
+  agent: {
+    type: 'object'
+  },
+  headers: {
+    type: 'object'
+  }
+};
+exports.DEFAULTS = DEFAULTS;

build/index.js

@@ -0,0 +1,132 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "webdriverMonad", {
+  enumerable: true,
+  get: function () {
+    return _monad.default;
+  }
+});
+Object.defineProperty(exports, "getPrototype", {
+  enumerable: true,
+  get: function () {
+    return _utils.getPrototype;
+  }
+});
+exports.default = void 0;
+
+var _logger = _interopRequireDefault(require("@wdio/logger"));
+
+var _config = require("@wdio/config");
+
+var _monad = _interopRequireDefault(require("./monad"));
+
+var _request = _interopRequireDefault(require("./request"));
+
+var _constants = require("./constants");
+
+var _utils = require("./utils");
+
+var _webdriver = _interopRequireDefault(require("../protocol/webdriver.json"));
+
+var _jsonwp = _interopRequireDefault(require("../protocol/jsonwp.json"));
+
+var _mjsonwp = _interopRequireDefault(require("../protocol/mjsonwp.json"));
+
+var _appium = _interopRequireDefault(require("../protocol/appium.json"));
+
+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);
+
+    if (!options.logLevels || !options.logLevels['webdriver']) {
+      _logger.default.setLevel('webdriver', params.logLevel);
+    }
+
+    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,
+      desiredCapabilities: jsonwpCaps
+    });
+    const response = await sessionRequest.makeRequest(params);
+    params.requestedCapabilities = {
+      w3cCaps,
+      jsonwpCaps
+    };
+    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 monad = (0, _monad.default)(params, modifier, prototype);
+    return monad(response.value.sessionId || response.sessionId, commandWrapper);
+  }
+
+  static attachToSession(options = {}, modifier, userPrototype = {}, commandWrapper) {
+    if (typeof options.sessionId !== 'string') {
+      throw new Error('sessionId is required to attach to existing session');
+    }
+
+    if (options.logLevel !== undefined) {
+      _logger.default.setLevel('webdriver', options.logLevel);
+    }
+
+    options.capabilities = options.capabilities || {};
+    options.isW3C = options.isW3C === false ? false : true;
+    const environmentPrototype = (0, _utils.getEnvironmentVars)(options);
+    const protocolCommands = (0, _utils.getPrototype)(options);
+
+    const prototype = _objectSpread({}, protocolCommands, {}, environmentPrototype, {}, userPrototype);
+
+    const monad = (0, _monad.default)(options, modifier, prototype);
+    return monad(options.sessionId, commandWrapper);
+  }
+
+  static get WebDriver() {
+    return WebDriver;
+  }
+
+  static get DEFAULTS() {
+    return _constants.DEFAULTS;
+  }
+
+  static get WebDriverProtocol() {
+    return _webdriver.default;
+  }
+
+  static get JsonWProtocol() {
+    return _jsonwp.default;
+  }
+
+  static get MJsonWProtocol() {
+    return _mjsonwp.default;
+  }
+
+  static get AppiumProtocol() {
+    return _appium.default;
+  }
+
+  static get ChromiumProtocol() {
+    return _chromium.default;
+  }
+
+}
+
+exports.default = WebDriver;