@testim/testim-cli 3.285.0 → 3.287.0

package/stepPlayers/tdkHybridStepPlayback.js

@@ -1,23 +1,23 @@
 'use strict';
 
 const _ = require('lodash');
-const sessionPlayerInit = require('../commons/getSessionPlayerRequire');
 const perfLogger = require('../commons/performance-logger');
 const { guid } = require('../utils');
+const { AbortError } = require('../commons/AbortError');
 const { getArgumentsFromContext } = require('../codim/hybrid-utils');
-const { AbortError } = require("../commons/AbortError");
+const { getSessionPlayer } = require('../commons/getSessionPlayerRequire');
 
 module.exports.execute = async function executeTdkFunction(player, hybridFunction, context, loginData, frameManager, step, source, abortSignal) {
     function onAbort() {
         player.sessionPlayer.stopPlaying();
     }
 
-    abortSignal.addEventListener("abort", onAbort);
+    abortSignal.addEventListener('abort', onAbort);
 
     function getLocator(arg) {
         if (step.parameterValues) { // tdk is all grown up and can run real locators
             const locateStep = step.parameterValues.find(param => param.type === 'locate' && param.id === arg.locatorId);
-            return { elementLocator: locateStep.elementLocator , id: locateStep.id, name: 'Hybrid Step Locator' };
+            return { elementLocator: locateStep.elementLocator, id: locateStep.id, name: 'Hybrid Step Locator' };
         }
         if (!arg.locatedElement.shadowPath) {
             return arg; // wat
@@ -36,6 +36,7 @@ module.exports.execute = async function executeTdkFunction(player, hybridFunctio
     const baseUrl = context.config.baseUrl;
     const userData = _.cloneDeep(context); // the context contains everything needed as userData except login data
     userData.loginData = loginData;
+    const sessionPlayerInit = getSessionPlayer();
     const version = sessionPlayerInit.manifestVersion || 'runner';
     const isLocalRun = false;
     const overrideTestConfigId = null;
@@ -52,13 +53,14 @@ module.exports.execute = async function executeTdkFunction(player, hybridFunctio
         sourceCode: fn.toString(),
         sourceName: fn.name,
         testId,
-        resultId: guid() // we don't want to reuse the resultId of the parent for the child - we need a new resultId
+        resultId: guid(), // we don't want to reuse the resultId of the parent for the child - we need a new resultId
     };
     const onlyLocalReporting = typeof hybridFunction.results === 'boolean' && !hybridFunction.results;
     try {
         perfLogger.log('tdkHybridStepPlayback before addAllTabs');
         if (frameManager) { // we have a frameManager we can reuse
-            player.sessionPlayer.playbackAutUtils.frameManager = player.sessionPlayer.frameManager = frameManager;
+            player.sessionPlayer.playbackAutUtils.frameManager = frameManager;
+            player.sessionPlayer.frameManager = frameManager;
         } else {
             // otherwise, we have to tell the session player about them tabs
             //TODO(benji) call getEditorUrl?
@@ -73,37 +75,38 @@ module.exports.execute = async function executeTdkFunction(player, hybridFunctio
             }
             function onAbort() {
                 reject(new AbortError());
-                abortSignal.removeEventListener("abort", onAbort);
+                abortSignal.removeEventListener('abort', onAbort);
             }
 
-            abortSignal.addEventListener("abort", onAbort);
+            abortSignal.addEventListener('abort', onAbort);
 
-            player.sessionPlayer.playTestByCode(testId, executionId, resultId, baseUrl, userData, version, resolve, isLocalRun, overrideTestConfigId, branch, [codeTest], testName, ignoreNavigation).catch(reject);
-            
+            player.sessionPlayer.playTestByCode(
+                testId, executionId, resultId, baseUrl, userData, version, resolve, isLocalRun, overrideTestConfigId, branch, [codeTest], testName, ignoreNavigation,
+            ).catch(reject);
         });
         perfLogger.log('tdkHybridStepPlayback after playTestByCode');
         // testResult.status?
         return { success: testResult.success, shouldRetry: false, resultInfo: { testId, executionId, resultId: codeTest.resultId } };
     } catch (e) {
-        return { success: false, error: e, shouldRetry: false }
+        return { success: false, error: e, shouldRetry: false };
     } finally {
-        abortSignal.removeEventListener("abort", onAbort);
+        abortSignal.removeEventListener('abort', onAbort);
     }
 };
 
 function resolveOnTestResultAndNotAssetsUploaded(player, resolve) {
-    const { commonConstants } = require('../commons/getSessionPlayerRequire');
-    player.sessionPlayer.playbackManager.on(commonConstants.playback.START, ({testResult}) => {
+    const { commonConstants } = getSessionPlayer();
+    player.sessionPlayer.playbackManager.on(commonConstants.playback.START, ({ testResult }) => {
         let runnerStatus = testResult.runnerStatus;
         Object.defineProperty(testResult, 'runnerStatus', {
-            get() { return runnerStatus },
-            set(value) { 
+            get() { return runnerStatus; },
+            set(value) {
                 runnerStatus = value;
                 if (value === 'FINISHED') {
                     // resolve as soon as the runner is finished, before assets are uploaded
                     resolve(testResult);
                 }
-            }
+            },
         });
     });
 }

package/workers/BaseWorker.js

@@ -207,8 +207,8 @@ class BaseWorker {
                     return player || getBrowserRes;
                 } catch (error) {
                     const grid = { provider: gridInfo.provider, host: gridInfo.host, failedGetBrowserAttempts, id: this.options.gridData.gridId, type: gridInfo.type };
-                    logger.error('error getting browser from grid',
-                        { error, testId: this.testId, testResultId: this.testResultId, executionId: this.executionId, grid });
+                    const instanceType = this.options.mode === CLI_MODE.APPIUM ? 'device' : 'browser';
+                    logger.error(`error getting ${instanceType} from grid`, { error, testId: this.testId, testResultId: this.testResultId, executionId: this.executionId, grid });
                     reporter.onGetBrowserFailure(this.id, projectId, ++failedGetBrowserAttempts);
                     player.onDone();
 
@@ -333,6 +333,7 @@ class BaseWorker {
          * @param {boolean} wasNetworkHealthy
          */
         const buildError = (err, wasNetworkHealthy) => {
+            const instanceType = this.options.mode === CLI_MODE.APPIUM ? 'device' : 'browser';
             if (!wasNetworkHealthy && featureFlags.flags.errorMessageOnBadNetwork.isEnabled()) {
                 return {
                     errorType: NETWORK_ERROR,
@@ -342,7 +343,7 @@ class BaseWorker {
 
             const msg = err instanceof Error ? err.message : err;
             if (msg.includes(GET_BROWSER_TIMEOUT_MSG)) {
-                return { errorType: SETUP_TIMEOUT, reason: "Test couldn't get browser" };
+                return { errorType: SETUP_TIMEOUT, reason: `Test couldn't get ${instanceType}` };
             }
             if (msg.includes(TEST_START_TIMEOUT_MSG)) {
                 return { errorType: SETUP_TIMEOUT, reason: "Test couldn't be started" };
@@ -361,7 +362,7 @@ class BaseWorker {
 
             if (err instanceof GetBrowserError && err.type) {
                 if (err.type === GRID_ERROR) {
-                    return { errorType: GRID_ERROR, reason: `Test couldn't get browser from grid - ${err.message}` };
+                    return { errorType: GRID_ERROR, reason: `Test couldn't get ${instanceType} from grid - ${err.message}` };
                 }
                 if (err.type === SELENIUM_ERROR) {
                     return { errorType: SELENIUM_ERROR, reason: `Failed to create new session - ${err.message}` };
@@ -372,7 +373,7 @@ class BaseWorker {
                 return { errorType: SELENIUM_ERROR, reason: 'Session terminated, it is possible that the cli could not connect to the grid to send keep-alive requests for a prolonged period' };
             }
             if (err.failure && err.failure instanceof SeleniumError) {
-                return { errorType: SELENIUM_ERROR, reason: `Test couldn't get browser from grid - ${err.failure.message}` };
+                return { errorType: SELENIUM_ERROR, reason: `Test couldn't get ${instanceType} from grid - ${err.failure.message}` };
             }
             if (/SeleniumError: connect ECONNREFUSED/.test(err.message) || /Couldn't connect to selenium server/.test(err.message)) {
                 return { errorType: SELENIUM_ERROR, reason: 'Failed to connect to the grid, please check if the grid is accessible from your network' };
@@ -384,7 +385,7 @@ class BaseWorker {
                 return { errorType: SELENIUM_ERROR, reason: 'Session terminated, it is likely that the grid is not responding, please try to rerun the test' };
             }
             if (/forwarding the new session cannot find : Capabilities/.test(err.message)) {
-                return { errorType: SELENIUM_ERROR, reason: 'Session could not be created, please check that the browser you requested is supported in your plan' };
+                return { errorType: SELENIUM_ERROR, reason: `Session could not be created, please check that the ${instanceType} you requested is supported in your plan` };
             }
             return { errorType: UNKNOWN_ERROR, reason: msg };
         };

package/workers/WorkerAppium.js

@@ -2,14 +2,15 @@
 
 const jsdom = require('jsdom');
 const BaseWorker = require('./BaseWorker');
-const logger = require('../commons/logger').getLogger('worker-appium');
+const config = require('../commons/config');
 const reporter = require('../reports/reporter');
 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');
+const desiredCapabilitiesBuilder = require('../commons/testimDesiredCapabilitiesBuilder');
+const { getSessionPlayer } = require('../commons/getSessionPlayerRequire');
+const { getLogger } = require('../commons/logger');
+
+const logger = getLogger('worker-appium');
 
 class WorkerAppium extends BaseWorker {
     /**
@@ -113,6 +114,7 @@ class WorkerAppium extends BaseWorker {
      * @param {import('../player/appiumTestPlayer')} appiumTestPlayer
      */
     async runTestOnce(testRunHandler, appiumTestPlayer) {
+        const sessionPlayerInit = getSessionPlayer();
         const { driver, sessionPlayer } = appiumTestPlayer;
         const version = sessionPlayerInit.manifestVersion || 'runner';
 
@@ -123,7 +125,7 @@ class WorkerAppium extends BaseWorker {
 
         const serverAddress = this.getDirectAddressConnection(driver.activeSession.capabilities) || this.getServerAddressFromGrid(testRunHandler);
         const DOMParser = new jsdom.JSDOM('').window.DOMParser;
-        sessionPlayer.playbackManager.appiumApi = new AppiumApi(serverAddress, driver.activeSession.sessionId, DOMParser);
+        sessionPlayer.playbackManager.appiumApi = new sessionPlayerInit.AppiumApi(serverAddress, driver.activeSession.sessionId, DOMParser);
         if (sessionPlayerInit.localAssetService) {
             sessionPlayerInit.localAssetService.initialize({ serverUrl: this.options.localRCASaver });
         }

package/workers/WorkerSelenium.js

@@ -1,16 +1,18 @@
 'use strict';
 
+const utils = require('../utils');
 const BaseWorker = require('./BaseWorker');
-const logger = require('../commons/logger').getLogger('worker-selenium');
 const reporter = require('../reports/reporter');
-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 WindowUtils = require('../player/utils/windowUtils');
+const SeleniumTestPlayer = require('../player/seleniumTestPlayer');
+const { getLogger } = require('../commons/logger');
 const { PageNotAvailableError } = require('../errors');
 const { preloadTests } = require('../commons/preloadTests');
+const { timeoutMessages } = require('../commons/constants');
+const { getSessionPlayer } = require('../commons/getSessionPlayerRequire');
+
+const logger = getLogger('worker-selenium');
 
 // this navigation timeout is handled from outside the worker, so don't pass a small timeout to navigate
 const NO_NAVIGATION_TIME_LIMIT = 1e9;
@@ -62,7 +64,7 @@ class WorkerSelenium extends BaseWorker {
                 this.testResultId,
                 testRunHandler.seleniumPerfStats,
                 fastInit,
-                this.lambdatestService
+                this.lambdatestService,
             );
             perf.log('in WorkerSelenium after driver.init');
             await seleniumTestPlayer.addTab(undefined, { skipLoadInfo: fastInit });
@@ -93,7 +95,9 @@ class WorkerSelenium extends BaseWorker {
      * @param {import('../player/seleniumTestPlayer')} seleniumTestPlayer
      */
     async runTestOnce(testRunHandler, seleniumTestPlayer) {
+        const sessionPlayerInit = getSessionPlayer();
         const { driver, sessionPlayer } = seleniumTestPlayer;
+
         const version = sessionPlayerInit.manifestVersion || 'runner';
 
         reporter.onWaitToTestComplete(this.id, this.isCodeMode);
@@ -126,7 +130,7 @@ class WorkerSelenium extends BaseWorker {
                     sessionPlayer.callOrderScheduler.schedule(
                         () => testRunHandler.waitForExecutionStartedFinished(),
                         // this key is shared by clickim and this ensures that we do wait for the execution to be created before we do this.
-                        { key: `test-result:${this.userData.projectId}:${this.testResultId}` }
+                        { key: `test-result:${this.userData.projectId}:${this.testResultId}` },
                     );
                 }
                 perf.log('right before playTestByCode');
@@ -144,7 +148,7 @@ class WorkerSelenium extends BaseWorker {
                         this.overrideTestConfigId,
                         this.branch,
                         testRunHandler.code,
-                        testRunHandler.testName
+                        testRunHandler.testName,
                     ).catch(reject);
                 });
                 return utils
@@ -154,7 +158,7 @@ class WorkerSelenium extends BaseWorker {
                             return testResult;
                         }),
                         this.testRunTimeout,
-                        timeoutMessages.TEST_COMPLETE_TIMEOUT_MSG
+                        timeoutMessages.TEST_COMPLETE_TIMEOUT_MSG,
                     )
                     .catch(err => {
                         if (err instanceof utils.TimeoutError) {
@@ -187,7 +191,7 @@ class WorkerSelenium extends BaseWorker {
                         testRunHandler.remoteRunId,
                         undefined,
                         undefined,
-                        preloadedTest
+                        preloadedTest,
                     ).catch(reject);
                 }),
                 this.testRunTimeout,
@@ -238,7 +242,7 @@ class WorkerSelenium extends BaseWorker {
     }
 }
 function setupCliPerformanceMonitoring(sessionPlayer) {
-    const { playback } = sessionPlayerInit.commonConstants;
+    const { playback } = getSessionPlayer().commonConstants;
     function monitorEvent(event) {
         sessionPlayer.playbackManager.on(event, () => {
             perf.log(`Got event ${event}`);