@testim/testim-cli 3.266.0 → 3.267.0

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@testim/testim-cli",
-  "version": "3.266.0",
+  "version": "3.267.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@testim/testim-cli",
-      "version": "3.266.0",
+      "version": "3.267.0",
       "license": "Proprietary",
       "dependencies": {
         "@applitools/eyes-sdk-core": "13.11.21",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testim/testim-cli",
-  "version": "3.266.0",
+  "version": "3.267.0",
   "description": "Command line interface for running Testing on your CI",
   "author": "Oren Rubin",
   "contributors": [{

package/runners/ParallelWorkerManager.js

@@ -14,11 +14,18 @@ const { StopRunOnError } = require('../errors');
 
 require('../player/webdriver'); // preload
 
+/**
+ * @template {unknown[]} T
+ * @typedef {T extends [infer H, ...infer R] ? R : T} RemoveFirst
+ */
+
 class ParallelWorkerManager {
+    /** @param {string=} customExtensionLocalLocation */
     constructor(customExtensionLocalLocation) {
         this.customExtensionLocalLocation = customExtensionLocalLocation;
     }
 
+    /** @param {typeof CLI_MODE[keyof typeof CLI_MODE]} mode */
     getWorkerType(mode) {
         switch (mode) {
             case CLI_MODE.SELENIUM:
@@ -33,6 +40,12 @@ class ParallelWorkerManager {
         }
     }
 
+    /**
+     * @param {number} count
+     * @param {ExecutionQueue} queue
+     * @param {typeof CLI_MODE[keyof typeof CLI_MODE]} mode
+     * @param  {...RemoveFirst<ConstructorParameters<typeof import('../workers/BaseWorker')>>} args
+     */
     createWorkers(count, queue, mode, ...args) {
         const Worker = this.getWorkerType(mode);
         const createWorker = () => {
@@ -47,6 +60,17 @@ class ParallelWorkerManager {
         return Array.from(new Array(count), createWorker);
     }
 
+    /**
+     * @param {import('./TestPlanRunner').ExecutionList} testList
+     * @param {import('../testRunStatus')} testStatus
+     * @param {string} executionId
+     * @param {string} executionName
+     * @param {import('../runOptions').RunnerOptions} options
+     * @param {string} branchToUse
+     * @param {ReturnType<typeof testimCustomToken['getTokenV3UserData']>} authData
+     * @param {number} workerCount
+     * @param {boolean} stopOnError
+     */
     async runTests(testList, testStatus, executionId, executionName, options, branchToUse, authData, workerCount, stopOnError) {
         if (testList && testList.length === 0) {
             return undefined;
@@ -72,6 +96,13 @@ class ParallelWorkerManager {
             const lightweightMode = options.lightweightMode;
             const sessionType = utils.getSessionType(options);
 
+            /**
+             * @param {number} wid
+             * @param {string} testId
+             * @param {string} resultId
+             * @param {boolean | undefined} isRerun
+             * @param {`${number}:${number}`} testRetryKey
+             */
             const onTestStarted = (wid, testId, resultId, isRerun, testRetryKey) => {
                 runningTests++;
                 analyticsService.analyticsTestStart({
@@ -93,6 +124,13 @@ class ParallelWorkerManager {
                 return testStatus.testStartAndReport(wid, executionId, resultId, isRerun, testRetryKey);
             };
 
+            /**
+             * @param {number} wid
+             * @param {string} testId
+             * @param {*} testResult
+             * @param {string} sessionId
+             * @param {boolean | undefined} isRerun
+             */
             const onTestCompleted = async (wid, testId, testResult, sessionId, isRerun) => {
                 runningTests--;
                 const update = {};
@@ -135,7 +173,7 @@ class ParallelWorkerManager {
                     .catch(err => logger.error('testEndAndReport threw an error', { err }));
 
                 if (isRerun) {
-                    return undefined;
+                    return;
                 }
                 combinedTestResults[testResult.resultId] = testResult;
                 analyticsService.analyticsTestEnd({
@@ -163,11 +201,13 @@ class ParallelWorkerManager {
                 const completedTests = Object.keys(combinedTestResults).length;
                 if (completedTests === testCount || (stoppedOnError && runningTests === 0)) {
                     resolve(combinedTestResults);
-                    return undefined;
                 }
-                return undefined;
             };
 
+            /**
+             * @param {number} wid
+             * @param {{ name: string; testId: string; resultId: string; runnerStatus: 'SKIPPED'; testStatus: 'quarantine' }} testResult
+             */
             const onTestIgnored = (wid, testResult) => {
                 combinedTestResults[testResult.resultId] = testResult;
                 testStatus.onTestIgnored(wid, testResult.resultId);
@@ -178,7 +218,7 @@ class ParallelWorkerManager {
                 }
             };
 
-            const onGridSlot = (_executionId, resultId, gridInfo) => testStatus.onGridSlot(_executionId, resultId, gridInfo);
+            const onGridSlot = (resultId, gridInfo) => testStatus.onGridSlot(resultId, gridInfo);
 
             options.userData = {
                 loginData: Object.assign({}, testimCustomToken.getTokenV3UserData(), {
@@ -191,14 +231,24 @@ class ParallelWorkerManager {
                 servicesUrl: config.SERVICES_HOST,
             };
             perf.log('in localStrategy before createWorker');
-            this.createWorkers(workerCount, executionQueue, options.mode, options, this.customExtensionLocalLocation, executionId, onTestStarted, onTestCompleted, onGridSlot, onTestIgnored)
-                .forEach((worker, index) => {
-                    perf.log('before schedule worker.run after createWorkers');
-                    schedule(() => {
-                        perf.log('right before worker.run');
-                        worker.run();
-                    }, index);
-                });
+            this.createWorkers(
+                workerCount,
+                executionQueue,
+                options.mode,
+                options,
+                this.customExtensionLocalLocation,
+                executionId,
+                onTestStarted,
+                onTestCompleted,
+                onGridSlot,
+                onTestIgnored,
+            ).forEach((worker, index) => {
+                perf.log('before schedule worker.run after createWorkers');
+                schedule(() => {
+                    perf.log('right before worker.run');
+                    worker.run();
+                }, index);
+            });
         });
 
         try {
@@ -215,6 +265,10 @@ class ParallelWorkerManager {
     }
 }
 
+/**
+ * @param {Function} fn
+ * @param {number} index
+ */
 function schedule(fn, index) {
     if (index === 0) {
         fn();

package/runners/TestPlanRunner.js

@@ -26,9 +26,7 @@ const TDK_CHILD_RESULTS_TIMEOUT = 1000 * 60 * 5;
 /** @typedef {Awaited<ReturnType<typeof getSuite>>['tests'][number]} ExecutionList */
 
 class TestPlanRunner {
-    /**
-     * @param {string=} customExtensionLocalLocation
-     */
+    /** @param {string=} customExtensionLocalLocation */
     constructor(customExtensionLocalLocation) {
         this.workerManager = new ParallelWorkerManager(customExtensionLocalLocation);
         this.startTime = Date.now();
@@ -115,7 +113,7 @@ class TestPlanRunner {
                 }
                 const { runKey: apiKey, url: serverUrl } = applitoolsIntegrationData;
                 const tmpSDK = require('@applitools/eyes-sdk-core').makeSDK({ name: 'Testim.io', version: '4.0.0', spec: {} });
-                await tmpSDK.closeBatch({ settings: { batchId: executionId, serverUrl, apiKey } });
+                await tmpSDK.closeBatches({ settings: { batchIds: [executionId], serverUrl, apiKey } });
             } catch (err) {
                 // If a batch with this name did not exist, do not log an error.
                 if (err.message && (err.message.startsWith('Request failed with status code 404') || err.message.startsWith('no batchIds were set'))) {

package/services/gridService.js

@@ -59,38 +59,47 @@ function getSerializableObject(grid) {
     };
 }
 
-function handleGetGridResponse(projectId, companyId, workerId, browser, getFun) {
-    return getFun()
-        .catch(err => {
-            logger.error('failed to get grid', { projectId, companyId, err });
-            throw new Error(gridMessages.UNKNOWN);
-        })
-        .then(async (res) => {
-            logger.info('get grid info', Object.assign({}, res, { projectId, companyId }));
-            const isSuccess = () => res.status === 'success';
-            const isError = () => res.status === 'error' && res.code;
-            if (!res || (!isError() && !isSuccess())) {
-                logger.error('invalid response - get grid', { res });
-                throw new Error(gridMessages.UNKNOWN);
-            }
-
-            if (isSuccess()) {
-                const serGrid = getSerializableObject(res.grid);
-                module.exports.addItemToGridCache(workerId, companyId, serGrid.gridId, serGrid.slotId, browser);
-                return serGrid;
-            }
-
-            if (isError() && res.code === 'not-found') {
-                throw new GridError(gridMessages.NOT_FOUND);
-            }
-
-            if (isError() && res.code === 'no-available-slot') {
-                throw new GridError(`Failed to run test on ${browser} - concurrency limit reached`);
-            }
-
-            logger.error('invalid code error response - get grid', { res });
-            throw new GridError(gridMessages.UNKNOWN);
-        });
+/**
+ * @template {{ status: string; code?: string; grid: * }} T
+ * @param {string} projectId
+ * @param {string} companyId
+ * @param {number} workerId
+ * @param {string} browser
+ * @param {() => Promise<T>} getFun
+ */
+async function handleGetGridResponse(projectId, companyId, workerId, browser, getFun) {
+    /** @type {T} */
+    let res;
+    try {
+        res = await getFun();
+    } catch (err) {
+        logger.error('failed to get grid', { projectId, companyId, err });
+        throw new Error(gridMessages.UNKNOWN);
+    }
+    logger.info('get grid info', Object.assign({}, res, { projectId, companyId }));
+    const isSuccess = () => res.status === 'success';
+    const isError = () => res.status === 'error' && res.code;
+    if (!res || (!isError() && !isSuccess())) {
+        logger.error('invalid response - get grid', { res });
+        throw new Error(gridMessages.UNKNOWN);
+    }
+
+    if (isSuccess()) {
+        const serGrid = getSerializableObject(res.grid);
+        module.exports.addItemToGridCache(workerId, companyId, serGrid.gridId, serGrid.slotId, browser);
+        return serGrid;
+    }
+
+    if (isError() && res.code === 'not-found') {
+        throw new GridError(gridMessages.NOT_FOUND);
+    }
+
+    if (isError() && res.code === 'no-available-slot') {
+        throw new GridError(`Failed to run test on ${browser} - concurrency limit reached`);
+    }
+
+    logger.error('invalid code error response - get grid', { res });
+    throw new GridError(gridMessages.UNKNOWN);
 }
 
 function addItemToGridCache(workerId, companyId, gridId, slotId, browser) {
@@ -264,7 +273,13 @@ async function getGridData(options) {
     throw new GridError('Missing host or grid configuration');
 }
 
-async function getGridSlot(browser, executionId, testResultId, onGridSlot, options, workerId) {
+/**
+ * @param {string} browser
+ * @param {string} executionId
+ * @param {import('../runOptions')} options
+ * @param {number} workerId
+ */
+async function getGridSlot(browser, executionId, options, workerId) {
     const getGridDataFromServer = async () => {
         const { host, project, grid, gridId, useLocalChromeDriver, useChromeLauncher, company = {} } = options;
         const companyId = company.companyId;
@@ -284,9 +299,6 @@ async function getGridSlot(browser, executionId, testResultId, onGridSlot, optio
     };
 
     const gridInfo = await getGridDataFromServer();
-
-    await onGridSlot(executionId, testResultId, gridInfo);
-
     return gridInfo;
 }
 

package/services/gridService.test.js

@@ -169,14 +169,12 @@ describe('gridService', () => {
     describe('getGridSlot', () => {
         let getGridByIdStub;
         let getGridByNameStub;
-        let onGridSlot;
         let addItemToGridCacheStub;
 
         beforeEach(() => {
             getGridByIdStub = sinon.stub(servicesApi, 'getGridById').resolves({ grid: { gridId: 'gridId', type: 'gridId' }, status: 'success' });
             getGridByNameStub = sinon.stub(servicesApi, 'getGridByName').resolves({ grid: { gridId: 'gridId', type: 'gridName' }, status: 'success' });
             addItemToGridCacheStub = sinon.stub(gridService, 'addItemToGridCache').callThrough();
-            onGridSlot = sinon.stub().resolves();
         });
         afterEach(() => {
             getGridByIdStub.restore();
@@ -185,82 +183,77 @@ describe('gridService', () => {
         });
 
         it('should not access server when using useLocalChromeDriver flag', async () => {
-            const slot = await gridService.getGridSlot('browser', 'executionId', 'testResultId', onGridSlot, { useLocalChromeDriver: true }, 'workerId');
+            const slot = await gridService.getGridSlot('browser', 'executionId', { useLocalChromeDriver: true }, 'workerId');
             expect(slot).to.eql({ mode: 'local' });
             sinon.assert.notCalled(getGridByIdStub);
             sinon.assert.notCalled(getGridByNameStub);
             sinon.assert.notCalled(addItemToGridCacheStub);
-            sinon.assert.calledOnce(onGridSlot);
         });
 
         it('should not access server when using useChromeLauncher flag', async () => {
-            const slot = await gridService.getGridSlot('browser', 'executionId', 'testResultId', onGridSlot, { useChromeLauncher: true }, 'workerId');
+            const slot = await gridService.getGridSlot('browser', 'executionId', { useChromeLauncher: true }, 'workerId');
             expect(slot).to.eql({ mode: 'local' });
             sinon.assert.notCalled(getGridByIdStub);
             sinon.assert.notCalled(getGridByNameStub);
             sinon.assert.notCalled(addItemToGridCacheStub);
-            sinon.assert.calledOnce(onGridSlot);
         });
 
         it('should return fixed grid when passing host and port', async () => {
-            const slot = await gridService.getGridSlot('browser', 'executionId', 'testResultId', onGridSlot, { host: 'localhost', port: 4444 }, 'workerId');
+            const slot = await gridService.getGridSlot('browser', 'executionId', { host: 'localhost', port: 4444 }, 'workerId');
             expect(slot).to.shallowDeepEqual({ type: 'hostAndPort', host: 'localhost', port: 4444 });
             sinon.assert.notCalled(getGridByIdStub);
             sinon.assert.notCalled(getGridByNameStub);
             sinon.assert.notCalled(addItemToGridCacheStub);
-            sinon.assert.calledOnce(onGridSlot);
         });
 
         it('should get grid from server when passing grid id', async () => {
-            const slot = await gridService.getGridSlot('browser', 'executionId', 'testResultId', onGridSlot, { gridId: 'gridId' }, 'workerId');
+            const slot = await gridService.getGridSlot('browser', 'executionId', { gridId: 'gridId' }, 'workerId');
             expect(slot).to.shallowDeepEqual({ type: 'gridId', gridId: 'gridId' });
             sinon.assert.calledOnce(getGridByIdStub);
             sinon.assert.notCalled(getGridByNameStub);
             sinon.assert.calledOnce(addItemToGridCacheStub);
-            sinon.assert.calledOnce(onGridSlot);
         });
 
         it('should get grid from server when passing grid name', async () => {
-            const slot = await gridService.getGridSlot('browser', 'executionId', 'testResultId', onGridSlot, { grid: 'gridName' }, 'workerId');
+            const slot = await gridService.getGridSlot('browser', 'executionId', { grid: 'gridName' }, 'workerId');
             expect(slot).to.shallowDeepEqual({ type: 'gridName', gridId: 'gridId' });
             sinon.assert.calledOnce(getGridByNameStub);
             sinon.assert.notCalled(getGridByIdStub);
             sinon.assert.calledOnce(addItemToGridCacheStub);
-            sinon.assert.calledOnce(onGridSlot);
         });
 
         it('should handle grid not found error', async () => {
             getGridByIdStub.resolves({ status: 'error', code: 'not-found' });
-            await expect(gridService.getGridSlot('browser', 'executionId', 'testResultId', onGridSlot, { gridId: 'gridId' }, 'workerId'))
+            await expect(gridService.getGridSlot('browser', 'executionId', { gridId: 'gridId' }, 'workerId'))
                 .to.eventually.be.rejectedWith('The specified grid is not available');
         });
 
         it('should handle no available slot error', async () => {
             getGridByIdStub.resolves({ status: 'error', code: 'no-available-slot' });
-            await expect(gridService.getGridSlot('browser', 'executionId', 'testResultId', onGridSlot, { gridId: 'gridId' }, 'workerId'))
+            await expect(gridService.getGridSlot('browser', 'executionId', { gridId: 'gridId' }, 'workerId'))
                 .to.eventually.be.rejectedWith('Failed to run test on browser - concurrency limit reached');
         });
 
         it('should handle getGridSlot request error', async () => {
             getGridByIdStub.rejects({ status: 'error', code: 'not-found' });
-            await expect(gridService.getGridSlot('browser', 'executionId', 'testResultId', onGridSlot, { gridId: 'gridId' }, 'workerId'))
+            await expect(gridService.getGridSlot('browser', 'executionId', { gridId: 'gridId' }, 'workerId'))
                 .to.eventually.be.rejectedWith('Test couldn\'t get browser - unknown error');
         });
 
         it('should throw when no grid selected', async () => {
-            await expect(gridService.getGridSlot('browser', 'executionId', 'testResultId', onGridSlot, {}, 'workerId'))
+            await expect(gridService.getGridSlot('browser', 'executionId', {}, 'workerId'))
                 .to.eventually.be.rejectedWith('Missing host or grid configuration');
         });
 
         it('should handle unkonwn errors', async () => {
             getGridByIdStub.resolves({ status: 'error', code: 'bla bla' });
-            await expect(gridService.getGridSlot('browser', 'executionId', 'testResultId', onGridSlot, { gridId: 'gridId' }, 'workerId'))
+            await expect(gridService.getGridSlot('browser', 'executionId', { gridId: 'gridId' }, 'workerId'))
                 .to.eventually.be.rejectedWith('Test couldn\'t get browser - unknown error');
         });
 
         it('should handle no status', async () => {
             getGridByIdStub.resolves({ code: 'bla bla' });
-            await expect(gridService.getGridSlot('browser', 'executionId', 'testResultId', onGridSlot, { gridId: 'gridId' }, 'workerId'))
+            await expect(gridService.getGridSlot('browser', 'executionId', { gridId: 'gridId' }, 'workerId'))
                 .to.eventually.be.rejectedWith('Test couldn\'t get browser - unknown error');
         });
     });

package/testRunStatus.js

@@ -233,7 +233,11 @@ class RunStatus {
         return this.testStartReport(test, executionId, testRetryKey);
     }
 
-    onGridSlot(executionId, resultId, gridInfo) {
+    /**
+     * @param {string} resultId
+     * @param {Awaited<ReturnType<typeof import('./services/gridService')['getGridSlot']>>} gridInfo
+     */
+    onGridSlot(resultId, gridInfo) {
         const test = this.getTestResult(resultId);
         test.config.gridInfo = Object.assign({}, gridInfo, { key: undefined, user: undefined });
         logger.info('on get grid info', { gridInfo: test.config.gridInfo });
@@ -264,6 +268,10 @@ class RunStatus {
         return result.success ? constants.runnerTestStatus.PASSED : constants.runnerTestStatus.FAILED;
     }
 
+    /**
+     * @param {number} wid
+     * @param {Parameters<ConstructorParameters<typeof import('./workers/BaseWorker')>[7]>[1]} resultId
+     */
     onTestIgnored(wid, resultId) {
         const test = this.getTestResult(resultId);
         reporter.onTestIgnored(wid, test, `test in ${constants.testStatus.QUARANTINE}`);

package/workers/BaseWorker.js

@@ -27,6 +27,12 @@ const { SETUP_TIMEOUT, NETWORK_ERROR, GRID_ERROR, BROWSER_CLOSED, SELENIUM_ERROR
 const DELAY_BETWEEN_TESTS = ms('1s');
 let ordinal = 1;
 
+/**
+ * @param {string} testId
+ * @param {string} testName
+ * @param {string} resultId
+ * @param {string} reason
+ */
 function buildFailureResult(testId, testName, resultId, reason) {
     return {
         testId,
@@ -43,10 +49,10 @@ class BaseWorker {
      * @param {import('../runOptions').RunnerOptions} options
      * @param {string=} customExtensionLocalLocation
      * @param {string} executionId
-     * @param {Function} onTestStarted
-     * @param {Function} onTestCompleted
-     * @param {Function} onGridSlot
-     * @param {Function} onTestIgnored
+     * @param {(workerId: number, testId: string, resultId: string, isRerun: boolean | undefined, testRetryKey: `${number}:${number}` ) => Promise<any>} onTestStarted
+     * @param {(workerId: number, testId: string, testResult: any, sessionId: string, shouldRerun: boolean | undefined) => Promise<void>} onTestCompleted
+     * @param {import('../testRunStatus')['onGridSlot']} onGridSlot
+     * @param {(workerId: number, testResult: { name: string; testId: string; resultId: string; runnerStatus: 'SKIPPED'; testStatus: 'quarantine' }) => void} onTestIgnored
      * @param {boolean=} releaseSlotOnTestFinished
      */
     constructor(executionQueue, options, customExtensionLocalLocation, executionId, onTestStarted, onTestCompleted, onGridSlot, onTestIgnored, releaseSlotOnTestFinished = true) {
@@ -75,10 +81,17 @@ class BaseWorker {
         return ordinal++;
     }
 
-    getGridSlot(browser, testRunHandler) {
-        return gridService.getGridSlot(browser, testRunHandler.getExecutionId(), testRunHandler.getTestResultId(), this.onGridSlot, this.options, this.id);
+    /**
+     * @param {string} browser
+     * @param {import('../testRunHandler')} testRunHandler
+     */
+    async getGridSlot(browser, testRunHandler) {
+        const slot = await gridService.getGridSlot(browser, testRunHandler.getExecutionId(), this.options, this.id);
+        this.onGridSlot(testRunHandler.getTestResultId(), slot);
+        return slot;
     }
 
+    /** @param {import('../testRunHandler')} testRunHandler */
     async getSlotOnce(testRunHandler) {
         const { browserValue } = this.testRunConfig;
         reporter.onGetSlot(this.id, browserValue || 'chrome');
@@ -86,6 +99,10 @@ class BaseWorker {
         return gridInfo;
     }
 
+    /**
+     * @abstract
+     * @returns {import('../player/appiumTestPlayer') | import('../player/seleniumTestPlayer')  | import('../player/extensionTestPlayer') | import('../player/chromeLauncherTestPlayer')}
+     */
     initPlayer() {
         throw new NotImplementedError(true);
     }
@@ -94,6 +111,10 @@ class BaseWorker {
         throw new NotImplementedError(true);
     }
 
+    /**
+     * @param {import('../testRunHandler')} testRunHandler
+     * @param {ReturnType<typeof this['initPlayer']>} player
+     */
     async runTestOnce(testRunHandler, player) {
         testRunHandler.setSessionId(player.getSessionId());
         logger.info('Test run started', {
@@ -105,19 +126,20 @@ class BaseWorker {
         return await testRunHandler.clearTestResult();
     }
 
+    /** @param {import('../testRunHandler')} testRunHandler */
     handleQuarantine(testRunHandler) {
-        if (utils.isQuarantineAndNotRemoteRun({ testStatus: testRunHandler.getTestStatus() }, this.options)) {
-            const testResult = {
-                name: testRunHandler.getTestName(),
-                testId: testRunHandler.getTestId(),
-                resultId: testRunHandler.getTestResultId(),
-                runnerStatus: runnerTestStatus.SKIPPED,
-                testStatus: testRunHandler.getTestStatus(),
-            };
-            this.onTestIgnored(this.id, testResult);
-            return testResult;
+        if (!utils.isQuarantineAndNotRemoteRun({ testStatus: testRunHandler.getTestStatus() }, this.options)) {
+            return undefined;
         }
-        return undefined;
+        const testResult = {
+            name: testRunHandler.getTestName(),
+            testId: testRunHandler.getTestId(),
+            resultId: testRunHandler.getTestResultId(),
+            runnerStatus: runnerTestStatus.SKIPPED,
+            testStatus: testRunHandler.getTestStatus(),
+        };
+        this.onTestIgnored(this.id, testResult);
+        return testResult;
     }
 
     setSessionTimeout() {
@@ -127,6 +149,10 @@ class BaseWorker {
         return Math.max(this.lambdatestService.getSessionTimeout, this.options.getSessionTimeout);
     }
 
+    /**
+     * @param {import('../testRunHandler')} testRunHandler
+     * @param {string=} customExtensionLocalLocation
+     */
     async getTestPlayer(testRunHandler, customExtensionLocalLocation) {
         const projectId = this.userData?.projectId;
         let testPlayer;
@@ -202,6 +228,11 @@ class BaseWorker {
         return testPlayer;
     }
 
+    /**
+     * @param {import('../testRunHandler')} testRunHandler
+     * @param {string=} customExtensionLocalLocation
+     * @param {boolean=} shouldRerun
+     */
     async runTest(testRunHandler, customExtensionLocalLocation, shouldRerun) {
         perf.log('inside runTest');
         const projectId = this.userData?.projectId;
@@ -233,6 +264,11 @@ class BaseWorker {
     run() {
         const runNextTest = () => process.nextTick(() => this.run());
 
+        /**
+         * @param {*} testResult
+         * @param {import('../testRunHandler')} testRunHandler
+         * @param {Error=} err
+         */
         const onRunComplete = async (testResult, testRunHandler, err) => {
             if (utils.isQuarantineAndNotRemoteRun(testResult, this.options)) {
                 return runNextTest();
@@ -287,6 +323,10 @@ class BaseWorker {
         const getNetworkErrorMessage = () => 'Due to network connectivity issues, Testim CLI has been unable to connect to the grid.\n' +
                                              `Please make sure the CLI has stable access to the internet. ${didNetworkConnectivityTestFail() ? '(Internal: network connectivity test failed)' : ''}`;
 
+        /**
+         * @param {Error} err
+         * @param {boolean} wasNetworkHealthy
+         */
         const buildError = (err, wasNetworkHealthy) => {
             if (!wasNetworkHealthy && featureFlags.flags.errorMessageOnBadNetwork.isEnabled()) {
                 return {
@@ -344,6 +384,10 @@ class BaseWorker {
             return { errorType: UNKNOWN_ERROR, reason: msg };
         };
 
+        /**
+         * @param {Error} err
+         * @param {import('../testRunHandler')} testRunHandler
+         */
         const onRunError = async (err, testRunHandler) => {
             const wasNetworkHealthy = await isNetworkHealthy();
             if (!wasNetworkHealthy && featureFlags.flags.warnOnBadNetwork.isEnabled()) {
@@ -366,6 +410,10 @@ class BaseWorker {
             await onRunComplete(buildFailureResult(this.testId, this.testName, this.testResultId, reason), testRunHandler, err);
         };
 
+        /**
+         * @param {Error} runError
+         * @param {import('../testRunHandler')} testRunHandler
+         */
         const recoverTestResults = async (runError, testRunHandler) => {
             const testId = this.testId;
             const resultId = this.testResultId;
@@ -401,23 +449,29 @@ class BaseWorker {
         const disableResults = this.options.disableSockets || (this.options.lightweightMode?.disableResults && (this.options.useChromeLauncher || this.options.mode !== 'extension'));
         const disableRemoteStep = this.options.disableSockets || (this.options.lightweightMode?.disableRemoteStep);
 
-        const runTestAndCalcResult = (testRunHandler, shouldRerun) => Promise.all([
-            !disableRemoteStep && remoteStepService.joinToRemoteStep(this.testResultId),
-            !disableResults && testResultService.joinToTestResult(this.testResultId, this.testId),
-        ])
-            .then(() => testRunHandler.validateRunConfig())
-            .then(() => this.runTest(testRunHandler, this.customExtensionLocalLocation, shouldRerun))
-            .then(testResult => onRunComplete(testResult, testRunHandler))
-            .then(result => {
+        /**
+         * @param {import('../testRunHandler')} testRunHandler
+         * @param {boolean=} shouldRerun
+         */
+        const runTestAndCalcResult = async (testRunHandler, shouldRerun) => {
+            try {
+                await Promise.all([
+                    !disableRemoteStep && remoteStepService.joinToRemoteStep(this.testResultId),
+                    !disableResults && testResultService.joinToTestResult(this.testResultId, this.testId),
+                ]);
+                testRunHandler.validateRunConfig();
+                const testResult = await this.runTest(testRunHandler, this.customExtensionLocalLocation, shouldRerun);
+                const result = await onRunComplete(testResult, testRunHandler);
                 perf.log('After onRunComplete');
                 return result;
-            })
-            .catch(runError => recoverTestResults(runError, testRunHandler))
-            .finally(() => {
+            } catch (runError) {
+                return recoverTestResults(runError, testRunHandler);
+            } finally {
                 if (!disableRemoteStep) {
                     remoteStepService.unlistenToRemoteStep(this.testResultId);
                 }
-            });
+            }
+        };
 
         const testRunHandler = this.executionQueue.getNext();
 

package/workers/BaseWorker.test.js

@@ -25,7 +25,7 @@ describe('BaseWorker', () => {
             },
         });
 
-        worker = new BaseWorker(null, {}, null, null, onTestStartedStub);
+        worker = new BaseWorker(null, {}, null, null, onTestStartedStub, null, () => { /* noop */ });
         worker.userData = {};
         worker.options = { gridData: {}, browser: 'chrome', company: { companyId: 'companyId' }, getBrowserTimeout: 1000, getSessionTimeout: 100, getBrowserRetries: 10 };
         worker.testRunConfig = {};

package/workers/WorkerAppium.js

@@ -10,11 +10,6 @@ const AppiumApi = require('../commons/getSessionPlayerRequire').AppiumApi;
 const desiredCapabilitiesBuilder = require('../commons/testimDesiredCapabilitiesBuilder');
 
 class WorkerAppium extends BaseWorker {
-    constructor(...args) {
-        super(...args);
-        this.getBrowserOnce = Promise.method(this.getBrowserOnce);
-    }
-
     initPlayer(testRunHandler) {
         return new AppiumTestPlayer(this.id,
             testRunHandler.getRunParams(),

package/workers/WorkerExtensionSingleBrowser.js

@@ -27,6 +27,11 @@ class WorkerExtensionSingleBrowser extends WorkerExtension {
         return this._getBrowserOnce(testRunHandler, customExtensionLocalLocation, player, gridInfo);
     }
 
+    /**
+     * @override
+     * @param {import('../testRunHandler')} testRunHandler
+     * @param {string=} customExtensionLocalLocation
+     */
     async getTestPlayer(testRunHandler, customExtensionLocalLocation) {
         if (this.testPlayer && !this.testPlayer.driver.isAlive()) {
             logger.warn('WorkerExtensionSingleBrowser is releasing a dead player', { workerId: this.id });

package/workers/WorkerSelenium.js

@@ -17,21 +17,29 @@ const { preloadTests } = require('../commons/preloadTests');
 const NO_NAVIGATION_TIME_LIMIT = 1e9;
 
 class WorkerSelenium extends BaseWorker {
-    constructor(...args) {
-        super(...args);
-        this.getBrowserOnce = Promise.method(this.getBrowserOnce);
-    }
-
+    /**
+     * @override
+     * @param {import('../testRunHandler')} testRunHandler
+     */
     initPlayer(testRunHandler) {
-        return new SeleniumTestPlayer(this.id,
+        return new SeleniumTestPlayer(
+            this.id,
             testRunHandler.getRunParams(),
             this.options.shouldMonitorPerformance,
             testRunHandler.getAutomationMode(),
             undefined,
             testRunHandler.getRetryCount(),
-            testRunHandler.getPreviousTestResultId());
+            testRunHandler.getPreviousTestResultId(),
+        );
     }
 
+    /**
+     * @override
+     * @param {import('../testRunHandler')} testRunHandler
+     * @param {string=} customExtensionLocalLocation
+     * @param {SeleniumTestPlayer} seleniumTestPlayer
+     * @param {Awaited<ReturnType<import('../services/gridService')['handleHybridOrVendorIfNeeded']>>} gridInfo
+     */
     async getBrowserOnce(testRunHandler, customExtensionLocalLocation, seleniumTestPlayer, gridInfo) {
         perf.log('in WorkerSelenium getBrowserOnce');
         reporter.onGetSession(this.id, this.testName, testRunHandler.getRunMode());
@@ -81,6 +89,7 @@ class WorkerSelenium extends BaseWorker {
     }
 
     /**
+     * @override
      * @param {import('../testRunHandler')} testRunHandler
      * @param {import('../player/seleniumTestPlayer')} seleniumTestPlayer
      */