@testim/testim-cli 3.266.0 → 3.268.0

package/testRunHandler.js

@@ -1,23 +1,23 @@
 'use strict';
 
-const pRetry = require('p-retry');
 const _ = require('lodash');
+const pRetry = require('p-retry');
+const utils = require('./utils');
+const config = require('./commons/config');
+const perf = require('./commons/performance-logger');
+const analytics = require('./commons/testimAnalytics');
 const testimCustomToken = require('./commons/testimCustomToken');
+const testimServicesApi = require('./commons/testimServicesApi');
+const remoteStepPlayback = require('./stepPlayers/remoteStepPlayback');
 const remoteStepService = require('./commons/socket/remoteStepService');
 const testResultService = require('./commons/socket/testResultService');
-const testimServicesApi = require('./commons/testimServicesApi');
-const { timeoutMessages, CLI_MODE } = require('./commons/constants');
-const logger = require('./commons/logger').getLogger('test-run-handler');
-const perf = require('./commons/performance-logger');
 const { URL } = require('url');
-const Promise = require('bluebird');
-const remoteStepPlayback = require('./stepPlayers/remoteStepPlayback');
-const utils = require('./utils');
-const config = require('./commons/config');
-const analytics = require('./commons/testimAnalytics');
-const { SeleniumPerfStats } = require('./commons/SeleniumPerfStats');
+const { getLogger } = require('./commons/logger');
 const { preloadTests } = require('./commons/preloadTests');
+const { timeoutMessages, CLI_MODE } = require('./commons/constants');
+const { SeleniumPerfStats } = require('./commons/SeleniumPerfStats');
 
+const logger = getLogger('test-run-handler');
 const RETRIES_ON_TIMEOUT = 3;
 const MAX_LIGHTWEIGHT_MODE_RUN_DATA_SIZE = 20 * 1000; // max size, in characters, of stringified run data sent over URL params. Chosen arbitrarily, this value should be changed according to data.
 const canSendRunDataOverUrl = (runData) => JSON.stringify(runData).length < MAX_LIGHTWEIGHT_MODE_RUN_DATA_SIZE;
@@ -26,7 +26,7 @@ class TestRun {
     /**
      * @param {string} executionId
      * @param {string} executionName
-     * @param {*} test
+     * @param {import('./runners/TestPlanRunner').ExecutionList[number]} test
      * @param {import('./runOptions').RunnerOptions} options
      * @param {string} branchToUse
      * @param {import('./testRunStatus')} testRunStatus
@@ -58,76 +58,78 @@ class TestRun {
         this.seleniumPerfStats = new SeleniumPerfStats();
     }
 
-    waitForExecutionStartedFinished() {
-        return this._testRunStatus.waitForExecutionStartedFinished() && this.clearTestResultFinished;
+    async waitForExecutionStartedFinished() {
+        return await this._testRunStatus.waitForExecutionStartedFinished() && await this.clearTestResultFinished;
     }
 
-    getTestStatus() {
+    get testStatus() {
         return this._testStatus;
     }
 
-    getRunMode() {
+    get runMode() {
         return this._options.mode;
     }
 
-    getAutomationMode() {
+    get automationMode() {
         return this._code ? 'codeful' : 'codeless';
     }
 
-    getCode() {
+    get code() {
         return this._code;
     }
 
-    getRunConfig() {
+    get runConfig() {
         return this._runConfig;
     }
 
-    getTestResultId() {
+    get testResultId() {
         return this._testResultId;
     }
 
-    getBaseUrl() {
+    get baseUrl() {
         return this._baseUrl;
     }
 
-    getExecutionId() {
+    get executionId() {
         return this._executionId;
     }
 
-    getExecutionName() {
+    get executionName() {
         return this._executionName;
     }
 
-    getNativeAppData() {
-        if (this._nativeApp && !this._options.baseUrl) {
-            return this._nativeApp;
+    async getNativeAppData() {
+        const { appId, baseUrl } = this._options;
+        if (baseUrl && !this._nativeApp && !appId) {
+            const url = baseUrl || this.baseUrl;
+            if (!url) {
+                return null;
+            }
+            const [packageName, activity] = url.split(':');
+            return {
+                packageName,
+                activity,
+            };
         }
-
-        const url = this._options.baseUrl || this.getBaseUrl();
-        if (!url) {
-            return null;
+        if (this._nativeApp && !appId) {
+            return this._nativeApp;
         }
-
-        const [packageName, activity] = url.split(':');
-        return {
-            packageName,
-            activity,
-        };
+        return null;
     }
 
-    getBranch() {
+    get branch() {
         return this._branch;
     }
 
-    getSfdcCredential() {
+    get sfdcCredential() {
         return this._options.sfdcCredential;
     }
 
-    getRemoteRunId() {
+    get remoteRunId() {
         return this._remoteRunId;
     }
 
-    getOverrideTestConfigId() {
+    get overrideTestConfigId() {
         return this._overrideTestConfigId;
     }
 
@@ -148,53 +150,38 @@ class TestRun {
             baseUrl: this._baseUrl,
             branch: this._branch,
             servicesUrl: config.EXTENSION_SERVICES_HOST,
-            remoteRunId: this.getRemoteRunId(),
-            previousTestResultId: this.getPreviousTestResultId(),
-            testRetryCount: this.getRetryCount(),
+            remoteRunId: this.remoteRunId,
+            previousTestResultId: this.previousTestResultId,
+            testRetryCount: this.retryCount,
+            ...(this.code && { isCodeMode: true, testName: this.testName }),
+            ...(this._options.shouldMonitorPerformance && { shouldMonitorPerformance: true }),
+            ...(this._options.company && {
+                companyId: this._options.company.companyId,
+                onprem: this._options.company.onprem,
+                storageBaseUrl: this._options.company.storageBaseUrl,
+                storageType: this._options.company.storageType,
+                planType: this._options.company.planType,
+                isPOC: this._options.company.isPOC,
+                isStartUp: this._options.company.isStartUp,
+            }),
+            ...(this._options.collectCodeCoverage && { codeCoverageUrlFilter: this._options.codeCoverageUrlFilter || `${this.baseUrl}*` }),
+            ...(this._options.disableMockNetwork && { disableMockNetwork: this._options.disableMockNetwork }),
+            ...(this._options.lightweightMode && { lightweightMode: this._options.lightweightMode }),
+            ...(this.clearBrowser && { clearBrowser: true }),
+            ...(this._options.localRCASaver && { localRCASaver: this._options.localRCASaver }),
+            ...(this.sfdcCredential && { sfdcCredential: this.sfdcCredential }),
         };
 
-        if (this._code) {
-            runRequestParams.isCodeMode = true;
-            runRequestParams.testName = this._testName;
-        }
-
-        if (this._options.shouldMonitorPerformance) {
-            runRequestParams.shouldMonitorPerformance = true;
-        }
-
-        if (this._options.company) {
-            runRequestParams.companyId = this._options.company.companyId;
-            runRequestParams.onprem = this._options.company.onprem;
-            runRequestParams.storageBaseUrl = this._options.company.storageBaseUrl;
-            runRequestParams.storageType = this._options.company.storageType;
-            runRequestParams.planType = this._options.company.planType;
-            runRequestParams.isPOC = this._options.company.isPOC;
-            runRequestParams.isStartUp = this._options.company.isStartUp;
-        }
-
-        if (this._options.collectCodeCoverage) {
-            if (this._options.codeCoverageUrlFilter) {
-                runRequestParams.codeCoverageUrlFilter = this._options.codeCoverageUrlFilter;
-            } else {
-                runRequestParams.codeCoverageUrlFilter = `${this._baseUrl}*`;
-            }
-        }
-
         if (this._options.disableMockNetwork) {
-            runRequestParams.disableMockNetwork = this._options.disableMockNetwork;
             analytics.trackWithCIUser('user-disable-mock');
         }
 
-        if (this._options.lightweightMode) {
-            runRequestParams.lightweightMode = this._options.lightweightMode;
-        }
-
         if (this._options.lightweightMode?.general) {
             runRequestParams.company = this._options.company;
-            const runData = this.getRunData();
+            const runData = this.runData;
             runRequestParams.lightweightMode.isRunDataSentInUrl = canSendRunDataOverUrl(runData);
             const stringifiedLength = JSON.stringify(runData).length;
-            const testId = this.getTestId();
+            const testId = this.testId;
             if (runRequestParams.lightweightMode.isRunDataSentInUrl) {
                 runRequestParams.runData = runData;
                 logger.info(`Run data sent as URL param, test id: ${testId} run data length: ${stringifiedLength}`);
@@ -209,59 +196,47 @@ class TestRun {
             runRequestParams.preloadedTest = preloadedTests[runRequestParams.testId];
         }
 
-        if (this.clearBrowser) {
-            runRequestParams.clearBrowser = true;
-        }
-
-        if (this._options.localRCASaver) {
-            runRequestParams.localRCASaver = this._options.localRCASaver;
-        }
-
-        if (this.getSfdcCredential()) {
-            runRequestParams.sfdcCredential = this.getSfdcCredential();
-        }
-
         return runRequestParams;
     }
 
     async getRunTestUrl() {
         const runRequestParams = await this.getRunRequestParams();
         const url = `https://run.testim.io/?params=${encodeURIComponent(JSON.stringify(runRequestParams))}`;
-        logger.info(`Test (${this.getTestId()}) run URL length: ${url.length}`);
+        logger.info(`Test (${this.testId}) run URL length: ${url.length}`);
         return url;
     }
 
-    setSessionId(sessionId) {
+    set sessionId(sessionId) {
         this._sessionId = sessionId;
     }
 
-    getSessionId() {
+    get sessionId() {
         return this._sessionId;
     }
 
-    getTestId() {
+    get testId() {
         return this._testId;
     }
 
-    getTestName() {
+    get testName() {
         return this._testName;
     }
 
-    getRunParams() {
+    get runParams() {
         return this._options.runParams[this._testResultId] || {};
     }
 
-    getRunData() {
+    get runData() {
         return {
-            userParamsData: this.getRunParams(),
+            userParamsData: this.runParams,
             overrideTestConfigId: this._overrideTestConfigId || null,
         };
     }
 
-    clearTestResult() {
-        const runData = this.getRunData();
-        if (this.getRunMode() === CLI_MODE.EXTENSION) {
-            runData.code = this.getCode();
+    async clearTestResult() {
+        const runData = this.runData;
+        if (this.runMode === CLI_MODE.EXTENSION) {
+            runData.code = this.code;
         }
 
         if (this._options.mockNetworkRules) {
@@ -270,28 +245,33 @@ class TestRun {
         const mustClearPreviousStepResults = (this._timeoutRetryCount > 1 || this._retryCount > 1);
 
         if (this._options.lightweightMode?.disableResults && !mustClearPreviousStepResults && canSendRunDataOverUrl(runData)) {
-            return Promise.resolve();
+            return undefined;
         }
 
-        this.clearTestResultFinished = testimServicesApi.uploadRunDataArtifact(this._options.project, this._testId, this._testResultId, runData)
-            .catch(err => {
+        const uploadRunDataArtifactAndFallbackToEmptyString = async () => {
+            try {
+                return await testimServicesApi.uploadRunDataArtifact(this._options.project, this._testId, this._testResultId, runData);
+            } catch (err) {
                 logger.error('failed to upload run data artifact (runner)', { err });
                 return '';
-            })
-            .then(async (runDataUrl) => {
-                // make sure the execution is created by now
-                await this._testRunStatus.waitForExecutionStartedFinished();
-                // we probably can save this backend call by initializing the execution
-                return testimServicesApi.clearTestResult(this._options.project, this._testResultId, this._testId, {
-                    name: this._testName,
-                    resultId: this._testResultId,
-                    status: 'pending',
-                    retryCount: this._retryCount,
-                    runDataUrl, // links the run data url to the test.
-                    runData: runDataUrl ? undefined : runData, // put runData in mongo if we fail to upload to S3.
-                    testRetryKey: this.getRetryKey(),
-                });
+            }
+        };
+        const clearTestResultFinished = async () => {
+            const runDataUrl = await uploadRunDataArtifactAndFallbackToEmptyString();
+            // make sure the execution is created by now
+            await this._testRunStatus.waitForExecutionStartedFinished();
+            // we probably can save this backend call by initializing the execution
+            return testimServicesApi.clearTestResult(this._options.project, this._testResultId, this._testId, {
+                name: this._testName,
+                resultId: this._testResultId,
+                status: 'pending',
+                retryCount: this._retryCount,
+                runDataUrl, // links the run data url to the test.
+                runData: runDataUrl ? undefined : runData, // put runData in mongo if we fail to upload to S3.
+                testRetryKey: this.retryKey,
             });
+        };
+        this.clearTestResultFinished = clearTestResultFinished();
         return this.clearTestResultFinished;
     }
 
@@ -299,7 +279,7 @@ class TestRun {
         return this._retryCount < this._maxRetryCount;
     }
 
-    getRetryKey() {
+    get retryKey() {
         return `${this._retryCount}:${this._timeoutRetryCount}`;
     }
 
@@ -335,7 +315,7 @@ class TestRun {
                 if (!result.value) {
                     throw new Error('runTestimTest not available on global scope');
                 }
-            }, { retries: 100, minTimeout: 30 });
+            }, { retries: 100, minTimeout: 30, factor: 1 });
 
             perf.log('after wait for runTestimTest function');
             const { result } = await cdpTestRunner.cdpCommand(
@@ -355,12 +335,11 @@ class TestRun {
     }
 
     isRetryKeyMismatch(testResult) {
-        return testResult.testRetryKey && (testResult.testRetryKey !== this.getRetryKey());
+        return testResult.testRetryKey && (testResult.testRetryKey !== this.retryKey);
     }
 
     validateRunConfig() {
-        const baseUrl = this.getBaseUrl();
-        const { browserValue } = this.getRunConfig();
+        const { baseUrl, runConfig: { browserValue } } = this;
 
         if (baseUrl && browserValue === 'safari') {
             let parsedUrl;
@@ -378,6 +357,7 @@ class TestRun {
         }
     }
 
+    /** @param {number} startTimeout */
     onStarted(startTimeout) {
         return new Promise(resolve => {
             // We can't leave the test result as it may remove other listeners as well
@@ -388,20 +368,20 @@ class TestRun {
                     return;
                 }
                 if (this.isRetryKeyMismatch(testResult)) {
-                    logger.warn(`ignoring result update for on started due to retry key mismatch, got ${testResult.testRetryKey}, current is ${this.getRetryKey()}`, {
-                        resultId: this.getTestResultId(),
-                        testId: this.getTestId(),
+                    logger.warn(`ignoring result update for on started due to retry key mismatch, got ${testResult.testRetryKey}, current is ${this.retryKey}`, {
+                        resultId: this.testResultId,
+                        testId: this.testId,
                     });
                     return;
                 }
                 if (['running', 'completed'].includes(testResult.status)) {
-                    testResult.resultId = this._testResultId;
+                    testResult.resultId = this.testResultId;
                     if (testResult.status === 'completed') {
                         logger.info('setting _wasCompletedOnStartedCheck to true', {
                             testResult,
-                            resultId: this.getTestResultId(),
-                            testId: this.getTestId(),
-                            testRetryKey: this.getRetryKey(),
+                            resultId: this.testResultId,
+                            testId: this.testId,
+                            testRetryKey: this.retryKey,
                         });
                         this._wasCompletedOnStartedCheck = testResult;
                     }
@@ -411,24 +391,22 @@ class TestRun {
             };
             if (this._options.disableSockets) {
                 const timeLimit = Date.now() + startTimeout;
-                const checkIfDone = () => {
+                const checkIfDone = async () => {
                     if (Date.now() > timeLimit) {
                         return;
                     }
-                    const testId = this._testId;
-                    const resultId = this._testResultId;
-                    const projectId = this._options.project;
-                    const branch = this.getBranch();
+                    const { testId, testResultId, branch, _options: { project: projectId } } = this;
 
-                    testimServicesApi.getTestResults(testId, resultId, projectId, branch).then(restResult => {
+                    try {
+                        const restResult = await testimServicesApi.getTestResults(testId, testResultId, projectId, branch);
                         resolveResult(restResult);
                         if (!reportedStart) {
                             setTimeout(checkIfDone, 3000);
                         }
-                    }).catch((err) => {
+                    } catch (err) {
                         logger.error('failed to check if done', { err });
                         setTimeout(checkIfDone, 3000);
-                    });
+                    }
                 };
                 setTimeout(checkIfDone, 3000);
             } else {
@@ -437,116 +415,119 @@ class TestRun {
         });
     }
 
-    checkViaRestAPIIfTestStarted() {
-        const testId = this._testId;
-        const resultId = this._testResultId;
-        const projectId = this._options.project;
-        const branch = this.getBranch();
-        return testimServicesApi.getTestResults(testId, resultId, projectId, branch)
-            .then(testResult => {
-                const expectedStatuses = ['running', 'completed'];
-                if (expectedStatuses.includes(testResult.status)) {
-                    logger.info(`get status: ${testResult.status} after not get test started status`, { testId, resultId, branch });
-                    return testResult;
-                }
-                logger.error(`test not start test status: ${testResult.status} (expected [${expectedStatuses.join(', ')}])`, { testId, resultId, branch });
-                throw new Error(timeoutMessages.TEST_START_TIMEOUT_MSG);
-            })
-            .catch(err => {
-                logger.error('failed to get test result after test start timeout', { err, testId, resultId, branch });
-                throw new Error(timeoutMessages.TEST_START_TIMEOUT_MSG);
-            });
+    async checkViaRestAPIIfTestStarted() {
+        const { testId, testResultId, _options: { project: projectId }, branch } = this;
+        try {
+            const testResult = testimServicesApi.getTestResults(testId, testResultId, projectId, branch);
+            const expectedStatuses = ['running', 'completed'];
+            if (expectedStatuses.includes(testResult.status)) {
+                logger.info(`get status: ${testResult.status} after not get test started status`, { testId, testResultId, branch });
+                return testResult;
+            }
+            logger.error(`test not start test status: ${testResult.status} (expected [${expectedStatuses.join(', ')}])`, { testId, testResultId, branch });
+            throw new Error(timeoutMessages.TEST_START_TIMEOUT_MSG);
+        } catch (err) {
+            logger.error('failed to get test result after test start timeout', { err, testId, testResultId, branch });
+            throw new Error(timeoutMessages.TEST_START_TIMEOUT_MSG);
+        }
     }
 
-    onCompletedCleanup() {
-        if (!this._options.disableSockets) {
-            return Promise.resolve(testResultService.leaveTestResult(this._testResultId, this._testId));
+    async onCompletedCleanup() {
+        if (this._options.disableSockets) {
+            return undefined;
         }
-        return Promise.resolve();
+        return await testResultService.leaveTestResult(this._testResultId, this._testId);
     }
 
-    onCompleted() {
+    async onCompleted() {
         let onConnected;
-        return new Promise(resolve => {
-            if (this._wasCompletedOnStartedCheck && !this.isRetryKeyMismatch(this._wasCompletedOnStartedCheck)) {
-                logger.info('test was already completed in on started check', {
-                    resultId: this.getTestResultId(),
-                    testId: this.getTestId(),
-                });
-                resolve(this._wasCompletedOnStartedCheck);
-                return;
-            }
+        try {
+            const res = await new Promise(resolve => {
+                if (this._wasCompletedOnStartedCheck && !this.isRetryKeyMismatch(this._wasCompletedOnStartedCheck)) {
+                    logger.info('test was already completed in on started check', {
+                        resultId: this.testResultId,
+                        testId: this.testId,
+                    });
+                    resolve(this._wasCompletedOnStartedCheck);
+                    return;
+                }
 
-            if (!this._options.disableSockets) {
-                testResultService.listenToTestResult(this._testResultId, this._testId, testResult => {
-                    if (this.isRetryKeyMismatch(testResult)) {
-                        logger.warn(`ignoring result update for on completed due to retry key mismatch, got ${testResult.testRetryKey}, current is ${this.getRetryKey()}`, {
-                            resultId: this.getTestResultId(),
-                            testId: this.getTestId(),
-                        });
-                        return;
-                    }
-                    if (testResult.status === 'completed') {
-                        testResult.resultId = this._testResultId;
-                        resolve(testResult);
-                    }
-                });
-            }
-            const debounceDelay = this._options.disableSockets ? 0 : Math.floor(10000 + (Math.random() * 5000));
-            const maxWait = this._options.disableSockets ? 0 : Math.floor(60000 + (Math.random() * 15000));
-            onConnected = _.debounce(() => testimServicesApi.getTestResults(this._testId, this._testResultId, this._options.project, this.getBranch())
-                .then(testResult => {
-                    if (this.isRetryKeyMismatch(testResult)) {
-                        logger.warn(`ignoring result update for on completed (in reconnect) due to retry key mismatch, got ${testResult.testRetryKey}, current is ${this.getRetryKey()}`, {
-                            resultId: this.getTestResultId(),
-                            testId: this.getTestId(),
-                        });
+                if (!this._options.disableSockets) {
+                    testResultService.listenToTestResult(this._testResultId, this._testId, testResult => {
+                        if (this.isRetryKeyMismatch(testResult)) {
+                            logger.warn(`ignoring result update for on completed due to retry key mismatch, got ${testResult.testRetryKey}, current is ${this.retryKey}`, {
+                                resultId: this.testResultId,
+                                testId: this.testId,
+                            });
+                            return;
+                        }
+                        if (testResult.status === 'completed') {
+                            testResult.resultId = this._testResultId;
+                            resolve(testResult);
+                        }
+                    });
+                }
+                const debounceDelay = this._options.disableSockets ? 0 : Math.floor(10000 + (Math.random() * 5000));
+                const maxWait = this._options.disableSockets ? 0 : Math.floor(60000 + (Math.random() * 15000));
+                onConnected = _.debounce(async () => {
+                    try {
+                        const testResult = await testimServicesApi.getTestResults(this._testId, this._testResultId, this._options.project, this.branch);
+                        if (this.isRetryKeyMismatch(testResult)) {
+                            logger.warn(`ignoring result update for on completed (in reconnect) due to retry key mismatch, got ${testResult.testRetryKey}, current is ${this.retryKey}`, {
+                                resultId: this.testResultId,
+                                testId: this.testId,
+                            });
+                            return false;
+                        }
+                        if (testResult?.status === 'completed') {
+                            logger.info('Socket reconnected - Test complete', { testId: this._testId, resultId: this._testResultId, projectId: this._options.project });
+                            testResult.resultId = this._testResultId;
+                            resolve(testResult);
+                            return true;
+                        }
+                        return false;
+                    } catch (err) {
+                        logger.warn('Error while trying to check status on socket connect', err);
                         return false;
                     }
-                    if (testResult && testResult.status === 'completed') {
-                        logger.info('Socket reconnected - Test complete', { testId: this._testId, resultId: this._testResultId, projectId: this._options.project });
-                        testResult.resultId = this._testResultId;
-                        resolve(testResult);
-                        return true;
-                    }
-                    return false;
-                })
-                .catch(err => logger.warn('Error while trying to check status on socket connect', err)), debounceDelay, { maxWait });
-            if (!this._options.disableSockets) {
-                testResultService.on('socket-connected', onConnected);
-            } else {
-                const waitForTestEnd = () => {
-                    setTimeout(async () => {
-                        try {
-                            const { isComplete } = await testimServicesApi.isTestResultCompleted(this._testResultId, this._options.project, this.getRetryKey());
-                            if (isComplete) {
-                                const isDone = await onConnected();
-                                if (!isDone) {
-                                    logger.warn('onConnected returned false even though isComplete was true');
+                }, debounceDelay, { maxWait });
+                if (!this._options.disableSockets) {
+                    testResultService.on('socket-connected', onConnected);
+                } else {
+                    const waitForTestEnd = () => {
+                        setTimeout(async () => {
+                            try {
+                                const { isComplete } = await testimServicesApi.isTestResultCompleted(this._testResultId, this._options.project, this.retryKey);
+                                if (isComplete) {
+                                    const isDone = await onConnected();
+                                    if (!isDone) {
+                                        logger.warn('onConnected returned false even though isComplete was true');
+                                        waitForTestEnd();
+                                    }
+                                } else {
                                     waitForTestEnd();
                                 }
-                            } else {
+                            } catch (err) {
+                                logger.error('failed to check is complete', { err });
                                 waitForTestEnd();
                             }
-                        } catch (err) {
-                            logger.error('failed to check is complete', { err });
-                            waitForTestEnd();
-                        }
-                    }, 3000);
-                };
-                waitForTestEnd();
+                        }, 3000);
+                    };
+                    waitForTestEnd();
+                }
+            });
+            await this.onCompletedCleanup();
+            return res;
+        } finally {
+            if (onConnected && !this._options.disableSockets) {
+                testResultService.off('socket-connected', onConnected);
             }
-        })
-            .then(async res => {
-                await this.onCompletedCleanup();
-                return res;
-            })
-            .finally(() => onConnected && !this._options.disableSockets && testResultService.off('socket-connected', onConnected));
+        }
     }
 
     listenToRemoteStep(browser) {
-        remoteStepService.listenToRemoteStep(this._testResultId, step => {
-            remoteStepPlayback.executeStep(this._options, browser, step, this._testResultId);
+        remoteStepService.listenToRemoteStep(this.testResultId, step => {
+            remoteStepPlayback.executeStep(this._options, browser, step, this.testResultId);
         });
     }
 
@@ -560,20 +541,20 @@ class TestRun {
         return this.onRetry();
     }
 
-    getRetryCount() {
+    get retryCount() {
         return this._retryCount;
     }
 
-    getPreviousTestResultId() {
+    get previousTestResultId() {
         return this._previousTestResultId;
     }
 
     isAllowReportTestResultRetries() {
-        return Boolean(_(this._options).get('company.activePlan.premiumFeatures.allowReportTestResultRetries'));
+        return Boolean(this._options.company?.activePlan?.premiumFeatures?.allowReportTestResultRetries);
     }
 
     async onRetry() {
-        this._previousTestResultId = this._testResultId;
+        this._previousTestResultId = this.testResultId;
 
         if (!this.isAllowReportTestResultRetries()) {
             return;