testcafe/lib/runner/browser-set.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const events_1 = require("events");
const time_limit_promise_1 = __importDefault(require("time-limit-promise"));
const promisify_event_1 = __importDefault(require("promisify-event"));
const lodash_1 = require("lodash");
const map_reverse_1 = __importDefault(require("map-reverse"));
const runtime_1 = require("../errors/runtime");
const types_1 = require("../errors/types");
const LOCAL_BROWSERS_READY_TIMEOUT = 2 * 60 * 1000;
const REMOTE_BROWSERS_READY_TIMEOUT = 6 * 60 * 1000;
class BrowserSet extends events_1.EventEmitter {
    constructor(browserConnectionGroups) {
        super();
        this.RELEASE_TIMEOUT = 10000;
        this.pendingReleases = [];
        this.browserConnectionGroups = browserConnectionGroups;
        this.browserConnections = lodash_1.flatten(browserConnectionGroups);
        this.connectionsReadyTimeout = null;
        this.browserErrorHandler = error => this.emit('error', error);
        this.browserConnections.forEach(bc => bc.on('error', this.browserErrorHandler));
        // NOTE: We're setting an empty error handler, because Node kills the process on an 'error' event
        // if there is no handler. See: https://nodejs.org/api/events.html#events_class_events_eventemitter
        this.on('error', lodash_1.noop);
    }
    static async _waitIdle(bc) {
        if (bc.idle || !bc.ready)
            return;
        await promisify_event_1.default(bc, 'idle');
    }
    static async _closeConnection(bc) {
        if (bc.closed || !bc.ready)
            return;
        bc.close();
        await promisify_event_1.default(bc, 'closed');
    }
    async _getReadyTimeout() {
        const isLocalBrowser = connection => connection.provider.isLocalBrowser(connection.id, connection.browserInfo.browserName);
        const remoteBrowsersExist = (await Promise.all(this.browserConnections.map(isLocalBrowser))).indexOf(false) > -1;
        return remoteBrowsersExist ? REMOTE_BROWSERS_READY_TIMEOUT : LOCAL_BROWSERS_READY_TIMEOUT;
    }
    _createPendingConnectionPromise(readyPromise, timeout, timeoutError) {
        const timeoutPromise = new Promise((_, reject) => {
            this.connectionsReadyTimeout = setTimeout(() => reject(timeoutError), timeout);
        });
        return Promise
            .race([readyPromise, timeoutPromise])
            .then(value => {
            this.connectionsReadyTimeout.unref();
            return value;
        }, error => {
            this.connectionsReadyTimeout.unref();
            throw error;
        });
    }
    async _waitConnectionsOpened() {
        const connectionsReadyPromise = Promise.all(this.browserConnections
            .filter(bc => !bc.opened)
            .map(bc => promisify_event_1.default(bc, 'opened')));
        const timeoutError = new runtime_1.GeneralError(types_1.RUNTIME_ERRORS.cannotEstablishBrowserConnection);
        const readyTimeout = await this._getReadyTimeout();
        await this._createPendingConnectionPromise(connectionsReadyPromise, readyTimeout, timeoutError);
    }
    _checkForDisconnections() {
        const disconnectedUserAgents = this.browserConnections
            .filter(bc => bc.closed)
            .map(bc => bc.userAgent);
        if (disconnectedUserAgents.length)
            throw new runtime_1.GeneralError(types_1.RUNTIME_ERRORS.cannotRunAgainstDisconnectedBrowsers, disconnectedUserAgents.join(', '));
    }
    //API
    static from(browserConnections) {
        const browserSet = new BrowserSet(browserConnections);
        const prepareConnection = Promise.resolve()
            .then(() => {
            browserSet._checkForDisconnections();
            return browserSet._waitConnectionsOpened();
        })
            .then(() => browserSet);
        return Promise
            .race([
            prepareConnection,
            promisify_event_1.default(browserSet, 'error')
        ])
            .catch(async (error) => {
            await browserSet.dispose();
            throw error;
        });
    }
    releaseConnection(bc) {
        if (this.browserConnections.indexOf(bc) < 0)
            return Promise.resolve();
        lodash_1.pull(this.browserConnections, bc);
        bc.removeListener('error', this.browserErrorHandler);
        const appropriateStateSwitch = !bc.permanent ?
            BrowserSet._closeConnection(bc) :
            BrowserSet._waitIdle(bc);
        const release = time_limit_promise_1.default(appropriateStateSwitch, this.RELEASE_TIMEOUT).then(() => lodash_1.pull(this.pendingReleases, release));
        this.pendingReleases.push(release);
        return release;
    }
    async dispose() {
        // NOTE: When browserConnection is cancelled, it is removed from
        // the this.connections array, which leads to shifting indexes
        // towards the beginning. So, we must copy the array in order to iterate it,
        // or we can perform iteration from the end to the beginning.
        if (this.connectionsReadyTimeout)
            this.connectionsReadyTimeout.unref();
        map_reverse_1.default(this.browserConnections, bc => this.releaseConnection(bc));
        await Promise.all(this.pendingReleases);
    }
}
exports.default = BrowserSet;
module.exports = exports.default;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"browser-set.js","sourceRoot":"","sources":["../../src/runner/browser-set.js"],"names":[],"mappings":";;;;;AAAA,mCAAsC;AACtC,4EAAuD;AACvD,sEAA6C;AAC7C,mCAAuD;AACvD,8DAAqC;AACrC,+CAAiD;AACjD,2CAAiD;AAEjD,MAAM,4BAA4B,GAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;AACpD,MAAM,6BAA6B,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;AAEpD,MAAqB,UAAW,SAAQ,qBAAY;IAChD,YAAa,uBAAuB;QAChC,KAAK,EAAE,CAAC;QAER,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;QAE7B,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;QAE1B,IAAI,CAAC,uBAAuB,GAAG,uBAAuB,CAAC;QACvD,IAAI,CAAC,kBAAkB,GAAQ,gBAAO,CAAC,uBAAuB,CAAC,CAAC;QAEhE,IAAI,CAAC,uBAAuB,GAAG,IAAI,CAAC;QAEpC,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAE9D,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,mBAAmB,CAAC,CAAC,CAAC;QAEhF,iGAAiG;QACjG,mGAAmG;QACnG,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,aAAI,CAAC,CAAC;IAC3B,CAAC;IAED,MAAM,CAAC,KAAK,CAAC,SAAS,CAAE,EAAE;QACtB,IAAI,EAAE,CAAC,IAAI,IAAI,CAAC,EAAE,CAAC,KAAK;YACpB,OAAO;QAEX,MAAM,yBAAc,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;IACrC,CAAC;IAED,MAAM,CAAC,KAAK,CAAC,gBAAgB,CAAE,EAAE;QAC7B,IAAI,EAAE,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC,KAAK;YACtB,OAAO;QAEX,EAAE,CAAC,KAAK,EAAE,CAAC;QAEX,MAAM,yBAAc,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC;IACvC,CAAC;IAED,KAAK,CAAC,gBAAgB;QAClB,MAAM,cAAc,GAAQ,UAAU,CAAC,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,cAAc,CAAC,UAAU,CAAC,EAAE,EAAE,UAAU,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;QAChI,MAAM,mBAAmB,GAAG,CAAC,MAAM,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;QAEjH,OAAO,mBAAmB,CAAC,CAAC,CAAC,6BAA6B,CAAC,CAAC,CAAC,4BAA4B,CAAC;IAC9F,CAAC;IAED,+BAA+B,CAAE,YAAY,EAAE,OAAO,EAAE,YAAY;QAChE,MAAM,cAAc,GAAG,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE;YAC7C,IAAI,CAAC,uBAAuB,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC,CAAC;QACnF,CAAC,CAAC,CAAC;QAEH,OAAO,OAAO;aACT,IAAI,CAAC,CAAC,YAAY,EAAE,cAAc,CAAC,CAAC;aACpC,IAAI,CACD,KAAK,CAAC,EAAE;YACJ,IAAI,CAAC,uBAAuB,CAAC,KAAK,EAAE,CAAC;YACrC,OAAO,KAAK,CAAC;QACjB,CAAC,EACD,KAAK,CAAC,EAAE;YACJ,IAAI,CAAC,uBAAuB,CAAC,KAAK,EAAE,CAAC;YACrC,MAAM,KAAK,CAAC;QAChB,CAAC,CACJ,CAAC;IACV,CAAC;IAED,KAAK,CAAC,sBAAsB;QACxB,MAAM,uBAAuB,GAAG,OAAO,CAAC,GAAG,CACvC,IAAI,CAAC,kBAAkB;aAClB,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC;aACxB,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,yBAAc,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC,CAC/C,CAAC;QAEF,MAAM,YAAY,GAAG,IAAI,sBAAY,CAAC,sBAAc,CAAC,gCAAgC,CAAC,CAAC;QACvF,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAEnD,MAAM,IAAI,CAAC,+BAA+B,CAAC,uBAAuB,EAAE,YAAY,EAAE,YAAY,CAAC,CAAC;IACpG,CAAC;IAED,uBAAuB;QACnB,MAAM,sBAAsB,GAAG,IAAI,CAAC,kBAAkB;aACjD,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,MAAM,CAAC;aACvB,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC;QAE7B,IAAI,sBAAsB,CAAC,MAAM;YAC7B,MAAM,IAAI,sBAAY,CAAC,sBAAc,CAAC,oCAAoC,EAAE,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IACvH,CAAC;IAGD,KAAK;IACL,MAAM,CAAC,IAAI,CAAE,kBAAkB;QAC3B,MAAM,UAAU,GAAG,IAAI,UAAU,CAAC,kBAAkB,CAAC,CAAC;QAEtD,MAAM,iBAAiB,GAAG,OAAO,CAAC,OAAO,EAAE;aACtC,IAAI,CAAC,GAAG,EAAE;YACP,UAAU,CAAC,uBAAuB,EAAE,CAAC;YACrC,OAAO,UAAU,CAAC,sBAAsB,EAAE,CAAC;QAC/C,CAAC,CAAC;aACD,IAAI,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,CAAC;QAE5B,OAAO,OAAO;aACT,IAAI,CAAC;YACF,iBAAiB;YACjB,yBAAc,CAAC,UAAU,EAAE,OAAO,CAAC;SACtC,CAAC;aACD,KAAK,CAAC,KAAK,EAAC,KAAK,EAAC,EAAE;YACjB,MAAM,UAAU,CAAC,OAAO,EAAE,CAAC;YAE3B,MAAM,KAAK,CAAC;QAChB,CAAC,CAAC,CAAC;IACX,CAAC;IAED,iBAAiB,CAAE,EAAE;QACjB,IAAI,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,EAAE,CAAC,GAAG,CAAC;YACvC,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;QAE7B,aAAM,CAAC,IAAI,CAAC,kBAAkB,EAAE,EAAE,CAAC,CAAC;QAEpC,EAAE,CAAC,cAAc,CAAC,OAAO,EAAE,IAAI,CAAC,mBAAmB,CAAC,CAAC;QAErD,MAAM,sBAAsB,GAAG,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC;YAC1C,UAAU,CAAC,gBAAgB,CAAC,EAAE,CAAC,CAAC,CAAC;YACjC,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;QAE7B,MAAM,OAAO,GAAG,4BAAqB,CAAC,sBAAsB,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,aAAM,CAAC,IAAI,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC,CAAC;QAEtI,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAEnC,OAAO,OAAO,CAAC;IACnB,CAAC;IAED,KAAK,CAAC,OAAO;QACT,gEAAgE;QAChE,8DAA8D;QAC9D,4EAA4E;QAC5E,6DAA6D;QAC7D,IAAI,IAAI,CAAC,uBAAuB;YAC5B,IAAI,CAAC,uBAAuB,CAAC,KAAK,EAAE,CAAC;QAEzC,qBAAU,CAAC,IAAI,CAAC,kBAAkB,EAAE,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC,CAAC;QAEtE,MAAM,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;IAC5C,CAAC;CACJ;AA7ID,6BA6IC","sourcesContent":["import { EventEmitter } from 'events';\nimport getTimeLimitedPromise from 'time-limit-promise';\nimport promisifyEvent from 'promisify-event';\nimport { noop, pull as remove, flatten } from 'lodash';\nimport mapReverse from 'map-reverse';\nimport { GeneralError } from '../errors/runtime';\nimport { RUNTIME_ERRORS } from '../errors/types';\n\nconst LOCAL_BROWSERS_READY_TIMEOUT  = 2 * 60 * 1000;\nconst REMOTE_BROWSERS_READY_TIMEOUT = 6 * 60 * 1000;\n\nexport default class BrowserSet extends EventEmitter {\n    constructor (browserConnectionGroups) {\n        super();\n\n        this.RELEASE_TIMEOUT = 10000;\n\n        this.pendingReleases = [];\n\n        this.browserConnectionGroups = browserConnectionGroups;\n        this.browserConnections      = flatten(browserConnectionGroups);\n\n        this.connectionsReadyTimeout = null;\n\n        this.browserErrorHandler = error => this.emit('error', error);\n\n        this.browserConnections.forEach(bc => bc.on('error', this.browserErrorHandler));\n\n        // NOTE: We're setting an empty error handler, because Node kills the process on an 'error' event\n        // if there is no handler. See: https://nodejs.org/api/events.html#events_class_events_eventemitter\n        this.on('error', noop);\n    }\n\n    static async _waitIdle (bc) {\n        if (bc.idle || !bc.ready)\n            return;\n\n        await promisifyEvent(bc, 'idle');\n    }\n\n    static async _closeConnection (bc) {\n        if (bc.closed || !bc.ready)\n            return;\n\n        bc.close();\n\n        await promisifyEvent(bc, 'closed');\n    }\n\n    async _getReadyTimeout () {\n        const isLocalBrowser      = connection => connection.provider.isLocalBrowser(connection.id, connection.browserInfo.browserName);\n        const remoteBrowsersExist = (await Promise.all(this.browserConnections.map(isLocalBrowser))).indexOf(false) > -1;\n\n        return remoteBrowsersExist ? REMOTE_BROWSERS_READY_TIMEOUT : LOCAL_BROWSERS_READY_TIMEOUT;\n    }\n\n    _createPendingConnectionPromise (readyPromise, timeout, timeoutError) {\n        const timeoutPromise = new Promise((_, reject) => {\n            this.connectionsReadyTimeout = setTimeout(() => reject(timeoutError), timeout);\n        });\n\n        return Promise\n            .race([readyPromise, timeoutPromise])\n            .then(\n                value => {\n                    this.connectionsReadyTimeout.unref();\n                    return value;\n                },\n                error => {\n                    this.connectionsReadyTimeout.unref();\n                    throw error;\n                }\n            );\n    }\n\n    async _waitConnectionsOpened () {\n        const connectionsReadyPromise = Promise.all(\n            this.browserConnections\n                .filter(bc => !bc.opened)\n                .map(bc => promisifyEvent(bc, 'opened'))\n        );\n\n        const timeoutError = new GeneralError(RUNTIME_ERRORS.cannotEstablishBrowserConnection);\n        const readyTimeout = await this._getReadyTimeout();\n\n        await this._createPendingConnectionPromise(connectionsReadyPromise, readyTimeout, timeoutError);\n    }\n\n    _checkForDisconnections () {\n        const disconnectedUserAgents = this.browserConnections\n            .filter(bc => bc.closed)\n            .map(bc => bc.userAgent);\n\n        if (disconnectedUserAgents.length)\n            throw new GeneralError(RUNTIME_ERRORS.cannotRunAgainstDisconnectedBrowsers, disconnectedUserAgents.join(', '));\n    }\n\n\n    //API\n    static from (browserConnections) {\n        const browserSet = new BrowserSet(browserConnections);\n\n        const prepareConnection = Promise.resolve()\n            .then(() => {\n                browserSet._checkForDisconnections();\n                return browserSet._waitConnectionsOpened();\n            })\n            .then(() => browserSet);\n\n        return Promise\n            .race([\n                prepareConnection,\n                promisifyEvent(browserSet, 'error')\n            ])\n            .catch(async error => {\n                await browserSet.dispose();\n\n                throw error;\n            });\n    }\n\n    releaseConnection (bc) {\n        if (this.browserConnections.indexOf(bc) < 0)\n            return Promise.resolve();\n\n        remove(this.browserConnections, bc);\n\n        bc.removeListener('error', this.browserErrorHandler);\n\n        const appropriateStateSwitch = !bc.permanent ?\n            BrowserSet._closeConnection(bc) :\n            BrowserSet._waitIdle(bc);\n\n        const release = getTimeLimitedPromise(appropriateStateSwitch, this.RELEASE_TIMEOUT).then(() => remove(this.pendingReleases, release));\n\n        this.pendingReleases.push(release);\n\n        return release;\n    }\n\n    async dispose () {\n        // NOTE: When browserConnection is cancelled, it is removed from\n        // the this.connections array, which leads to shifting indexes\n        // towards the beginning. So, we must copy the array in order to iterate it,\n        // or we can perform iteration from the end to the beginning.\n        if (this.connectionsReadyTimeout)\n            this.connectionsReadyTimeout.unref();\n\n        mapReverse(this.browserConnections, bc => this.releaseConnection(bc));\n\n        await Promise.all(this.pendingReleases);\n    }\n}\n"]}