@testim/testim-cli 3.254.0 → 3.255.0

package/runner.js

@@ -180,6 +180,7 @@ function setAuthData(options, authData) {
 function setProject(options, project) {
     const { id, name, type, defaults } = project;
     featureFlags.setProjectId(id);
+    featureFlags.setProjectType(type);
     options.projectData = {
         projectId: id,
         type,
@@ -203,7 +204,7 @@ async function setMockNetworkRules(options) {
 }
 
 /**
- * @param {Awaited<ReturnType<typeof import('./runOptions')['process']>>} options
+ * @param {import('./runOptions').RunnerOptions} options
  * @param {string=} customExtensionLocalLocation
  */
 async function runRunner(options, customExtensionLocalLocation) {

package/runners/ParallelWorkerManager.js

@@ -61,13 +61,13 @@ class ParallelWorkerManager {
             const combinedTestResults = {};
             const testCount = testList.length;
 
-            const companyId = options.company && options.company.companyId;
-            const companyName = options.company && options.company.name;
+            const companyId = options.company?.companyId;
+            const companyName = options.company?.name;
             const source = options.source || 'cli';
             const user = options.user;
-            const companyPlan = options.company && options.company.planType;
-            const isStartUp = options.company && options.company.isStartUp;
-            const projectName = options.projectData && options.projectData.name;
+            const companyPlan = options.company?.planType;
+            const isStartUp = options.company?.isStartUp;
+            const projectName = options.projectData?.name;
             const lightweightMode = options.lightweightMode;
             const sessionType = utils.getSessionType(options);
 
@@ -95,7 +95,7 @@ class ParallelWorkerManager {
             const onTestCompleted = async (wid, testId, testResult, sessionId, isRerun) => {
                 runningTests--;
                 const update = {};
-                if (lightweightMode && lightweightMode.onlyTestIdsNoSuite) {
+                if (lightweightMode?.onlyTestIdsNoSuite) {
                     update.show = true;
                 }
                 if (testResult.seleniumStats) {
@@ -115,9 +115,9 @@ class ParallelWorkerManager {
                     update.gridHost = options.host;
                 }
                 if (options.grid || options.gridId) {
-                    update.gridName = options.grid || (options.gridData && options.gridData.name);
-                    update.gridType = options.gridData && options.gridData.type;
-                    update.gridProvider = options.gridData && options.gridData.provider;
+                    update.gridName = options.grid || options.gridData?.name;
+                    update.gridType = options.gridData?.type;
+                    update.gridProvider = options.gridData?.provider;
                 } else if (options.useLocalChromeDriver) {
                     update.gridName = 'local-chrome-driver-from-options';
                     update.gridType = 'local-chrome';
@@ -214,7 +214,6 @@ class ParallelWorkerManager {
     }
 }
 
-
 function schedule(fn, index) {
     if (index === 0) {
         fn();

package/runners/TestPlanRunner.js

@@ -71,10 +71,6 @@ class TestPlanRunner {
             Object.assign(executionResults, afterTestsResults);
         };
 
-        function catchBeforeTestsFailed() {
-            return testStatus.markAllQueuedTests(executionId, constants.runnerTestStatus.ABORTED, 'aborted', false);
-        }
-
         const sessionType = utils.getSessionType(tpOptions);
         analyticsService.analyticsExecsStart({ authData, executionId, projectId: tpOptions.project, sessionType });
         perf.log('right before runBeforeTests');
@@ -88,7 +84,7 @@ class TestPlanRunner {
         } catch (err) {
             logger.error('error running test plan', { err });
             if (err instanceof StopRunOnError) {
-                return catchBeforeTestsFailed();
+                return testStatus.markAllQueuedTests(executionId, constants.runnerTestStatus.ABORTED, 'aborted', false);
             }
             throw err;
         } finally {
@@ -218,7 +214,7 @@ class TestPlanRunner {
      * @param {any[]} beforeTests
      * @param {any[]} tests
      * @param {any[]} afterTests
-     * @param {Awaited<ReturnType<typeof import('../runOptions')['process']>>} tpOptions
+     * @param {import('../runOptions').RunnerOptions} tpOptions
      * @param {string} testPlanName
      * @param {string | null} testPlanId
      * @param {string} branch
@@ -276,7 +272,7 @@ class TestPlanRunner {
 
     /**
      * @private
-     * @param {Awaited<ReturnType<typeof import('../runOptions')['process']>>} options
+     * @param {import('../runOptions').RunnerOptions} options
      * @param {string} branchToUse
      */
     async runTestPlans(options, branchToUse) {
@@ -347,7 +343,7 @@ class TestPlanRunner {
 
     /**
      * @private
-     * @param {Awaited<ReturnType<typeof import('../runOptions')['process']>>} options
+     * @param {import('../runOptions').RunnerOptions} options
      * @param {string} branchToUse
      */
     async runAnonymousTestPlan(options, branchToUse) {
@@ -400,7 +396,7 @@ class TestPlanRunner {
     }
 
     /**
-     * @param {Awaited<ReturnType<typeof import('../runOptions')['process']>>} options
+     * @param {import('../runOptions').RunnerOptions} options
      */
     async run(options) {
         const branchToUse = branchService.getCurrentBranch();

package/services/gridService.js

@@ -4,7 +4,7 @@ const _ = require('lodash');
 const Promise = require('bluebird');
 
 const { GridError, ArgError } = require('../errors');
-const { hasTestPlanFlag } = require('../utils');
+const { hasTestPlanFlag, promiseMap } = require('../utils');
 const { gridMessages, gridTypes } = require('../commons/constants');
 const logger = require('../commons/logger').getLogger('grid-service');
 const servicesApi = require('../commons/testimServicesApi');
@@ -37,22 +37,22 @@ function extractHost(hostUrl) {
 
 function getSerializableObject(grid) {
     const host = grid && extractHost(grid.host);
-    const port = grid && grid.port;
-    const path = grid && grid.path;
+    const port = grid?.port;
+    const path = grid?.path;
     const protocol = grid && extractProtocol(grid);
-    const accessToken = grid && grid.token;
-    const slotId = grid && grid.slotId;
-    const tunnel = grid && grid.hybrid && grid.hybrid.tunnel;
-    const user = grid && grid.external && grid.external.user;
-    const key = grid && grid.external && grid.external.key;
-    const type = grid && grid.type;
+    const accessToken = grid?.token;
+    const slotId = grid?.slotId;
+    const tunnel = grid?.hybrid?.tunnel;
+    const user = grid?.external?.user;
+    const key = grid?.external?.key;
+    const type = grid?.type;
     const tunnelUser = type === gridTypes.HYBRID ?
         (tunnel && grid.hybrid.external && grid.hybrid.external[grid.hybrid.tunnel] && grid.hybrid.external[grid.hybrid.tunnel].user) : user;
     const tunnelKey = type === gridTypes.HYBRID ?
         (tunnel && grid.hybrid.external && grid.hybrid.external[grid.hybrid.tunnel] && grid.hybrid.external[grid.hybrid.tunnel].key) : key;
-    const name = grid && grid.name;
+    const name = grid?.name;
     const gridId = grid && (grid._id || grid.gridId);
-    const provider = grid && grid.provider;
+    const provider = grid?.provider;
 
     return {
         host, port, path, protocol, accessToken, slotId, gridId, tunnel, user, key, type, name, provider, tunnelUser, tunnelKey,
@@ -97,14 +97,16 @@ function addItemToGridCache(workerId, companyId, gridId, slotId, browser) {
     gridCache[workerId] = { gridId, companyId, slotId, browser };
 }
 
-function getHostAndPortById(workerId, companyId, projectId, gridId, browser, executionId, options) {
-    return handleGetGridResponse(projectId, companyId, workerId, browser, () => servicesApi.getGridById(companyId, projectId, gridId, browser, executionId));
+function getHostAndPortById(workerId, companyId, projectId, gridId, browser, executionId) {
+    return handleGetGridResponse(projectId, companyId, workerId, browser, () =>
+        servicesApi.getGridById(companyId, projectId, gridId, browser, executionId),
+    );
 }
 
 function getHostAndPortByName(workerId, companyId, projectId, gridName, browser, executionId, options) {
     const get = () => {
-        const grid = options.allGrids && options.allGrids.find(grid => (grid.name || '').toLowerCase() === gridName.toLowerCase());
-        if (grid && grid._id) {
+        const grid = options.allGrids?.find(g => (g.name || '').toLowerCase() === gridName.toLowerCase());
+        if (grid?._id) {
             return servicesApi.getGridById(companyId, projectId, grid._id, browser, executionId);
         }
         return servicesApi.getGridByName(companyId, projectId, gridName, browser, executionId);
@@ -116,26 +118,22 @@ function getAllGrids(companyId) {
     return servicesApi.getAllGrids(companyId);
 }
 
-function getGridDataByGridId(companyId, gridId, allGrids) {
-    return Promise.resolve(allGrids || getAllGrids(companyId))
-        .then(grids => {
-            const grid = grids.find(grid => grid._id === gridId);
-            if (!grid) {
-                throw new ArgError(`Failed to find grid id: ${gridId}`);
-            }
-            return getSerializableObject(grid);
-        });
+async function getGridDataByGridId(companyId, gridId, allGrids) {
+    const grids = await Promise.resolve(allGrids || getAllGrids(companyId));
+    const grid = grids.find(g => g._id === gridId);
+    if (!grid) {
+        throw new ArgError(`Failed to find grid id: ${gridId}`);
+    }
+    return getSerializableObject(grid);
 }
 
-function getGridDataByGridName(companyId, gridName, allGrids) {
-    return Promise.resolve(allGrids || getAllGrids(companyId))
-        .then(grids => {
-            const grid = grids.find(grid => (grid.name || '').toLowerCase() === gridName.toLowerCase());
-            if (!grid) {
-                throw new ArgError(`Failed to find grid name: ${gridName}`);
-            }
-            return getSerializableObject(grid);
-        });
+async function getGridDataByGridName(companyId, gridName, allGrids) {
+    const grids = await Promise.resolve(allGrids || getAllGrids(companyId));
+    const grid = grids.find(g => (g.name || '').toLowerCase() === gridName.toLowerCase());
+    if (!grid) {
+        throw new ArgError(`Failed to find grid name: ${gridName}`);
+    }
+    return getSerializableObject(grid);
 }
 
 function releaseGridSlot(workerId, projectId) {
@@ -184,7 +182,7 @@ function releaseAllSlots(projectId) {
     }
 
     logger.warn('not all slots released before end runner flow', { projectId });
-    return Promise.map(workerIds, workerId => releaseGridSlot(workerId, projectId))
+    return promiseMap(workerIds, workerId => releaseGridSlot(workerId, projectId))
         .catch(err => logger.error('failed to release all slots', { err, projectId }));
 }
 
@@ -266,20 +264,18 @@ async function getGridData(options) {
     throw new GridError('Missing host or grid configuration');
 }
 
-const getGridSlot = Promise.method(_getGridSlot);
-
-async function _getGridSlot(browser, executionId, testResultId, onGridSlot, options, workerId) {
-    const getGridDataFromServer = () => {
+async function getGridSlot(browser, executionId, testResultId, onGridSlot, options, workerId) {
+    const getGridDataFromServer = async () => {
         const { host, project, grid, gridId, useLocalChromeDriver, useChromeLauncher, company = {} } = options;
         const companyId = company.companyId;
         if (useLocalChromeDriver || useChromeLauncher) {
             return { mode: 'local' };
         }
         if (host) {
-            return Promise.resolve(getOptionGrid(options));
+            return getOptionGrid(options);
         }
         if (gridId) {
-            return getHostAndPortById(workerId, companyId, project, gridId, browser, executionId, options);
+            return getHostAndPortById(workerId, companyId, project, gridId, browser, executionId);
         }
         if (grid) {
             return getHostAndPortByName(workerId, companyId, project, grid, browser, executionId, options);

package/testRunStatus.js

@@ -17,6 +17,7 @@ const { calculateCoverage } = require('./coverage/jsCoverage');
 const featureAvailabilityService = require('./commons/featureAvailabilityService');
 const featureFlags = require('./commons/featureFlags');
 const { mapFilesToLocalDrive } = require('./services/localRCASaver');
+const { promiseMap } = require('./utils');
 
 const gitBranch = utils.getEnvironmentGitBranch();
 const gitCommit = process.env.GIT_COMMIT || process.env.CIRCLE_SHA1 || process.env.TRAVIS_COMMIT;
@@ -400,7 +401,7 @@ class RunStatus {
 
                 const reportExecutionStarted = () => {
                     const testResults = _.cloneDeep(this.testRunStatus);
-                    return Promise.map(Object.keys(testResults), testResultId => {
+                    return promiseMap(Object.keys(testResults), testResultId => {
                         const test = testResults[testResultId];
                         const testData = test.config?.testData;
                         const testId = test.testId;
@@ -498,10 +499,10 @@ class RunStatus {
             });
     }
 
-    markAllQueuedTests(executionId, status, failureReason, success) {
+    async markAllQueuedTests(executionId, status, failureReason, success) {
         const queuedResultIds = Object.keys(this.testRunStatus).filter(resultId => this.getTestResult(resultId).status === 'QUEUED');
 
-        return servicesApi.updateExecutionTests(
+        await servicesApi.updateExecutionTests(
             executionId,
             ['QUEUED'],
             status,
@@ -510,12 +511,14 @@ class RunStatus {
             this.startTime,
             null,
             this.options.project
-        ).then(() => Promise.each(queuedResultIds, resultId => {
+        );
+        for (const resultId of queuedResultIds) {
             const test = this.getTestResult(resultId);
             test.status = status;
             test.failureReason = failureReason;
             test.success = success;
-        })).then(() => this.testRunStatus);
+        }
+        return this.testRunStatus;
     }
 }
 

package/utils/argsUtils.js

@@ -0,0 +1,86 @@
+// @ts-check
+
+'use strict';
+
+const { sessionType, testStatus: testStatusConst } = require('../commons/constants');
+
+
+/**
+ * @typedef {import('../runOptions').Options} Options
+ * @typedef {import('../runOptions').InitModeOptions} InitModeOptions
+ * @typedef {import('../runOptions').LoginModeOptions} LoginModeOptions
+ * @typedef {import('../runOptions').TunnelOptions} TunnelOptions
+ * @typedef {import('../runOptions').NgrokTunnelOptions} NgrokTunnelOptions
+ * @typedef {import('../runOptions').TunnelDaemonOptions} TunnelDaemonOptions
+ * @typedef {import('../runOptions').RunnerOptions} RunnerOptions
+ */
+
+/** @param {RunnerOptions} options */
+function getSessionType(options) {
+    return options.files.length > 0 ? sessionType.CODEFUL : sessionType.CODELESS;
+}
+
+/**
+ * @param {RunnerOptions} options
+ * @param {{ runConfig: { browserValue: string } }[]} testList
+ */
+function getUniqBrowsers(options, testList) {
+    if ((options.testConfigNames?.length || options.testConfigIds?.length || options.testPlan.length || options.testPlanIds.length) && !options.browser) {
+        return [...new Set(testList.map(t => t.runConfig.browserValue))];
+    }
+    return [options.browser?.toLowerCase()];
+}
+
+/** @param {RunnerOptions} options */
+const hasTestPlanFlag = (options) => Boolean(options.testPlan?.length || options.testPlanIds?.length);
+
+/** @param {RunnerOptions} options */
+const isRemoteRun = (options) => options.resultId && options.source === 'remote-run';
+
+/**
+ * @param {{ testStatus?: string }} test
+ * @param {RunnerOptions} options
+ */
+const isQuarantineAndNotRemoteRun = (test, options) => test.testStatus === testStatusConst.QUARANTINE && !isRemoteRun(options) && !options.runQuarantinedTests;
+
+function getArgsOnRemoteRunFailure() {
+    const { argv: args } = process;
+    if (!args.includes('--remoteRunId')) {
+        return undefined;
+    }
+    return {
+        remoteRunId: args[args.indexOf('--remoteRunId') + 1],
+        projectId: args[args.indexOf('--project') + 1],
+        token: args[args.indexOf('--token') + 1],
+    };
+}
+
+
+/** @type {(options: Options) => options is InitModeOptions} options */
+// @ts-ignore should be `as any` etc
+const isInitCodimMode = (options) => Boolean(options.initCodimMode);
+
+/** @type {(options: Options) => options is LoginModeOptions} options */
+// @ts-ignore should be `as any` etc
+const isLoginMode = (options) => Boolean(options.loginMode);
+
+/** @type {(options: Options) => options is TunnelOptions} options */
+// @ts-ignore should be `as any` etc
+const isTunnelOnlyMode = (options) => Boolean(options.tunnelOnlyMode);
+
+/** @type {(options: Options) => options is RunnerOptions & { createPrefechedData: true; }} options */
+// @ts-ignore should be `as any` etc
+const isCreatePrefetchedDataMode = (options) => Boolean(options.createPrefechedData);
+
+module.exports = {
+    getSessionType,
+    getUniqBrowsers,
+    hasTestPlanFlag,
+    isRemoteRun,
+    isQuarantineAndNotRemoteRun,
+    getArgsOnRemoteRunFailure,
+    isInitCodimMode,
+    isLoginMode,
+    isTunnelOnlyMode,
+    isCreatePrefetchedDataMode,
+};

package/utils/argsUtils.test.js

@@ -0,0 +1,32 @@
+const chai = require('chai'); // eslint-disable-line import/no-extraneous-dependencies
+const argsUtils = require('./argsUtils');
+
+const expect = chai.expect;
+
+describe('argsUtils', () => {
+    describe('getArgsOnRemoteRunFailure', () => {
+        let originalArgv;
+
+        beforeEach(() => {
+            originalArgv = process.argv;
+        });
+
+        afterEach(() => {
+            process.argv = originalArgv;
+        });
+
+        it('should return undefined if no remote run is current', () => {
+            process.argv = ['node', 'file.js', '--token', 'token', '--project', 'project-id'];
+            expect(argsUtils.getArgsOnRemoteRunFailure()).to.be.undefined;
+        });
+
+        it('should return details if remote run is current', () => {
+            process.argv = ['node', 'file.js', '--token', 'token', '--project', 'project-id', '--remoteRunId', 'remote-run-id'];
+            expect(argsUtils.getArgsOnRemoteRunFailure()).to.eql({
+                remoteRunId: 'remote-run-id',
+                projectId: 'project-id',
+                token: 'token',
+            });
+        });
+    });
+});

package/utils/fsUtils.js

@@ -0,0 +1,154 @@
+// @ts-check
+
+'use strict';
+
+const path = require('path');
+const pRetry = require('p-retry');
+const decompress = require('decompress');
+const stringUtils = require('./stringUtils');
+const httpRequest = require('../commons/httpRequest');
+const { promises: fsPromises, createReadStream, createWriteStream, statSync } = require('fs');
+
+const DOWNLOAD_RETRY = 3;
+
+function getCliLocation() {
+    let cliLocation;
+    if (!require.main) { // we're in a REPL
+        return process.cwd(); // fall back on the current working directory
+    }
+    if (require.main.filename.includes('/src') || require.main.filename.includes('\\src') || process.env.IS_UNIT_TEST) {
+        cliLocation = path.resolve(__dirname, '../../');
+    } else {
+        cliLocation = path.resolve(__dirname, '../');
+    }
+
+    return cliLocation;
+}
+
+/**
+ * @param {string} url
+ */
+const download = async (url) => pRetry(() => httpRequest.download(url), { retries: DOWNLOAD_RETRY });
+
+/**
+ * @param {string} url
+ * @param {import('fs').PathLike} saveToLocation
+ */
+const downloadAndSave = async (url, saveToLocation) => {
+    const res = await download(url);
+    return fsPromises.writeFile(saveToLocation, res.body);
+};
+
+/**
+ * @param {import('fs').PathLike} readFile
+ * @param {import('fs').PathLike} destFile
+ * @return {Promise<void>}
+ */
+const copy = async (readFile, destFile) => new Promise((resolve, reject) => {
+    try {
+        // TODO: can this use fsPromises.copyFile?
+        const file = createWriteStream(destFile);
+        createReadStream(readFile).pipe(file);
+        file.on('finish', () => {
+            file.close(() => resolve());
+        });
+    } catch (err) {
+        reject(err);
+    }
+});
+
+/**
+ * @param {string} location
+ * @param {string=} fileName
+ */
+function getSourcePath(location, fileName) {
+    if (stringUtils.isURL(location)) {
+        return fileName || path.join(process.cwd(), location.replace(/^.*[\\\/]/, ''));
+    }
+
+    return fileName || path.basename(location);
+}
+
+/**
+ * @param {string} location
+ * @param {string} fileName
+ */
+const getSource = async (location, fileName) => {
+    const destFile = getSourcePath(location, fileName);
+    if (stringUtils.isURL(location)) {
+        return downloadAndSave(location, destFile);
+    }
+
+    return copy(location, destFile);
+};
+
+/**
+ * @param {string} location
+ */
+const getSourceAsBuffer = async (location) => {
+    if (stringUtils.isURL(location)) {
+        return download(location);
+    }
+    return fsPromises.readFile(location);
+};
+
+/**
+ * @param {string} srcZipFile
+ * @param {string} destZipPath
+ */
+const unzipFile = async (srcZipFile, destZipPath) => await decompress(srcZipFile, destZipPath);
+
+/**
+ * @param {import('fs').PathLike} fileLocation
+ */
+const getLocalFileSizeInMB = (fileLocation) => {
+    const stats = statSync(fileLocation);
+    const fileSizeInBytes = stats.size;
+    return fileSizeInBytes / 1000000;
+};
+
+
+function getRunnerVersion() {
+    try {
+        /** @type {import('../../package.json')} */
+        const pack = require(`${__dirname}/../package.json`); // eslint-disable-line import/no-dynamic-require
+        return pack.version;
+    } catch (err) {
+        return '';
+    }
+}
+
+function getEnginesVersion() {
+    try {
+        /** @type {import('../../package.json')} */
+        const pack = require(`${__dirname}/../package.json`); // eslint-disable-line import/no-dynamic-require
+        return pack.engines.node;
+    } catch (err) {
+        return '';
+    }
+}
+
+async function getEnginesVersionAsync() {
+    try {
+        /** @type {import('../../package.json')} */
+        const pack = JSON.parse(await fsPromises.readFile(`${__dirname}/../package.json`, 'utf8'));
+        return pack.engines.node;
+    } catch (err) {
+        return '';
+    }
+}
+
+module.exports = {
+    getCliLocation,
+    download,
+    downloadAndSave,
+    copy,
+    getSourcePath,
+    getSource,
+    getSourceAsBuffer,
+    unzipFile,
+    getLocalFileSizeInMB,
+    getRunnerVersion,
+    getEnginesVersion,
+    getEnginesVersionAsync,
+};