@testim/testim-cli 3.255.0 → 3.257.0

package/runner.js

@@ -1,32 +1,34 @@
 'use strict';
 
 /* eslint-disable no-console */
-const { CLI_MODE } = require('./commons/constants');
 const _ = require('lodash');
-const { EDITOR_URL } = require('./commons/config');
-const tunnel = require('./commons/testimTunnel');
 const utils = require('./utils');
 const reporter = require('./reports/reporter');
-const testimCustomToken = require('./commons/testimCustomToken');
-const socketService = require('./commons/socket/socketService');
-const servicesApi = require('./commons/testimServicesApi.js');
-const npmDriver = require('./testimNpmDriver.js');
+const npmDriver = require('./testimNpmDriver');
+const tunnel = require('./commons/testimTunnel');
+const perf = require('./commons/performance-logger');
+const gridService = require('./services/gridService');
 const analytics = require('./commons/testimAnalytics');
+const featureFlags = require('./commons/featureFlags');
 const branchService = require('./services/branchService');
-const gridService = require('./services/gridService');
+const servicesApi = require('./commons/testimServicesApi');
+const TestPlanRunner = require('./runners/TestPlanRunner');
+const socketService = require('./commons/socket/socketService');
+const testimCustomToken = require('./commons/testimCustomToken');
+const labFeaturesService = require('./services/labFeaturesService');
+const featureAvailabilityService = require('./commons/featureAvailabilityService');
+const { getLogger } = require('./commons/logger');
+const { EDITOR_URL } = require('./commons/config');
+const { CLI_MODE } = require('./commons/constants');
 const { ArgError, QuotaDepletedError } = require('./errors');
-const featureFlags = require('./commons/featureFlags');
-const perf = require('./commons/performance-logger');
 const { prepareMockNetwork, initializeUserWithAuth } = require('./commons/prepareRunner');
 
 const FREE_PLAN_MINIMUM_BROWSER_TIMEOUT = 30 * 60 * 1000;
 
-const TestPlanRunner = require('./runners/TestPlanRunner');
-const labFeaturesService = require('./services/labFeaturesService');
-const featureAvailabilityService = require('./commons/featureAvailabilityService');
 
-const logger = require('./commons/logger').getLogger('runner');
+const logger = getLogger('runner');
 
+/** @param {import('./runOptions').RunnerOptions} options */
 function validateCLIRunsAreAllowed(options) {
     const hasCliAccess = _.get(options, 'company.activePlan.premiumFeatures.allowCLI');
 
@@ -34,14 +36,16 @@ function validateCLIRunsAreAllowed(options) {
         const projectId = options.project;
         analytics.track(options.authData.uid, 'cli-not-supported', { projectId });
         console.warn('Testim CLI is not supported in this plan');
+        // TODO: shouldn't this throw an error? 🤔
     }
 }
 
+/** @param {import('./runOptions').RunnerOptions} options */
 async function validateProjectQuotaNotDepleted(options) {
     const projectId = options.project;
 
     const usage = await servicesApi.getUsageForCurrentBillingPeriod(projectId);
-    const isExecutionBlocked = usage && usage.isExecutionBlocked;
+    const isExecutionBlocked = usage?.isExecutionBlocked;
     if (!isExecutionBlocked) {
         return;
     }
@@ -51,6 +55,10 @@ async function validateProjectQuotaNotDepleted(options) {
     throw new QuotaDepletedError();
 }
 
+/**
+ * @param {import('./runOptions').RunnerOptions} options
+ * @param {Awaited<ReturnType<initializeUserWithAuth>>['companyByProjectId']} company
+ */
 function validateOptionsForCompany(options, company) {
     const optionsRetention = options.retentionDays;
     if (!optionsRetention) {
@@ -63,8 +71,9 @@ function validateOptionsForCompany(options, company) {
     }
 }
 
+/** @param {import('./runOptions').RunnerOptions} options */
 async function validateCliAccount(options) {
-    if (options.lightweightMode && options.lightweightMode.disableQuotaBlocking) {
+    if (options.lightweightMode?.disableQuotaBlocking) {
         return;
     }
     try {
@@ -73,13 +82,14 @@ async function validateCliAccount(options) {
             validateCLIRunsAreAllowed(options),
         ]);
     } catch (err) {
-        if (err instanceof ArgError || err instanceof QuotaDepletedError) {
+        if ([ArgError, QuotaDepletedError].some(errType => err instanceof errType)) {
             throw err;
         }
         logger.error('could not validate cli account', { err });
     }
 }
 
+/** @param {string} projectId */
 function analyticsIdentify(projectId) {
     const authData = testimCustomToken.getTokenV3UserData();
     return analytics.identify({
@@ -95,6 +105,7 @@ function analyticsIdentify(projectId) {
     });
 }
 
+/** @param {string} projectId */
 function initSocketServices(projectId, { disableResults = false, disableRemoteStep = false }) {
     if (featureFlags.flags.useNewWSCLI.isEnabled() && !disableResults && !disableRemoteStep) {
         return socketService.connect(projectId);
@@ -110,6 +121,10 @@ function initSocketServices(projectId, { disableResults = false, disableRemoteSt
     return undefined;
 }
 
+/**
+ * @param {import('./runOptions').RunnerOptions} options
+ * @param {Awaited<ReturnType<initializeUserWithAuth>>['branchName']} branchInfoFromServer
+ */
 function setBranch(options, branchInfoFromServer) {
     const { branch, autoDetect } = options;
     branchService.setCurrentBranch(branchInfoFromServer, autoDetect);
@@ -118,14 +133,19 @@ function setBranch(options, branchInfoFromServer) {
     }
 }
 
+/** @param {import('./runOptions').RunnerOptions} options */
 async function setSfdcCredential(options) {
-    const { projectData: { projectId } } = options;
+    const { projectData: { projectId } = {} } = options;
     const branch = branchService.getCurrentBranch();
     if (_.get(options, 'company.activePlan.premiumFeatures.ttaForSalesforce')) {
         options.sfdcCredential = await servicesApi.loadSfdcCredential({ projectId, branch });
     }
 }
 
+/**
+ * @param {import('./runOptions').RunnerOptions} options
+ * @param {Awaited<ReturnType<initializeUserWithAuth>>['companyByProjectId']} company
+ */
 function setCompany(options, company) {
     const { onprem, id, storageBaseUrl, storageType, name, activePlan = {} } = company;
     if (onprem) {
@@ -161,6 +181,10 @@ function setCompany(options, company) {
     };
 }
 
+/**
+ * @param {import('./runOptions').RunnerOptions} options
+ * @param {Awaited<ReturnType<initializeUserWithAuth>>['editorConfig']} editorConfig
+ */
 function setSystemInfo(options, editorConfig) {
     if (EDITOR_URL) {
         options.editorUrl = EDITOR_URL;
@@ -169,14 +193,26 @@ function setSystemInfo(options, editorConfig) {
     options.editorUrl = editorConfig.editorUrl;
 }
 
+/**
+ * @param {import('./runOptions').RunnerOptions} options
+ * @param {Awaited<ReturnType<initializeUserWithAuth>>['allGrids']} allGrids
+ */
 function setAllGrids(options, allGrids) {
     options.allGrids = allGrids;
 }
 
+/**
+ * @param {import('./runOptions').RunnerOptions} options
+ * @param {Awaited<ReturnType<initializeUserWithAuth>>['authData']} authData
+ */
 function setAuthData(options, authData) {
     options.authData = authData;
 }
 
+/**
+ * @param {import('./runOptions').RunnerOptions} options
+ * @param {Awaited<ReturnType<initializeUserWithAuth>>['projectById']} project
+ */
 function setProject(options, project) {
     const { id, name, type, defaults } = project;
     featureFlags.setProjectId(id);
@@ -189,10 +225,12 @@ function setProject(options, project) {
     };
 }
 
+/** @param {import('./runOptions').RunnerOptions} options */
 async function setGrid(options) {
     options.gridData = await gridService.getGridData(options);
 }
 
+/** @param {import('./runOptions').RunnerOptions} options */
 async function setMockNetworkRules(options) {
     const { project } = options;
     const props = { projectId: project };
@@ -236,8 +274,9 @@ async function runRunner(options, customExtensionLocalLocation) {
     return results;
 }
 
+/** @param {import('./runOptions').RunnerOptions} options */
 function showFreeGridRunWarningIfNeeded(options) {
-    if (featureAvailabilityService.shouldShowFreeGridRunWarning(options.gridData && options.gridData.type)) {
+    if (featureAvailabilityService.shouldShowFreeGridRunWarning(options.gridData?.type)) {
         const CYAN = '\x1b[36m';
         const UNDERSCORE = '\x1b[4m';
         const RESET = '\x1b[0m';
@@ -252,15 +291,15 @@ function showFreeGridRunWarningIfNeeded(options) {
  * - Reporting the user to analytics
  * - Authenticating the user and exchanging their token for a jwt
  * - Sets the grids for the company and validates the user has permission to run the CLI
- * @param {Object} options - the run options passed to the CLI, namely the project and token
+ * @param {import('./runOptions').RunnerOptions} options - the run options passed to the CLI, namely the project and token
  */
 async function init(options) {
     perf.log('start runner init');
     const { project, lightweightMode, useChromeLauncher, mode, disableSockets } = options;
     const featureFlagsReady = featureFlags.fetch();
     const socketConnected = initSocketServices(project, {
-        disableResults: disableSockets || Boolean(lightweightMode && lightweightMode.disableResults && (useChromeLauncher || mode !== 'extension')),
-        disableRemoteStep: disableSockets || Boolean(lightweightMode && lightweightMode.disableRemoteStep),
+        disableResults: disableSockets || Boolean(lightweightMode?.disableResults && (useChromeLauncher || mode !== 'extension')),
+        disableRemoteStep: disableSockets || Boolean(lightweightMode?.disableRemoteStep),
     });
 
     featureFlagsReady.catch(() => {}); // suppress unhandled rejection
@@ -280,7 +319,7 @@ async function init(options) {
     setAuthData(options, authData);
     await setSfdcCredential(options);
 
-    if (!(options.lightweightMode && options.lightweightMode.disableLabs)) {
+    if (!options.lightweightMode?.disableLabs) {
         await labFeaturesService.loadLabFeatures(projectById.id, companyByProjectId.activePlan);
     }
 

package/runners/ParallelWorkerManager.js

@@ -54,10 +54,11 @@ class ParallelWorkerManager {
 
         let stoppedOnError = false;
         let runningTests = 0;
-        const runAndWaitToComplete = token => new Promise((resolve, reject) => {
+        const runAndWaitToComplete = token => new Promise((resolve) => {
             const projectId = options.project;
             const executionQueue = new ExecutionQueue(executionId, executionName, testList, options, branchToUse, testStatus);
 
+            /** @type {{ [testResultId: string]: any; }} */
             const combinedTestResults = {};
             const testCount = testList.length;
 
@@ -177,7 +178,7 @@ class ParallelWorkerManager {
                 }
             };
 
-            const onGridSlot = (executionId, resultId, gridInfo) => testStatus.onGridSlot(executionId, resultId, gridInfo);
+            const onGridSlot = (_executionId, resultId, gridInfo) => testStatus.onGridSlot(_executionId, resultId, gridInfo);
 
             options.userData = {
                 loginData: Object.assign({}, testimCustomToken.getTokenV3UserData(), {

package/runners/TestPlanRunner.js

@@ -39,12 +39,13 @@ class TestPlanRunner {
      * @param {any[]} tests
      * @param {any[]} afterTests
      * @param {string} branchToUse
-     * @param {*} tpOptions
+     * @param {import('../runOptions').RunnerOptions} tpOptions
      * @param {string} executionId
      * @param {string} executionName
      * @param {TestRunStatus} testStatus
      */
     async runTestAllPhases(beforeTests, tests, afterTests, branchToUse, tpOptions, executionId, executionName, testStatus) {
+        /** @type {{ [testResultId: string]: any; }} */
         const executionResults = {};
         const authData = testimCustomToken.getTokenV3UserData();
 
@@ -145,6 +146,7 @@ class TestPlanRunner {
         const childTestResults = {};
         realDataService.joinToTestResultsByRunId(runId, projectId);
         let isPromisePending = true;
+        /** @type {Promise<any[]>} */
         const promise = new Promise(_resolve => {
             const resolve = (val) => {
                 isPromisePending = false;
@@ -226,17 +228,18 @@ class TestPlanRunner {
         Logger.setExecutionId(executionId);
         beforeTests.forEach(test => { test.isBeforeTestPlan = true; });
         afterTests.forEach(test => { test.isAfterTestPlan = true; });
-        const testStatus = new TestRunStatus(_.concat(beforeTests, tests, afterTests), tpOptions, testPlanId, branch);
+        const testStatus = new TestRunStatus([].concat(beforeTests, tests, afterTests), tpOptions, testPlanId, branch);
 
-        const configs = _.chain(_.concat(beforeTests, tests, afterTests))
+        const configs = _.chain([].concat(beforeTests, tests, afterTests))
             .map(test => test.overrideTestConfig?.name || '')
             .uniq()
             .compact()
             .value();
+        /** @type {string | null} */
         const configName = configs?.length === 1 ? configs[0] : null;
 
         const isCodeMode = tpOptions.files.length > 0;
-        const testNames = 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?.onlyTestIdsNoSuite ?
             { beforeTests, tests, afterTests } :
@@ -375,13 +378,13 @@ class TestPlanRunner {
                 suiteResult.runName = `rerun-${options.rerunFailedByRunId}`;
             }
         }
-        const testPlanName = options.overrideExecutionName || suiteResult.runName || _.concat(options.label, options.name, options.suites).join(' ');
+        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 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);
+                const firstTest = suiteTests[0];
                 firstTest.resultId = options.resultId;
                 suiteTests = [firstTest];
             }

package/runners/buildCodeTests.js

@@ -122,6 +122,7 @@ async function buildCodeTests(files, webpackConfig = { mode: 'development' }, ru
         throw new ArgError(`Compilation Webpack Error in tests: ${e.message}`);
     }
 
+    /** @type {{ code: string; name: string; }[]} */
     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 }) => ({

package/runners/runnerUtils.js

@@ -7,9 +7,14 @@ const analytics = require('../commons/testimAnalytics');
 const { ArgError } = require('../errors');
 
 
+/**
+ * @param {import('../runOptions').RunnerOptions} options
+ * @param {string} branchToUse
+ * @returns
+ */
 async function getSuite(options, branchToUse) {
     if (options.lightweightMode?.onlyTestIdsNoSuite && options.testId) {
-        return { tests: [options.testId.map(testId => ({ testId, testConfig: { }, resultId: utils.guid() }))] };
+        return { tests: [options.testId.map(testId => ({ testId, testConfig: {}, resultId: utils.guid() }))] };
     }
     // local code test
     if (options.files.length > 0) {
@@ -47,7 +52,11 @@ function calcTestResultStatus(tests) {
 }
 
 
-
+/**
+ * @template T
+ * @param {import('../runOptions').RunnerOptions} options
+ * @param {T[]} testList
+ */
 async function validateConfig(options, testList) {
     const supportedBrowsers = options.mode === 'extension' ? [
         'edge-chromium', 'chrome',

package/services/branchService.js

@@ -1,12 +1,18 @@
-"use strict";
+'use strict';
 
+/** @type {string | undefined} */
 let currentBranch;
 
 function getCurrentBranch() {
-    return currentBranch || "master";
+    return currentBranch || 'master';
 }
-function setCurrentBranch(branchData = "master", acknowledgeAutoDetect = "false") {
-    if (branchData && branchData.branch && branchData.branch === 'master') {
+
+/**
+ * @param {Awaited<ReturnType<import('../commons/initializeUserWithAuth')['initializeUserWithAuth']>>['branchName']} branchData
+ * @param {boolean | string} acknowledgeAutoDetect
+ */
+function setCurrentBranch(branchData = 'master', acknowledgeAutoDetect = 'false') {
+    if (branchData?.branch && branchData.branch === 'master') {
         currentBranch = 'master';
         return;
     }
@@ -19,5 +25,5 @@ function setCurrentBranch(branchData = "master", acknowledgeAutoDetect = "false"
 
 module.exports = {
     getCurrentBranch,
-    setCurrentBranch
+    setCurrentBranch,
 };

package/services/localRCASaver.js

@@ -37,6 +37,10 @@ function mapFilesToLocalDrive(test, logger) {
     }
 }
 
+/**
+ * @param {Partial<Pick<import('../runOptions').AgentModeOptions, 'agentPort' | 'agentBind'> & Pick<import('../runOptions').RunnerOptions, 'saveRCALocally'>>} param0
+ * @returns {Promise<import('net').AddressInfo>}
+ */
 async function initServer({ agentPort, agentBind, saveRCALocally }) {
     const multer = await lazyRequire('multer');
     saveRCALocally = typeof saveRCALocally === 'string' ? saveRCALocally : DEFUALT_PATH;