Current Dev State

static/js/ketcher2/node_modules/webdriverio/build/lib/webdriverio.js

@@ -0,0 +1,794 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+var _getIterator2 = require('babel-runtime/core-js/get-iterator');
+
+var _getIterator3 = _interopRequireDefault(_getIterator2);
+
+var _keys = require('babel-runtime/core-js/object/keys');
+
+var _keys2 = _interopRequireDefault(_keys);
+
+var _assign = require('babel-runtime/core-js/object/assign');
+
+var _assign2 = _interopRequireDefault(_assign);
+
+var _promise = require('babel-runtime/core-js/promise');
+
+var _promise2 = _interopRequireDefault(_promise);
+
+var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');
+
+var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
+
+var _create = require('babel-runtime/core-js/object/create');
+
+var _create2 = _interopRequireDefault(_create);
+
+var _q = require('q');
+
+var _q2 = _interopRequireDefault(_q);
+
+var _fs = require('fs');
+
+var _fs2 = _interopRequireDefault(_fs);
+
+var _path = require('path');
+
+var _path2 = _interopRequireDefault(_path);
+
+var _deepmerge = require('deepmerge');
+
+var _deepmerge2 = _interopRequireDefault(_deepmerge);
+
+var _mkdirp = require('mkdirp');
+
+var _mkdirp2 = _interopRequireDefault(_mkdirp);
+
+var _events = require('events');
+
+var _events2 = _interopRequireDefault(_events);
+
+var _safeBuffer = require('safe-buffer');
+
+var _RequestHandler = require('./utils/RequestHandler');
+
+var _RequestHandler2 = _interopRequireDefault(_RequestHandler);
+
+var _ErrorHandler = require('./utils/ErrorHandler');
+
+var _Logger = require('./utils/Logger');
+
+var _Logger2 = _interopRequireDefault(_Logger);
+
+var _safeExecute = require('./helpers/safeExecute');
+
+var _safeExecute2 = _interopRequireDefault(_safeExecute);
+
+var _sanitize = require('./helpers/sanitize');
+
+var _sanitize2 = _interopRequireDefault(_sanitize);
+
+var _mobileDetector2 = require('./helpers/mobileDetector');
+
+var _mobileDetector3 = _interopRequireDefault(_mobileDetector2);
+
+var _detectSeleniumBackend = require('./helpers/detectSeleniumBackend');
+
+var _detectSeleniumBackend2 = _interopRequireDefault(_detectSeleniumBackend);
+
+var _errorHandler = require('./helpers/errorHandler');
+
+var _errorHandler2 = _interopRequireDefault(_errorHandler);
+
+var _hasElementResultHelper = require('./helpers/hasElementResultHelper');
+
+var _hasElementResultHelper2 = _interopRequireDefault(_hasElementResultHelper);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var INTERNAL_EVENTS = ['init', 'command', 'error', 'result', 'end', 'screenshot'];
+var PROMISE_FUNCTIONS = ['then', 'catch', 'finally'];
+
+var EventEmitter = _events2.default.EventEmitter;
+
+/**
+ * WebdriverIO v4
+ */
+var WebdriverIO = function WebdriverIO(args, modifier) {
+    var prototype = (0, _create2.default)(Object.prototype);
+    var rawCommands = {};
+    var eventHandler = new EventEmitter();
+    var fulFilledPromise = (0, _q2.default)();
+    var stacktrace = [];
+    var commandList = [];
+
+    var EVENTHANDLER_FUNCTIONS = (0, _getPrototypeOf2.default)(eventHandler);
+
+    /**
+     * merge default options with given user options
+     */
+    var options = (0, _deepmerge2.default)({
+        protocol: 'http',
+        waitforTimeout: 1000,
+        waitforInterval: 500,
+        coloredLogs: true,
+        logLevel: 'silent',
+        baseUrl: null,
+        onError: [],
+        connectionRetryTimeout: 90000,
+        connectionRetryCount: 3
+    }, typeof args !== 'string' ? args : {});
+
+    /**
+     * define Selenium backend given on user options
+     */
+    options = (0, _deepmerge2.default)((0, _detectSeleniumBackend2.default)(args), options);
+
+    /**
+     * only set globals we wouldn't get otherwise
+     */
+    if (!process.env.WEBDRIVERIO_COLORED_LOGS) {
+        process.env.WEBDRIVERIO_COLORED_LOGS = options.coloredLogs;
+    }
+
+    var logger = new _Logger2.default(options, eventHandler);
+    var requestHandler = new _RequestHandler2.default(options, eventHandler, logger);
+
+    /**
+     * assign instance to existing session
+     */
+    if (typeof args === 'string') {
+        requestHandler.sessionID = args;
+    }
+
+    /**
+     * sanitize error handler
+     */
+    if (!Array.isArray(options.onError)) {
+        options.onError = [options.onError];
+    }
+    options.onError = options.onError.filter(function (fn) {
+        return typeof fn === 'function';
+    });
+
+    var desiredCapabilities = (0, _deepmerge2.default)({
+        javascriptEnabled: true,
+        locationContextEnabled: true,
+        handlesAlerts: true,
+        rotatable: true
+    }, options.desiredCapabilities || {});
+
+    var _mobileDetector = (0, _mobileDetector3.default)(desiredCapabilities),
+        isMobile = _mobileDetector.isMobile,
+        isIOS = _mobileDetector.isIOS,
+        isAndroid = _mobileDetector.isAndroid;
+
+    /**
+     * if no caps are specified fall back to firefox
+     */
+
+
+    if (!desiredCapabilities.browserName && !isMobile) {
+        desiredCapabilities.browserName = 'firefox';
+    }
+
+    if (!isMobile && typeof desiredCapabilities.loggingPrefs === 'undefined') {
+        desiredCapabilities.loggingPrefs = {
+            browser: 'ALL',
+            driver: 'ALL'
+        };
+    }
+
+    var resolve = function resolve(result, onFulfilled, onRejected, context) {
+        if (typeof result === 'function') {
+            this.isExecuted = true;
+            result = result.call(this);
+        }
+
+        /**
+         * run error handler if command fails
+         */
+        if (result instanceof Error) {
+            var _result = result;
+
+            this.defer.resolve(_promise2.default.all(_errorHandler2.default.map(function (fn) {
+                return fn.call(context, result);
+            })).then(function (res) {
+                var handlerResponses = res.filter(function (r) {
+                    return typeof r !== 'undefined';
+                });
+
+                /**
+                 * if no handler was triggered trough actual error
+                 */
+                if (handlerResponses.length === 0) {
+                    return callErrorHandlerAndReject.call(context, _result, onRejected);
+                }
+
+                return onFulfilled.call(context, handlerResponses[0]);
+            }, function (e) {
+                return callErrorHandlerAndReject.call(context, e, onRejected);
+            }));
+        } else {
+            this.defer.resolve(result);
+        }
+
+        return this.promise;
+    };
+
+    /**
+     * middleware to call on error handler in wdio mode
+     */
+    var callErrorHandlerAndReject = function callErrorHandlerAndReject(err, onRejected) {
+        var _this = this;
+
+        /**
+         * only call error handler if there is any and if error has bubbled up
+         */
+        if (!this || this.depth !== 0 || options.onError.length === 0) {
+            return reject.call(this, err, onRejected);
+        }
+
+        return new _promise2.default(function (resolve, reject) {
+            return _promise2.default.all(options.onError.map(function (fn) {
+                if (!global.wdioSync) {
+                    return fn.call(_this, err);
+                }
+
+                return new _promise2.default(function (resolve) {
+                    return global.wdioSync(fn, resolve).call(_this, err);
+                });
+            })).then(resolve, reject);
+        }).then(function () {
+            return reject.call(_this, err, onRejected);
+        });
+    };
+
+    /**
+     * By using finally in our next method we omit the duty to throw an exception at some
+     * point. To avoid propagating rejected promises until everything crashes silently we
+     * check if the last and current promise got rejected. If so we can throw the error.
+     */
+    var reject = function reject(err, onRejected) {
+        if (!options.isWDIO && !options.screenshotOnReject && typeof onRejected === 'function') {
+            delete err.screenshot;
+            return onRejected(err);
+        }
+
+        var onRejectedSafe = function onRejectedSafe(err) {
+            if (typeof onRejected === 'function') {
+                onRejected(err);
+            }
+        };
+
+        if (!this && !options.screenshotOnReject) {
+            onRejectedSafe(err);
+            throw err;
+        }
+
+        if (this && this.depth !== 0) {
+            onRejectedSafe(err);
+            return this.promise;
+        }
+
+        var shouldTakeScreenshot = options.screenshotOnReject || typeof options.screenshotPath === 'string';
+        if (!shouldTakeScreenshot || err.shotTaken || insideCommand('screenshot', this)) {
+            return fail(err, onRejected);
+        }
+
+        err.shotTaken = true;
+        return takeScreenshot(err).catch(function (e) {
+            return logger.log('\tFailed to take screenshot on reject:', e);
+        }).then(function () {
+            return fail(err, onRejected);
+        });
+    };
+
+    function insideCommand(command, unit) {
+        var commands = unit && unit.commandList;
+        return commands && commands[commands.length - 1].name === command;
+    }
+
+    function takeScreenshot(err) {
+        var client = unit();
+        var failDate = new Date();
+
+        if (typeof options.screenshotOnReject === 'object') {
+            client.requestHandler = createRequestHandlerDecorator(options.screenshotOnReject);
+        }
+
+        // don't take a new screenshot if we already got one from Selenium
+        var getScreenshot = typeof err.screenshot === 'string' ? function () {
+            return err.screenshot;
+        } : function () {
+            return rawCommands.screenshot.call(client).then(function (res) {
+                return res.value;
+            });
+        };
+
+        return _q2.default.fcall(getScreenshot).then(function (screenshot) {
+            if (options.screenshotOnReject) {
+                err.screenshot = screenshot;
+            }
+
+            if (typeof options.screenshotPath === 'string') {
+                var filename = saveScreenshotSync(screenshot, failDate);
+                client.emit('screenshot', { data: screenshot, filename: filename });
+            }
+        });
+    }
+
+    function createRequestHandlerDecorator(opts) {
+        return (0, _create2.default)(requestHandler, {
+            defaultOptions: {
+                value: (0, _assign2.default)({}, requestHandler.defaultOptions, opts)
+            }
+        });
+    }
+
+    function saveScreenshotSync(screenshot, date) {
+        var screenshotPath = _path2.default.isAbsolute(options.screenshotPath) ? options.screenshotPath : _path2.default.join(process.cwd(), options.screenshotPath);
+
+        /**
+        * create directory if not existing
+        */
+        try {
+            _fs2.default.statSync(screenshotPath);
+        } catch (e) {
+            _mkdirp2.default.sync(screenshotPath);
+        }
+
+        var capId = _sanitize2.default.caps(desiredCapabilities);
+        var timestamp = date.toJSON().replace(/:/g, '-');
+        var filename = 'ERROR_' + capId + '_' + timestamp + '.png';
+        var filePath = _path2.default.join(screenshotPath, filename);
+
+        _fs2.default.writeFileSync(filePath, new _safeBuffer.Buffer(screenshot, 'base64'));
+        logger.log('\tSaved screenshot: ' + filename);
+
+        return filename;
+    }
+
+    function fail(e, onRejected) {
+        if (!e.stack) {
+            e = new Error(e);
+        }
+
+        var message = e.seleniumStack && e.seleniumStack.message || e.message;
+
+        var stack = stacktrace.slice().map(function (trace) {
+            return '    at ' + trace;
+        });
+        e.stack = e.name + ': ' + message + '\n' + stack.reverse().join('\n');
+
+        /**
+         * the waitUntil command can execute a lot of functions until it resolves
+         * to keep the stacktrace sane we just shrink down the stacktrack and
+         * only keep waitUntil in it
+         */
+        if (e.name === 'WaitUntilTimeoutError') {
+            stack = e.stack.split('\n');
+            stack.splice(1, stack.length - 2);
+            e.stack = stack.join('\n');
+        }
+
+        /**
+         * ToDo useful feature for standalone mode:
+         * option that if true causes script to throw exception if command fails:
+         *
+         * process.nextTick(() => {
+         *     throw e
+         * })
+         */
+
+        if (typeof onRejected !== 'function') {
+            throw e;
+        }
+
+        return onRejected(e);
+    }
+
+    /**
+     * WebdriverIO Monad
+     */
+    function unit(lastPromise) {
+        var client = (0, _create2.default)(prototype);
+        var defer = _q2.default.defer();
+        var promise = defer.promise;
+
+        client.defer = defer;
+        client.promise = promise;
+        client.lastPromise = lastPromise || fulFilledPromise;
+
+        client.desiredCapabilities = desiredCapabilities;
+        client.requestHandler = requestHandler;
+        client.logger = logger;
+        client.options = options;
+        client.commandList = commandList;
+
+        client.isMobile = isMobile;
+        client.isIOS = isIOS;
+        client.isAndroid = isAndroid;
+
+        /**
+         * actual bind function
+         */
+        client.next = function (func, args, name) {
+            var _this2 = this;
+
+            /**
+             * use finally to propagate rejected promises up the chain
+             */
+            return this.lastPromise.then(function (val) {
+                /**
+                 * store command into command list so `getHistory` can return it
+                 */
+                var timestamp = Date.now();
+                commandList.push({ name: name, args: args, timestamp: timestamp });
+
+                /**
+                 * allow user to leave out selector argument if they have already queried an element before
+                 */
+                var lastResult = val || _this2.lastResult;
+                if ((0, _hasElementResultHelper2.default)(lastResult) && args.length < func.length && func.toString().indexOf('function ' + name + '(selector') === 0) {
+                    var isWaitFor = name.match(/^waitFor/);
+                    var isWaitForWithSelector = isWaitFor && typeof args[0] === 'string';
+
+                    /**
+                     * Throw error if someone tries to call an action on a chained element call,
+                     * otherwise the context would be ignored and a different element could
+                     * selected.
+                     * Ignore this behavior for all waitFor calls as we want to refetch elements
+                     * in case they haven't been found. Also not throw an error for isExisting
+                     * and isVisible since they use that information to return their result.
+                     */
+                    if (!isWaitFor && !name.match(/^is(Existing|Visible)/) && lastResult.state === 'failure') {
+                        var message = lastResult.message;
+
+                        /**
+                         * add selector parameter if no existing
+                         */
+                        if (message.match(/using the given search parameters\.$/)) {
+                            message = message.slice(0, -1) + ' ("' + lastResult.selector + '").';
+                        }
+
+                        var error = new Error(message);
+                        return resolve.call(_this2, error, null, null, { depth: 0 });
+                    }
+
+                    /**
+                     * propagate last element result if last result has a selector and we've
+                     * called a waitFor command without selector
+                     *
+                     * e.g. when calling `waitForExist` via $('#notExisting').waitForExist()
+                     */
+                    if (lastResult.selector && isWaitFor && !isWaitForWithSelector) {
+                        _this2.lastResult = null;
+                        args.unshift(lastResult.selector);
+
+                        /**
+                         * All non waitFor commands get null as selector which will be replaced by
+                         * the actual web element id in the element(s) protocol commands
+                         *
+                         * e.g. when calling `getText` via $('#existing').getText()
+                         */
+                    } else if (!isWaitForWithSelector) {
+                        args.unshift(null);
+                    }
+                }
+
+                return resolve.call(_this2, (0, _safeExecute2.default)(func, args));
+            }, function (e) {
+                /**
+                 * this will get reached only in standalone mode if the command
+                 * fails and doesn't get followed by a then or catch method
+                 */
+                return resolve.call(_this2, e, null, null, { depth: 0 });
+            });
+        };
+
+        client.finally = function (fn) {
+            var _this3 = this;
+
+            var client = unit(this.promise.finally(function () {
+                return resolve.call(client, (0, _safeExecute2.default)(fn, []).bind(_this3));
+            }));
+            return client;
+        };
+
+        client.call = function (fn) {
+            var _this4 = this;
+
+            var client = unit(this.promise.done(function () {
+                return resolve.call(client, (0, _safeExecute2.default)(fn, []).bind(_this4));
+            }));
+            return client;
+        };
+
+        client.then = function (onFulfilled, onRejected) {
+            var _this5 = this;
+
+            if (typeof onFulfilled !== 'function' && typeof onRejected !== 'function') {
+                return this;
+            }
+
+            /**
+             * execute then function in context of the new instance
+             * but resolve result with this
+             */
+            var client = unit(this.promise.then(function () {
+                for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+                    args[_key] = arguments[_key];
+                }
+
+                /**
+                 * store result in commandList
+                 */
+                if (commandList.length) {
+                    commandList[commandList.length - 1].result = args[0];
+                }
+
+                /**
+                 * resolve command
+                 */
+                return resolve.call(client, (0, _safeExecute2.default)(onFulfilled, args).bind(_this5));
+            }, function (e) {
+                var result = (0, _safeExecute2.default)(onRejected, [e]).bind(_this5);
+
+                /**
+                 * handle error once command was bubbled up the command chain
+                 */
+                if (_this5.depth === 0) {
+                    result = e;
+                }
+
+                return resolve.call(client, result, onFulfilled, onRejected, _this5);
+            }));
+
+            return client;
+        };
+
+        client.catch = function (onRejected) {
+            return this.then(undefined, onRejected);
+        };
+
+        client.inspect = function () {
+            return this.promise.inspect();
+        };
+
+        /**
+         * internal helper method to handle command results
+         *
+         * @param  {Promise[]} promises  list of promises
+         * @param  {Boolean}   option    if true extract value property from selenium result
+         */
+        client.unify = function (promises) {
+            var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+            promises = Array.isArray(promises) ? promises : [promises];
+
+            return _promise2.default.all(promises)
+            /**
+             * extract value property from result if desired
+             */
+            .then(function (result) {
+                if (!option.extractValue || !Array.isArray(result)) {
+                    return result;
+                }
+
+                return result.map(function (res) {
+                    return res.value;
+                });
+
+                /**
+                 * sanitize result for better assertion
+                 */
+            }).then(function (result) {
+                if (Array.isArray(result) && result.length === 1) {
+                    result = result[0];
+                }
+
+                if (option.lowercase && typeof result === 'string') {
+                    result = result.toLowerCase();
+                }
+
+                return result;
+            });
+        };
+
+        /**
+         * addCommand handler for async or standalone mode
+         * @param {String}   fnName         function name
+         * @param {Function} fn             function
+         * @param {Boolean}  forceOverwrite if true it can overwrite existing commands
+         */
+        client.addCommand = function (fnName, fn, forceOverwrite) {
+            if (typeof fn === 'string') {
+                var namespace = arguments[0];
+                fnName = arguments[1];
+                fn = arguments[2];
+                forceOverwrite = arguments[3];
+
+                switch (typeof client[namespace]) {
+                    case 'function':
+                        throw new _ErrorHandler.RuntimeError('Command namespace "' + namespace + '" is used internally, and can\'t be overwritten!');
+                    case 'object':
+                        if (client[namespace][fnName] && !forceOverwrite) {
+                            throw new _ErrorHandler.RuntimeError('Command "' + fnName + '" is already defined!');
+                        }
+                        break;
+                }
+                return unit.lift(namespace, fnName, fn);
+            }
+
+            if (client[fnName] && !forceOverwrite) {
+                throw new _ErrorHandler.RuntimeError('Command "' + fnName + '" is already defined!');
+            }
+            return unit.lift(fnName, fn);
+        };
+
+        client.getPrototype = function () {
+            return prototype;
+        };
+
+        client.transferPromiseness = function (target, promise) {
+            /**
+             * transfer WebdriverIO commands
+             */
+            var clientFunctions = (0, _keys2.default)(prototype);
+            var functionsToTranfer = clientFunctions.concat(PROMISE_FUNCTIONS);
+
+            var _iteratorNormalCompletion = true;
+            var _didIteratorError = false;
+            var _iteratorError = undefined;
+
+            try {
+                for (var _iterator = (0, _getIterator3.default)(functionsToTranfer), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                    var fnName = _step.value;
+
+                    if (typeof promise[fnName] === 'function') {
+                        target[fnName] = promise[fnName].bind(promise);
+                    }
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally {
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return) {
+                        _iterator.return();
+                    }
+                } finally {
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+        };
+
+        if (typeof modifier === 'function') {
+            client = modifier(client, options);
+        }
+
+        return client;
+    }
+
+    /**
+     * enhance base monad prototype with methods
+     */
+    unit.lift = function (name, func) {
+        var commandGroup = prototype;
+
+        if (typeof func === 'string') {
+            var namespace = arguments[0];
+            name = arguments[1];
+            func = arguments[2];
+
+            if (!prototype[namespace]) {
+                prototype[namespace] = {};
+            }
+
+            commandGroup = prototype[namespace];
+        }
+
+        rawCommands[name] = func;
+
+        commandGroup[name] = function () {
+            var nextPromise = this.promise;
+
+            /**
+             * commands executed inside commands don't have to wait
+             * on any promise
+             */
+            if (this.isExecuted) {
+                nextPromise = this.lastPromise;
+            }
+
+            var client = unit(nextPromise);
+
+            /**
+             * catch stack to find information about where the command that causes
+             * the error was used (stack line 2) and only save it when it was not
+             * within WebdriverIO context
+             */
+            var stack = new Error().stack;
+            var lineInTest = stack.split('\n').slice(2, 3).join('\n');
+            var fileAndPosition = lineInTest.slice(lineInTest.indexOf('(') + 1, lineInTest.indexOf(')'));
+            var atCommand = lineInTest.trim().slice(3).split(' ')[0];
+
+            atCommand = atCommand.slice(atCommand.lastIndexOf('.') + 1);
+
+            for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+                args[_key2] = arguments[_key2];
+            }
+
+            var trace = name + '(' + _sanitize2.default.args(args) + ') - ' + fileAndPosition.slice(fileAndPosition.lastIndexOf('/') + 1);
+            if ((0, _keys2.default)(prototype).indexOf(atCommand) === -1 && atCommand !== 'exports') {
+                stacktrace = [trace];
+            } else {
+                /**
+                 * save trace for nested commands
+                 */
+                stacktrace.push(trace);
+            }
+
+            /**
+             * determine execution depth:
+             * This little tweak helps us to determine whether the command was executed
+             * by the test script or by another command. With that we can make sure
+             * that errors are getting thrown once they bubbled up the command chain.
+             */
+            client.depth = stack.split('\n').filter(function (line) {
+                return !!line.match(/\/lib\/(commands|protocol)\/(\w+)\.js/);
+            }).length;
+
+            /**
+             * queue command
+             */
+            client.name = name;
+            client.lastResult = this.lastResult;
+            client.next(func, args, name);
+            return client;
+        };
+
+        return unit;
+    };
+
+    /**
+     * register event emitter
+     */
+
+    var _loop = function _loop(eventCommand) {
+        prototype[eventCommand] = function () {
+            for (var _len3 = arguments.length, args = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+                args[_key3] = arguments[_key3];
+            }
+
+            /**
+             * custom commands needs to get emitted and registered in order
+             * to prevent race conditions
+             */
+            if (INTERNAL_EVENTS.indexOf(args[0]) === -1) {
+                return this.finally(function () {
+                    return eventHandler[eventCommand].apply(eventHandler, args);
+                });
+            }
+
+            eventHandler[eventCommand].apply(eventHandler, args);
+            return this;
+        };
+    };
+
+    for (var eventCommand in EVENTHANDLER_FUNCTIONS) {
+        _loop(eventCommand);
+    }
+
+    return unit;
+};
+
+exports.default = WebdriverIO;
+module.exports = exports['default'];