@testim/testim-cli 3.267.0 → 3.269.0

package/testimNpmDriver.js

@@ -1,5 +1,6 @@
+// @ts-check
+
 /* eslint-disable no-console */
-const Promise = require('bluebird');
 const semver = require('semver');
 const config = require('./commons/config');
 const fs = require('fs');
@@ -7,10 +8,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 +29,21 @@ function getPackageVersion() {
     }
 }
 
-function checkNpmVersion() {
+async function checkNpmVersion() {
     if (config.IS_ON_PREM) {
-        return Promise.resolve();
+        return;
+    }
+    try {
+        const latestVersion = await utils.promiseTimeout(getNpmVersion(), 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/utils/promiseUtils.js

@@ -87,4 +87,5 @@ module.exports = {
     promiseTimeout,
     promiseMap,
     promiseFromCallback,
+    TimeoutError,
 };

package/workers/BaseWorker.js

@@ -86,8 +86,8 @@ class BaseWorker {
      * @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);
+        const slot = await gridService.getGridSlot(browser, testRunHandler.executionId, this.options, this.id);
+        this.onGridSlot(testRunHandler.testResultId, slot);
         return slot;
     }
 
@@ -116,10 +116,10 @@ class BaseWorker {
      * @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(),
         });
 
@@ -128,15 +128,15 @@ class BaseWorker {
 
     /** @param {import('../testRunHandler')} testRunHandler */
     handleQuarantine(testRunHandler) {
-        if (!utils.isQuarantineAndNotRemoteRun({ testStatus: testRunHandler.getTestStatus() }, this.options)) {
+        if (!utils.isQuarantineAndNotRemoteRun({ testStatus: testRunHandler.testStatus }, this.options)) {
             return undefined;
         }
         const testResult = {
-            name: testRunHandler.getTestName(),
-            testId: testRunHandler.getTestId(),
-            resultId: testRunHandler.getTestResultId(),
+            name: testRunHandler.testName,
+            testId: testRunHandler.testId,
+            resultId: testRunHandler.testResultId,
             runnerStatus: runnerTestStatus.SKIPPED,
-            testStatus: testRunHandler.getTestStatus(),
+            testStatus: testRunHandler.testStatus,
         };
         this.onTestIgnored(this.id, testResult);
         return testResult;
@@ -242,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);
@@ -273,7 +273,7 @@ class BaseWorker {
             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);
@@ -287,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) {
@@ -307,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();
@@ -404,9 +404,9 @@ 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);
         };
 
@@ -478,12 +478,12 @@ class BaseWorker {
         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

@@ -30,7 +30,7 @@ describe('BaseWorker', () => {
         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,28 +8,56 @@ 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 {
+    /**
+     * @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();
         const projectType = this.options.projectData.type;
-        const capabilities = desiredCapabilitiesBuilder.buildAppiumOptions({ projectType, gridInfo, testRunConfig: this.testRunConfig, nativeApp, options: this.options });
+        const nativeApp = await testRunHandler.getNativeAppData();
+        const androidActivityWait = projectType === 'android' ? testRunHandler.androidActivityWait : null;
+        let appPath = testRunHandler.nativeAppLink;
+        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}`;
+        }
         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,
+                androidActivityWait,
+            });
+
             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
@@ -39,10 +67,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) {
@@ -51,27 +103,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,
@@ -85,11 +139,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,7 +23,7 @@ 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);
     }
 
@@ -43,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) {
@@ -50,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);
 

package/workers/WorkerSelenium.js

@@ -1,9 +1,6 @@
 'use strict';
 
 const Promise = require('bluebird');
-
-const { timeoutMessages } = require('../commons/constants');
-const { PageNotAvailableError } = require('../errors');
 const BaseWorker = require('./BaseWorker');
 const logger = require('../commons/logger').getLogger('worker-selenium');
 const reporter = require('../reports/reporter');
@@ -11,6 +8,9 @@ const SeleniumTestPlayer = require('../player/seleniumTestPlayer');
 const WindowUtils = require('../player/utils/windowUtils');
 const sessionPlayerInit = require('../commons/getSessionPlayerRequire');
 const perf = require('../commons/performance-logger');
+const utils = require('../utils');
+const { timeoutMessages } = require('../commons/constants');
+const { PageNotAvailableError } = require('../errors');
 const { preloadTests } = require('../commons/preloadTests');
 
 // this navigation timeout is handled from outside the worker, so don't pass a small timeout to navigate
@@ -24,12 +24,12 @@ class WorkerSelenium extends BaseWorker {
     initPlayer(testRunHandler) {
         return new SeleniumTestPlayer(
             this.id,
-            testRunHandler.getRunParams(),
+            testRunHandler.runParams,
             this.options.shouldMonitorPerformance,
-            testRunHandler.getAutomationMode(),
+            testRunHandler.automationMode,
             undefined,
-            testRunHandler.getRetryCount(),
-            testRunHandler.getPreviousTestResultId(),
+            testRunHandler.retryCount,
+            testRunHandler.previousTestResultId,
         );
     }
 
@@ -42,14 +42,14 @@ class WorkerSelenium extends BaseWorker {
      */
     async getBrowserOnce(testRunHandler, customExtensionLocalLocation, seleniumTestPlayer, gridInfo) {
         perf.log('in WorkerSelenium getBrowserOnce');
-        reporter.onGetSession(this.id, this.testName, testRunHandler.getRunMode());
+        reporter.onGetSession(this.id, this.testName, testRunHandler.runMode);
         const { driver } = seleniumTestPlayer;
 
         this.windowUtils = new WindowUtils(this.id, driver);
         seleniumTestPlayer.clearSessionTabs();
 
         const { browserValue } = this.testRunConfig;
-        const baseUrl = testRunHandler.getBaseUrl();
+        const baseUrl = testRunHandler.baseUrl;
 
         try {
             const fastInit = this.options.useLocalChromeDriver;
@@ -101,12 +101,12 @@ class WorkerSelenium extends BaseWorker {
 
         setupCliPerformanceMonitoring(sessionPlayer);
 
-        sessionPlayer.playbackManager.executionId = testRunHandler.getExecutionId();
-        sessionPlayer.playbackManager.executionName = testRunHandler.getExecutionName();
+        sessionPlayer.playbackManager.executionId = testRunHandler.executionId;
+        sessionPlayer.playbackManager.executionName = testRunHandler.executionName;
 
         sessionPlayer.setLightweightMode(this.options.lightweightMode);
-        if (testRunHandler.getSfdcCredential()) {
-            sessionPlayer.setSfdcCredential(testRunHandler.getSfdcCredential());
+        if (testRunHandler.sfdcCredential) {
+            sessionPlayer.setSfdcCredential(testRunHandler.sfdcCredential);
         }
         if (sessionPlayerInit.localAssetService) {
             sessionPlayerInit.localAssetService.initialize({ serverUrl: this.options.localRCASaver });
@@ -119,7 +119,7 @@ class WorkerSelenium extends BaseWorker {
         }
 
         async function runSeleniumTest() {
-            if (testRunHandler.getAutomationMode() === 'codeful') {
+            if (testRunHandler.automationMode === 'codeful') {
                 // Testim Development Kit test;
                 if (!sessionPlayer.callOrderScheduler) { // old session player
                     await testRunHandler.waitForExecutionStartedFinished();
@@ -142,14 +142,14 @@ class WorkerSelenium extends BaseWorker {
                     false,
                     this.overrideTestConfigId,
                     this.branch,
-                    testRunHandler.getCode(),
-                    testRunHandler.getTestName()
+                    testRunHandler.code,
+                    testRunHandler.testName
                 ).catch(reject))
                     .log('right after playTestByCode')
                     .timeout(this.testRunTimeout, timeoutMessages.TEST_COMPLETE_TIMEOUT_MSG)
-                    .catch(Promise.TimeoutError, err => {
-                        if (sessionPlayer.stopPlayingOnTestTimeout) {
-                            sessionPlayer.stopPlayingOnTestTimeout();
+                    .catch(err => {
+                        if (err instanceof utils.TimeoutError) {
+                            sessionPlayer.stopPlayingOnTestTimeout?.();
                         }
                         throw err;
                     })
@@ -173,15 +173,15 @@ class WorkerSelenium extends BaseWorker {
                     this.overrideTestConfigId,
                     this.branch,
                     INCOGNITO,
-                    testRunHandler.getRemoteRunId(),
+                    testRunHandler.remoteRunId,
                     undefined,
                     undefined,
                     preloadedTest
                 ).catch(reject))
                 .timeout(this.testRunTimeout, timeoutMessages.TEST_COMPLETE_TIMEOUT_MSG)
-                .catch(Promise.TimeoutError, err => {
-                    if (sessionPlayer.stopPlayingOnTestTimeout) {
-                        sessionPlayer.stopPlayingOnTestTimeout();
+                .catch(err => {
+                    if (err instanceof utils.TimeoutError) {
+                        sessionPlayer.stopPlayingOnTestTimeout?.();
                     }
                     throw err;
                 })