testcafe 1.14.1 → 1.14.2

package/lib/runner/browser-job-result.js

@@ -1,11 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var BrowserJobResult;
-(function (BrowserJobResult) {
-    BrowserJobResult["done"] = "browser-job-done";
-    BrowserJobResult["errored"] = "browser-job-errored";
-    BrowserJobResult["aborted"] = "browser-job-aborted";
-})(BrowserJobResult || (BrowserJobResult = {}));
-exports.default = BrowserJobResult;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var BrowserJobResult;
+(function (BrowserJobResult) {
+    BrowserJobResult["done"] = "browser-job-done";
+    BrowserJobResult["errored"] = "browser-job-errored";
+    BrowserJobResult["aborted"] = "browser-job-aborted";
+})(BrowserJobResult || (BrowserJobResult = {}));
+exports.default = BrowserJobResult;
 module.exports = exports.default;
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJvd3Nlci1qb2ItcmVzdWx0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3J1bm5lci9icm93c2VyLWpvYi1yZXN1bHQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxJQUFLLGdCQUlKO0FBSkQsV0FBSyxnQkFBZ0I7SUFDakIsNkNBQXlCLENBQUE7SUFDekIsbURBQStCLENBQUE7SUFDL0IsbURBQStCLENBQUE7QUFDbkMsQ0FBQyxFQUpJLGdCQUFnQixLQUFoQixnQkFBZ0IsUUFJcEI7QUFFRCxrQkFBZSxnQkFBZ0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImVudW0gQnJvd3NlckpvYlJlc3VsdCB7XG4gICAgZG9uZSA9ICdicm93c2VyLWpvYi1kb25lJyxcbiAgICBlcnJvcmVkID0gJ2Jyb3dzZXItam9iLWVycm9yZWQnLFxuICAgIGFib3J0ZWQgPSAnYnJvd3Nlci1qb2ItYWJvcnRlZCdcbn1cblxuZXhwb3J0IGRlZmF1bHQgQnJvd3NlckpvYlJlc3VsdDtcbiJdfQ==

package/lib/runner/browser-job.js

@@ -1,154 +1,154 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const lodash_1 = require("lodash");
-const async_event_emitter_1 = __importDefault(require("../utils/async-event-emitter"));
-const test_run_controller_1 = __importDefault(require("./test-run-controller"));
-const session_controller_1 = __importDefault(require("../test-run/session-controller"));
-const browser_job_result_1 = __importDefault(require("./browser-job-result"));
-class BrowserJob extends async_event_emitter_1.default {
-    constructor({ tests, browserConnections, proxy, screenshots, warningLog, fixtureHookController, opts, compilerService }) {
-        super();
-        this._started = false;
-        this._total = 0;
-        this._passed = 0;
-        this._opts = opts;
-        this._proxy = proxy;
-        this.browserConnections = browserConnections;
-        this._screenshots = screenshots;
-        this.warningLog = warningLog;
-        this.fixtureHookController = fixtureHookController;
-        this._result = null;
-        this._testRunControllerQueue = tests.map((test, index) => this._createTestRunController(test, index, compilerService));
-        this._completionQueue = [];
-        this._reportsPending = [];
-        this._connectionErrorListener = (error) => this._setResult(browser_job_result_1.default.errored, error);
-        this._resolveWaitingLastTestInFixture = null;
-        this.browserConnections.map(bc => bc.once('error', this._connectionErrorListener));
-    }
-    _createTestRunController(test, index, compilerService) {
-        const testRunController = new test_run_controller_1.default({
-            test,
-            index: index + 1,
-            proxy: this._proxy,
-            screenshots: this._screenshots,
-            warningLog: this.warningLog,
-            fixtureHookController: this.fixtureHookController,
-            opts: this._opts,
-            compilerService
-        });
-        testRunController.on('test-run-create', async (testRunInfo) => {
-            await this.emit('test-run-create', testRunInfo);
-        });
-        testRunController.on('test-run-start', async () => {
-            await this.emit('test-run-start', testRunController.testRun);
-        });
-        testRunController.on('test-run-ready', async () => {
-            await this.emit('test-run-ready', testRunController);
-        });
-        testRunController.on('test-run-restart', async () => this._onTestRunRestart(testRunController));
-        testRunController.on('test-run-before-done', async () => {
-            await this.emit('test-run-before-done', testRunController);
-        });
-        testRunController.on('test-run-done', async () => this._onTestRunDone(testRunController));
-        testRunController.on('test-action-start', async (args) => {
-            await this.emit('test-action-start', args);
-        });
-        testRunController.on('test-action-done', async (args) => {
-            await this.emit('test-action-done', args);
-        });
-        return testRunController;
-    }
-    async _setResult(status, data) {
-        if (this._result)
-            return;
-        this._result = { status, data };
-        this.browserConnections.forEach(bc => bc.removeListener('error', this._connectionErrorListener));
-        await Promise.all(this.browserConnections.map(bc => bc.reportJobResult(this._result.status, this._result.data)));
-    }
-    _addToCompletionQueue(testRunInfo) {
-        this._completionQueue.push(testRunInfo);
-    }
-    _removeFromCompletionQueue(testRunInfo) {
-        lodash_1.pull(this._completionQueue, testRunInfo);
-    }
-    _onTestRunRestart(testRunController) {
-        this._removeFromCompletionQueue(testRunController);
-        this._testRunControllerQueue.unshift(testRunController);
-    }
-    async _onTestRunDone(testRunController) {
-        this._total++;
-        if (!testRunController.testRun.errs.length)
-            this._passed++;
-        while (this._completionQueue.length && this._completionQueue[0].done) {
-            testRunController = this._completionQueue.shift();
-            await this.emit('test-run-done', testRunController.testRun);
-            lodash_1.pull(this._reportsPending, testRunController);
-            if (!this._reportsPending.length && this._resolveWaitingLastTestInFixture) {
-                this._resolveWaitingLastTestInFixture();
-                this._resolveWaitingLastTestInFixture = null;
-            }
-        }
-        if (!this._completionQueue.length && !this.hasQueuedTestRuns) {
-            if (!this._opts.live)
-                session_controller_1.default.closeSession(testRunController.testRun);
-            this
-                ._setResult(browser_job_result_1.default.done, { total: this._total, passed: this._passed })
-                .then(() => this.emit('done'));
-        }
-    }
-    async _isNextTestRunAvailable(testRunController) {
-        // NOTE: before hook for test run fixture is currently
-        // executing, so test run is temporary blocked
-        const isBlocked = testRunController.blocked;
-        const isConcurrency = this._opts.concurrency > 1;
-        const hasIncompleteTestRuns = this._completionQueue.some(controller => !controller.done);
-        const needWaitLastTestInFixture = this._reportsPending.some(controller => controller.test.fixture !== testRunController.test.fixture);
-        if (isBlocked || (hasIncompleteTestRuns || needWaitLastTestInFixture) && !isConcurrency) {
-            const disablePageReloads = testRunController.test.disablePageReloads ||
-                this._opts.disablePageReloads && testRunController.test.disablePageReloads !== false;
-            if (!needWaitLastTestInFixture || !disablePageReloads)
-                return false;
-            // NOTE: if we have `disablePageReloads` enabled and the next test is from next
-            // fixture, then we need to wait until all reporters finished to prevent
-            // redirecting to the `idle` page
-            await new Promise(resolve => {
-                this._resolveWaitingLastTestInFixture = resolve;
-            });
-        }
-        return true;
-    }
-    // API
-    get hasQueuedTestRuns() {
-        return !!this._testRunControllerQueue.length;
-    }
-    async popNextTestRunUrl(connection) {
-        while (this._testRunControllerQueue.length) {
-            const testRunController = this._testRunControllerQueue[0];
-            const isNextTestRunAvailable = await this._isNextTestRunAvailable(testRunController);
-            if (!isNextTestRunAvailable)
-                break;
-            this._reportsPending.push(testRunController);
-            this._testRunControllerQueue.shift();
-            this._addToCompletionQueue(testRunController);
-            if (!this._started) {
-                this._started = true;
-                await this.emit('start');
-            }
-            const testRunUrl = await testRunController.start(connection);
-            if (testRunUrl)
-                return testRunUrl;
-        }
-        return null;
-    }
-    abort() {
-        this.clearListeners();
-        this._setResult(browser_job_result_1.default.aborted);
-        this.browserConnections.map(bc => bc.removeJob(this));
-    }
-}
-exports.default = BrowserJob;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = require("lodash");
+const async_event_emitter_1 = __importDefault(require("../utils/async-event-emitter"));
+const test_run_controller_1 = __importDefault(require("./test-run-controller"));
+const session_controller_1 = __importDefault(require("../test-run/session-controller"));
+const browser_job_result_1 = __importDefault(require("./browser-job-result"));
+class BrowserJob extends async_event_emitter_1.default {
+    constructor({ tests, browserConnections, proxy, screenshots, warningLog, fixtureHookController, opts, compilerService }) {
+        super();
+        this._started = false;
+        this._total = 0;
+        this._passed = 0;
+        this._opts = opts;
+        this._proxy = proxy;
+        this.browserConnections = browserConnections;
+        this._screenshots = screenshots;
+        this.warningLog = warningLog;
+        this.fixtureHookController = fixtureHookController;
+        this._result = null;
+        this._testRunControllerQueue = tests.map((test, index) => this._createTestRunController(test, index, compilerService));
+        this._completionQueue = [];
+        this._reportsPending = [];
+        this._connectionErrorListener = (error) => this._setResult(browser_job_result_1.default.errored, error);
+        this._resolveWaitingLastTestInFixture = null;
+        this.browserConnections.map(bc => bc.once('error', this._connectionErrorListener));
+    }
+    _createTestRunController(test, index, compilerService) {
+        const testRunController = new test_run_controller_1.default({
+            test,
+            index: index + 1,
+            proxy: this._proxy,
+            screenshots: this._screenshots,
+            warningLog: this.warningLog,
+            fixtureHookController: this.fixtureHookController,
+            opts: this._opts,
+            compilerService
+        });
+        testRunController.on('test-run-create', async (testRunInfo) => {
+            await this.emit('test-run-create', testRunInfo);
+        });
+        testRunController.on('test-run-start', async () => {
+            await this.emit('test-run-start', testRunController.testRun);
+        });
+        testRunController.on('test-run-ready', async () => {
+            await this.emit('test-run-ready', testRunController);
+        });
+        testRunController.on('test-run-restart', async () => this._onTestRunRestart(testRunController));
+        testRunController.on('test-run-before-done', async () => {
+            await this.emit('test-run-before-done', testRunController);
+        });
+        testRunController.on('test-run-done', async () => this._onTestRunDone(testRunController));
+        testRunController.on('test-action-start', async (args) => {
+            await this.emit('test-action-start', args);
+        });
+        testRunController.on('test-action-done', async (args) => {
+            await this.emit('test-action-done', args);
+        });
+        return testRunController;
+    }
+    async _setResult(status, data) {
+        if (this._result)
+            return;
+        this._result = { status, data };
+        this.browserConnections.forEach(bc => bc.removeListener('error', this._connectionErrorListener));
+        await Promise.all(this.browserConnections.map(bc => bc.reportJobResult(this._result.status, this._result.data)));
+    }
+    _addToCompletionQueue(testRunInfo) {
+        this._completionQueue.push(testRunInfo);
+    }
+    _removeFromCompletionQueue(testRunInfo) {
+        lodash_1.pull(this._completionQueue, testRunInfo);
+    }
+    _onTestRunRestart(testRunController) {
+        this._removeFromCompletionQueue(testRunController);
+        this._testRunControllerQueue.unshift(testRunController);
+    }
+    async _onTestRunDone(testRunController) {
+        this._total++;
+        if (!testRunController.testRun.errs.length)
+            this._passed++;
+        while (this._completionQueue.length && this._completionQueue[0].done) {
+            testRunController = this._completionQueue.shift();
+            await this.emit('test-run-done', testRunController.testRun);
+            lodash_1.pull(this._reportsPending, testRunController);
+            if (!this._reportsPending.length && this._resolveWaitingLastTestInFixture) {
+                this._resolveWaitingLastTestInFixture();
+                this._resolveWaitingLastTestInFixture = null;
+            }
+        }
+        if (!this._completionQueue.length && !this.hasQueuedTestRuns) {
+            if (!this._opts.live)
+                session_controller_1.default.closeSession(testRunController.testRun);
+            this
+                ._setResult(browser_job_result_1.default.done, { total: this._total, passed: this._passed })
+                .then(() => this.emit('done'));
+        }
+    }
+    async _isNextTestRunAvailable(testRunController) {
+        // NOTE: before hook for test run fixture is currently
+        // executing, so test run is temporary blocked
+        const isBlocked = testRunController.blocked;
+        const isConcurrency = this._opts.concurrency > 1;
+        const hasIncompleteTestRuns = this._completionQueue.some(controller => !controller.done);
+        const needWaitLastTestInFixture = this._reportsPending.some(controller => controller.test.fixture !== testRunController.test.fixture);
+        if (isBlocked || (hasIncompleteTestRuns || needWaitLastTestInFixture) && !isConcurrency) {
+            const disablePageReloads = testRunController.test.disablePageReloads ||
+                this._opts.disablePageReloads && testRunController.test.disablePageReloads !== false;
+            if (!needWaitLastTestInFixture || !disablePageReloads)
+                return false;
+            // NOTE: if we have `disablePageReloads` enabled and the next test is from next
+            // fixture, then we need to wait until all reporters finished to prevent
+            // redirecting to the `idle` page
+            await new Promise(resolve => {
+                this._resolveWaitingLastTestInFixture = resolve;
+            });
+        }
+        return true;
+    }
+    // API
+    get hasQueuedTestRuns() {
+        return !!this._testRunControllerQueue.length;
+    }
+    async popNextTestRunUrl(connection) {
+        while (this._testRunControllerQueue.length) {
+            const testRunController = this._testRunControllerQueue[0];
+            const isNextTestRunAvailable = await this._isNextTestRunAvailable(testRunController);
+            if (!isNextTestRunAvailable)
+                break;
+            this._reportsPending.push(testRunController);
+            this._testRunControllerQueue.shift();
+            this._addToCompletionQueue(testRunController);
+            if (!this._started) {
+                this._started = true;
+                await this.emit('start');
+            }
+            const testRunUrl = await testRunController.start(connection);
+            if (testRunUrl)
+                return testRunUrl;
+        }
+        return null;
+    }
+    abort() {
+        this.clearListeners();
+        this._setResult(browser_job_result_1.default.aborted);
+        this.browserConnections.map(bc => bc.removeJob(this));
+    }
+}
+exports.default = BrowserJob;
 module.exports = exports.default;
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"browser-job.js","sourceRoot":"","sources":["../../src/runner/browser-job.ts"],"names":[],"mappings":"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","sourcesContent":["import { pull as remove } from 'lodash';\nimport AsyncEventEmitter from '../utils/async-event-emitter';\nimport TestRunController from './test-run-controller';\nimport SessionController from '../test-run/session-controller';\nimport BrowserConnection from '../browser/connection';\nimport { Proxy } from 'testcafe-hammerhead';\nimport Test from '../api/structure/test';\nimport Screenshots from '../screenshots';\nimport WarningLog from '../notifications/warning-log';\nimport FixtureHookController from './fixture-hook-controller';\nimport { Dictionary } from '../configuration/interfaces';\nimport BrowserJobResult from './browser-job-result';\nimport CompilerService from '../services/compiler/host';\nimport { BrowserJobInit } from './interfaces';\n\ninterface BrowserJobResultInfo {\n    status: BrowserJobResult;\n    data?: any; // eslint-disable-line @typescript-eslint/no-explicit-any\n}\n\nexport default class BrowserJob extends AsyncEventEmitter {\n    private _started: boolean;\n    private _total: number;\n    private _passed: number;\n    private readonly _opts: Dictionary<OptionValue>;\n    private readonly _proxy: Proxy;\n    public readonly browserConnections: BrowserConnection[];\n    private readonly _screenshots: Screenshots;\n    public readonly warningLog: WarningLog;\n    public readonly fixtureHookController: FixtureHookController;\n    private _result: BrowserJobResultInfo | null;\n    private readonly _testRunControllerQueue: TestRunController[];\n    private readonly _reportsPending: TestRunController[];\n    private readonly _connectionErrorListener: (error: Error) => void;\n    private readonly _completionQueue: TestRunController[];\n    private _resolveWaitingLastTestInFixture: Function | null;\n\n    public constructor ({\n        tests,\n        browserConnections,\n        proxy,\n        screenshots,\n        warningLog,\n        fixtureHookController,\n        opts,\n        compilerService\n    }: BrowserJobInit) {\n        super();\n\n        this._started = false;\n\n        this._total                = 0;\n        this._passed               = 0;\n        this._opts                 = opts;\n        this._proxy                = proxy;\n        this.browserConnections    = browserConnections;\n        this._screenshots          = screenshots;\n        this.warningLog            = warningLog;\n        this.fixtureHookController = fixtureHookController;\n        this._result               = null;\n\n        this._testRunControllerQueue = tests.map((test, index) => this._createTestRunController(test, index, compilerService));\n\n        this._completionQueue = [];\n        this._reportsPending  = [];\n\n        this._connectionErrorListener = (error: Error) => this._setResult(BrowserJobResult.errored, error);\n\n        this._resolveWaitingLastTestInFixture = null;\n\n        this.browserConnections.map(bc => bc.once('error', this._connectionErrorListener));\n    }\n\n    private _createTestRunController (test: Test, index: number, compilerService?: CompilerService): TestRunController {\n        const testRunController = new TestRunController({\n            test,\n            index:                 index + 1,\n            proxy:                 this._proxy,\n            screenshots:           this._screenshots,\n            warningLog:            this.warningLog,\n            fixtureHookController: this.fixtureHookController,\n            opts:                  this._opts,\n            compilerService\n        });\n\n        testRunController.on('test-run-create', async testRunInfo => {\n            await this.emit('test-run-create', testRunInfo);\n        });\n        testRunController.on('test-run-start', async () => {\n            await this.emit('test-run-start', testRunController.testRun);\n        });\n        testRunController.on('test-run-ready', async () => {\n            await this.emit('test-run-ready', testRunController);\n        });\n        testRunController.on('test-run-restart', async () => this._onTestRunRestart(testRunController));\n        testRunController.on('test-run-before-done', async () => {\n            await this.emit('test-run-before-done', testRunController);\n        });\n        testRunController.on('test-run-done', async () => this._onTestRunDone(testRunController));\n\n        testRunController.on('test-action-start', async args => {\n            await this.emit('test-action-start', args);\n        });\n\n        testRunController.on('test-action-done', async args => {\n            await this.emit('test-action-done', args);\n        });\n\n        return testRunController;\n    }\n\n    private async _setResult (status: BrowserJobResult, data?: any): Promise<void> { // eslint-disable-line @typescript-eslint/no-explicit-any\n        if (this._result)\n            return;\n\n        this._result = { status, data };\n\n        this.browserConnections.forEach(bc => bc.removeListener('error', this._connectionErrorListener));\n\n        await Promise.all(this.browserConnections.map(bc => bc.reportJobResult((this._result as BrowserJobResultInfo).status, (this._result as BrowserJobResultInfo).data)));\n    }\n\n    private _addToCompletionQueue (testRunInfo: TestRunController): void {\n        this._completionQueue.push(testRunInfo);\n    }\n\n    private _removeFromCompletionQueue (testRunInfo: TestRunController): void {\n        remove(this._completionQueue, testRunInfo);\n    }\n\n    private _onTestRunRestart (testRunController: TestRunController): void {\n        this._removeFromCompletionQueue(testRunController);\n        this._testRunControllerQueue.unshift(testRunController);\n    }\n\n    private async _onTestRunDone (testRunController: TestRunController): Promise<void> {\n        this._total++;\n\n        if (!testRunController.testRun.errs.length)\n            this._passed++;\n\n        while (this._completionQueue.length && this._completionQueue[0].done) {\n            testRunController = this._completionQueue.shift() as TestRunController;\n\n            await this.emit('test-run-done', testRunController.testRun);\n\n            remove(this._reportsPending, testRunController);\n\n            if (!this._reportsPending.length && this._resolveWaitingLastTestInFixture) {\n                this._resolveWaitingLastTestInFixture();\n\n                this._resolveWaitingLastTestInFixture = null;\n            }\n        }\n\n        if (!this._completionQueue.length && !this.hasQueuedTestRuns) {\n            if (!this._opts.live)\n                SessionController.closeSession(testRunController.testRun);\n\n            this\n                ._setResult(BrowserJobResult.done, { total: this._total, passed: this._passed })\n                .then(() => this.emit('done'));\n        }\n    }\n\n    private async _isNextTestRunAvailable (testRunController: TestRunController): Promise<boolean> {\n        // NOTE: before hook for test run fixture is currently\n        // executing, so test run is temporary blocked\n        const isBlocked                 = testRunController.blocked;\n        const isConcurrency             = this._opts.concurrency as number > 1;\n        const hasIncompleteTestRuns     = this._completionQueue.some(controller => !controller.done);\n        const needWaitLastTestInFixture = this._reportsPending.some(controller => controller.test.fixture !== testRunController.test.fixture);\n\n        if (isBlocked || (hasIncompleteTestRuns || needWaitLastTestInFixture) && !isConcurrency) {\n            const disablePageReloads = testRunController.test.disablePageReloads ||\n                this._opts.disablePageReloads && testRunController.test.disablePageReloads !== false;\n\n            if (!needWaitLastTestInFixture || !disablePageReloads)\n                return false;\n\n            // NOTE: if we have `disablePageReloads` enabled and the next test is from next\n            // fixture, then we need to wait until all reporters finished to prevent\n            // redirecting to the `idle` page\n            await new Promise(resolve => {\n                this._resolveWaitingLastTestInFixture = resolve;\n            });\n        }\n\n        return true;\n    }\n\n    // API\n    public get hasQueuedTestRuns (): boolean {\n        return !!this._testRunControllerQueue.length;\n    }\n\n    public async popNextTestRunUrl (connection: BrowserConnection): Promise<string | null> {\n        while (this._testRunControllerQueue.length) {\n            const testRunController = this._testRunControllerQueue[0];\n\n            const isNextTestRunAvailable = await this._isNextTestRunAvailable(testRunController);\n\n            if (!isNextTestRunAvailable)\n                break;\n\n            this._reportsPending.push(testRunController);\n            this._testRunControllerQueue.shift();\n            this._addToCompletionQueue(testRunController);\n\n            if (!this._started) {\n                this._started = true;\n\n                await this.emit('start');\n            }\n\n            const testRunUrl = await testRunController.start(connection);\n\n            if (testRunUrl)\n                return testRunUrl;\n        }\n\n        return null;\n    }\n\n    public abort (): void {\n        this.clearListeners();\n        this._setResult(BrowserJobResult.aborted);\n        this.browserConnections.map(bc => bc.removeJob(this));\n    }\n}\n"]}