@testim/testim-cli 3.253.0 → 3.255.0

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/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;
+    }
 };

package/testRunHandler.js

@@ -111,6 +111,10 @@ class TestRun {
         return this._branch;
     }
 
+    getSfdcCredential() {
+        return this._options.sfdcCredential;
+    }
+
     getRemoteRunId() {
         return this._remoteRunId;
     }
@@ -203,6 +207,10 @@ class TestRun {
             runRequestParams.localRCASaver = this._options.localRCASaver;
         }
 
+        if (this.getSfdcCredential()) {
+            runRequestParams.sfdcCredential = this.getSfdcCredential();
+        }
+
         return runRequestParams;
     }
 

package/testRunStatus.js

@@ -2,7 +2,7 @@
 
 const constants = require('./commons/constants');
 const { TESTIM_CONCURRENT_WORKER_COUNT } = require('./commons/config');
-const utils = require('./utils.js');
+const utils = require('./utils');
 const reporter = require('./reports/reporter.js');
 const servicesApi = require('./commons/testimServicesApi.js');
 const gridService = require('./services/gridService');
@@ -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,
+};