@appium/execute-driver-plugin 1.0.1 → 1.0.4

package/build/lib/plugin.js

@@ -1,132 +1,134 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExecuteDriverPlugin = void 0;
-const base_plugin_1 = __importDefault(require("@appium/base-plugin"));
-const lodash_1 = __importDefault(require("lodash"));
-const child_process_1 = __importDefault(require("child_process"));
-const support_1 = require("@appium/support");
-const bluebird_1 = __importDefault(require("bluebird"));
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.ExecuteDriverPlugin = void 0;
+
+require("source-map-support/register");
+
+var _basePlugin = _interopRequireDefault(require("@appium/base-plugin"));
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _child_process = _interopRequireDefault(require("child_process"));
+
+var _support = require("@appium/support");
+
+var _bluebird = _interopRequireDefault(require("bluebird"));
+
 const FEAT_FLAG = 'execute_driver_script';
-const DEFAULT_SCRIPT_TIMEOUT_MS = 1000 * 60 * 60; // default to 1 hour timeout
+const DEFAULT_SCRIPT_TIMEOUT_MS = 1000 * 60 * 60;
 const SCRIPT_TYPE_WDIO = 'webdriverio';
-class ExecuteDriverPlugin extends base_plugin_1.default {
-    /**
-     * This method takes a string which is executed as javascript in the context of
-     * a new nodejs VM, and which has available a webdriverio driver object, having
-     * already been attached to the currently running session.
-     *
-     * @param {function} next - standard behaviour for executeDriverScript
-     * @param {BaseDriver} driver - Appium driver handling this command
-     * @param {string} script - the string representing the driver script to run
-     * @param {string} [scriptType='webdriverio'] - the name of the driver script
-     * library (currently only webdriverio is supported)
-     * @param {number} [timeoutMs=3600000] - timeout for the script process
-     *
-     * @returns {Object} - a JSONifiable object representing the return value of
-     * the script
-     */
-    async executeDriverScript(next, driver, script, scriptType = 'webdriverio', timeoutMs = DEFAULT_SCRIPT_TIMEOUT_MS) {
-        if (!driver.isFeatureEnabled(FEAT_FLAG)) {
-            throw new Error(`Execute driver script functionality is not available ` +
-                `unless server is started with --allow-insecure including ` +
-                `the '${FEAT_FLAG}' flag, e.g., --allow-insecure=${FEAT_FLAG}`);
-        }
-        if (scriptType !== SCRIPT_TYPE_WDIO) {
-            throw new TypeError(`Only the '${SCRIPT_TYPE_WDIO}' script type is currently supported`);
-        }
-        if (!driver.serverHost || !driver.serverPort) {
-            throw new Error('Address or port of running server were not defined; this ' +
-                'is required. This is probably a programming error in the driver');
-        }
-        if (!lodash_1.default.isNumber(timeoutMs)) {
-            throw new TypeError('Timeout parameter must be a number');
+
+class ExecuteDriverPlugin extends _basePlugin.default {
+  static newMethodMap = {
+    '/session/:sessionId/appium/execute_driver': {
+      POST: {
+        command: 'executeDriverScript',
+        payloadParams: {
+          required: ['script'],
+          optional: ['type', 'timeout']
         }
-        const driverOpts = {
-            sessionId: driver.sessionId,
-            // Appium probably won't be behind ssl locally; if it ever is, might need to update this to
-            // provide a user configurable parameter
-            protocol: 'http',
-            hostname: driver.serverHost,
-            port: driver.serverPort,
-            path: driver.serverPath,
-            isW3C: true,
-            isMobile: true,
-            capabilities: driver.caps
-        };
-        this.logger.info(`Constructed webdriverio driver options; W3C mode is ${driverOpts.isW3C ? 'on' : 'off'}`);
-        // fork the execution script as a child process
-        const childScript = require.resolve('./execute-child.js');
-        this.logger.info(`Forking process to run webdriver script as child using ${childScript}`);
-        const scriptProc = child_process_1.default.fork(childScript);
-        // keep track of whether we have canceled the script timeout, so we can stop
-        // waiting for it and allow this process to finish gracefully
-        let timeoutCanceled = false;
-        try {
-            const timer = new support_1.timing.Timer();
-            timer.start();
-            // promise that deals with the result from the child process
-            const waitForResult = async () => {
-                const res = await new bluebird_1.default((res) => {
-                    scriptProc.on('message', res); // this is node IPC
-                });
-                this.logger.info('Received execute driver script result from child process, shutting it down');
-                if (res.error) {
-                    throw new Error(res.error.message);
-                }
-                return res.success;
-            };
-            // promise that waits up to the timeout and throws an error if so, or does
-            // nothing if the timeout is canceled because we got a result from the
-            // child script
-            const waitForTimeout = async () => {
-                while (!timeoutCanceled && timer.getDuration().asMilliSeconds < timeoutMs) {
-                    await bluebird_1.default.delay(500);
-                }
-                if (timeoutCanceled) {
-                    return;
-                }
-                throw new Error(`Execute driver script timed out after ${timeoutMs}ms. ` +
-                    `You can adjust this with the 'timeout' parameter.`);
-            };
-            // now that the child script is alive, send it the data it needs to start
-            // running the driver script
-            this.logger.info('Sending driver and script data to child');
-            scriptProc.send({ driverOpts, script, timeoutMs });
-            // and set up a race between the response from the child and the timeout
-            return await bluebird_1.default.race([waitForResult(), waitForTimeout()]);
+      }
+    }
+  };
+
+  async executeDriverScript(next, driver, script, scriptType = 'webdriverio', timeoutMs = DEFAULT_SCRIPT_TIMEOUT_MS) {
+    if (!driver.isFeatureEnabled(FEAT_FLAG)) {
+      throw new Error(`Execute driver script functionality is not available ` + `unless server is started with --allow-insecure including ` + `the '${FEAT_FLAG}' flag, e.g., --allow-insecure=${FEAT_FLAG}`);
+    }
+
+    if (scriptType !== SCRIPT_TYPE_WDIO) {
+      throw new TypeError(`Only the '${SCRIPT_TYPE_WDIO}' script type is currently supported`);
+    }
+
+    if (!driver.serverHost || !driver.serverPort) {
+      throw new Error('Address or port of running server were not defined; this ' + 'is required. This is probably a programming error in the driver');
+    }
+
+    if (!_lodash.default.isNumber(timeoutMs)) {
+      throw new TypeError('Timeout parameter must be a number');
+    }
+
+    const driverOpts = {
+      sessionId: driver.sessionId,
+      protocol: 'http',
+      hostname: driver.serverHost,
+      port: driver.serverPort,
+      path: driver.serverPath,
+      isW3C: true,
+      isMobile: true,
+      capabilities: driver.caps
+    };
+    this.logger.info(`Constructed webdriverio driver options; W3C mode is ${driverOpts.isW3C ? 'on' : 'off'}`);
+
+    const childScript = require.resolve('./execute-child.js');
+
+    this.logger.info(`Forking process to run webdriver script as child using ${childScript}`);
+
+    const scriptProc = _child_process.default.fork(childScript);
+
+    let timeoutCanceled = false;
+
+    try {
+      const timer = new _support.timing.Timer();
+      timer.start();
+
+      const waitForResult = async () => {
+        const res = await new _bluebird.default(res => {
+          scriptProc.on('message', res);
+        });
+        this.logger.info('Received execute driver script result from child process, shutting it down');
+
+        if (res.error) {
+          throw new Error(res.error.message);
         }
-        catch (err) {
-            throw new Error(`Could not execute driver script. Original error was: ${err}`);
+
+        return res.success;
+      };
+
+      const waitForTimeout = async () => {
+        while (!timeoutCanceled && timer.getDuration().asMilliSeconds < timeoutMs) {
+          await _bluebird.default.delay(500);
         }
-        finally {
-            // ensure we always cancel the timeout so that the timeout promise stops
-            // spinning and allows this process to die gracefully
-            timeoutCanceled = true;
-            if (scriptProc.connected) {
-                this.logger.info('Disconnecting from child proc');
-                scriptProc.disconnect();
-            }
-            if (scriptProc.exitCode === null) {
-                this.logger.info('Disconnecting from and killing driver script child proc');
-                scriptProc.kill();
-            }
-            else {
-                this.logger.info('Script already ended on its own, no need to kill it');
-            }
+
+        if (timeoutCanceled) {
+          return;
         }
+
+        throw new Error(`Execute driver script timed out after ${timeoutMs}ms. ` + `You can adjust this with the 'timeout' parameter.`);
+      };
+
+      this.logger.info('Sending driver and script data to child');
+      scriptProc.send({
+        driverOpts,
+        script,
+        timeoutMs
+      });
+      return await _bluebird.default.race([waitForResult(), waitForTimeout()]);
+    } catch (err) {
+      throw new Error(`Could not execute driver script. Original error was: ${err}`);
+    } finally {
+      timeoutCanceled = true;
+
+      if (scriptProc.connected) {
+        this.logger.info('Disconnecting from child proc');
+        scriptProc.disconnect();
+      }
+
+      if (scriptProc.exitCode === null) {
+        this.logger.info('Disconnecting from and killing driver script child proc');
+        scriptProc.kill();
+      } else {
+        this.logger.info('Script already ended on its own, no need to kill it');
+      }
     }
+  }
+
 }
-exports.default = ExecuteDriverPlugin;
-exports.ExecuteDriverPlugin = ExecuteDriverPlugin;
-ExecuteDriverPlugin.newMethodMap = {
-    '/session/:sessionId/appium/execute_driver': {
-        POST: {
-            command: 'executeDriverScript',
-            payloadParams: { required: ['script'], optional: ['type', 'timeout'] }
-        }
-    }
-};
-//# sourceMappingURL=data:application/json;base64,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
+
+exports.ExecuteDriverPlugin = exports.default = ExecuteDriverPlugin;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../lib/plugin.js"],"names":["FEAT_FLAG","DEFAULT_SCRIPT_TIMEOUT_MS","SCRIPT_TYPE_WDIO","ExecuteDriverPlugin","BasePlugin","newMethodMap","POST","command","payloadParams","required","optional","executeDriverScript","next","driver","script","scriptType","timeoutMs","isFeatureEnabled","Error","TypeError","serverHost","serverPort","_","isNumber","driverOpts","sessionId","protocol","hostname","port","path","serverPath","isW3C","isMobile","capabilities","caps","logger","info","childScript","require","resolve","scriptProc","cp","fork","timeoutCanceled","timer","timing","Timer","start","waitForResult","res","B","on","error","message","success","waitForTimeout","getDuration","asMilliSeconds","delay","send","race","err","connected","disconnect","exitCode","kill"],"mappings":"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","sourcesContent":["import BasePlugin from '@appium/base-plugin';\nimport _ from 'lodash';\nimport cp from 'child_process';\nimport { timing } from '@appium/support';\nimport B from 'bluebird';\n\nconst FEAT_FLAG = 'execute_driver_script';\nconst DEFAULT_SCRIPT_TIMEOUT_MS = 1000 * 60 * 60; // default to 1 hour timeout\nconst SCRIPT_TYPE_WDIO = 'webdriverio';\n\nexport default class ExecuteDriverPlugin extends BasePlugin {\n\n  static newMethodMap = {\n    '/session/:sessionId/appium/execute_driver': {\n      POST: {\n        command: 'executeDriverScript',\n        payloadParams: {required: ['script'], optional: ['type', 'timeout']}\n      }\n    }\n  };\n\n  /**\n   * This method takes a string which is executed as javascript in the context of\n   * a new nodejs VM, and which has available a webdriverio driver object, having\n   * already been attached to the currently running session.\n   *\n   * @param {function} next - standard behaviour for executeDriverScript\n   * @param {BaseDriver} driver - Appium driver handling this command\n   * @param {string} script - the string representing the driver script to run\n   * @param {string} [scriptType='webdriverio'] - the name of the driver script\n   * library (currently only webdriverio is supported)\n   * @param {number} [timeoutMs=3600000] - timeout for the script process\n   *\n   * @returns {Object} - a JSONifiable object representing the return value of\n   * the script\n   */\n  async executeDriverScript (next, driver, script, scriptType = 'webdriverio',\n    timeoutMs = DEFAULT_SCRIPT_TIMEOUT_MS) {\n\n    if (!driver.isFeatureEnabled(FEAT_FLAG)) {\n      throw new Error(`Execute driver script functionality is not available ` +\n                      `unless server is started with --allow-insecure including ` +\n                      `the '${FEAT_FLAG}' flag, e.g., --allow-insecure=${FEAT_FLAG}`);\n    }\n\n    if (scriptType !== SCRIPT_TYPE_WDIO) {\n      throw new TypeError(`Only the '${SCRIPT_TYPE_WDIO}' script type is currently supported`);\n    }\n\n    if (!driver.serverHost || !driver.serverPort) {\n      throw new Error('Address or port of running server were not defined; this ' +\n                      'is required. This is probably a programming error in the driver');\n    }\n\n    if (!_.isNumber(timeoutMs)) {\n      throw new TypeError('Timeout parameter must be a number');\n    }\n\n    const driverOpts = {\n      sessionId: driver.sessionId,\n      // Appium probably won't be behind ssl locally; if it ever is, might need to update this to\n      // provide a user configurable parameter\n      protocol: 'http',\n      hostname: driver.serverHost,\n      port: driver.serverPort,\n      path: driver.serverPath,\n      isW3C: true,\n      isMobile: true,\n      capabilities: driver.caps\n    };\n    this.logger.info(`Constructed webdriverio driver options; W3C mode is ${driverOpts.isW3C ? 'on' : 'off'}`);\n\n\n    // fork the execution script as a child process\n    const childScript = require.resolve('./execute-child.js');\n    this.logger.info(`Forking process to run webdriver script as child using ${childScript}`);\n    const scriptProc = cp.fork(childScript);\n\n    // keep track of whether we have canceled the script timeout, so we can stop\n    // waiting for it and allow this process to finish gracefully\n    let timeoutCanceled = false;\n\n    try {\n      const timer = new timing.Timer();\n      timer.start();\n\n      // promise that deals with the result from the child process\n      const waitForResult = async () => {\n        const res = await new B((res) => {\n          scriptProc.on('message', res); // this is node IPC\n        });\n\n        this.logger.info('Received execute driver script result from child process, shutting it down');\n\n        if (res.error) {\n          throw new Error(res.error.message);\n        }\n\n        return res.success;\n      };\n\n      // promise that waits up to the timeout and throws an error if so, or does\n      // nothing if the timeout is canceled because we got a result from the\n      // child script\n      const waitForTimeout = async () => {\n        while (!timeoutCanceled && timer.getDuration().asMilliSeconds < timeoutMs) {\n          await B.delay(500);\n        }\n\n        if (timeoutCanceled) {\n          return;\n        }\n\n        throw new Error(`Execute driver script timed out after ${timeoutMs}ms. ` +\n                        `You can adjust this with the 'timeout' parameter.`);\n      };\n\n      // now that the child script is alive, send it the data it needs to start\n      // running the driver script\n      this.logger.info('Sending driver and script data to child');\n      scriptProc.send({driverOpts, script, timeoutMs});\n\n      // and set up a race between the response from the child and the timeout\n      return await B.race([waitForResult(), waitForTimeout()]);\n    } catch (err) {\n      throw new Error(`Could not execute driver script. Original error was: ${err}`);\n    } finally {\n      // ensure we always cancel the timeout so that the timeout promise stops\n      // spinning and allows this process to die gracefully\n      timeoutCanceled = true;\n\n      if (scriptProc.connected) {\n        this.logger.info('Disconnecting from child proc');\n        scriptProc.disconnect();\n      }\n\n      if (scriptProc.exitCode === null) {\n        this.logger.info('Disconnecting from and killing driver script child proc');\n        scriptProc.kill();\n      } else {\n        this.logger.info('Script already ended on its own, no need to kill it');\n      }\n    }\n  }\n}\n\nexport { ExecuteDriverPlugin };\n"]}