testcafe 1.14.1 → 1.14.2

package/lib/runner/test-run-controller.js

@@ -1,167 +1,167 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const async_event_emitter_1 = __importDefault(require("../utils/async-event-emitter"));
-//@ts-ignore
-const testcafe_legacy_api_1 = require("testcafe-legacy-api");
-const test_run_1 = __importDefault(require("../test-run"));
-const session_controller_1 = __importDefault(require("../test-run/session-controller"));
-const quarantine_1 = require("../utils/get-options/quarantine");
-const DISCONNECT_THRESHOLD = 3;
-class TestRunController extends async_event_emitter_1.default {
-    constructor({ test, index, proxy, screenshots, warningLog, fixtureHookController, opts, compilerService }) {
-        super();
-        this.test = test;
-        this.index = index;
-        this._opts = opts;
-        this._proxy = proxy;
-        this._screenshots = screenshots;
-        this._warningLog = warningLog;
-        this._fixtureHookController = fixtureHookController;
-        this._testRunCtor = TestRunController._getTestRunCtor(test, opts);
-        this.testRun = null;
-        this.done = false;
-        this._quarantine = this._opts.quarantineMode ? new quarantine_1.Quarantine() : null;
-        this._disconnectionCount = 0;
-        this.compilerService = compilerService;
-    }
-    static _getTestRunCtor(test, opts) {
-        if (opts.TestRunCtor)
-            return opts.TestRunCtor;
-        return test.isLegacy ? testcafe_legacy_api_1.TestRun : test_run_1.default;
-    }
-    async _createTestRun(connection) {
-        const screenshotCapturer = this._screenshots.createCapturerFor(this.test, this.index, this._quarantine, connection, this._warningLog);
-        const TestRunCtor = this._testRunCtor;
-        this.testRun = new TestRunCtor({
-            test: this.test,
-            browserConnection: connection,
-            globalWarningLog: this._warningLog,
-            opts: this._opts,
-            compilerService: this.compilerService,
-            screenshotCapturer
-        });
-        await this.testRun.initialize();
-        this._screenshots.addTestRun(this.test, this.testRun);
-        if (this.testRun.addQuarantineInfo)
-            this.testRun.addQuarantineInfo(this._quarantine);
-        if (this._quarantine) {
-            const { passCount, retryCount } = this._opts.quarantineMode;
-            if (retryCount)
-                this._quarantine.setTestRunThreshold(retryCount);
-            if (passCount)
-                this._quarantine.setPassedQuarantineThreshold(passCount);
-        }
-        if (!this._quarantine || this._isFirstQuarantineAttempt()) {
-            await this.emit('test-run-create', {
-                testRun: this.testRun,
-                legacy: TestRunCtor === testcafe_legacy_api_1.TestRun,
-                test: this.test,
-                index: this.index,
-                quarantine: this._quarantine,
-            });
-        }
-        return this.testRun;
-    }
-    async _endQuarantine() {
-        if (this._quarantine.attempts.length > 1)
-            this.testRun.unstable = this._quarantine.getPassedAttempts().length > 0;
-        await this._emitTestRunDone();
-    }
-    _shouldKeepInQuarantine() {
-        const errors = this.testRun.errs;
-        const hasErrors = !!errors.length;
-        const attempts = this._quarantine.attempts;
-        const isFirstAttempt = this._isFirstQuarantineAttempt();
-        attempts.push(errors);
-        return isFirstAttempt ? hasErrors : !this._quarantine.isThresholdReached();
-    }
-    _isFirstQuarantineAttempt() {
-        return !!this._quarantine && !this._quarantine.attempts.length;
-    }
-    async _keepInQuarantine() {
-        await this._restartTest();
-    }
-    async _restartTest() {
-        await this.emit('test-run-restart');
-    }
-    async _testRunDoneInQuarantineMode() {
-        if (this._shouldKeepInQuarantine())
-            await this._keepInQuarantine();
-        else
-            await this._endQuarantine();
-    }
-    async _testRunDone() {
-        if (this._quarantine)
-            await this._testRunDoneInQuarantineMode();
-        else
-            await this._emitTestRunDone();
-    }
-    async _emitActionStart(args) {
-        await this.emit('test-action-start', args);
-    }
-    async _emitActionDone(args) {
-        await this.emit('test-action-done', args);
-    }
-    async _emitTestRunDone() {
-        // NOTE: we should report test run completion in order they were completed in browser.
-        // To keep a sequence after fixture hook execution we use completion queue.
-        await this._fixtureHookController.runFixtureAfterHookIfNecessary(this.testRun);
-        this.done = true;
-        await this.emit('test-run-done');
-    }
-    async _emitTestRunStart() {
-        await this.emit('test-run-start');
-    }
-    async _testRunBeforeDone() {
-        let raiseEvent = !this._quarantine;
-        if (!raiseEvent) {
-            const isSuccessfulQuarantineFirstAttempt = this._isFirstQuarantineAttempt() && !this.testRun.errs.length;
-            const isAttemptsThresholdReached = this._quarantine.isThresholdReached(this.testRun.errs);
-            raiseEvent = isSuccessfulQuarantineFirstAttempt || isAttemptsThresholdReached;
-        }
-        if (raiseEvent)
-            await this.emit('test-run-before-done');
-    }
-    _testRunDisconnected(connection) {
-        this._disconnectionCount++;
-        const disconnectionThresholdExceedeed = this._disconnectionCount >= DISCONNECT_THRESHOLD;
-        return connection
-            .processDisconnection(disconnectionThresholdExceedeed)
-            .then(() => {
-            return this._restartTest();
-        });
-    }
-    _assignTestRunEvents(testRun, connection) {
-        testRun.on('action-start', async (args) => this._emitActionStart(Object.assign(args, { testRun })));
-        testRun.on('action-done', async (args) => this._emitActionDone(Object.assign(args, { testRun })));
-        testRun.once('start', async () => this._emitTestRunStart());
-        testRun.once('ready', async () => {
-            if (!this._quarantine || this._isFirstQuarantineAttempt())
-                await this.emit('test-run-ready');
-        });
-        testRun.once('before-done', () => this._testRunBeforeDone());
-        testRun.once('done', () => this._testRunDone());
-        testRun.once('disconnected', () => this._testRunDisconnected(connection));
-    }
-    get blocked() {
-        return this._fixtureHookController.isTestBlocked(this.test);
-    }
-    async start(connection) {
-        const testRun = await this._createTestRun(connection);
-        const hookOk = await this._fixtureHookController.runFixtureBeforeHookIfNecessary(testRun);
-        if (this.test.skip || !hookOk) {
-            await this.emit('test-run-start');
-            await this._emitTestRunDone();
-            return null;
-        }
-        this._assignTestRunEvents(testRun, connection);
-        testRun.start();
-        return session_controller_1.default.getSessionUrl(testRun, this._proxy);
-    }
-}
-exports.default = TestRunController;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const async_event_emitter_1 = __importDefault(require("../utils/async-event-emitter"));
+//@ts-ignore
+const testcafe_legacy_api_1 = require("testcafe-legacy-api");
+const test_run_1 = __importDefault(require("../test-run"));
+const session_controller_1 = __importDefault(require("../test-run/session-controller"));
+const quarantine_1 = require("../utils/get-options/quarantine");
+const DISCONNECT_THRESHOLD = 3;
+class TestRunController extends async_event_emitter_1.default {
+    constructor({ test, index, proxy, screenshots, warningLog, fixtureHookController, opts, compilerService }) {
+        super();
+        this.test = test;
+        this.index = index;
+        this._opts = opts;
+        this._proxy = proxy;
+        this._screenshots = screenshots;
+        this._warningLog = warningLog;
+        this._fixtureHookController = fixtureHookController;
+        this._testRunCtor = TestRunController._getTestRunCtor(test, opts);
+        this.testRun = null;
+        this.done = false;
+        this._quarantine = this._opts.quarantineMode ? new quarantine_1.Quarantine() : null;
+        this._disconnectionCount = 0;
+        this.compilerService = compilerService;
+    }
+    static _getTestRunCtor(test, opts) {
+        if (opts.TestRunCtor)
+            return opts.TestRunCtor;
+        return test.isLegacy ? testcafe_legacy_api_1.TestRun : test_run_1.default;
+    }
+    async _createTestRun(connection) {
+        const screenshotCapturer = this._screenshots.createCapturerFor(this.test, this.index, this._quarantine, connection, this._warningLog);
+        const TestRunCtor = this._testRunCtor;
+        this.testRun = new TestRunCtor({
+            test: this.test,
+            browserConnection: connection,
+            globalWarningLog: this._warningLog,
+            opts: this._opts,
+            compilerService: this.compilerService,
+            screenshotCapturer
+        });
+        await this.testRun.initialize();
+        this._screenshots.addTestRun(this.test, this.testRun);
+        if (this.testRun.addQuarantineInfo)
+            this.testRun.addQuarantineInfo(this._quarantine);
+        if (this._quarantine) {
+            const { passCount, retryCount } = this._opts.quarantineMode;
+            if (retryCount)
+                this._quarantine.setTestRunThreshold(retryCount);
+            if (passCount)
+                this._quarantine.setPassedQuarantineThreshold(passCount);
+        }
+        if (!this._quarantine || this._isFirstQuarantineAttempt()) {
+            await this.emit('test-run-create', {
+                testRun: this.testRun,
+                legacy: TestRunCtor === testcafe_legacy_api_1.TestRun,
+                test: this.test,
+                index: this.index,
+                quarantine: this._quarantine,
+            });
+        }
+        return this.testRun;
+    }
+    async _endQuarantine() {
+        if (this._quarantine.attempts.length > 1)
+            this.testRun.unstable = this._quarantine.getPassedAttempts().length > 0;
+        await this._emitTestRunDone();
+    }
+    _shouldKeepInQuarantine() {
+        const errors = this.testRun.errs;
+        const hasErrors = !!errors.length;
+        const attempts = this._quarantine.attempts;
+        const isFirstAttempt = this._isFirstQuarantineAttempt();
+        attempts.push(errors);
+        return isFirstAttempt ? hasErrors : !this._quarantine.isThresholdReached();
+    }
+    _isFirstQuarantineAttempt() {
+        return !!this._quarantine && !this._quarantine.attempts.length;
+    }
+    async _keepInQuarantine() {
+        await this._restartTest();
+    }
+    async _restartTest() {
+        await this.emit('test-run-restart');
+    }
+    async _testRunDoneInQuarantineMode() {
+        if (this._shouldKeepInQuarantine())
+            await this._keepInQuarantine();
+        else
+            await this._endQuarantine();
+    }
+    async _testRunDone() {
+        if (this._quarantine)
+            await this._testRunDoneInQuarantineMode();
+        else
+            await this._emitTestRunDone();
+    }
+    async _emitActionStart(args) {
+        await this.emit('test-action-start', args);
+    }
+    async _emitActionDone(args) {
+        await this.emit('test-action-done', args);
+    }
+    async _emitTestRunDone() {
+        // NOTE: we should report test run completion in order they were completed in browser.
+        // To keep a sequence after fixture hook execution we use completion queue.
+        await this._fixtureHookController.runFixtureAfterHookIfNecessary(this.testRun);
+        this.done = true;
+        await this.emit('test-run-done');
+    }
+    async _emitTestRunStart() {
+        await this.emit('test-run-start');
+    }
+    async _testRunBeforeDone() {
+        let raiseEvent = !this._quarantine;
+        if (!raiseEvent) {
+            const isSuccessfulQuarantineFirstAttempt = this._isFirstQuarantineAttempt() && !this.testRun.errs.length;
+            const isAttemptsThresholdReached = this._quarantine.isThresholdReached(this.testRun.errs);
+            raiseEvent = isSuccessfulQuarantineFirstAttempt || isAttemptsThresholdReached;
+        }
+        if (raiseEvent)
+            await this.emit('test-run-before-done');
+    }
+    _testRunDisconnected(connection) {
+        this._disconnectionCount++;
+        const disconnectionThresholdExceedeed = this._disconnectionCount >= DISCONNECT_THRESHOLD;
+        return connection
+            .processDisconnection(disconnectionThresholdExceedeed)
+            .then(() => {
+            return this._restartTest();
+        });
+    }
+    _assignTestRunEvents(testRun, connection) {
+        testRun.on('action-start', async (args) => this._emitActionStart(Object.assign(args, { testRun })));
+        testRun.on('action-done', async (args) => this._emitActionDone(Object.assign(args, { testRun })));
+        testRun.once('start', async () => this._emitTestRunStart());
+        testRun.once('ready', async () => {
+            if (!this._quarantine || this._isFirstQuarantineAttempt())
+                await this.emit('test-run-ready');
+        });
+        testRun.once('before-done', () => this._testRunBeforeDone());
+        testRun.once('done', () => this._testRunDone());
+        testRun.once('disconnected', () => this._testRunDisconnected(connection));
+    }
+    get blocked() {
+        return this._fixtureHookController.isTestBlocked(this.test);
+    }
+    async start(connection) {
+        const testRun = await this._createTestRun(connection);
+        const hookOk = await this._fixtureHookController.runFixtureBeforeHookIfNecessary(testRun);
+        if (this.test.skip || !hookOk) {
+            await this.emit('test-run-start');
+            await this._emitTestRunDone();
+            return null;
+        }
+        this._assignTestRunEvents(testRun, connection);
+        testRun.start();
+        return session_controller_1.default.getSessionUrl(testRun, this._proxy);
+    }
+}
+exports.default = TestRunController;
 module.exports = exports.default;
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-run-controller.js","sourceRoot":"","sources":["../../src/runner/test-run-controller.ts"],"names":[],"mappings":"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","sourcesContent":["import AsyncEventEmitter from '../utils/async-event-emitter';\n//@ts-ignore\nimport { TestRun as LegacyTestRun } from 'testcafe-legacy-api';\nimport TestRun from '../test-run';\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 { ActionEventArg, TestRunControllerInit } from './interfaces';\nimport CompilerService from '../services/compiler/host';\nimport { Quarantine } from '../utils/get-options/quarantine';\n\nconst DISCONNECT_THRESHOLD = 3;\n\n\nexport default class TestRunController extends AsyncEventEmitter {\n    private readonly _quarantine: null | Quarantine;\n    private _disconnectionCount: number;\n    private readonly _proxy: Proxy;\n    public readonly index: number;\n    public test: Test;\n    private readonly _opts: Dictionary<OptionValue>;\n    private _screenshots: Screenshots;\n    private readonly _warningLog: WarningLog;\n    private readonly _fixtureHookController: FixtureHookController;\n    private readonly _testRunCtor: LegacyTestRun['constructor'] | TestRun['constructor'];\n    public testRun: null | LegacyTestRun | TestRun;\n    public done: boolean;\n    private readonly compilerService?: CompilerService;\n\n    public constructor ({\n        test,\n        index,\n        proxy,\n        screenshots,\n        warningLog,\n        fixtureHookController,\n        opts,\n        compilerService\n    }: TestRunControllerInit) {\n        super();\n\n        this.test  = test;\n        this.index = index;\n        this._opts = opts;\n\n        this._proxy                 = proxy;\n        this._screenshots           = screenshots;\n        this._warningLog            = warningLog;\n        this._fixtureHookController = fixtureHookController;\n\n        this._testRunCtor = TestRunController._getTestRunCtor(test, opts);\n\n        this.testRun             = null;\n        this.done                = false;\n        this._quarantine         = this._opts.quarantineMode ? new Quarantine() : null;\n        this._disconnectionCount = 0;\n        this.compilerService     = compilerService;\n    }\n\n    private static _getTestRunCtor (test: Test, opts: Dictionary<OptionValue>): LegacyTestRun | TestRun {\n        if (opts.TestRunCtor)\n            return opts.TestRunCtor;\n\n        return (test as LegacyTestRun).isLegacy ? LegacyTestRun : TestRun;\n    }\n\n    private async _createTestRun (connection: BrowserConnection): Promise<TestRun | LegacyTestRun> {\n        const screenshotCapturer = this._screenshots.createCapturerFor(this.test, this.index, this._quarantine, connection, this._warningLog);\n        const TestRunCtor        = this._testRunCtor;\n\n        this.testRun = new TestRunCtor({\n            test:              this.test,\n            browserConnection: connection,\n            globalWarningLog:  this._warningLog,\n            opts:              this._opts,\n            compilerService:   this.compilerService,\n            screenshotCapturer\n        });\n\n        await this.testRun.initialize();\n\n        this._screenshots.addTestRun(this.test, this.testRun);\n\n        if (this.testRun.addQuarantineInfo)\n            this.testRun.addQuarantineInfo(this._quarantine);\n\n        if (this._quarantine) {\n            const { passCount, retryCount } = this._opts.quarantineMode as QuarantineOptionValue;\n\n            if (retryCount) this._quarantine.setTestRunThreshold(retryCount);\n            if (passCount) this._quarantine.setPassedQuarantineThreshold(passCount);\n        }\n\n        if (!this._quarantine || this._isFirstQuarantineAttempt()) {\n            await this.emit('test-run-create', {\n                testRun:    this.testRun,\n                legacy:     TestRunCtor === LegacyTestRun,\n                test:       this.test,\n                index:      this.index,\n                quarantine: this._quarantine,\n            });\n        }\n\n        return this.testRun;\n    }\n\n    private async _endQuarantine (): Promise<void> {\n        if ((this._quarantine as Quarantine).attempts.length > 1)\n            this.testRun.unstable = (this._quarantine as Quarantine).getPassedAttempts().length > 0;\n\n        await this._emitTestRunDone();\n    }\n\n    private _shouldKeepInQuarantine (): boolean {\n        const errors         = this.testRun.errs;\n        const hasErrors      = !!errors.length;\n        const attempts       = (this._quarantine as Quarantine).attempts;\n        const isFirstAttempt = this._isFirstQuarantineAttempt();\n\n        attempts.push(errors);\n\n        return isFirstAttempt ? hasErrors : !(this._quarantine as Quarantine).isThresholdReached();\n    }\n\n    private _isFirstQuarantineAttempt (): boolean {\n        return !!this._quarantine && !this._quarantine.attempts.length;\n    }\n\n    private async _keepInQuarantine (): Promise<void> {\n        await this._restartTest();\n    }\n\n    private async _restartTest (): Promise<void> {\n        await this.emit('test-run-restart');\n    }\n\n    private async _testRunDoneInQuarantineMode (): Promise<void> {\n        if (this._shouldKeepInQuarantine())\n            await this._keepInQuarantine();\n        else\n            await this._endQuarantine();\n    }\n\n    private async _testRunDone (): Promise<void> {\n        if (this._quarantine)\n            await this._testRunDoneInQuarantineMode();\n        else\n            await this._emitTestRunDone();\n    }\n\n    private async _emitActionStart (args: ActionEventArg): Promise<void> {\n        await this.emit('test-action-start', args);\n    }\n\n    private async _emitActionDone (args: ActionEventArg): Promise<void> {\n        await this.emit('test-action-done', args);\n    }\n\n    private async _emitTestRunDone (): Promise<void> {\n        // NOTE: we should report test run completion in order they were completed in browser.\n        // To keep a sequence after fixture hook execution we use completion queue.\n        await this._fixtureHookController.runFixtureAfterHookIfNecessary(this.testRun);\n\n        this.done = true;\n\n        await this.emit('test-run-done');\n    }\n\n    private async _emitTestRunStart (): Promise<void> {\n        await this.emit('test-run-start');\n    }\n\n    private async _testRunBeforeDone (): Promise<void> {\n        let raiseEvent = !this._quarantine;\n\n        if (!raiseEvent) {\n            const isSuccessfulQuarantineFirstAttempt = this._isFirstQuarantineAttempt() && !this.testRun.errs.length;\n            const isAttemptsThresholdReached         = (this._quarantine as Quarantine).isThresholdReached(this.testRun.errs);\n\n            raiseEvent = isSuccessfulQuarantineFirstAttempt || isAttemptsThresholdReached;\n        }\n\n        if (raiseEvent)\n            await this.emit('test-run-before-done');\n    }\n\n    private _testRunDisconnected (connection: BrowserConnection): Promise<void> {\n        this._disconnectionCount++;\n\n        const disconnectionThresholdExceedeed = this._disconnectionCount >= DISCONNECT_THRESHOLD;\n\n        return connection\n            .processDisconnection(disconnectionThresholdExceedeed)\n            .then(() => {\n                return this._restartTest();\n            });\n    }\n\n    private _assignTestRunEvents (testRun: TestRun | LegacyTestRun, connection: BrowserConnection): void {\n        testRun.on('action-start', async (args: ActionEventArg) => this._emitActionStart(Object.assign(args, { testRun })));\n        testRun.on('action-done', async (args: ActionEventArg) => this._emitActionDone(Object.assign(args, { testRun })));\n\n        testRun.once('start', async () => this._emitTestRunStart());\n        testRun.once('ready', async () => {\n            if (!this._quarantine || this._isFirstQuarantineAttempt())\n                await this.emit('test-run-ready');\n        });\n        testRun.once('before-done', () => this._testRunBeforeDone());\n        testRun.once('done', () => this._testRunDone());\n        testRun.once('disconnected', () => this._testRunDisconnected(connection));\n    }\n\n    public get blocked (): boolean {\n        return this._fixtureHookController.isTestBlocked(this.test);\n    }\n\n    public async start (connection: BrowserConnection): Promise<string | null> {\n        const testRun = await this._createTestRun(connection);\n\n        const hookOk = await this._fixtureHookController.runFixtureBeforeHookIfNecessary(testRun);\n\n        if (this.test.skip || !hookOk) {\n            await this.emit('test-run-start');\n            await this._emitTestRunDone();\n\n            return null;\n        }\n\n        this._assignTestRunEvents(testRun, connection);\n\n        testRun.start();\n\n        return SessionController.getSessionUrl(testRun, this._proxy);\n    }\n}\n"]}

package/lib/runner/tested-app.js

@@ -1,74 +1,74 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = require("path");
-const execa_1 = require("execa");
-const lodash_1 = require("lodash");
-const tree_kill_1 = __importDefault(require("tree-kill"));
-const os_family_1 = __importDefault(require("os-family"));
-const delay_1 = __importDefault(require("../utils/delay"));
-const runtime_1 = require("../errors/runtime");
-const types_1 = require("../errors/types");
-const resolve_path_relatively_cwd_1 = __importDefault(require("../utils/resolve-path-relatively-cwd"));
-const debug_1 = __importDefault(require("debug"));
-const MODULES_BIN_DIR = resolve_path_relatively_cwd_1.default('./node_modules/.bin');
-const ENV_PATH_KEY = (function () {
-    if (os_family_1.default.win) {
-        let pathKey = 'Path';
-        Object.keys(process.env).forEach(key => {
-            if (key.toLowerCase() === 'path')
-                pathKey = key;
-        });
-        return pathKey;
-    }
-    return 'PATH';
-})();
-class TestedApp {
-    constructor() {
-        this._process = null;
-        this._killed = false;
-        this._stdoutLogger = debug_1.default('testcafe:tested-app:stdout');
-        this._stderrLogger = debug_1.default('testcafe:tested-app:stderr');
-        this.errorPromise = null;
-    }
-    async _run(command) {
-        var _a, _b;
-        const env = Object.assign({}, process.env);
-        const path = env[ENV_PATH_KEY] || '';
-        const pathParts = path.split(path_1.delimiter);
-        pathParts.unshift(MODULES_BIN_DIR);
-        env[ENV_PATH_KEY] = pathParts.join(path_1.delimiter);
-        this._process = execa_1.command(command, { shell: true, env });
-        (_a = this._process.stdout) === null || _a === void 0 ? void 0 : _a.on('data', data => this._stdoutLogger(String(data)));
-        (_b = this._process.stderr) === null || _b === void 0 ? void 0 : _b.on('data', data => this._stderrLogger(String(data)));
-        try {
-            await this._process;
-        }
-        catch (err) {
-            if (this._killed)
-                return;
-            const message = err.stack || String(err);
-            throw new runtime_1.GeneralError(types_1.RUNTIME_ERRORS.testedAppFailedWithError, message);
-        }
-    }
-    async start(command, initDelay) {
-        // NOTE: We should not resolve it if no error was thrown
-        this.errorPromise = this
-            ._run(command)
-            .then(() => new Promise(lodash_1.noop));
-        await Promise.race([
-            delay_1.default(initDelay),
-            this.errorPromise
-        ]);
-    }
-    async kill() {
-        this._killed = true;
-        const killPromise = new Promise(resolve => tree_kill_1.default(this._process.pid, 'SIGTERM', resolve));
-        await killPromise;
-    }
-}
-exports.default = TestedApp;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const execa_1 = require("execa");
+const lodash_1 = require("lodash");
+const tree_kill_1 = __importDefault(require("tree-kill"));
+const os_family_1 = __importDefault(require("os-family"));
+const delay_1 = __importDefault(require("../utils/delay"));
+const runtime_1 = require("../errors/runtime");
+const types_1 = require("../errors/types");
+const resolve_path_relatively_cwd_1 = __importDefault(require("../utils/resolve-path-relatively-cwd"));
+const debug_1 = __importDefault(require("debug"));
+const MODULES_BIN_DIR = resolve_path_relatively_cwd_1.default('./node_modules/.bin');
+const ENV_PATH_KEY = (function () {
+    if (os_family_1.default.win) {
+        let pathKey = 'Path';
+        Object.keys(process.env).forEach(key => {
+            if (key.toLowerCase() === 'path')
+                pathKey = key;
+        });
+        return pathKey;
+    }
+    return 'PATH';
+})();
+class TestedApp {
+    constructor() {
+        this._process = null;
+        this._killed = false;
+        this._stdoutLogger = debug_1.default('testcafe:tested-app:stdout');
+        this._stderrLogger = debug_1.default('testcafe:tested-app:stderr');
+        this.errorPromise = null;
+    }
+    async _run(command) {
+        var _a, _b;
+        const env = Object.assign({}, process.env);
+        const path = env[ENV_PATH_KEY] || '';
+        const pathParts = path.split(path_1.delimiter);
+        pathParts.unshift(MODULES_BIN_DIR);
+        env[ENV_PATH_KEY] = pathParts.join(path_1.delimiter);
+        this._process = execa_1.command(command, { shell: true, env });
+        (_a = this._process.stdout) === null || _a === void 0 ? void 0 : _a.on('data', data => this._stdoutLogger(String(data)));
+        (_b = this._process.stderr) === null || _b === void 0 ? void 0 : _b.on('data', data => this._stderrLogger(String(data)));
+        try {
+            await this._process;
+        }
+        catch (err) {
+            if (this._killed)
+                return;
+            const message = err.stack || String(err);
+            throw new runtime_1.GeneralError(types_1.RUNTIME_ERRORS.testedAppFailedWithError, message);
+        }
+    }
+    async start(command, initDelay) {
+        // NOTE: We should not resolve it if no error was thrown
+        this.errorPromise = this
+            ._run(command)
+            .then(() => new Promise(lodash_1.noop));
+        await Promise.race([
+            delay_1.default(initDelay),
+            this.errorPromise
+        ]);
+    }
+    async kill() {
+        this._killed = true;
+        const killPromise = new Promise(resolve => tree_kill_1.default(this._process.pid, 'SIGTERM', resolve));
+        await killPromise;
+    }
+}
+exports.default = TestedApp;
 module.exports = exports.default;
 //# sourceMappingURL=data:application/json;base64,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