all files / DEV/lib/protocol/ executeAsync.js

84.62% Statements 11/13
22.22% Branches 2/9
0% Functions 0/1
66.67% Lines 2/3
6 statements, 2 branches Ignored     
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83                                                                                                                                                                   
/**
 *
 * Inject a snippet of JavaScript into the page for execution in the context of the currently selected
 * frame. The executed script is assumed to be asynchronous and must signal that is done by invoking
 * the provided callback, which is always provided as the final argument to the function. The value
 * to this callback will be returned to the client.
 *
 * Asynchronous script commands may not span page loads. If an unload event is fired while waiting
 * for a script result, an error should be returned to the client.
 *
 * The script argument defines the script to execute in the form of a function body. The function will
 * be invoked with the provided args array and the values may be accessed via the arguments object
 * in the order specified. The final argument will always be a callback function that must be invoked
 * to signal that the script has finished.
 *
 * Arguments may be any JSON-primitive, array, or JSON object. JSON objects that define a WebElement
 * reference will be converted to the corresponding DOM element. Likewise, any WebElements in the script
 * result will be returned to the client as [WebElement JSON objects](https://code.google.com/p/selenium/wiki/JsonWireProtocol#WebElement_JSON_Object).
 *
 * <example>
    :executeAsync.js
    client
        .timeoutsAsyncScript(5000)
        .executeAsync(function(a, b, c, d, done) {
            // browser context - you may access neither client nor console
            setTimeout(function() {
                done(a + b + c + d);
            }, 3000);
        }, 1, 2, 3, 4).then(function(ret) {
            // node.js context - client and console are available
            console.log(ret.value); // outputs: 10
        });
 * </example>
 *
 * @param {String|Function} script     The script to execute.
 * @param {*}               arguments  script arguments
 *
 * @returns {*}             The script result.
 *
 * @see  https://code.google.com/p/selenium/wiki/JsonWireProtocol#/session/:sessionId/execute_async
 * @type protocol
 *
 */
 
'use strict';
 
Object.defineProperty(exports, '__esModule', {
    value: true
});
 
var _utilsErrorHandler = require('../utils/ErrorHandler');
 
var executeAsync = function executeAsync() {
    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
    }
 
    var script = args.shift();
 
    /*!
     * parameter check
     */
    if (typeof script !== 'string' && typeof script !== 'function') {
        throw new _utilsErrorHandler.ProtocolError('number or type of arguments don\'t agree with execute protocol command');
    }
 
    /*!
     * instances started as multibrowserinstance can't getting called with
     * a function parameter, therefor we need to check if it starts with "function () {"
     */
    if (typeof script === 'function' || this.inMultibrowserMode && script.indexOf('function (') === 0) {
        script = 'return (' + script + ').apply(null, arguments)';
    }
 
    return this.requestHandler.create('/session/:sessionId/execute_async', {
        script: script,
        args: args
    });
};
 
exports['default'] = executeAsync;
module.exports = exports['default'];
//# sourceMappingURL=data:application/json;base64,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