testcafe-browser-provider-saucelabs/lib/index.js

saucelabs TestCafe browser provider plugin.

'use strict';

exports.__esModule = true;

var _assign = require('babel-runtime/core-js/object/assign');

var _assign2 = _interopRequireDefault(_assign);

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _maxSafeInteger = require('babel-runtime/core-js/number/max-safe-integer');

var _maxSafeInteger2 = _interopRequireDefault(_maxSafeInteger);

var readConfigFromFile = function () {
    var _ref = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee(filename) {
        var data;
        return _regenerator2.default.wrap(function _callee$(_context) {
            while (1) {
                switch (_context.prev = _context.next) {
                    case 0:
                        _context.prev = 0;
                        _context.next = 3;
                        return readFile(filename, 'utf8');

                    case 3:
                        data = _context.sent;
                        return _context.abrupt('return', JSON.parse(data));

                    case 7:
                        _context.prev = 7;
                        _context.t0 = _context['catch'](0);
                        return _context.abrupt('return', {});

                    case 10:
                    case 'end':
                        return _context.stop();
                }
            }
        }, _callee, this, [[0, 7]]);
    }));

    return function readConfigFromFile(_x) {
        return _ref.apply(this, arguments);
    };
}();

var fetchPlatforms = function () {
    var _ref2 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee2() {
        var host, response;
        return _regenerator2.default.wrap(function _callee2$(_context2) {
            while (1) {
                switch (_context2.prev = _context2.next) {
                    case 0:
                        if (!(!process.env['SAUCE_USERNAME'] || !process.env['SAUCE_ACCESS_KEY'])) {
                            _context2.next = 2;
                            break;
                        }

                        throw new Error(AUTH_FAILED_ERROR);

                    case 2:
                        host = process.env.SAUCE_API_HOST || 'us-west-1.saucelabs.com';
                        _context2.next = 5;
                        return (0, _httpsRequest.httpsRequest)({
                            hostname: 'api.' + host,
                            path: '/rest/v1.1/info/platforms/all',
                            user: process.env['SAUCE_USERNAME'],
                            password: process.env['SAUCE_ACCESS_KEY']
                        });

                    case 5:
                        response = _context2.sent;
                        _context2.prev = 6;
                        return _context2.abrupt('return', JSON.parse(response.body));

                    case 10:
                        _context2.prev = 10;
                        _context2.t0 = _context2['catch'](6);
                        return _context2.abrupt('return', null);

                    case 13:
                    case 'end':
                        return _context2.stop();
                }
            }
        }, _callee2, this, [[6, 10]]);
    }));

    return function fetchPlatforms() {
        return _ref2.apply(this, arguments);
    };
}();

var getAutomationApiInfo = function () {
    var _ref3 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee3() {
        var platforms;
        return _regenerator2.default.wrap(function _callee3$(_context3) {
            while (1) {
                switch (_context3.prev = _context3.next) {
                    case 0:
                        _context3.next = 2;
                        return fetchPlatforms();

                    case 2:
                        platforms = _context3.sent;
                        return _context3.abrupt('return', platforms.map(function (platform) {
                            return formatAutomationApiData(platform);
                        }).filter(function (platform) {
                            return platform;
                        }));

                    case 4:
                    case 'end':
                        return _context3.stop();
                }
            }
        }, _callee3, this);
    }));

    return function getAutomationApiInfo() {
        return _ref3.apply(this, arguments);
    };
}();

var _saucelabsConnector = require('saucelabs-connector');

var _saucelabsConnector2 = _interopRequireDefault(_saucelabsConnector);

var _desiredCapabilities = require('desired-capabilities');

var _desiredCapabilities2 = _interopRequireDefault(_desiredCapabilities);

var _pinkie = require('pinkie');

var _pinkie2 = _interopRequireDefault(_pinkie);

var _util = require('util');

var _util2 = _interopRequireDefault(_util);

var _lodash = require('lodash');

var _fs = require('fs');

var fs = _interopRequireWildcard(_fs);

var _httpsRequest = require('./https-request');

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var AUTH_FAILED_ERROR = 'Authentication failed. Please assign the correct username and access key ' + 'to the SAUCE_USERNAME and SAUCE_ACCESS_KEY environment variables.';

var SAUCE_LABS_REQUESTED_MACHINES_COUNT = 1;
var WAIT_FOR_FREE_MACHINES_REQUEST_INTERVAL = 60000;
var WAIT_FOR_FREE_MACHINES_MAX_ATTEMPT_COUNT = 45;
var MAX_TUNNEL_CONNECT_RETRY_COUNT = 3;
var minWindowSize = 0;
var maxWindowSize = _maxSafeInteger2.default;

var readFile = _util2.default.promisify(fs.readFile);
var access = _util2.default.promisify(fs.access);

var isDesktop = function isDesktop(platformInfo) {
    return platformInfo.platformGroup === 'Desktop';
};

function formatAutomationApiData(platform) {
    var platformGroup = void 0;

    switch (platform.api_name) {
        case 'android':
            platformGroup = 'Android';
            break;
        case 'iphone':
        case 'ipad':
            platformGroup = 'iOS';
            break;
        default:
            platformGroup = 'Desktop';
    }

    var formattedData = {
        automationBackend: platform.automation_backend,
        platformGroup: platformGroup
    };

    if (platformGroup === 'Desktop') {
        formattedData.os = platform.os;
        formattedData.browserName = platform.api_name;
        formattedData.browserVersion = platform.short_version;

        if (platform.os.startsWith('Windows')) formattedData.device = 'PC';else if (platform.os.startsWith('Mac')) formattedData.device = 'Mac';
    }
    // Filtering out the combo of webdriver + mobile. We would have duplicate entries otherwise.
    else if ((platformGroup === 'Android' || platformGroup === 'iOS') && platform.automation_backend === 'appium') {
            formattedData.os = platform.short_version;
            formattedData.device = platform.long_name;
        } else return null;

    return formattedData;
}

function getCorrectedSize(currentClientAreaSize, currentWindowSize, requestedSize) {
    var horizontalChrome = currentWindowSize.width - currentClientAreaSize.width;
    var verticalChrome = currentWindowSize.height - currentClientAreaSize.height;

    return {
        width: requestedSize.width + horizontalChrome,
        height: requestedSize.height + verticalChrome
    };
}

function getAppiumBrowserName(platformInfo) {
    if (platformInfo.platformGroup === 'iOS') return 'safari';

    if (platformInfo.platformGroup === 'Android') return 'chrome';

    throw new Error('unsupported platform group ' + platformInfo.platformGroup);
}

exports.default = {
    connectorPromise: _pinkie2.default.resolve(null),
    openedBrowsers: {},
    aliasesCache: [],
    platformsInfo: [],
    availableAliases: [],

    tunnelConnectRetryCount: 0,

    isMultiBrowser: true,

    _getConnector: function _getConnector() {
        var _this = this;

        this.connectorPromise = this.connectorPromise.then(function () {
            var _ref4 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee4(connector) {
                var sauceConnectOptions;
                return _regenerator2.default.wrap(function _callee4$(_context4) {
                    while (1) {
                        switch (_context4.prev = _context4.next) {
                            case 0:
                                if (connector) {
                                    _context4.next = 7;
                                    break;
                                }

                                _context4.next = 3;
                                return _this._generateSauceConnectOptions();

                            case 3:
                                sauceConnectOptions = _context4.sent;


                                connector = new _saucelabsConnector2.default(process.env['SAUCE_USERNAME'], process.env['SAUCE_ACCESS_KEY'], sauceConnectOptions);

                                _context4.next = 7;
                                return connector.connect();

                            case 7:

                                _this.tunnelConnectRetryCount = 0;
                                return _context4.abrupt('return', connector);

                            case 9:
                            case 'end':
                                return _context4.stop();
                        }
                    }
                }, _callee4, _this);
            }));

            return function (_x2) {
                return _ref4.apply(this, arguments);
            };
        }()).catch(function (error) {
            _this.tunnelConnectRetryCount++;

            if (_this.tunnelConnectRetryCount > MAX_TUNNEL_CONNECT_RETRY_COUNT) throw error;

            _this.connectorPromise = _pinkie2.default.resolve(null);

            return _this._getConnector();
        });

        return this.connectorPromise;
    },
    _disposeConnector: function _disposeConnector() {
        var _this2 = this;

        this.connectorPromise = this.connectorPromise.then(function () {
            var _ref5 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee5(connector) {
                return _regenerator2.default.wrap(function _callee5$(_context5) {
                    while (1) {
                        switch (_context5.prev = _context5.next) {
                            case 0:
                                if (!connector) {
                                    _context5.next = 3;
                                    break;
                                }

                                _context5.next = 3;
                                return connector.disconnect();

                            case 3:
                                return _context5.abrupt('return', null);

                            case 4:
                            case 'end':
                                return _context5.stop();
                        }
                    }
                }, _callee5, _this2);
            }));

            return function (_x3) {
                return _ref5.apply(this, arguments);
            };
        }());

        return this.connectorPromise;
    },
    _generateSauceConnectOptions: function _generateSauceConnectOptions() {
        var _this3 = this;

        return (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee6() {
            var defaults, overrides;
            return _regenerator2.default.wrap(function _callee6$(_context6) {
                while (1) {
                    switch (_context6.prev = _context6.next) {
                        case 0:
                            defaults = {
                                connectorLogging: false
                            };

                            if (!process.env['SAUCE_CONNECT_OVERRIDES_PATH']) {
                                _context6.next = 7;
                                break;
                            }

                            _context6.next = 4;
                            return readConfigFromFile(process.env['SAUCE_CONNECT_OVERRIDES_PATH']);

                        case 4:
                            _context6.t0 = _context6.sent;
                            _context6.next = 8;
                            break;

                        case 7:
                            _context6.t0 = {};

                        case 8:
                            overrides = _context6.t0;
                            return _context6.abrupt('return', (0, _assign2.default)({}, defaults, overrides));

                        case 10:
                        case 'end':
                            return _context6.stop();
                    }
                }
            }, _callee6, _this3);
        }))();
    },
    _fetchPlatformInfoAndAliases: function _fetchPlatformInfoAndAliases() {
        var _this4 = this;

        return (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee7() {
            var unstructuredBrowserNames;
            return _regenerator2.default.wrap(function _callee7$(_context7) {
                while (1) {
                    switch (_context7.prev = _context7.next) {
                        case 0:
                            _context7.next = 2;
                            return getAutomationApiInfo();

                        case 2:
                            _this4.platformsInfo = _context7.sent;
                            unstructuredBrowserNames = _this4.platformsInfo.map(function (platformInfo) {
                                return _this4._createAliasesForPlatformInfo(platformInfo);
                            }).flat();


                            _this4.availableBrowserNames = unstructuredBrowserNames.sort();

                        case 5:
                        case 'end':
                            return _context7.stop();
                    }
                }
            }, _callee7, _this4);
        }))();
    },
    _createAliasesForPlatformInfo: function _createAliasesForPlatformInfo(platformInfo) {
        if (platformInfo.device === 'Android Emulator') {
            return [this._createAliasesForPlatformInfo((0, _lodash.assign)({}, platformInfo, { device: 'Android Emulator Tablet' })), this._createAliasesForPlatformInfo((0, _lodash.assign)({}, platformInfo, { device: 'Android Emulator Phone' }))];
        }

        var name = isDesktop(platformInfo) ? platformInfo.browserName : platformInfo.device;
        var version = isDesktop(platformInfo) ? platformInfo.browserVersion : platformInfo.os;
        var platform = isDesktop(platformInfo) ? platformInfo['os'] : '';

        return name + '@' + version + (platform ? ':' + platform : '');
    },
    _createQuery: function _createQuery(capabilities) {
        var _parseCapabilities$ = (0, _desiredCapabilities2.default)(capabilities)[0],
            browserName = _parseCapabilities$.browserName,
            browserVersion = _parseCapabilities$.browserVersion,
            platform = _parseCapabilities$.platform;


        var query = {
            name: browserName.toLowerCase(),
            version: browserVersion.toLowerCase(),
            platform: platform.toLowerCase()
        };

        if (/^android emulator/.test(query.name)) {
            query.deviceType = query.name.replace('android emulator ', '');
            query.name = 'android emulator';
        }

        return query;
    },
    _filterPlatformInfo: function _filterPlatformInfo(query) {
        return this.platformsInfo.filter(function (info) {
            var browserNameMatched = info.browserName && info.browserName.toLowerCase() === query.name;
            var deviceNameMatched = info.device && info.device.toLowerCase() === query.name;

            var majorBrowserVersionMatch = info.browserVersion && info.browserVersion.match(/^\d+/);
            var majorBrowserVersion = info.browserVersion && majorBrowserVersionMatch && majorBrowserVersionMatch[0];
            var browserVersionMatched = info.browserVersion === query.version || majorBrowserVersion === query.version;

            var platformVersionMatched = info.os === query.version;
            var platformNameMatched = info.os.toLowerCase() === query.platform;

            var isAnyVersion = query.version === 'any';
            var isAnyPlatform = query.platform === 'any';

            var desktopBrowserMatched = browserNameMatched && (browserVersionMatched || isAnyVersion) && (platformNameMatched || isAnyPlatform);

            var mobileBrowserMatched = deviceNameMatched && (platformVersionMatched || isAnyVersion);

            return desktopBrowserMatched || mobileBrowserMatched;
        });
    },
    _generateMobileCapabilities: function _generateMobileCapabilities(query, platformInfo) {
        // sanity check
        if (platformInfo.automationBackend !== 'appium') throw new Error('tried generating mobile capabilities for non appium backend');

        var capabilities = {
            deviceName: platformInfo.device,
            browserName: getAppiumBrowserName(platformInfo),
            platformName: platformInfo.platformGroup
        };

        if (query.version !== 'any') capabilities.platformVersion = query.version;

        if (query.deviceType) capabilities.deviceType = query.deviceType;

        return capabilities;
    },
    _generateDesktopCapabilities: function _generateDesktopCapabilities(query) {
        var capabilities = { browserName: query.name };

        if (query.version !== 'any') capabilities.version = query.version;

        if (query.platform !== 'any') capabilities.platform = query.platform;
        if (process.env['SAUCE_SCREEN_RESOLUTION']) capabilities.screenResolution = process.env['SAUCE_SCREEN_RESOLUTION'];
        return capabilities;
    },
    _generateCapabilities: function _generateCapabilities(browserName) {
        var _this5 = this;

        return (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee8() {
            var query, platformInfo, capabilities, capabilitiesOverride;
            return _regenerator2.default.wrap(function _callee8$(_context8) {
                while (1) {
                    switch (_context8.prev = _context8.next) {
                        case 0:
                            query = _this5._createQuery(browserName);
                            platformInfo = _this5._filterPlatformInfo(query)[0];
                            capabilities = platformInfo.platformGroup === 'Desktop' ? _this5._generateDesktopCapabilities(query) : _this5._generateMobileCapabilities(query, platformInfo);
                            capabilitiesOverride = {};

                            if (!process.env['SAUCE_CAPABILITIES_OVERRIDES_PATH']) {
                                _context8.next = 8;
                                break;
                            }

                            _context8.next = 7;
                            return readConfigFromFile(process.env['SAUCE_CAPABILITIES_OVERRIDES_PATH']);

                        case 7:
                            capabilitiesOverride = _context8.sent;

                        case 8:
                            return _context8.abrupt('return', (0, _assign2.default)({}, capabilities, capabilitiesOverride));

                        case 9:
                        case 'end':
                            return _context8.stop();
                    }
                }
            }, _callee8, _this5);
        }))();
    },


    // API
    init: function init() {
        var _this6 = this;

        return (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee9() {
            return _regenerator2.default.wrap(function _callee9$(_context9) {
                while (1) {
                    switch (_context9.prev = _context9.next) {
                        case 0:
                            _context9.next = 2;
                            return _this6._fetchPlatformInfoAndAliases();

                        case 2:
                        case 'end':
                            return _context9.stop();
                    }
                }
            }, _callee9, _this6);
        }))();
    },
    dispose: function dispose() {
        var _this7 = this;

        return (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee10() {
            return _regenerator2.default.wrap(function _callee10$(_context10) {
                while (1) {
                    switch (_context10.prev = _context10.next) {
                        case 0:
                            _context10.next = 2;
                            return _this7._disposeConnector();

                        case 2:
                        case 'end':
                            return _context10.stop();
                    }
                }
            }, _callee10, _this7);
        }))();
    },
    openBrowser: function openBrowser(id, pageUrl, browserName) {
        var _this8 = this;

        return (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee11() {
            var capabilities, connector, jobOptions, newBrowser, sessionUrl;
            return _regenerator2.default.wrap(function _callee11$(_context11) {
                while (1) {
                    switch (_context11.prev = _context11.next) {
                        case 0:
                            if (!(!process.env['SAUCE_USERNAME'] || !process.env['SAUCE_ACCESS_KEY'])) {
                                _context11.next = 2;
                                break;
                            }

                            throw new Error(AUTH_FAILED_ERROR);

                        case 2:
                            _context11.next = 4;
                            return _this8._generateCapabilities(browserName);

                        case 4:
                            capabilities = _context11.sent;
                            _context11.next = 7;
                            return _this8._getConnector();

                        case 7:
                            connector = _context11.sent;
                            _context11.next = 10;
                            return connector.waitForFreeMachines(SAUCE_LABS_REQUESTED_MACHINES_COUNT, WAIT_FOR_FREE_MACHINES_REQUEST_INTERVAL, WAIT_FOR_FREE_MACHINES_MAX_ATTEMPT_COUNT);

                        case 10:
                            _context11.t0 = _assign2.default;
                            _context11.t1 = {
                                jobName: process.env['SAUCE_JOB'],
                                build: process.env['SAUCE_BUILD']
                            };

                            if (!process.env['SAUCE_CONFIG_PATH']) {
                                _context11.next = 18;
                                break;
                            }

                            _context11.next = 15;
                            return readConfigFromFile(process.env['SAUCE_CONFIG_PATH']);

                        case 15:
                            _context11.t2 = _context11.sent;
                            _context11.next = 19;
                            break;

                        case 18:
                            _context11.t2 = {};

                        case 19:
                            _context11.t3 = _context11.t2;
                            jobOptions = (0, _context11.t0)(_context11.t1, _context11.t3);
                            _context11.next = 23;
                            return connector.startBrowser(capabilities, pageUrl, jobOptions);

                        case 23:
                            newBrowser = _context11.sent;


                            _this8.openedBrowsers[id] = newBrowser;

                            _context11.next = 27;
                            return connector.getSessionUrl(newBrowser);

                        case 27:
                            sessionUrl = _context11.sent;


                            _this8.setUserAgentMetaInfo(id, '' + sessionUrl);

                        case 29:
                        case 'end':
                            return _context11.stop();
                    }
                }
            }, _callee11, _this8);
        }))();
    },
    closeBrowser: function closeBrowser(id) {
        var _this9 = this;

        return (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee12() {
            var connector;
            return _regenerator2.default.wrap(function _callee12$(_context12) {
                while (1) {
                    switch (_context12.prev = _context12.next) {
                        case 0:
                            _context12.next = 2;
                            return _this9._getConnector();

                        case 2:
                            connector = _context12.sent;
                            _context12.next = 5;
                            return connector.stopBrowser(_this9.openedBrowsers[id]);

                        case 5:

                            delete _this9.openedBrowsers[id];

                        case 6:
                        case 'end':
                            return _context12.stop();
                    }
                }
            }, _callee12, _this9);
        }))();
    },
    isValidBrowserName: function isValidBrowserName(browserName) {
        var _this10 = this;

        return (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee13() {
            return _regenerator2.default.wrap(function _callee13$(_context13) {
                while (1) {
                    switch (_context13.prev = _context13.next) {
                        case 0:
                            return _context13.abrupt('return', (0, _desiredCapabilities2.default)(browserName).length === 1 && !!_this10._filterPlatformInfo(_this10._createQuery(browserName)).length);

                        case 1:
                        case 'end':
                            return _context13.stop();
                    }
                }
            }, _callee13, _this10);
        }))();
    },
    getBrowserList: function getBrowserList() {
        var _this11 = this;

        return (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee14() {
            return _regenerator2.default.wrap(function _callee14$(_context14) {
                while (1) {
                    switch (_context14.prev = _context14.next) {
                        case 0:
                            return _context14.abrupt('return', _this11.availableBrowserNames);

                        case 1:
                        case 'end':
                            return _context14.stop();
                    }
                }
            }, _callee14, _this11);
        }))();
    },
    resizeWindow: function resizeWindow(id, width, height, currentWidth, currentHeight) {
        var _this12 = this;

        return (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee15() {
            var currentWindowSize, currentClientAreaSize, requestedSize, correctedSize;
            return _regenerator2.default.wrap(function _callee15$(_context15) {
                while (1) {
                    switch (_context15.prev = _context15.next) {
                        case 0:
                            _context15.next = 2;
                            return _this12._getWindowSize(_this12.openedBrowsers[id]);

                        case 2:
                            currentWindowSize = _context15.sent;
                            currentClientAreaSize = { width: currentWidth, height: currentHeight };
                            requestedSize = { width: width, height: height };
                            correctedSize = getCorrectedSize(currentClientAreaSize, currentWindowSize, requestedSize);
                            _context15.next = 8;
                            return _this12._setWindowSize(_this12.openedBrowsers[id], correctedSize.width, correctedSize.height);

                        case 8:
                        case 'end':
                            return _context15.stop();
                    }
                }
            }, _callee15, _this12);
        }))();
    },
    _getWindowSize: function _getWindowSize(browser) {
        var _this13 = this;

        return (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee16() {
            var _ref6, width, height;

            return _regenerator2.default.wrap(function _callee16$(_context16) {
                while (1) {
                    switch (_context16.prev = _context16.next) {
                        case 0:
                            if (browser.isW3C) {
                                _context16.next = 2;
                                break;
                            }

                            return _context16.abrupt('return', browser._getWindowSize());

                        case 2:
                            _context16.next = 4;
                            return browser.getWindowRect();

                        case 4:
                            _ref6 = _context16.sent;
                            width = _ref6.width;
                            height = _ref6.height;
                            return _context16.abrupt('return', { width: width, height: height });

                        case 8:
                        case 'end':
                            return _context16.stop();
                    }
                }
            }, _callee16, _this13);
        }))();
    },
    _setWindowSize: function _setWindowSize(browser, width, height) {
        var _this14 = this;

        return (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee17() {
            return _regenerator2.default.wrap(function _callee17$(_context17) {
                while (1) {
                    switch (_context17.prev = _context17.next) {
                        case 0:
                            if (!(typeof width !== 'number' || typeof height !== 'number')) {
                                _context17.next = 2;
                                break;
                            }

                            throw new Error('setWindowSize expects width and height of type number');

                        case 2:
                            if (!(width < minWindowSize || width > maxWindowSize || height < minWindowSize || height > maxWindowSize)) {
                                _context17.next = 4;
                                break;
                            }

                            throw new Error('setWindowSize expects width and height to be a number in the 0 to 2^31 − 1 range');

                        case 4:
                            if (browser.isW3C) {
                                _context17.next = 6;
                                break;
                            }

                            return _context17.abrupt('return', browser._setWindowSize(width, height));

                        case 6:
                            _context17.next = 8;
                            return browser.setWindowRect(null, null, width, height);

                        case 8:
                            return _context17.abrupt('return', _context17.sent);

                        case 9:
                        case 'end':
                            return _context17.stop();
                    }
                }
            }, _callee17, _this14);
        }))();
    },
    takeScreenshot: function takeScreenshot(id, screenshotPath) {
        var _this15 = this;

        return (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee18() {
            return _regenerator2.default.wrap(function _callee18$(_context18) {
                while (1) {
                    switch (_context18.prev = _context18.next) {
                        case 0:
                            _context18.next = 2;
                            return _this15._saveScreenshot(_this15.openedBrowsers[id], screenshotPath);

                        case 2:
                        case 'end':
                            return _context18.stop();
                    }
                }
            }, _callee18, _this15);
        }))();
    },
    _saveScreenshot: function _saveScreenshot(browser, filepath) {
        var _this16 = this;

        return (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee19() {
            var absoluteFilepath, screenBuffer, _ref7, contexts, _ref8, data, screenshot;

            return _regenerator2.default.wrap(function _callee19$(_context19) {
                while (1) {
                    switch (_context19.prev = _context19.next) {
                        case 0:
                            if (!(typeof filepath !== 'string' || !filepath.endsWith('.png'))) {
                                _context19.next = 2;
                                break;
                            }

                            throw new Error('saveScreenshot expects a filepath of type string and ".png" file ending');

                        case 2:
                            absoluteFilepath = _this16._getAbsoluteFilepath(filepath);
                            _context19.next = 5;
                            return _this16._assertDirectoryExists(absoluteFilepath);

                        case 5:
                            screenBuffer = void 0;

                            if (!browser.isBidi) {
                                _context19.next = 18;
                                break;
                            }

                            _context19.next = 9;
                            return browser.browsingContextGetTree({});

                        case 9:
                            _ref7 = _context19.sent;
                            contexts = _ref7.contexts;
                            _context19.next = 13;
                            return browser.browsingContextCaptureScreenshot({
                                context: contexts[0].context
                            });

                        case 13:
                            _ref8 = _context19.sent;
                            data = _ref8.data;


                            screenBuffer = data;
                            _context19.next = 21;
                            break;

                        case 18:
                            _context19.next = 20;
                            return browser.takeScreenshot();

                        case 20:
                            screenBuffer = _context19.sent;

                        case 21:
                            screenshot = Buffer.from(screenBuffer, 'base64');


                            fs.writeFileSync(absoluteFilepath, screenshot);

                            return _context19.abrupt('return', screenshot);

                        case 24:
                        case 'end':
                            return _context19.stop();
                    }
                }
            }, _callee19, _this16);
        }))();
    },
    _getAbsoluteFilepath: function _getAbsoluteFilepath(filepath) {
        return filepath.startsWith('/') || filepath.startsWith('\\') || filepath.match(/^[a-zA-Z]:\\/) ? filepath : _path2.default.join(process.cwd(), filepath);
    },
    _assertDirectoryExists: function _assertDirectoryExists(filepath) {
        var _this17 = this;

        return (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee20() {
            var exist;
            return _regenerator2.default.wrap(function _callee20$(_context20) {
                while (1) {
                    switch (_context20.prev = _context20.next) {
                        case 0:
                            _context20.next = 2;
                            return access(_path2.default.dirname(filepath)).then(function () {
                                return true;
                            }, function () {
                                return false;
                            });

                        case 2:
                            exist = _context20.sent;

                            if (exist) {
                                _context20.next = 5;
                                break;
                            }

                            throw new Error('directory (' + _path2.default.dirname(filepath) + ') doesn\'t exist');

                        case 5:
                        case 'end':
                            return _context20.stop();
                    }
                }
            }, _callee20, _this17);
        }))();
    },
    reportJobResult: function reportJobResult(id, jobResult, jobData) {
        var _this18 = this;

        return (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee21() {
            var connector, jobPassed, status;
            return _regenerator2.default.wrap(function _callee21$(_context21) {
                while (1) {
                    switch (_context21.prev = _context21.next) {
                        case 0:
                            if (!(jobResult !== _this18.JOB_RESULT.done && jobResult !== _this18.JOB_RESULT.errored)) {
                                _context21.next = 2;
                                break;
                            }

                            return _context21.abrupt('return');

                        case 2:
                            _context21.next = 4;
                            return _this18._getConnector();

                        case 4:
                            connector = _context21.sent;
                            jobPassed = jobResult === _this18.JOB_RESULT.done && jobData.total === jobData.passed;
                            status = jobPassed ? 'passed' : 'failed';
                            _context21.next = 9;
                            return connector.setSauceJobStatus(_this18.openedBrowsers[id], status);

                        case 9:
                        case 'end':
                            return _context21.stop();
                    }
                }
            }, _callee21, _this18);
        }))();
    }
};
module.exports = exports['default'];