@testim/testim-cli 3.252.0 → 3.254.0

package/runners/TestPlanRunner.js

@@ -1,6 +1,5 @@
 'use strict';
 
-const Bluebird = require('bluebird');
 const _ = require('lodash');
 const constants = require('../commons/constants');
 
@@ -26,35 +25,50 @@ const logger = Logger.getLogger('test-plan-runner');
 const TDK_CHILD_RESULTS_TIMEOUT = 1000 * 60 * 5;
 
 class TestPlanRunner {
+    /**
+     * @param {string=} customExtensionLocalLocation
+     */
     constructor(customExtensionLocalLocation) {
         this.workerManager = new ParallelWorkerManager(customExtensionLocalLocation);
         this.startTime = Date.now();
     }
-    runTestAllPhases(beforeTests, tests, afterTests, branchToUse, tpOptions, executionId, executionName, testStatus) {
+
+    /**
+     * @private
+     * @param {any[]} beforeTests
+     * @param {any[]} tests
+     * @param {any[]} afterTests
+     * @param {string} branchToUse
+     * @param {*} tpOptions
+     * @param {string} executionId
+     * @param {string} executionName
+     * @param {TestRunStatus} testStatus
+     */
+    async runTestAllPhases(beforeTests, tests, afterTests, branchToUse, tpOptions, executionId, executionName, testStatus) {
         const executionResults = {};
         const authData = testimCustomToken.getTokenV3UserData();
 
-        const runBeforeTests = () => {
+        const runBeforeTests = async () => {
             const workerCount = tpOptions.beforeParallel || 1;
             const stopOnError = true;
-            return this.workerManager.runTests(beforeTests, testStatus, executionId, executionName, tpOptions, branchToUse, authData, workerCount, stopOnError)
-                .then(beforeTestsResults => Object.assign(executionResults, beforeTestsResults));
+            const beforeTestsResults = await this.workerManager.runTests(beforeTests, testStatus, executionId, executionName, tpOptions, branchToUse, authData, workerCount, stopOnError);
+            Object.assign(executionResults, beforeTestsResults);
         };
 
-        const runTestPlanTests = () => {
+        const runTestPlanTests = async () => {
             const workerCount = config.TESTIM_CONCURRENT_WORKER_COUNT || tpOptions.parallel;
             const stopOnError = false;
             perf.log('right before this.workerManager.runTests');
-            return this.workerManager.runTests(tests, testStatus, executionId, executionName, tpOptions, branchToUse, authData, workerCount, stopOnError)
-                .log('right after this.workerManager.runTests')
-                .then(testsResults => Object.assign(executionResults, testsResults));
+            const testsResults = await this.workerManager.runTests(tests, testStatus, executionId, executionName, tpOptions, branchToUse, authData, workerCount, stopOnError);
+            perf.log('right after this.workerManager.runTests');
+            Object.assign(executionResults, testsResults);
         };
 
-        const runAfterTests = () => {
+        const runAfterTests = async () => {
             const workerCount = tpOptions.afterParallel || 1;
             const stopOnError = false;
-            return this.workerManager.runTests(afterTests, testStatus, executionId, executionName, tpOptions, branchToUse, authData, workerCount, stopOnError)
-                .then(afterTestsResults => Object.assign(executionResults, afterTestsResults));
+            const afterTestsResults = await this.workerManager.runTests(afterTests, testStatus, executionId, executionName, tpOptions, branchToUse, authData, workerCount, stopOnError);
+            Object.assign(executionResults, afterTestsResults);
         };
 
         function catchBeforeTestsFailed() {
@@ -64,62 +78,82 @@ class TestPlanRunner {
         const sessionType = utils.getSessionType(tpOptions);
         analyticsService.analyticsExecsStart({ authData, executionId, projectId: tpOptions.project, sessionType });
         perf.log('right before runBeforeTests');
-        return runBeforeTests()
-            .log('right before runTestPlanTests')
-            .then(() => runTestPlanTests())
-            .log('right after runTestPlanTests')
-            .then(() => runAfterTests())
-            .then(() => executionResults)
-            .catch(err => {
-                logger.error('error running test plan', { err });
-                if (err instanceof StopRunOnError) {
-                    return catchBeforeTestsFailed();
-                }
-                throw err;
-            })
-            .finally(async () => {
-                if ((tpOptions.lightweightMode && tpOptions.lightweightMode.disablePixelValidation)) {
+        try {
+            await runBeforeTests();
+            perf.log('right before runTestPlanTests');
+            await runTestPlanTests();
+            perf.log('right after runTestPlanTests');
+            await runAfterTests();
+            return executionResults;
+        } catch (err) {
+            logger.error('error running test plan', { err });
+            if (err instanceof StopRunOnError) {
+                return catchBeforeTestsFailed();
+            }
+            throw err;
+        } finally {
+            await handlePixelValidationBatches();
+        }
+
+        async function handlePixelValidationBatches() {
+            if (tpOptions.lightweightMode?.disablePixelValidation) {
+                return;
+            }
+            // When sessionPlayer is available, use it - as it only attempts to close batches that exist.
+            if (tpOptions.mode === constants.CLI_MODE.SELENIUM) {
+                const { EyeSdkBuilder } = require('../commons/getSessionPlayerRequire');
+                await EyeSdkBuilder.closeBatch(executionId);
+                return;
+            }
+            /** @type {Awaited<ReturnType<typeof testimServicesApi['getApplitoolsIntegrationData']>>} */
+            let applitoolsIntegrationData;
+            try {
+                if (!tpOptions.company || !tpOptions.company.activePlan || !tpOptions.company.activePlan.premiumFeatures || !tpOptions.company.activePlan.premiumFeatures.applitools) {
                     return;
                 }
-                // When sessionPlayer is available, use it - as it only attempts to close batches that exist.
-                if (tpOptions.mode === constants.CLI_MODE.SELENIUM) {
-                    const { EyeSdkBuilder } = require('../commons/getSessionPlayerRequire');
-                    await EyeSdkBuilder.closeBatch(executionId);
+                applitoolsIntegrationData = await testimServicesApi.getApplitoolsIntegrationData(tpOptions.project);
+                if (_.isEmpty(applitoolsIntegrationData) || !executionId) {
                     return;
                 }
-                /** @type {Awaited<ReturnType<typeof testimServicesApi['getApplitoolsIntegrationData']>>} */
-                let applitoolsIntegrationData;
-                try {
-                    if (!tpOptions.company || !tpOptions.company.activePlan || !tpOptions.company.activePlan.premiumFeatures || !tpOptions.company.activePlan.premiumFeatures.applitools) {
-                        return;
-                    }
-                    applitoolsIntegrationData = await testimServicesApi.getApplitoolsIntegrationData(tpOptions.project);
-                    if (_.isEmpty(applitoolsIntegrationData) || !executionId) {
-                        return;
-                    }
-                    const { runKey: apiKey, url: serverUrl } = applitoolsIntegrationData;
-                    const tmpSDK = require('@applitools/eyes-sdk-core').makeSDK({ name: 'Testim.io', version: '4.0.0', spec: {} });
-                    await tmpSDK.closeBatches({ batchIds: [executionId], serverUrl, apiKey });
-                } catch (err) {
-                    // If a batch with this name did not exist, do not log an error.
-                    if (err.message && (err.message.startsWith('Request failed with status code 404') || err.message.startsWith('no batchIds were set'))) {
-                        return;
-                    }
-                    logger.error('Failed closing batch in extension mode', { err, projectId: tpOptions.project, applitoolsIntegrationData, batchIds: [executionId] });
+                const { runKey: apiKey, url: serverUrl } = applitoolsIntegrationData;
+                const tmpSDK = require('@applitools/eyes-sdk-core').makeSDK({ name: 'Testim.io', version: '4.0.0', spec: {} });
+                await tmpSDK.closeBatches({ batchIds: [executionId], serverUrl, apiKey });
+            } catch (err) {
+                // If a batch with this name did not exist, do not log an error.
+                if (err.message && (err.message.startsWith('Request failed with status code 404') || err.message.startsWith('no batchIds were set'))) {
+                    return;
                 }
-            });
+                logger.error('Failed closing batch in extension mode', { err, projectId: tpOptions.project, applitoolsIntegrationData, batchIds: [executionId] });
+            }
+        }
     }
 
+    /**
+     * @private
+     * @param {string} projectId
+     */
     async initRealDataService(projectId) {
         const realDataService = new RealDataService();
         await realDataService.init(projectId);
         return realDataService;
     }
 
+    /**
+     * @private
+     * @param {RealDataService} realDataService
+     * @param {string} projectId
+     * @param {string} runId
+     * @param {TestRunStatus} testStatus
+     */
     async listenToTestCreatedInFile(realDataService, projectId, runId, testStatus) {
         const childTestResults = {};
         realDataService.joinToTestResultsByRunId(runId, projectId);
-        const promise = new Promise(resolve => {
+        let isPromisePending = true;
+        const promise = new Promise(_resolve => {
+            const resolve = (val) => {
+                isPromisePending = false;
+                _resolve(val);
+            };
             realDataService.listenToTestResultsByRunId(runId, testResult => {
                 const resultId = testResult.id;
                 if (!testStatus.getTestResult(resultId)) {
@@ -151,9 +185,9 @@ class TestPlanRunner {
 
                 if (allParentTestResultCompleted && !allChildTestResultCompleted) {
                     // wait 10 sec to handle race condition when parent test result (file) finished before child test result
-                    return Bluebird.delay(10000)
+                    return utils.delay(10000)
                         .then(() => {
-                            if (promise.isPending()) {
+                            if (isPromisePending) {
                                 // TODO(Benji) we are missing the child test results here.
                                 // we are resolving here with partial data - we should consider fetching it
                                 // from the server
@@ -168,6 +202,28 @@ class TestPlanRunner {
         return await promise;
     }
 
+    /**
+     * @private
+     * @param {string} projectId
+     * @param {string} executionId
+     * @param {TestRunStatus} testStatus
+     */
+    async initRealDataServiceAndListenToTestsCreatedInFile(projectId, executionId, testStatus) {
+        const realDataService = await this.initRealDataService(projectId);
+        return this.listenToTestCreatedInFile(realDataService, projectId, executionId, testStatus);
+    }
+
+    /**
+     * @private
+     * @param {any[]} beforeTests
+     * @param {any[]} tests
+     * @param {any[]} afterTests
+     * @param {Awaited<ReturnType<typeof import('../runOptions')['process']>>} tpOptions
+     * @param {string} testPlanName
+     * @param {string | null} testPlanId
+     * @param {string} branch
+     * @param {boolean=} isAnonymous
+     */
     async runTestPlan(beforeTests, tests, afterTests, tpOptions, testPlanName, testPlanId, branch, isAnonymous) {
         const executionId = guid();
         const projectId = tpOptions.project;
@@ -176,37 +232,36 @@ class TestPlanRunner {
         afterTests.forEach(test => { test.isAfterTestPlan = true; });
         const testStatus = new TestRunStatus(_.concat(beforeTests, tests, afterTests), tpOptions, testPlanId, branch);
 
-        const configs = _(_.concat(beforeTests, tests, afterTests)).map(test => (test.overrideTestConfig && test.overrideTestConfig.name) || '').uniq().filter(Boolean)
+        const configs = _.chain(_.concat(beforeTests, tests, afterTests))
+            .map(test => test.overrideTestConfig?.name || '')
+            .uniq()
+            .compact()
             .value();
-        const configName = configs && configs.length === 1 ? configs[0] : null;
+        const configName = configs?.length === 1 ? configs[0] : null;
 
         const isCodeMode = tpOptions.files.length > 0;
-        const testNames = tpOptions.lightweightMode && tpOptions.lightweightMode.onlyTestIdsNoSuite ? [] : _.concat(beforeTests, tests, afterTests).map(test => test.name);
+        const testNames = tpOptions.lightweightMode?.onlyTestIdsNoSuite ? [] : _.concat(beforeTests, tests, afterTests).map(test => test.name);
 
-        const testListInfoPromise = tpOptions.lightweightMode && tpOptions.lightweightMode.onlyTestIdsNoSuite ?
+        const testListInfoPromise = tpOptions.lightweightMode?.onlyTestIdsNoSuite ?
             { beforeTests, tests, afterTests } :
             testStatus.executionStart(executionId, projectId, this.startTime, testPlanName, testNames);
         let childTestResults;
         if (isCodeMode) {
-            childTestResults = Bluebird.try(async () => {
-                const realDataService = await this.initRealDataService(projectId);
-                return this.listenToTestCreatedInFile(realDataService, projectId, executionId, testStatus);
-            });
+            childTestResults = this.initRealDataServiceAndListenToTestsCreatedInFile(projectId, executionId, testStatus);
         }
         perf.log('before testListInfoPromise');
         const testListInfo = await testListInfoPromise;
-        if (!(tpOptions.lightweightMode && tpOptions.lightweightMode.onlyTestIdsNoSuite)) {
+        if (!tpOptions.lightweightMode?.onlyTestIdsNoSuite) {
             reporter.onTestPlanStarted(testListInfo.beforeTests, testListInfo.tests, testListInfo.afterTests, testPlanName, executionId, isAnonymous, configName, isCodeMode);
         }
 
         perf.log('before runTestAllPhases');
         const results = await this.runTestAllPhases(testListInfo.beforeTests, testListInfo.tests, testListInfo.afterTests, branch, tpOptions, executionId, testPlanName || 'All Tests', testStatus);
-        const childResults = await Bluebird.resolve(childTestResults)
-            .timeout(TDK_CHILD_RESULTS_TIMEOUT)
+        const childResults = await utils.promiseTimeout(childTestResults, TDK_CHILD_RESULTS_TIMEOUT)
             .catch(async () => {
-                logger.warn('timed out waiting for child resutls on websocket. using REST fallback', { projectId, executionId });
+                logger.warn('timed out waiting for child results on websocket. using REST fallback', { projectId, executionId });
                 const testResults = await testimServicesApi.getRealData(projectId, 'testResult', `runId=${executionId}&sort=runOrder`);
-                return _.chain((testResults && testResults.data && testResults.data.docs) || [])
+                return _.chain((testResults?.data?.docs) || [])
                     .groupBy('parentResultId')
                     .omit('undefined')
                     .values()
@@ -219,6 +274,11 @@ class TestPlanRunner {
         return { results, executionId, testPlanName, configName, childTestResults: childResults };
     }
 
+    /**
+     * @private
+     * @param {Awaited<ReturnType<typeof import('../runOptions')['process']>>} options
+     * @param {string} branchToUse
+     */
     async runTestPlans(options, branchToUse) {
         logger.info('start to run test plan', {
             options: Object.assign({}, options, { token: undefined, userParamsData: undefined }),
@@ -246,7 +306,7 @@ class TestPlanRunner {
             throw new ArgError(`no test to run in test plan ${options.testPlan}`);
         }
         await validateConfig(options, flattenTestListData(testPlansData));
-        return await Promise.all(testPlans.map(async testPlan => {
+        return await utils.promiseMap(testPlans, async testPlan => {
             const id = testPlan.testPlanId;
             testPlansResults[id] = {};
 
@@ -265,7 +325,7 @@ class TestPlanRunner {
             tpOptions.gridData = await gridService.getTestPlanGridData(options, testPlan);
 
             const testPlanName = tpOptions.overrideExecutionName || testPlan.name;
-            return await Promise.all(testPlansData[id].map(async testPlanTests => {
+            return await utils.promiseMap(testPlansData[id], async testPlanTests => {
                 const res = await this.runTestPlan(testPlanTests.beforeTests, testPlanTests.tests, testPlanTests.afterTests, tpOptions, testPlanName, id, branchToUse);
                 const isCodeMode = options.files.length > 0;
                 reporter.onTestPlanFinished(res.results, testPlan.name, this.startTime, res.executionId, false, isCodeMode, res.childTestResults);
@@ -281,10 +341,15 @@ class TestPlanRunner {
                 const executionId = success ? executions[0].executionId : executions.find(exec => !exec.success).executionId;
                 await testimServicesApi.saveTestPlanResult(projectId, id, { success, executions, executionId });
                 return res;
-            }));
-        }));
+            });
+        });
     }
 
+    /**
+     * @private
+     * @param {Awaited<ReturnType<typeof import('../runOptions')['process']>>} options
+     * @param {string} branchToUse
+     */
     async runAnonymousTestPlan(options, branchToUse) {
         logger.info('start to run anonymous', {
             options: Object.assign({}, options, { token: undefined }),
@@ -295,7 +360,7 @@ class TestPlanRunner {
         const suiteResult = await getSuite(options, branchToUse);
         perf.log('after getSuite');
 
-        if (!suiteResult.tests[0] || suiteResult.tests[0].length === 0) {
+        if (!suiteResult.tests[0]?.length) {
             if (options.rerunFailedByRunId) {
                 throw new ArgError('No failed tests found in the provided run');
             }
@@ -317,7 +382,7 @@ class TestPlanRunner {
         const testPlanName = options.overrideExecutionName || suiteResult.runName || _.concat(options.label, options.name, options.suites).join(' ');
         const isAnonymous = true;
         perf.log('Right before validateConfig + runAnonymousTestPlan tests map');
-        return await Promise.all(suiteResult.tests.map(async suiteTests => { // array of results per execution
+        return await utils.promiseMap(suiteResult.tests, async suiteTests => { // array of results per execution
             //override result id for remote run mode and run only the first test data
             if (options.resultId) {
                 const firstTest = _.first(suiteTests);
@@ -331,9 +396,12 @@ class TestPlanRunner {
             const isCodeMode = options.files.length > 0;
             await reporter.onTestPlanFinished(res.results, testPlanName, this.startTime, res.executionId, isAnonymous, isCodeMode, res.childTestResults);
             return res;
-        }));
+        });
     }
 
+    /**
+     * @param {Awaited<ReturnType<typeof import('../runOptions')['process']>>} options
+     */
     async run(options) {
         const branchToUse = branchService.getCurrentBranch();
         let results = [];

package/runners/buildCodeTests.js

@@ -1,19 +1,17 @@
-"use strict";
+'use strict';
 
-const MemoryFS = require('memory-fs');
+const _ = require('lodash');
 const path = require('path');
-const utils = require('../utils');
 const Promise = require('bluebird');
-const _ = require('lodash');
+const MemoryFS = require('memory-fs');
+const utils = require('../utils');
 const lazyRequire = require('../commons/lazyRequire');
 const { AbortError } = require('../commons/AbortError');
 
-const { isEqual, cloneDeep } = require('lodash');
-
 // compiler instance we can reuse between calls
 const state = {
     compiler: null,
-    webpackConfig: null
+    webpackConfig: null,
 };
 
 exports.buildCodeTests = async function buildCodeTestsGuarded(
@@ -36,36 +34,40 @@ exports.buildCodeTests = async function buildCodeTestsGuarded(
         }
         throw e;
     }
-}
-
-async function buildCodeTests(files, webpackConfig = {mode: 'development'}, runnerOptionsToMaybeCopyToTestEnvironment, fileSystem, optionalAbortSignal) {
+};
 
+async function buildCodeTests(files, webpackConfig = { mode: 'development' }, runnerOptionsToMaybeCopyToTestEnvironment = undefined, fileSystem = undefined, optionalAbortSignal = undefined) {
     const webpack = await lazyRequire('webpack');
 
     const suite = {};
-    const webpackConfigBeforeOurChanges = cloneDeep(webpackConfig);
+    const webpackConfigBeforeOurChanges = _.cloneDeep(webpackConfig);
 
     webpackConfig.externals = { // define testim as an external
-        'testim': '__testim',
+        testim: '__testim',
         // 'chai': '__chai'
     };
     webpackConfig.devtool = webpackConfig.devtool || 'inline-source-map';
 
     webpackConfig.plugins = webpackConfig.plugins || [];
 
-    webpackConfig.plugins.push(new webpack.DefinePlugin(getEnvironmentVariables(runnerOptionsToMaybeCopyToTestEnvironment)))
-    webpackConfig.plugins.push(new webpack.DefinePlugin({
-        'process.argv': JSON.stringify(process.argv)
+    webpackConfig.plugins.push(new webpack.DefinePlugin(getEnvironmentVariables(runnerOptionsToMaybeCopyToTestEnvironment)), new webpack.DefinePlugin({
+        'process.argv': JSON.stringify(process.argv),
     }));
     files = files.map(f => path.resolve(f));
 
-    const fileHashes = files.map(x => utils.guid(30));
+    const fileHashes = files.map(() => utils.guid(30));
 
     webpackConfig.optimization = { minimize: false };
 
-    webpackConfig.entry = _.fromPairs(_.zip(files, fileHashes).map(([filename, hash]) => {
-        return [hash, filename];
-    }));
+    const majorNodeVersion = Number(process.versions.node.split('.')[0]);
+    if (majorNodeVersion >= 17) {
+        // TODO ugly hack to be removed once using Webpack 5 - https://stackoverflow.com/a/73465262 + https://github.com/webpack/webpack/issues/14532
+        const crypto = require('crypto');
+        const originalCryptoCreateHash = crypto.createHash;
+        crypto.createHash = (algorithm, options) => originalCryptoCreateHash(algorithm === 'md4' ? 'sha256' : algorithm, options);
+    }
+
+    webpackConfig.entry = Object.fromEntries(_.zip(files, fileHashes).map(([filename, hash]) => [hash, filename]));
     webpackConfig.output = Object.assign({
         devtoolModuleFilenameTemplate: (info) => `file:///${info.absoluteResourcePath}`,
         filename: '[name].bundle.js',
@@ -76,7 +78,7 @@ async function buildCodeTests(files, webpackConfig = {mode: 'development'}, runn
     // if we are passed a filesystem, assume reuse between calls and turn on watch mode
     if (fileSystem) {
         // were we passed a filesystem before to compile the same thing?
-        if (isEqual(state.webpackConfig, webpackConfigBeforeOurChanges) && state.compiler) {
+        if (_.isEqual(state.webpackConfig, webpackConfigBeforeOurChanges) && state.compiler) {
             // we already have a compiler up and running
             compiler = state.compiler;
         } else {
@@ -92,9 +94,9 @@ async function buildCodeTests(files, webpackConfig = {mode: 'development'}, runn
     compiler.outputFileSystem = mfs; // no need to write compiled tests to disk
 
     // This can only reject
-    const abortSignalPromise = Promise.fromCallback(cb => {
+    const abortSignalPromise = utils.promiseFromCallback(cb => {
         if (optionalAbortSignal) {
-            optionalAbortSignal.addEventListener("abort", () => {
+            optionalAbortSignal.addEventListener('abort', () => {
                 cb(new AbortError());
             });
         }
@@ -102,12 +104,12 @@ async function buildCodeTests(files, webpackConfig = {mode: 'development'}, runn
 
     // run compiler:
     try {
-        const stats = await Promise.race([Promise.fromCallback(cb => compiler.run(cb)), abortSignalPromise]);
+        const stats = await Promise.race([utils.promiseFromCallback(cb => compiler.run(cb)), abortSignalPromise]);
         if (stats.hasErrors()) {
             throw new Error(stats.toJson().errors);
         }
     } catch (e) {
-        const {ArgError} = require('../errors');
+        const { ArgError } = require('../errors');
 
         const cantFindFile = e.message.match(/Entry module not found: Error: Can't resolve '(.*)'/);
         if (cantFindFile && cantFindFile.length === 2) {
@@ -117,40 +119,39 @@ async function buildCodeTests(files, webpackConfig = {mode: 'development'}, runn
             throw new ArgError(`Can't find test files in: '${cantFindFile[1]}'`);
         }
 
-        throw new ArgError("Compilation Webpack Error in tests: " + e.message);
+        throw new ArgError(`Compilation Webpack Error in tests: ${e.message}`);
     }
 
-    const fileResults = files.map((file, i) => ({code: mfs.readFileSync(path.resolve('./dist', `${fileHashes[i]}.bundle.js`)), name: file })); // read all files
+    const fileResults = files.map((file, i) => ({ code: mfs.readFileSync(path.resolve('./dist', `${fileHashes[i]}.bundle.js`)), name: file })); // read all files
 
-    suite.tests = [fileResults.map(({code, name}) => ({
+    suite.tests = [fileResults.map(({ code, name }) => ({
         code: code.toString(),
-        baseUrl: "", // not supported at the moment
+        baseUrl: '', // not supported at the moment
         name: path.resolve(name),
         testConfig: {},
         testConfigId: null,
         testId: utils.guid(),
         resultId: utils.guid(),
-        isTestsContainer: true
+        isTestsContainer: true,
     }))];
-    suite.runName = 'Testim Dev Kit Run ' + (new Date().toLocaleString());
+    suite.runName = `Testim Dev Kit Run ${new Date().toLocaleString()}`;
     return suite;
 }
 
 // copied mostly from facebook/create-react-app/blob/8b7b819b4b9e6ba457e011e92e33266690e26957/packages/react-scripts/config/env.js
 function getEnvironmentVariables(runnerOptionsToMaybeCopyToTestEnvironment) {
-
-    let fromEnvironment = _.fromPairs(
+    const fromEnvironment = _.fromPairs(
         Object.keys(process.env)
-                .filter(key => /^TDK_/i.test(key) || key === 'BASE_URL')
-                .map(key => [key, process.env[key]])
+            .filter(key => /^TDK_/i.test(key) || key === 'BASE_URL')
+            .map(key => [key, process.env[key]])
     );
 
-    let fromConfig = {
-        'BASE_URL': runnerOptionsToMaybeCopyToTestEnvironment.baseUrl
+    const fromConfig = {
+        BASE_URL: runnerOptionsToMaybeCopyToTestEnvironment.baseUrl,
     };
 
     return {
-        'process.env': stringifyValues({ ...fromConfig, ...fromEnvironment})
+        'process.env': stringifyValues({ ...fromConfig, ...fromEnvironment }),
     };
 }
 function stringifyValues(object) {

package/runners/runnerUtils.js

@@ -2,13 +2,13 @@
 
 const _ = require('lodash');
 const path = require('path');
-const utils = require('../utils.js');
+const utils = require('../utils');
 const analytics = require('../commons/testimAnalytics');
 const { ArgError } = require('../errors');
 
 
 async function getSuite(options, branchToUse) {
-    if (options.lightweightMode && options.lightweightMode.onlyTestIdsNoSuite && options.testId) {
+    if (options.lightweightMode?.onlyTestIdsNoSuite && options.testId) {
         return { tests: [options.testId.map(testId => ({ testId, testConfig: { }, resultId: utils.guid() }))] };
     }
     // local code test
@@ -17,7 +17,7 @@ async function getSuite(options, branchToUse) {
         let webpackConfig = {};
         if (options.webpackConfig) {
             const webpackConfigPath = path.join(process.cwd(), options.webpackConfig);
-            webpackConfig = require(webpackConfigPath);
+            webpackConfig = require(webpackConfigPath); // eslint-disable-line import/no-dynamic-require
         }
 
         return buildCodeTests(options.files, webpackConfig, { baseUrl: options.baseUrl });

package/services/lambdatestService.js

@@ -4,8 +4,6 @@ const pRetry = require('p-retry');
 const fse = require('fs-extra');
 const portfinder = require('portfinder');
 const ms = require('ms');
-
-const { guid, isURL } = require('../utils');
 const utils = require('../utils');
 const { gridTypes, CLI_MODE } = require('../commons/constants');
 const httpRequest = require('../commons/httpRequest');
@@ -98,7 +96,7 @@ class LambdatestService {
         const infoAPIPort = await portfinder.getPortPromise();
         const { gridData = {}, gridUsername, gridPassword } = runnerOptions;
         const proxyUri = global.proxyUri;
-        LambdatestService.tunnelName = guid();
+        LambdatestService.tunnelName = utils.guid();
 
         let tunnelArgs = [
             '--tunnelName', LambdatestService.tunnelName,
@@ -198,11 +196,11 @@ class LambdatestService {
             if (!extensionPath && extUrls[browser]) {
                 loadExtension = [...loadExtension, extUrls[browser]];
             }
-            if (extensionPath && isURL(extensionPath)) {
+            if (extensionPath && utils.isURL(extensionPath)) {
                 loadExtension = [...loadExtension, extensionPath];
             }
         }
-        if (installCustomExtension && isURL(installCustomExtension)) {
+        if (installCustomExtension && utils.isURL(installCustomExtension)) {
             loadExtension = [...loadExtension, installCustomExtension];
         }
 

package/stepPlayers/cliJsStepPlayback.js

@@ -1,16 +1,15 @@
-"use strict";
+'use strict';
 
 const service = require('../agent/routers/cliJsCode/service');
-const Promise = require('bluebird');
+const { TimeoutError } = require('bluebird');
 const featureFlags = require('../commons/featureFlags');
-const logger = require('../commons/logger').getLogger('cli-js-step-playback');
 
 function isExceedingMaxResultSize(data, project) {
     try {
         const shouldEnforceMaxSize = project.defaults.enforceMaximumJsResultSize;
         const maximumJsResultSize = featureFlags.flags.maximumJsResultSize.getValue();
         const dataSizeExceeded = JSON.stringify(data).length > maximumJsResultSize;
-        if(!shouldEnforceMaxSize) {
+        if (!shouldEnforceMaxSize) {
             return false;
         }
         return dataSizeExceeded;
@@ -19,17 +18,23 @@ function isExceedingMaxResultSize(data, project) {
     }
 }
 
-module.exports.run = (browser, step, projectData) => {
-    const {code, stepId, incomingParams, context, testResultId, retryIndex, stepResultId, runTimeout, fileDataUrl, s3filepath} = step.data;
-    return service.runCodeWithPackages(code, stepId, incomingParams, context, testResultId, retryIndex, stepResultId, runTimeout, fileDataUrl, s3filepath)
-        .then(data => {
-            if (data && isExceedingMaxResultSize({result: data.result, tstConsoleLogs: data.tstConsoleLogs}, projectData)) {
-                return {
-                    code: 'js-result-max-size-exceeded',
-                    success: false,
-                };
-            }
-            return {data, success: true};
-        })
-        .catch(Promise.TimeoutError, () => Promise.reject(new Error("Timeout while running action")));
+module.exports.run = async (browser, step, projectData) => {
+    const {
+        code, stepId, incomingParams, context, testResultId, retryIndex, stepResultId, runTimeout, fileDataUrl, s3filepath,
+    } = step.data;
+    try {
+        const data = await service.runCodeWithPackages(code, stepId, incomingParams, context, testResultId, retryIndex, stepResultId, runTimeout, fileDataUrl, s3filepath);
+        if (data && isExceedingMaxResultSize({ result: data.result, tstConsoleLogs: data.tstConsoleLogs }, projectData)) {
+            return {
+                code: 'js-result-max-size-exceeded',
+                success: false,
+            };
+        }
+        return { data, success: true };
+    } catch (err) {
+        if (err instanceof TimeoutError) {
+            throw new Error('Timeout while running action');
+        }
+        throw err;
+    }
 };