@testim/testim-cli 3.266.0 → 3.268.0

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/testimNpmDriver.js

@@ -1,5 +1,4 @@
 /* eslint-disable no-console */
-const Promise = require('bluebird');
 const semver = require('semver');
 const config = require('./commons/config');
 const fs = require('fs');
@@ -7,10 +6,9 @@ const logger = require('./commons/logger').getLogger('npm-driver');
 const localRunnerCache = require('./commons/runnerFileCache');
 const npmWrapper = require('./commons/npmWrapper');
 const chalk = require('chalk');
+const utils = require('./utils');
 
-function getNpmVersion(packName) {
-    return Promise.resolve(npmWrapper.getLatestPackageVersion(packName));
-}
+const getNpmVersion = localRunnerCache.memoize(() => npmWrapper.getLatestPackageVersion('@testim/testim-cli'), 'getNpmVersion');
 
 function getPackageVersion() {
     try {
@@ -29,22 +27,21 @@ function getPackageVersion() {
     }
 }
 
-function checkNpmVersion() {
+async function checkNpmVersion() {
     if (config.IS_ON_PREM) {
-        return Promise.resolve();
+        return;
+    }
+    try {
+        const latestVersion = await utils.promiseTimeout(getNpmVersion('@testim/testim-cli'), 5000, 'The API call to NPM timed out');
+        const packVersion = getPackageVersion();
+        if (packVersion && semver.lt(packVersion, latestVersion)) {
+            console.log(chalk.yellow(
+                `Warning: You are using version ${packVersion}, a newer version is available. To update please run npm install (npm install -g @testim/testim-cli)`)
+            );
+        }
+    } catch (err) {
+        logger.warn('Failed to get NPM version', { err });
     }
-    return localRunnerCache.memoize(() => getNpmVersion('@testim/testim-cli')
-        .timeout(5000, 'The API call to NPM timed out')
-        .then(latestVersion => {
-            const packVersion = getPackageVersion();
-            if (packVersion && semver.lt(packVersion, latestVersion)) {
-                console.log(chalk.yellow(
-                    `Warning: You are using version ${packVersion}, a newer version is available. To update please run npm install (npm install -g @testim/testim-cli)`)
-                );
-            }
-        })
-        .catch(err => logger.warn('Failed to get NPM version', { err }))
-        .then(() => true), 'checkNpmVersion');
 }
 
 module.exports = {

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.executionId, this.options, this.id);
+        this.onGridSlot(testRunHandler.testResultId, 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,30 +111,35 @@ class BaseWorker {
         throw new NotImplementedError(true);
     }
 
+    /**
+     * @param {import('../testRunHandler')} testRunHandler
+     * @param {ReturnType<typeof this['initPlayer']>} player
+     */
     async runTestOnce(testRunHandler, player) {
-        testRunHandler.setSessionId(player.getSessionId());
+        testRunHandler.sessionId = player.getSessionId();
         logger.info('Test run started', {
-            testId: testRunHandler.getTestId(),
-            resultId: testRunHandler.getTestResultId(),
+            testId: testRunHandler.testId,
+            resultId: testRunHandler.testResultId,
             seleniumSession: player.getSessionId(),
         });
 
         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.testStatus }, this.options)) {
+            return undefined;
         }
-        return undefined;
+        const testResult = {
+            name: testRunHandler.testName,
+            testId: testRunHandler.testId,
+            resultId: testRunHandler.testResultId,
+            runnerStatus: runnerTestStatus.SKIPPED,
+            testStatus: testRunHandler.testStatus,
+        };
+        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;
@@ -211,7 +242,7 @@ class BaseWorker {
         }
 
         perf.log('before runTest onTestStarted');
-        const test = await this.onTestStarted(this.id, testRunHandler.getTestId(), testRunHandler.getTestResultId(), shouldRerun, testRunHandler.getRetryKey());
+        const test = await this.onTestStarted(this.id, testRunHandler.testId, testRunHandler.testResultId, shouldRerun, testRunHandler.retryKey);
         testRunHandler._baseUrl = test.config.baseUrl;
 
         const testPlayer = await this.getTestPlayer(testRunHandler, customExtensionLocalLocation);
@@ -233,11 +264,16 @@ 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();
             }
-            const sessionId = testRunHandler.getSessionId();
+            const sessionId = testRunHandler.sessionId;
 
             const isTimeoutError = (timeoutMsg) => err.message.includes(timeoutMsg);
             const isIgnoreErrors = err && (err instanceof GetBrowserError);
@@ -251,7 +287,7 @@ class BaseWorker {
                 );
 
             try {
-                const testRetryKey = testRunHandler.getRetryKey();
+                const testRetryKey = testRunHandler.retryKey;
                 testResult.testRetryKey = testRetryKey;
                 await this.onTestCompleted(this.id, this.testId, testResult, sessionId, shouldRerun);
                 if (this.executionQueue.hasMoreTests() && !this.options.lightweightMode?.general) {
@@ -271,7 +307,7 @@ class BaseWorker {
                         testRetryKey,
                         totalRetries: testRunHandler._totalRetryCount,
                     });
-                    this.testResultId = testRunHandler.getTestResultId();
+                    this.testResultId = testRunHandler.testResultId;
                     return await runTestAndCalcResult(testRunHandler, shouldRerun);
                 }
                 return await 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()) {
@@ -360,12 +404,16 @@ class BaseWorker {
                 success: false,
                 reason,
                 errorType,
-                testRetryKey: testRunHandler.getRetryKey(),
+                testRetryKey: testRunHandler.retryKey,
                 setupStepResult: { status: testRunStatus.COMPLETED, success: false, reason, errorType },
-            }, testRunHandler.getRemoteRunId());
+            }, testRunHandler.remoteRunId);
             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,35 +449,41 @@ 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();
 
         if (!testRunHandler) { // no more tests to run
             return this.onQueueCompleted();
         }
-        this.testId = testRunHandler.getTestId();
-        this.testName = testRunHandler.getTestName();
-        this.testResultId = testRunHandler.getTestResultId();
-        this.overrideTestConfigId = testRunHandler.getOverrideTestConfigId();
-        this.testRunConfig = testRunHandler.getRunConfig();
-        this.branch = testRunHandler.getBranch();
+        this.testId = testRunHandler.testId;
+        this.testName = testRunHandler.testName;
+        this.testResultId = testRunHandler.testResultId;
+        this.overrideTestConfigId = testRunHandler.overrideTestConfigId;
+        this.testRunConfig = testRunHandler.runConfig;
+        this.branch = testRunHandler.branch;
 
         return runTestAndCalcResult(testRunHandler);
     }

package/workers/BaseWorker.test.js

@@ -25,12 +25,12 @@ 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 = {};
 
-        testRunHandlerMock = { getExecutionId: () => 'executionId', getTestResultId: () => 'testResultId' };
+        testRunHandlerMock = { executionId: 'executionId', testResultId: 'testResultId' };
         testPlayerMock = { onDone: sinon.spy() };
 
         sinon.stub(worker, 'initPlayer').returns(testPlayerMock);
@@ -170,11 +170,6 @@ describe('BaseWorker', () => {
             it('should call the runTestOnc with the base url of the test object we acquired from onTestStarted', async () => {
                 const testRunHandler = {
                     _baseUrl: 'https://testim.io',
-                    getTestStatus: () => sinon.stub().returns(42),
-                    getTestId: () => sinon.stub().returns(42),
-                    getTestResultId: () => sinon.stub().returns(42),
-                    getRetryKey: () => sinon.stub().returns(42),
-                    getExecutionId: () => sinon.stub().returns(42),
                     testRunHandler: () => sinon.stub().returns(42),
                     clearTestResult: () => sinon.stub().returns(42),
                 };

package/workers/WorkerAppium.js

@@ -8,33 +8,46 @@ const AppiumTestPlayer = require('../player/appiumTestPlayer');
 const sessionPlayerInit = require('../commons/getSessionPlayerRequire');
 const AppiumApi = require('../commons/getSessionPlayerRequire').AppiumApi;
 const desiredCapabilitiesBuilder = require('../commons/testimDesiredCapabilitiesBuilder');
+const testimServicesApi = require('../commons/testimServicesApi');
+const config = require('../commons/config');
 
 class WorkerAppium extends BaseWorker {
-    constructor(...args) {
-        super(...args);
-        this.getBrowserOnce = Promise.method(this.getBrowserOnce);
-    }
-
+    /**
+     * @override
+     * @param {import('../testRunHandler')} testRunHandler
+     */
     initPlayer(testRunHandler) {
-        return new AppiumTestPlayer(this.id,
-            testRunHandler.getRunParams(),
+        return new AppiumTestPlayer(
+            this.id,
+            testRunHandler.runParams,
             this.options.shouldMonitorPerformance,
-            testRunHandler.getAutomationMode(),
+            testRunHandler.automationMode,
             undefined,
-            testRunHandler.getRetryCount(),
-            testRunHandler.getPreviousTestResultId());
+            testRunHandler.retryCount,
+            testRunHandler.previousTestResultId,
+        );
     }
 
     async getBrowserOnce(testRunHandler, customExtensionLocalLocation, appiumTestPlayer, gridInfo) {
-        reporter.onGetSession(this.id, this.testName, testRunHandler.getRunMode());
+        reporter.onGetSession(this.id, this.testName, testRunHandler.runMode);
         const { driver } = appiumTestPlayer;
-        const nativeApp = testRunHandler.getNativeAppData();
+        let appPath = null;
+        if (this.options.appId) {
+            const { project: projectId, appId } = this.options;
+            const mobileApp = await testimServicesApi.getAppDetails({ appId, projectId });
+            if (!mobileApp) {
+                logger.error('mobile app not found', { appId, projectId });
+                throw new Error('mobile app not found');
+            }
+            appPath = `${config.SERVICES_HOST}/storage${mobileApp.filePath}?access_token=${this.options.authData.token}`;
+        }
+        const nativeApp = await testRunHandler.getNativeAppData();
         const projectType = this.options.projectData.type;
-        const capabilities = desiredCapabilitiesBuilder.buildAppiumOptions({ projectType, gridInfo, testRunConfig: this.testRunConfig, nativeApp, options: this.options });
         try {
-            //we assume the application is installed on the device. (all headspin allocated devices)
+            const capabilities = desiredCapabilitiesBuilder.buildAppiumOptions({ projectType, gridInfo, testRunConfig: this.testRunConfig, nativeApp, options: this.options, appPath });
             const activeSession = await driver.remote(capabilities);
             driver.activeSession = activeSession;
+            await this.updateDeviceInfo(testRunHandler, activeSession);
             logger.info(`init new appium session testName: ${this.testName}`, { sessionId: activeSession.sessionId, testResultId: this.testResultId, nativeApp });
         } catch (err) {
             //TODO:  catch app status validation
@@ -44,10 +57,34 @@ class WorkerAppium extends BaseWorker {
     }
 
     getServerAddressFromGrid(testRunHandler) {
-        const { _options: { gridData: { host, port, accessToken } } } = testRunHandler;
+        const { host, port, accessToken } = testRunHandler._options.gridData;
         return `https://${host}:${port}/v0/${accessToken}/wd/hub`;
     }
 
+    async updateDeviceInfo(testRunHandler, activeSession) {
+        const {
+            _executionId, _testId, _testResultId,
+            _options: { project: projectId },
+        } = testRunHandler;
+        const device = {
+            name: activeSession.capabilities.deviceName,
+            model: activeSession.capabilities.deviceModel,
+            osVersion: activeSession.capabilities.platformVersion,
+            udid: activeSession.capabilities.udid,
+            osType: activeSession.capabilities.platformName,
+            scaleFactor: activeSession.capabilities.pixelRatio,
+            virtual: false,
+        };
+        await testimServicesApi.updateTestStatus(
+            projectId,
+            _executionId,
+            _testId,
+            _testResultId,
+            'RUNNING',
+            { device },
+        );
+    }
+
     getDirectAddressConnection(activeSessionCapabilities) {
         const { directConnectProtocol: protocol, directConnectHost: host, directConnectPort: port, directConnectPath: path } = activeSessionCapabilities;
         if (protocol && host && port && path) {
@@ -56,27 +93,29 @@ class WorkerAppium extends BaseWorker {
         return undefined;
     }
 
+    /**
+     * @param {import('../testRunHandler')} testRunHandler
+     * @param {import('../player/appiumTestPlayer')} appiumTestPlayer
+     */
     async runTestOnce(testRunHandler, appiumTestPlayer) {
         const { driver, sessionPlayer } = appiumTestPlayer;
         const version = sessionPlayerInit.manifestVersion || 'runner';
 
         reporter.onWaitToTestComplete(this.id, this.isCodeMode);
 
-        sessionPlayer.playbackManager.executionId = testRunHandler.getExecutionId();
-        sessionPlayer.playbackManager.executionName = testRunHandler.getExecutionName();
+        sessionPlayer.playbackManager.executionId = testRunHandler.executionId;
+        sessionPlayer.playbackManager.executionName = testRunHandler.executionName;
 
         const serverAddress = this.getDirectAddressConnection(driver.activeSession.capabilities) || this.getServerAddressFromGrid(testRunHandler);
-        const DOMParser = new (jsdom.JSDOM)('').window.DOMParser;
+        const DOMParser = new jsdom.JSDOM('').window.DOMParser;
         sessionPlayer.playbackManager.appiumApi = new AppiumApi(serverAddress, driver.activeSession.sessionId, DOMParser);
-
-
         if (sessionPlayerInit.localAssetService) {
             sessionPlayerInit.localAssetService.initialize({ serverUrl: this.options.localRCASaver });
         }
         async function runAppiumTest() {
             try {
                 const INCOGNITO = false;
-                const testResult = await (new Promise((resolve, reject) =>
+                const testResult = await new Promise((resolve, reject) =>
                     // eslint-disable-next-line no-promise-executor-return
                     sessionPlayer.playByTestId(
                         this.testId,
@@ -90,11 +129,12 @@ class WorkerAppium extends BaseWorker {
                         this.overrideTestConfigId,
                         this.branch,
                         INCOGNITO,
-                        testRunHandler.getRemoteRunId(),
-                        undefined,
+                        testRunHandler.remoteRunId,
                         undefined,
                         undefined,
-                    )));
+                        undefined
+                    )
+                );
                 if (sessionPlayerInit.localAssetService) {
                     await sessionPlayerInit.localAssetService.drain();
                 }

package/workers/WorkerExtension.js

@@ -21,6 +21,12 @@ class WorkerExtension extends BaseWorker {
         return new ExtensionTestPlayer(this.id);
     }
 
+    /**
+     * @param {import('../testRunHandler')} testRunHandler
+     * @param {string=} customExtensionLocalLocation
+     * @param {import('../player/extensionTestPlayer')} player
+     * @param {Awaited<ReturnType<import('../services/gridService')['getGridSlot']>>} gridInfo
+     */
     async _getBrowserOnce(testRunHandler, customExtensionLocalLocation, player, gridInfo) {
         const { driver } = player;
         try {
@@ -40,8 +46,8 @@ class WorkerExtension extends BaseWorker {
             logger.error('failed to get browser', {
                 err,
                 gridInfo,
-                testId: testRunHandler.getTestId(),
-                resultId: testRunHandler.getTestResultId(),
+                testId: testRunHandler.testId,
+                resultId: testRunHandler.testResultId,
             });
             throw err;
         }
@@ -49,7 +55,7 @@ class WorkerExtension extends BaseWorker {
 
     /** @override */
     async getBrowserOnce(testRunHandler, customExtensionLocalLocation, player, gridInfo) {
-        reporter.onGetSession(this.id, this.testName, testRunHandler.getRunMode());
+        reporter.onGetSession(this.id, this.testName, testRunHandler.runMode);
         return this._getBrowserOnce(testRunHandler, customExtensionLocalLocation, player, gridInfo);
     }
 
@@ -175,8 +181,8 @@ class WorkerExtension extends BaseWorker {
         } catch (err) {
             logger.error('failed to run test', {
                 err,
-                testId: testRunHandler.getTestId(),
-                resultId: testRunHandler.getTestResultId(),
+                testId: testRunHandler.testId,
+                resultId: testRunHandler.testResultId,
             });
             throw err;
         }

package/workers/WorkerExtensionSingleBrowser.js

@@ -23,10 +23,15 @@ class WorkerExtensionSingleBrowser extends WorkerExtension {
     }
 
     async getBrowserOnce(testRunHandler, customExtensionLocalLocation, player, gridInfo) {
-        reporter.onGetSession(this.id, `worker ${this.id}`, testRunHandler.getRunMode());
+        reporter.onGetSession(this.id, `worker ${this.id}`, testRunHandler.runMode);
         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 });
@@ -38,6 +43,11 @@ class WorkerExtensionSingleBrowser extends WorkerExtension {
         return this.testPlayer;
     }
 
+    /**
+     * @param {import('../testRunHandler')} testRunHandler
+     * @param {string=} customExtensionLocalLocation
+     * @param {boolean=} shouldRerun
+     */
     async runTest(testRunHandler, customExtensionLocalLocation, shouldRerun) {
         const quarantineResult = this.handleQuarantine(testRunHandler);
         if (quarantineResult) {
@@ -45,7 +55,7 @@ class WorkerExtensionSingleBrowser extends WorkerExtension {
         }
 
         perf.log('before runTest onTestStarted single browser');
-        const test = await this.onTestStarted(this.id, testRunHandler.getTestId(), testRunHandler.getTestResultId(), shouldRerun, testRunHandler.getRetryKey());
+        const test = await this.onTestStarted(this.id, testRunHandler.testId, testRunHandler.testResultId, shouldRerun, testRunHandler.retryKey);
         testRunHandler._baseUrl = test.config.baseUrl;
         const testPlayer = await this.getTestPlayer(testRunHandler, customExtensionLocalLocation);