testcafe 1.13.0 → 1.14.2

package/lib/runner/browser-set.js

@@ -1,116 +1,116 @@
-"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 runtime_1 = require("../errors/runtime");
-const types_1 = require("../errors/types");
-const status_1 = __importDefault(require("../browser/connection/status"));
-const get_hints_1 = __importDefault(require("../browser/connection/get-hints"));
-const string_1 = require("../utils/string");
-const RELEASE_TIMEOUT = 10000;
-class BrowserSet extends events_1.EventEmitter {
-    constructor(browserConnectionGroups, options) {
-        super();
-        this._pendingReleases = [];
-        this.browserConnectionGroups = browserConnectionGroups;
-        this._browserConnections = lodash_1.flatten(browserConnectionGroups);
-        this._options = options;
-        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.isReady())
-            return;
-        await promisify_event_1.default(bc, 'idle');
-    }
-    static async _closeConnection(bc) {
-        if (bc.status === status_1.default.closed || bc.status === status_1.default.closing)
-            return;
-        await bc.close();
-    }
-    async _waitConnectionOpened(bc) {
-        const openedTimeout = this._options.browserInitTimeout || await bc.getDefaultBrowserInitTimeout();
-        const timeoutErr = new runtime_1.GeneralError(types_1.RUNTIME_ERRORS.cannotEstablishBrowserConnection);
-        const openedOrError = Promise.race([
-            promisify_event_1.default(this, 'error'),
-            promisify_event_1.default(bc, 'opened')
-        ]);
-        return time_limit_promise_1.default(openedOrError, openedTimeout, { rejectWith: timeoutErr });
-    }
-    async _waitConnectionsOpened() {
-        return Promise.all(this._browserConnections
-            .filter(bc => bc.status !== status_1.default.opened)
-            .map(notOpenedConnection => this._waitConnectionOpened(notOpenedConnection)));
-    }
-    _checkForDisconnections() {
-        const disconnectedUserAgents = this._browserConnections
-            .filter(bc => bc.status === status_1.default.closed)
-            .map(bc => bc.userAgent);
-        if (disconnectedUserAgents.length)
-            throw new runtime_1.GeneralError(types_1.RUNTIME_ERRORS.cannotRunAgainstDisconnectedBrowsers, disconnectedUserAgents.join(', '));
-    }
-    async prepareConnections() {
-        await this._checkForDisconnections();
-        await this._waitConnectionsOpened();
-    }
-    // NOTE: creates and prepares BrowserSet instance with given browser connections
-    static async from(browserConnections, opts) {
-        const browserSet = new BrowserSet(browserConnections, opts);
-        try {
-            const prepareConnections = browserSet.prepareConnections();
-            const browserSetError = promisify_event_1.default(browserSet, 'error');
-            await Promise.race([prepareConnections, browserSetError]);
-            return browserSet;
-        }
-        catch (e) {
-            const finalError = e.code === types_1.RUNTIME_ERRORS.cannotEstablishBrowserConnection
-                ? browserSet.createBrowserConnectionError(e)
-                : e;
-            await browserSet.dispose();
-            throw finalError;
-        }
-    }
-    createBrowserConnectionError(error) {
-        const notOpenedConnections = this._browserConnections.filter(bc => bc.status !== status_1.default.opened);
-        const numOfAllConnections = this._browserConnections.length;
-        const numOfNotOpenedConnections = notOpenedConnections.length;
-        const listOfNotOpenedConnections = string_1.createList(notOpenedConnections.map(bc => bc.browserInfo.alias));
-        const listOfHints = string_1.createList(get_hints_1.default(this._browserConnections, this._options));
-        return new runtime_1.BrowserConnectionError(error.message, numOfNotOpenedConnections, numOfAllConnections, listOfNotOpenedConnections, listOfHints);
-    }
-    releaseConnection(bc) {
-        if (!this._browserConnections.includes(bc))
-            return Promise.resolve();
-        lodash_1.pull(this._browserConnections, bc);
-        bc.removeListener('error', this._browserErrorHandler);
-        const appropriateStateSwitch = bc.permanent ?
-            BrowserSet._waitIdle(bc) :
-            BrowserSet._closeConnection(bc);
-        const release = time_limit_promise_1.default(appropriateStateSwitch, 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.
-        this._browserConnections.reduceRight((_, bc) => {
-            this.releaseConnection(bc);
-            return bc;
-        }, {});
-        await Promise.all(this._pendingReleases);
-    }
-}
-exports.default = BrowserSet;
+"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 runtime_1 = require("../errors/runtime");
+const types_1 = require("../errors/types");
+const status_1 = __importDefault(require("../browser/connection/status"));
+const get_hints_1 = __importDefault(require("../browser/connection/get-hints"));
+const string_1 = require("../utils/string");
+const RELEASE_TIMEOUT = 10000;
+class BrowserSet extends events_1.EventEmitter {
+    constructor(browserConnectionGroups, options) {
+        super();
+        this._pendingReleases = [];
+        this.browserConnectionGroups = browserConnectionGroups;
+        this._browserConnections = lodash_1.flatten(browserConnectionGroups);
+        this._options = options;
+        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.isReady())
+            return;
+        await promisify_event_1.default(bc, 'idle');
+    }
+    static async _closeConnection(bc) {
+        if (bc.status === status_1.default.closed || bc.status === status_1.default.closing)
+            return;
+        await bc.close();
+    }
+    async _waitConnectionOpened(bc) {
+        const openedTimeout = this._options.browserInitTimeout || await bc.getDefaultBrowserInitTimeout();
+        const timeoutErr = new runtime_1.GeneralError(types_1.RUNTIME_ERRORS.cannotEstablishBrowserConnection);
+        const openedOrError = Promise.race([
+            promisify_event_1.default(this, 'error'),
+            promisify_event_1.default(bc, 'opened')
+        ]);
+        return time_limit_promise_1.default(openedOrError, openedTimeout, { rejectWith: timeoutErr });
+    }
+    async _waitConnectionsOpened() {
+        return Promise.all(this._browserConnections
+            .filter(bc => bc.status !== status_1.default.opened)
+            .map(notOpenedConnection => this._waitConnectionOpened(notOpenedConnection)));
+    }
+    _checkForDisconnections() {
+        const disconnectedUserAgents = this._browserConnections
+            .filter(bc => bc.status === status_1.default.closed)
+            .map(bc => bc.userAgent);
+        if (disconnectedUserAgents.length)
+            throw new runtime_1.GeneralError(types_1.RUNTIME_ERRORS.cannotRunAgainstDisconnectedBrowsers, disconnectedUserAgents.join(', '));
+    }
+    async prepareConnections() {
+        await this._checkForDisconnections();
+        await this._waitConnectionsOpened();
+    }
+    // NOTE: creates and prepares BrowserSet instance with given browser connections
+    static async from(browserConnections, opts) {
+        const browserSet = new BrowserSet(browserConnections, opts);
+        try {
+            const prepareConnections = browserSet.prepareConnections();
+            const browserSetError = promisify_event_1.default(browserSet, 'error');
+            await Promise.race([prepareConnections, browserSetError]);
+            return browserSet;
+        }
+        catch (e) {
+            const finalError = e.code === types_1.RUNTIME_ERRORS.cannotEstablishBrowserConnection
+                ? browserSet.createBrowserConnectionError(e)
+                : e;
+            await browserSet.dispose();
+            throw finalError;
+        }
+    }
+    createBrowserConnectionError(error) {
+        const notOpenedConnections = this._browserConnections.filter(bc => bc.status !== status_1.default.opened);
+        const numOfAllConnections = this._browserConnections.length;
+        const numOfNotOpenedConnections = notOpenedConnections.length;
+        const listOfNotOpenedConnections = string_1.createList(notOpenedConnections.map(bc => bc.browserInfo.alias));
+        const listOfHints = string_1.createList(get_hints_1.default(this._browserConnections, this._options));
+        return new runtime_1.BrowserConnectionError(error.message, numOfNotOpenedConnections, numOfAllConnections, listOfNotOpenedConnections, listOfHints);
+    }
+    releaseConnection(bc) {
+        if (!this._browserConnections.includes(bc))
+            return Promise.resolve();
+        lodash_1.pull(this._browserConnections, bc);
+        bc.removeListener('error', this._browserErrorHandler);
+        const appropriateStateSwitch = bc.permanent ?
+            BrowserSet._waitIdle(bc) :
+            BrowserSet._closeConnection(bc);
+        const release = time_limit_promise_1.default(appropriateStateSwitch, 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.
+        this._browserConnections.reduceRight((_, bc) => {
+            this.releaseConnection(bc);
+            return 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.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitter } from 'events';\nimport getTimeLimitedPromise from 'time-limit-promise';\nimport promisifyEvent from 'promisify-event';\nimport {\n    flatten,\n    noop,\n    pull as remove\n} from 'lodash';\n\nimport { BrowserConnectionError, GeneralError } from '../errors/runtime';\nimport { RUNTIME_ERRORS } from '../errors/types';\nimport BrowserConnection from '../browser/connection';\nimport BrowserConnectionStatus from '../browser/connection/status';\nimport { BrowserSetOptions } from './interfaces';\nimport getBrowserConnectionHints from '../browser/connection/get-hints';\nimport { createList } from '../utils/string';\n\nconst RELEASE_TIMEOUT = 10000;\n\nexport default class BrowserSet extends EventEmitter {\n    private readonly _browserConnections: BrowserConnection[];\n    private readonly _browserErrorHandler: (error: Error) => void;\n    private readonly _pendingReleases: Promise<void>[];\n    private readonly _options: BrowserSetOptions;\n    public browserConnectionGroups: BrowserConnection[][];\n\n    public constructor (browserConnectionGroups: BrowserConnection[][], options: BrowserSetOptions) {\n        super();\n\n        this._pendingReleases         = [];\n        this.browserConnectionGroups  = browserConnectionGroups;\n        this._browserConnections      = flatten(browserConnectionGroups);\n        this._options                 = options;\n\n        this._browserErrorHandler = (error: 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    private static async _waitIdle (bc: BrowserConnection): Promise<void> {\n        if (bc.idle || !bc.isReady())\n            return;\n\n        await promisifyEvent(bc, 'idle');\n    }\n\n    private static async _closeConnection (bc: BrowserConnection): Promise<void> {\n        if (bc.status === BrowserConnectionStatus.closed || bc.status === BrowserConnectionStatus.closing)\n            return;\n\n        await bc.close();\n    }\n\n    private async _waitConnectionOpened (bc: BrowserConnection): Promise<BrowserConnection> {\n        const openedTimeout = this._options.browserInitTimeout || await bc.getDefaultBrowserInitTimeout();\n        const timeoutErr    = new GeneralError(RUNTIME_ERRORS.cannotEstablishBrowserConnection);\n        const openedOrError = Promise.race([\n            promisifyEvent(this, 'error'),\n            promisifyEvent(bc, 'opened')\n        ]);\n\n        return getTimeLimitedPromise(openedOrError, openedTimeout, { rejectWith: timeoutErr });\n    }\n\n    private async _waitConnectionsOpened (): Promise<BrowserConnection[]> {\n        return Promise.all(\n            this._browserConnections\n                .filter(bc => bc.status !== BrowserConnectionStatus.opened)\n                .map(notOpenedConnection => this._waitConnectionOpened(notOpenedConnection))\n        );\n    }\n\n    private _checkForDisconnections (): void {\n        const disconnectedUserAgents = this._browserConnections\n            .filter(bc => bc.status === BrowserConnectionStatus.closed)\n            .map(bc => bc.userAgent);\n\n        if (disconnectedUserAgents.length)\n            throw new GeneralError(RUNTIME_ERRORS.cannotRunAgainstDisconnectedBrowsers, disconnectedUserAgents.join(', '));\n    }\n\n    public async prepareConnections (): Promise<void> {\n        await this._checkForDisconnections();\n        await this._waitConnectionsOpened();\n    }\n\n    // NOTE: creates and prepares BrowserSet instance with given browser connections\n    public static async from (browserConnections: BrowserConnection[][], opts: BrowserSetOptions): Promise<BrowserSet> {\n        const browserSet = new BrowserSet(browserConnections, opts);\n\n        try {\n            const prepareConnections = browserSet.prepareConnections();\n            const browserSetError    = promisifyEvent(browserSet, 'error');\n\n            await Promise.race([ prepareConnections, browserSetError ]);\n\n            return browserSet;\n        }\n        catch (e) {\n            const finalError = e.code === RUNTIME_ERRORS.cannotEstablishBrowserConnection\n                ? browserSet.createBrowserConnectionError(e)\n                : e;\n\n            await browserSet.dispose();\n\n            throw finalError;\n        }\n    }\n\n    public createBrowserConnectionError (error: Error): BrowserConnectionError {\n        const notOpenedConnections = this._browserConnections.filter(bc => bc.status !== BrowserConnectionStatus.opened);\n\n        const numOfAllConnections       = this._browserConnections.length;\n        const numOfNotOpenedConnections = notOpenedConnections.length;\n\n        const listOfNotOpenedConnections = createList(notOpenedConnections.map(bc => bc.browserInfo.alias));\n        const listOfHints                = createList(getBrowserConnectionHints(this._browserConnections, this._options));\n\n        return new BrowserConnectionError(\n            error.message,\n            numOfNotOpenedConnections,\n            numOfAllConnections,\n            listOfNotOpenedConnections,\n            listOfHints\n        );\n    }\n\n    public releaseConnection (bc: BrowserConnection): Promise<void> {\n        if (!this._browserConnections.includes(bc))\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._waitIdle(bc) :\n            BrowserSet._closeConnection(bc);\n\n        const release = getTimeLimitedPromise(appropriateStateSwitch, RELEASE_TIMEOUT)\n            .then(() => remove(this._pendingReleases, release)) as Promise<void>;\n\n        this._pendingReleases.push(release);\n\n        return release;\n    }\n\n    public async dispose (): Promise<void> {\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        this._browserConnections.reduceRight((_, bc) => {\n            this.releaseConnection(bc);\n\n            return bc;\n        }, {});\n\n        await Promise.all(this._pendingReleases);\n    }\n}\n"]}

package/lib/runner/fixture-hook-controller.js

@@ -1,87 +1,87 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const phase_1 = __importDefault(require("../test-run/phase"));
-const process_test_fn_error_1 = __importDefault(require("../errors/process-test-fn-error"));
-class FixtureHookController {
-    constructor(tests, browserConnectionCount) {
-        this._fixtureMap = FixtureHookController._createFixtureMap(tests, browserConnectionCount);
-    }
-    static _ensureFixtureMapItem(fixtureMap, fixture) {
-        if (!fixtureMap.has(fixture)) {
-            const item = {
-                started: false,
-                runningFixtureBeforeHook: false,
-                fixtureBeforeHookErr: null,
-                pendingTestRunCount: 0,
-                fixtureCtx: Object.create(null)
-            };
-            fixtureMap.set(fixture, item);
-        }
-    }
-    static _createFixtureMap(tests, browserConnectionCount) {
-        return tests.reduce((fixtureMap, test) => {
-            const fixture = test.fixture;
-            if (!test.skip) {
-                FixtureHookController._ensureFixtureMapItem(fixtureMap, fixture);
-                const item = fixtureMap.get(fixture);
-                item.pendingTestRunCount += browserConnectionCount;
-            }
-            return fixtureMap;
-        }, new Map());
-    }
-    _getFixtureMapItem(test) {
-        return test.skip ? null : this._fixtureMap.get(test.fixture);
-    }
-    isTestBlocked(test) {
-        const item = this._getFixtureMapItem(test);
-        return !!item && item.runningFixtureBeforeHook;
-    }
-    async runFixtureBeforeHookIfNecessary(testRun) {
-        const fixture = testRun.test.fixture;
-        const item = this._getFixtureMapItem(testRun.test);
-        if (item) {
-            const shouldRunBeforeHook = !item.started && fixture.beforeFn;
-            item.started = true;
-            if (shouldRunBeforeHook) {
-                item.runningFixtureBeforeHook = true;
-                try {
-                    await fixture.beforeFn(item.fixtureCtx);
-                }
-                catch (err) {
-                    item.fixtureBeforeHookErr = process_test_fn_error_1.default(err);
-                }
-                item.runningFixtureBeforeHook = false;
-            }
-            // NOTE: fail all tests in fixture if fixture.before hook has error
-            if (item.fixtureBeforeHookErr) {
-                testRun.phase = phase_1.default.inFixtureBeforeHook;
-                testRun.addError(item.fixtureBeforeHookErr);
-                return false;
-            }
-            testRun.fixtureCtx = item.fixtureCtx;
-        }
-        return true;
-    }
-    async runFixtureAfterHookIfNecessary(testRun) {
-        const fixture = testRun.test.fixture;
-        const item = this._getFixtureMapItem(testRun.test);
-        if (item) {
-            item.pendingTestRunCount--;
-            if (item.pendingTestRunCount === 0 && fixture.afterFn) {
-                testRun.phase = phase_1.default.inFixtureAfterHook;
-                try {
-                    await fixture.afterFn(item.fixtureCtx);
-                }
-                catch (err) {
-                    testRun.addError(process_test_fn_error_1.default(err));
-                }
-            }
-        }
-    }
-}
-exports.default = FixtureHookController;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const phase_1 = __importDefault(require("../test-run/phase"));
+const process_test_fn_error_1 = __importDefault(require("../errors/process-test-fn-error"));
+class FixtureHookController {
+    constructor(tests, browserConnectionCount) {
+        this._fixtureMap = FixtureHookController._createFixtureMap(tests, browserConnectionCount);
+    }
+    static _ensureFixtureMapItem(fixtureMap, fixture) {
+        if (!fixtureMap.has(fixture)) {
+            const item = {
+                started: false,
+                runningFixtureBeforeHook: false,
+                fixtureBeforeHookErr: null,
+                pendingTestRunCount: 0,
+                fixtureCtx: Object.create(null)
+            };
+            fixtureMap.set(fixture, item);
+        }
+    }
+    static _createFixtureMap(tests, browserConnectionCount) {
+        return tests.reduce((fixtureMap, test) => {
+            const fixture = test.fixture;
+            if (!test.skip) {
+                FixtureHookController._ensureFixtureMapItem(fixtureMap, fixture);
+                const item = fixtureMap.get(fixture);
+                item.pendingTestRunCount += browserConnectionCount;
+            }
+            return fixtureMap;
+        }, new Map());
+    }
+    _getFixtureMapItem(test) {
+        return test.skip ? null : this._fixtureMap.get(test.fixture);
+    }
+    isTestBlocked(test) {
+        const item = this._getFixtureMapItem(test);
+        return !!item && item.runningFixtureBeforeHook;
+    }
+    async runFixtureBeforeHookIfNecessary(testRun) {
+        const fixture = testRun.test.fixture;
+        const item = this._getFixtureMapItem(testRun.test);
+        if (item) {
+            const shouldRunBeforeHook = !item.started && fixture.beforeFn;
+            item.started = true;
+            if (shouldRunBeforeHook) {
+                item.runningFixtureBeforeHook = true;
+                try {
+                    await fixture.beforeFn(item.fixtureCtx);
+                }
+                catch (err) {
+                    item.fixtureBeforeHookErr = process_test_fn_error_1.default(err);
+                }
+                item.runningFixtureBeforeHook = false;
+            }
+            // NOTE: fail all tests in fixture if fixture.before hook has error
+            if (item.fixtureBeforeHookErr) {
+                testRun.phase = phase_1.default.inFixtureBeforeHook;
+                testRun.addError(item.fixtureBeforeHookErr);
+                return false;
+            }
+            testRun.fixtureCtx = item.fixtureCtx;
+        }
+        return true;
+    }
+    async runFixtureAfterHookIfNecessary(testRun) {
+        const fixture = testRun.test.fixture;
+        const item = this._getFixtureMapItem(testRun.test);
+        if (item) {
+            item.pendingTestRunCount--;
+            if (item.pendingTestRunCount === 0 && fixture.afterFn) {
+                testRun.phase = phase_1.default.inFixtureAfterHook;
+                try {
+                    await fixture.afterFn(item.fixtureCtx);
+                }
+                catch (err) {
+                    testRun.addError(process_test_fn_error_1.default(err));
+                }
+            }
+        }
+    }
+}
+exports.default = FixtureHookController;
 module.exports = exports.default;
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fixture-hook-controller.js","sourceRoot":"","sources":["../../src/runner/fixture-hook-controller.ts"],"names":[],"mappings":"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","sourcesContent":["import TEST_RUN_PHASE from '../test-run/phase';\nimport processTestFnError from '../errors/process-test-fn-error';\nimport Test from '../api/structure/test';\nimport Fixture from '../api/structure/fixture';\nimport TestRun from '../test-run';\n\ninterface FixtureState {\n    started: boolean;\n    runningFixtureBeforeHook: boolean;\n    fixtureBeforeHookErr: null | Error;\n    pendingTestRunCount: number;\n    fixtureCtx: object;\n}\n\nexport default class FixtureHookController {\n    private readonly _fixtureMap: Map<Fixture, FixtureState>;\n\n    public constructor (tests: Test[], browserConnectionCount: number) {\n        this._fixtureMap = FixtureHookController._createFixtureMap(tests, browserConnectionCount);\n    }\n\n    private static _ensureFixtureMapItem (fixtureMap: Map<Fixture, FixtureState>, fixture: Fixture): void {\n        if (!fixtureMap.has(fixture)) {\n            const item = {\n                started:                  false,\n                runningFixtureBeforeHook: false,\n                fixtureBeforeHookErr:     null,\n                pendingTestRunCount:      0,\n                fixtureCtx:               Object.create(null)\n            };\n\n            fixtureMap.set(fixture, item);\n        }\n    }\n\n    private static _createFixtureMap (tests: Test[], browserConnectionCount: number): Map<Fixture, FixtureState> {\n        return tests.reduce((fixtureMap, test) => {\n            const fixture = test.fixture;\n\n            if (!test.skip) {\n                FixtureHookController._ensureFixtureMapItem(fixtureMap, fixture);\n\n                const item = fixtureMap.get(fixture);\n\n                item.pendingTestRunCount += browserConnectionCount;\n            }\n\n            return fixtureMap;\n        }, new Map());\n    }\n\n    private _getFixtureMapItem (test: Test): null | FixtureState | undefined {\n        return test.skip ? null : this._fixtureMap.get(test.fixture);\n    }\n\n    public isTestBlocked (test: Test): boolean {\n        const item = this._getFixtureMapItem(test);\n\n        return !!item && item.runningFixtureBeforeHook;\n    }\n\n    public async runFixtureBeforeHookIfNecessary (testRun: TestRun): Promise<boolean> {\n        const fixture = testRun.test.fixture;\n        const item    = this._getFixtureMapItem(testRun.test);\n\n        if (item) {\n            const shouldRunBeforeHook = !item.started && fixture.beforeFn;\n\n            item.started = true;\n\n            if (shouldRunBeforeHook) {\n                item.runningFixtureBeforeHook = true;\n\n                try {\n                    await fixture.beforeFn(item.fixtureCtx);\n                }\n                catch (err) {\n                    item.fixtureBeforeHookErr = processTestFnError(err);\n                }\n\n                item.runningFixtureBeforeHook = false;\n            }\n\n            // NOTE: fail all tests in fixture if fixture.before hook has error\n            if (item.fixtureBeforeHookErr) {\n                testRun.phase = TEST_RUN_PHASE.inFixtureBeforeHook;\n\n                testRun.addError(item.fixtureBeforeHookErr);\n\n                return false;\n            }\n\n            testRun.fixtureCtx = item.fixtureCtx;\n        }\n\n        return true;\n    }\n\n    public async runFixtureAfterHookIfNecessary (testRun: TestRun): Promise<void> {\n        const fixture = testRun.test.fixture;\n        const item    = this._getFixtureMapItem(testRun.test);\n\n        if (item) {\n            item.pendingTestRunCount--;\n\n            if (item.pendingTestRunCount === 0 && fixture.afterFn) {\n                testRun.phase = TEST_RUN_PHASE.inFixtureAfterHook;\n\n                try {\n                    await fixture.afterFn(item.fixtureCtx);\n                }\n                catch (err) {\n                    testRun.addError(processTestFnError(err));\n                }\n            }\n        }\n    }\n}\n"]}