@testim/testim-cli 3.244.0 → 3.247.0

package/runOptions.js

@@ -474,7 +474,7 @@ module.exports = {
             const originalRequire = Module.prototype.require;
             Module.prototype.require = function requireThatOverridesSessionPlayer(id) {
                 if (id.endsWith('getSessionPlayerRequire')) {
-                    const sessionPlayerPath = path.resolve(fullPlayerPath, 'src/background/sessionPlayerInit.js');
+                    const sessionPlayerPath = path.resolve(fullPlayerPath, 'src/background/sessionPlayerInit.ts');
                     return originalRequire.call(this, sessionPlayerPath);
                 }
                 if (id === 'rox-alias') {
@@ -1230,6 +1230,8 @@ module.exports = {
                 suiteNames: program.intersectWithSuite.length ? [program.intersectWithSuite].flat() : undefined,
                 suiteIds: program.intersectWithSuiteId.length ? [program.intersectWithSuiteId].flat() : undefined,
             },
+
+            downloadBrowser: program.downloadBrowser,
         });
     },
 };

package/runner.js

@@ -2,7 +2,6 @@
 
 /* eslint-disable no-console */
 const { CLI_MODE } = require('./commons/constants');
-const Promise = require('bluebird');
 const _ = require('lodash');
 const { EDITOR_URL } = require('./commons/config');
 const tunnel = require('./commons/testimTunnel');
@@ -29,7 +28,7 @@ const featureAvailabilityService = require('./commons/featureAvailabilityService
 const logger = require('./commons/logger').getLogger('runner');
 
 function validateCLIRunsAreAllowed(options) {
-    const hasCliAccess = _(options).get('company.activePlan.premiumFeatures.allowCLI');
+    const hasCliAccess = _.get(options, 'company.activePlan.premiumFeatures.allowCLI');
 
     if (!hasCliAccess) {
         const projectId = options.project;
@@ -38,20 +37,18 @@ function validateCLIRunsAreAllowed(options) {
     }
 }
 
-function validateProjectQuotaNotDepleted(options) {
+async function validateProjectQuotaNotDepleted(options) {
     const projectId = options.project;
 
-    return servicesApi.getUsageForCurrentBillingPeriod(projectId)
-        .then(usage => {
-            const isExecutionBlocked = usage && usage.isExecutionBlocked;
-            if (!isExecutionBlocked) {
-                return;
-            }
-
-            console.error('You have reached the limit of runs for the billing month, please upgrade your plan at https://www.testim.io/upgrade-contact-us?source=cli');
-            analytics.track(options.authData.uid, 'execution-quota-surpassed', { projectId });
-            throw new QuotaDepletedError();
-        });
+    const usage = await servicesApi.getUsageForCurrentBillingPeriod(projectId);
+    const isExecutionBlocked = usage && usage.isExecutionBlocked;
+    if (!isExecutionBlocked) {
+        return;
+    }
+
+    console.error('You have reached the limit of runs for the billing month, please upgrade your plan at https://www.testim.io/upgrade-contact-us?source=cli');
+    analytics.track(options.authData.uid, 'execution-quota-surpassed', { projectId });
+    throw new QuotaDepletedError();
 }
 
 function validateOptionsForCompany(options, company) {
@@ -60,26 +57,27 @@ function validateOptionsForCompany(options, company) {
         return;
     }
 
-    const companyRetention = _(company).get('activePlan.premiumFeatures.resultRetention');
+    const companyRetention = _.get(company, 'activePlan.premiumFeatures.resultRetention');
     if (optionsRetention > companyRetention) {
         throw new ArgError(`Retention days (${optionsRetention}) cannot be greater than the company's retention days (${companyRetention}). Run aborted`);
     }
 }
 
-function validateCliAccount(options) {
+async function validateCliAccount(options) {
     if (options.lightweightMode && options.lightweightMode.disableQuotaBlocking) {
-        return Promise.resolve();
+        return;
     }
-    return Promise.all([
-        validateProjectQuotaNotDepleted(options),
-        validateCLIRunsAreAllowed(options),
-    ]).catch(err => {
+    try {
+        await Promise.all([
+            validateProjectQuotaNotDepleted(options),
+            validateCLIRunsAreAllowed(options),
+        ]);
+    } catch (err) {
         if (err instanceof ArgError || err instanceof QuotaDepletedError) {
-            return Promise.reject(err);
+            throw err;
         }
         logger.error('could not validate cli account', { err });
-        return undefined;
-    });
+    }
 }
 
 function analyticsIdentify(projectId) {
@@ -125,10 +123,10 @@ function setCompany(options, company) {
     if (onprem) {
         const { mode, extensionPath, ext, playerPath } = options;
         if ([CLI_MODE.SELENIUM].includes(mode) && !playerPath) {
-            return Promise.reject(new ArgError('in selenium on prem mode --player-path must be provided'));
+            throw new ArgError('in selenium on prem mode --player-path must be provided');
         }
         if (mode === 'extension' && !extensionPath && !ext) {
-            return Promise.reject(new ArgError('In extension on prem mode --ext or --extension-path must be provided'));
+            throw new ArgError('In extension on prem mode --ext or --extension-path must be provided');
         }
     }
     const isPOC = Boolean(activePlan.isPoc);
@@ -153,16 +151,14 @@ function setCompany(options, company) {
         isStartUp,
         activePlan,
     };
-    return undefined;
 }
 
 function setSystemInfo(options, editorConfig) {
     if (EDITOR_URL) {
         options.editorUrl = EDITOR_URL;
-        return Promise.resolve();
+        return;
     }
     options.editorUrl = editorConfig.editorUrl;
-    return undefined;
 }
 
 function setAllGrids(options, allGrids) {
@@ -198,7 +194,7 @@ async function setMockNetworkRules(options) {
     }
 }
 
-function runRunner(options, customExtensionLocalLocation) {
+async function runRunner(options, customExtensionLocalLocation) {
     perf.log('in runner.js runRunner');
 
     const { project, remoteRunId, useLocalChromeDriver, useChromeLauncher } = options;
@@ -210,15 +206,21 @@ function runRunner(options, customExtensionLocalLocation) {
     npmDriver.checkNpmVersion();
     perf.log('in runner.js after checkNpmVersion');
 
-    return validateCliAccount(options)
-        .log('in runRunner before tunnel.connect')
-        .then(() => tunnel.connect(options))
-        .log('in runRunner after tunnel.connect')
-        .then(() => new TestPlanRunner(customExtensionLocalLocation).run(options))
-        .log('before tunnel.disconnect')
-        .tap(() => tunnel.disconnect(options))
-        .tap(() => gridService.keepAlive.end(project))
-        .log('after tunnel.disconnect and gridService.keepAlive.end');
+    await validateCliAccount(options);
+
+    perf.log('in runRunner before tunnel.connect');
+    await tunnel.connect(options);
+    perf.log('in runRunner after tunnel.connect');
+
+    const testPlanRunner = new TestPlanRunner(customExtensionLocalLocation);
+    const results = await testPlanRunner.run(options);
+
+    perf.log('before tunnel.disconnect');
+    await tunnel.disconnect(options);
+    await gridService.keepAlive.end(project);
+    perf.log('after tunnel.disconnect and gridService.keepAlive.end');
+
+    return results;
 }
 
 function showFreeGridRunWarningIfNeeded(options) {
@@ -237,7 +239,7 @@ function showFreeGridRunWarningIfNeeded(options) {
  * - Reporting the user to analytics
  * - Authenticating the user and exchanging their token for a jwt
  * - Sets the grids for the company and validates the user has permission to run the CLI
- * @param {Object} options - the run options rpassed to the CLI, namely the project and token
+ * @param {Object} options - the run options passed to the CLI, namely the project and token
  */
 async function init(options) {
     perf.log('start runner init');
@@ -273,6 +275,7 @@ async function init(options) {
     }
 
     if (options.lightweightMode && options.lightweightMode.type === 'turboMode') {
+        // eslint-disable-next-line max-len
         console.log('\nTurbo mode will ignore step delays. Test artifacts like screenshots and logs will only be saved for failed runs. For more information see our docs: https://help.testim.io/docs/turbo-mode');
     }
 
@@ -288,5 +291,5 @@ async function init(options) {
 
 module.exports = {
     run: runRunner,
-    init: Promise.method(init),
+    init,
 };

package/services/lambdatestService.js

@@ -1,6 +1,6 @@
 const os = require('os');
 const childProcess = require('child_process');
-const Promise = require('bluebird');
+const pRetry = require('p-retry');
 const fse = require('fs-extra');
 const portfinder = require('portfinder');
 const ms = require('ms');
@@ -154,7 +154,7 @@ class LambdatestService {
 
         // verify that LT tunnel strated successfully
         try {
-            const ltInfo = await utils.runWithRetries(() => httpRequest.get(`http://127.0.0.1:${infoAPIPort}/api/v1.0/info`, {}, {}, undefined, { skipProxy: true }), 30, 2000);
+            const ltInfo = await pRetry(() => httpRequest.get(`http://127.0.0.1:${infoAPIPort}/api/v1.0/info`, {}, {}, undefined, { skipProxy: true }), { retries: 30, minTimeout: 2000 });
             logger.info('LT tunnel info', ltInfo);
         } catch (err) {
             logger.error('Failed to start LT tunnel', { err, stdoutResult, stderrResult });

package/services/lambdatestService.test.js

@@ -4,6 +4,7 @@ const httpRequest = require('../commons/httpRequest');
 const LambdatestService = require('./lambdatestService');
 const utils = require('../utils');
 const fse = require('fs-extra');
+const { AbortError } = require('p-retry');
 const os = require('os');
 const childProcess = require('child_process');
 const EventEmitter = require('events');
@@ -312,7 +313,7 @@ describe('LambdatestService', () => {
             sinon.assert.calledOnce(httpGetStub);
         });
         it('should throw when tunnel did not start', async () => {
-            sandbox.stub(utils, 'runWithRetries').rejects(new Error('tunnel did not start'));
+            httpGetStub.rejects(new AbortError('tunnel did not start'));
             await expect(LambdatestService.connectTunnel({ ...credentials })).to.be.rejectedWith(Error, 'tunnel did not start');
             processMock.stdout.emit('data', '');
             processMock.stderr.emit('data', '');

package/testRunHandler.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const pRetry = require('p-retry');
 const _ = require('lodash');
 const testimCustomToken = require('./commons/testimCustomToken');
 const remoteStepService = require('./commons/socket/remoteStepService');
@@ -312,12 +313,12 @@ class TestRun {
             const { sessionId: extensionSessionId } = extensionSession || {};
             perf.log('before Runtime.evaluate');
 
-            await utils.runWithRetries(async () => {
+            await pRetry(async () => {
                 const { result } = await cdpTestRunner.cdpCommand('Runtime.evaluate', { expression: 'typeof runTestimTest !== \'undefined\'', returnByValue: true }, extensionSessionId);
                 if (!result.value) {
                     throw new Error('runTestimTest not available on global scope');
                 }
-            }, 100, 30);
+            }, { retries: 100, minTimeout: 30 });
 
             perf.log('after wait for runTestimTest function');
             const { result } = await cdpTestRunner.cdpCommand(
@@ -519,7 +520,10 @@ class TestRun {
                 waitForTestEnd();
             }
         })
-            .tap(() => this.onCompletedCleanup())
+            .then(async res => {
+                await this.onCompletedCleanup();
+                return res;
+            })
             .finally(() => onConnected && !this._options.disableSockets && testResultService.off('socket-connected', onConnected));
     }
 

package/testRunStatus.js

@@ -442,7 +442,8 @@ RunStatus.prototype.executionStart = function (executionId, projectId, startTime
                     logger.error('Failed to start suite', { err });
                     // eslint-disable-next-line no-console
                     console.error('Failed to start test run. Please contact support@testim.io');
-                }).return({ beforeTests, tests, afterTests });
+                })
+                .then(() => ({ beforeTests, tests, afterTests }));
         });
 };
 

package/utils.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const moment = require('moment');
-const retry = require('bluebird-retry');
+const pRetry = require('p-retry');
 const _ = require('lodash');
 const Promise = require('bluebird');
 const fs = Promise.promisifyAll(require('fs'));
@@ -10,6 +10,10 @@ const { sessionType, testStatus: testStatusConst } = require('./commons/constant
 const path = require('path');
 const httpRequest = require('./commons/httpRequest');
 const decompress = require('decompress');
+const os = require('os');
+
+const HOMEDIR = os.homedir();
+const TESTIM_BROWSER_DIR = path.join(HOMEDIR, '.testim-browser-profile');
 
 const OSS = [
     { osName: 'Linux', bs: { os: 'LINUX' }, sl: { platform: 'Linux' } },
@@ -96,17 +100,6 @@ function getDurationSec(ms) {
     return moment.duration(ms).asSeconds();
 }
 
-function runWithRetries(task, times, interval, predicate) {
-    times = times || 3;
-    interval = interval || 3000;
-
-    const opt = { max_tries: times, interval, throw_original: true };
-    if (predicate) {
-        opt.predicate = predicate;
-    }
-    return retry(task, opt);
-}
-
 function getRunnerVersion() {
     try {
         const pack = require(`${__dirname}/package.json`);
@@ -194,7 +187,7 @@ function extractElementId(element) {
 }
 
 function isURL(path) {
-    const legacyPattern = new RegExp('^(https?:\\/\\/)', 'i');
+    const legacyPattern = /^(https?:\/\/)/i;
 
     // https://gist.github.com/dperini/729294 (validator.js based on).
     const pattern = new RegExp(
@@ -243,7 +236,7 @@ function isURL(path) {
 }
 
 const DOWNLOAD_RETRY = 3;
-const download = async (url) => runWithRetries(() => httpRequest.download(url), DOWNLOAD_RETRY);
+const download = async (url) => pRetry(() => httpRequest.download(url), { retries: DOWNLOAD_RETRY });
 
 const downloadAndSave = async (url, saveToLocation) => {
     const res = await download(url);
@@ -311,6 +304,16 @@ function getPlanType(plan) {
     return 'free';
 }
 
+/**
+ * @param time {number} in ms
+ * @returns {Promise}
+ */
+function delay(time) {
+    return new Promise(((resolve) => {
+        setTimeout(resolve, time);
+    }));
+}
+
 const calcPercentile = (arr, percentile) => {
     if (arr.length === 0) return 0;
     if (typeof percentile !== 'number') throw new TypeError('p must be a number');
@@ -357,12 +360,45 @@ function groupTestsByRetries(testResults = []) { // NOTE: This duplicates a func
         .value();
 }
 
+async function getCdpAddressForHost(browserInstanceHost, timeout) {
+    try {
+        /**
+            Example response:
+            {
+                "Browser": "Chrome/81.0.4044.138",
+                "Protocol-Version": "1.3",
+                "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36",
+                "V8-Version": "8.1.307.32",
+                "WebKit-Version": "537.36 (@8c6c7ba89cc9453625af54f11fd83179e23450fa)",
+                "webSocketDebuggerUrl": "ws://localhost:58938/devtools/browser/d4290379-ec08-4d03-a41a-ab9d9d4c36ac"
+            }
+        */
+        const debuggerAddress = await httpRequest.get(`http://${browserInstanceHost}/json/version`, undefined, undefined, timeout);
+        return debuggerAddress.webSocketDebuggerUrl;
+    } catch (e) {
+        throw new Error('unable to connect to devtools server');
+    }
+}
+
+function getArgsOnRemoteRunFailure() {
+    const { argv: args } = process;
+    if (!args.includes('--remoteRunId')) {
+        return undefined;
+    }
+    return {
+        remoteRunId: args[args.indexOf('--remoteRunId') + 1],
+        projectId: args[args.indexOf('--project') + 1],
+        token: args[args.indexOf('--token') + 1],
+    };
+}
+
+
 module.exports = {
+    TESTIM_BROWSER_DIR,
     removePropertyFromObject,
     getTestUrl,
     getDuration,
     getDurationSec,
-    runWithRetries,
     getRunnerVersion,
     getEnginesVersion,
     getEnginesVersionAsync,
@@ -391,4 +427,7 @@ module.exports = {
     isQuarantineAndNotRemoteRun,
     groupTestsByRetries,
     getPlanType,
+    delay,
+    getCdpAddressForHost,
+    getArgsOnRemoteRunFailure,
 };

package/utils.test.js

@@ -39,4 +39,30 @@ describe('utils', () => {
                 .to.equal('http://localhost:8080/#/project/project/branch/encoded%2520branch/test/test?result-id=result');
         });
     });
+
+    describe('getArgsOnRemoteRunFailure', () => {
+        let originalArgv;
+
+        beforeEach(() => {
+            originalArgv = process.argv;
+        });
+
+        afterEach(() => {
+            process.argv = originalArgv;
+        });
+
+        it('should return undefined if no remote run is current', () => {
+            process.argv = ['node', 'file.js', '--token', 'token', '--project', 'project-id'];
+            expect(utils.getArgsOnRemoteRunFailure()).to.be.undefined;
+        });
+
+        it('should return details if remote run is current', () => {
+            process.argv = ['node', 'file.js', '--token', 'token', '--project', 'project-id', '--remoteRunId', 'remote-run-id'];
+            expect(utils.getArgsOnRemoteRunFailure()).to.eql({
+                remoteRunId: 'remote-run-id',
+                projectId: 'project-id',
+                token: 'token',
+            });
+        });
+    });
 });

package/workers/BaseWorker.js

@@ -2,6 +2,7 @@
 
 const Bluebird = require('bluebird');
 const moment = require('moment');
+const pRetry = require('p-retry');
 const ms = require('ms');
 
 const { timeoutMessages, testRunStatus, stepResult, runnerTestStatus } = require('../commons/constants');
@@ -116,7 +117,8 @@ class BaseWorker {
         try {
             perf.log('before getSlotOnce retries');
             let failedGetSlotAttempts = 0;
-            let gridInfo = await utils.runWithRetries(async () => {
+
+            let gridInfo = await pRetry(async () => {
                 const startTime = Date.now();
                 try {
                     return await Bluebird.resolve(this.getSlotOnce(testRunHandler))
@@ -124,10 +126,10 @@ class BaseWorker {
                 } catch (error) {
                     logger.error('error getting grid slot', { error, testId: this.testId, testResultId: this.testResultId, executionId: this.executionId });
                     failedGetSlotAttempts++;
-                    await Bluebird.delay(this.options.getBrowserTimeout - (Date.now() - startTime));
+                    await utils.delay(this.options.getBrowserTimeout - (Date.now() - startTime));
                     throw error;
                 }
-            }, this.options.getBrowserRetries);
+            }, { retries: this.options.getBrowserRetries - 1, minTimeout: 0 });
             perf.log('after getSlotOnce retries');
 
             perf.log('before getBrowserOnce retries');
@@ -136,7 +138,7 @@ class BaseWorker {
                 throw new Error('No free browser slots in desired grid');
             }
             let failedGetBrowserAttempts = 0;
-            testPlayer = await utils.runWithRetries(async () => {
+            testPlayer = await pRetry(async () => {
                 const startTime = Date.now();
                 const player = this.initPlayer(testRunHandler);
                 try {
@@ -162,11 +164,11 @@ class BaseWorker {
                     player.onDone();
 
                     if (!(error instanceof PageNotAvailableError)) {
-                        await Bluebird.delay(this.options.getBrowserTimeout - (Date.now() - startTime));
+                        await utils.delay(this.options.getBrowserTimeout - (Date.now() - startTime));
                     }
                     throw error;
                 }
-            }, getBrowserRetriesNumber, undefined, (err) => !(err instanceof PageNotAvailableError));
+            }, { retries: getBrowserRetriesNumber - 1, minTimeout: 0 });
             perf.log('after getBrowserOnce retries');
         } catch (err) {
             await releasePlayer(this.id, this.releaseSlotOnTestFinished, projectId, testPlayer);
@@ -235,7 +237,7 @@ class BaseWorker {
                 testResult.testRetryKey = testRetryKey;
                 await this.onTestCompleted(this.id, this.testId, testResult, sessionId, shouldRerun);
                 if (this.executionQueue.hasMoreTests() && !(this.options.lightweightMode && this.options.lightweightMode.general)) {
-                    await Bluebird.delay(DELAY_BETWEEN_TESTS);
+                    await utils.delay(DELAY_BETWEEN_TESTS);
                 }
                 await this.runTestCleanup();
                 if (shouldRerun) {

package/workers/BaseWorker.test.js

@@ -3,10 +3,9 @@ const proxyquire = require('proxyquire');
 const { expect, sinon } = require('../../test/utils/testUtils');
 const gridService = require('../services/gridService');
 const reporter = require('../reports/reporter');
-const Bluebird = require('bluebird');
 const { PageNotAvailableError, GridError, GetBrowserError } = require('../errors');
 const servicesApi = require('../commons/testimServicesApi');
-const { releasePlayer } = require('./workerUtils');
+const utils = require('../utils');
 
 
 describe('BaseWorker', () => {
@@ -41,7 +40,7 @@ describe('BaseWorker', () => {
         getGridSlotStub = sinon.stub(gridService, 'getGridSlot').resolves({});
 
 
-        sandbox.stub(Bluebird, 'delay').returns(Promise.resolve());
+        sandbox.stub(utils, 'delay').returns(Promise.resolve());
         sandbox.stub(reporter);
     });
 
@@ -57,7 +56,7 @@ describe('BaseWorker', () => {
             it('should get grid slot from server', async () => {
                 await worker.getTestPlayer(testRunHandlerMock);
                 sinon.assert.calledOnce(getGridSlotStub);
-                sinon.assert.notCalled(Bluebird.delay);
+                sinon.assert.notCalled(utils.delay);
             });
             it('should retry getting slot until it succeeds', async () => {
                 getGridSlotStub.onFirstCall().rejects();
@@ -65,7 +64,7 @@ describe('BaseWorker', () => {
 
                 await worker.getTestPlayer(testRunHandlerMock);
                 sinon.assert.calledTwice(getGridSlotStub);
-                sinon.assert.calledTwice(Bluebird.delay);
+                sinon.assert.calledOnce(utils.delay);
             });
             it('should not proceed to getting browser if all retries used for getting a slot', async () => {
                 getGridSlotStub.resolves({});
@@ -74,7 +73,7 @@ describe('BaseWorker', () => {
                 sinon.assert.calledOnce(getGridSlotStub);
                 sinon.assert.notCalled(worker.getBrowserOnce);
                 sinon.assert.notCalled(worker.initPlayer);
-                sinon.assert.notCalled(Bluebird.delay);
+                sinon.assert.notCalled(utils.delay);
             });
         });
 
@@ -84,7 +83,7 @@ describe('BaseWorker', () => {
                 sinon.assert.calledOnce(getGridSlotStub);
                 sinon.assert.calledOnce(worker.getBrowserOnce);
                 sinon.assert.calledOnce(worker.initPlayer);
-                sinon.assert.notCalled(Bluebird.delay);
+                sinon.assert.notCalled(utils.delay);
             });
             it('should retry getting browser until it succeeds', async () => {
                 worker.getBrowserOnce.onFirstCall().rejects();
@@ -95,16 +94,16 @@ describe('BaseWorker', () => {
                 sinon.assert.calledTwice(worker.getBrowserOnce);
                 sinon.assert.calledTwice(worker.initPlayer);
                 sinon.assert.calledOnce(testPlayerMock.onDone);
-                sinon.assert.calledTwice(Bluebird.delay);
+                sinon.assert.calledOnce(utils.delay);
             });
             it('should not retry if page is not available', async () => {
                 worker.getBrowserOnce.throws(() => new PageNotAvailableError());
 
-                await expect(worker.getTestPlayer(testRunHandlerMock)).to.eventually.be.rejectedWith(PageNotAvailableError);
+                await expect(worker.getTestPlayer(testRunHandlerMock)).to.eventually.be.rejectedWith(Error);
                 sinon.assert.calledOnce(getGridSlotStub);
                 sinon.assert.calledOnce(worker.getBrowserOnce);
                 sinon.assert.calledOnce(testPlayerMock.onDone);
-                sinon.assert.notCalled(Bluebird.delay);
+                sinon.assert.notCalled(utils.delay);
             });
             it('should handle get grid error', async () => {
                 worker.getBrowserOnce.throws(() => new GridError());
@@ -153,8 +152,8 @@ describe('BaseWorker', () => {
                 getHybridGridProviderStub.onFirstCall().resolves({ provider: 'loacker', connectionDetails: { host: 'localhost', external: { user: 'user', key: 'password' } } });
                 getHybridGridProviderStub.onSecondCall().resolves({ provider: 'nitzan', connectionDetails: { host: 'google.com', port: 443 } });
                 getHybridGridProviderStub.onThirdCall().resolves({ provider: 'a', connectionDetails: { host: 'google.com', port: 4444 } });
-                worker.getBrowserOnce.onFirstCall().rejects();
-                worker.getBrowserOnce.onSecondCall().rejects();
+                worker.getBrowserOnce.onFirstCall().rejects(new Error());
+                worker.getBrowserOnce.onSecondCall().rejects(new Error());
                 worker.getBrowserOnce.onThirdCall().resolves({});
 
                 await worker.getTestPlayer(testRunHandlerMock);