@testim/testim-cli 3.254.0 → 3.256.0

package/commons/preloadTests.js

@@ -1,11 +1,14 @@
-const Promise = require('bluebird');
 const _ = require('lodash');
 const localRunnerCache = require('./runnerFileCache');
-const servicesApi = require('./testimServicesApi.js');
+const servicesApi = require('./testimServicesApi');
+const { promiseMap } = require('../utils');
 
 
 const TEN_HOURS = 1000 * 60 * 60 * 10;
 
+/**
+ * @param {import('../runOptions').RunnerOptions} options
+ */
 async function preloadTests(options) {
     if (!Array.isArray(options.testId) || !options.testId.length) {
         return {};
@@ -15,7 +18,7 @@ async function preloadTests(options) {
         projectId: options.project,
     };
     return await localRunnerCache.memoize(async () => {
-        const results = await Promise.map(options.testId, testId => servicesApi.loadTest({ ...opts, testId }), { concurrency: 2 });
+        const results = await promiseMap(options.testId, testId => servicesApi.loadTest({ ...opts, testId }), { concurrency: 2 });
         return _.keyBy(results, 'testData.id');
     }, 'loadTests', TEN_HOURS, [opts, options.testId])();
 }

package/commons/prepareRunner.js

@@ -22,9 +22,10 @@ Promise.resolve().then(() => {
     global.xhr2 = require('./xhr2'); // this is inside a `then` to not block and let network requests start
 });
 
+/** @param {import('../runOptions').RunnerOptions} options */
 async function prepare(options) {
     /**
-     * @type {Promise}
+     * @type {globalThis.Promise<void>}
      */
     let chromedriverPromise = Promise.resolve();
 
@@ -35,7 +36,7 @@ async function prepare(options) {
         chromedriverPromise = prepareRunnerAndTestimStartUtils.prepareChromeDriver(
             { projectId: options.project, userId: options.user },
             { chromeBinaryLocation: options.chromeBinaryLocation },
-            Boolean(options.lightweightMode && options.lightweightMode.general)
+            Boolean(options.lightweightMode?.general)
         );
         options.useLocalChromeDriver = true;
     }
@@ -61,14 +62,15 @@ async function prepare(options) {
 
 async function prepareMockNetwork(location) {
     logger.info('prepare MockNetwork', { location });
-    const rulesJsonBuf = await utils.getSourceAsBuffer(location);
+    const _rulesJson = await utils.getSourceAsBuffer(location);
+    const rulesJsonBuf = Buffer.isBuffer(_rulesJson) ? _rulesJson : _rulesJson.body;
     if (rulesJsonBuf.byteLength > MAX_RULE_FILE_SIZE_IN_MB * 1000000) {
         throw new Error(`${PREPARE_MOCK_NETWORK_ERROR_PREFIX} exceeded ${MAX_RULE_FILE_SIZE_IN_MB}MB`);
     }
 
     let rulesJson;
     try {
-        rulesJson = JSON.parse(rulesJsonBuf);
+        rulesJson = JSON.parse(rulesJsonBuf.toString('utf-8'));
     } catch (error) {
         throw new Error(`${PREPARE_MOCK_NETWORK_ERROR_PREFIX} cannot be parsed.${os.EOL}${error}`);
     }
@@ -76,7 +78,7 @@ async function prepareMockNetwork(location) {
     const ajv = new Ajv();
     const valid = ajv.validate(mockNetworkRuleFileSchema, rulesJson);
     if (!valid) {
-        const errors = ajv.errors.map((e, i) => `${++i}) ${e.dataPath} ${e.message}`).join(os.EOL);
+        const errors = ajv.errors?.map((e, i) => `${++i}) ${e.dataPath} ${e.message}`).join(os.EOL);
         throw new Error(`${PREPARE_MOCK_NETWORK_ERROR_PREFIX} is malformed.${os.EOL}${errors}`);
     }
 

package/commons/prepareRunnerAndTestimStartUtils.js

@@ -1,9 +1,7 @@
 // @ts-check
 
-// @ts-ignore
-const Promise = require('bluebird');
 const path = require('path');
-const fs = Promise.promisifyAll(require('fs'));
+const fs = require('fs');
 const ms = require('ms');
 const { serializeError } = require('serialize-error');
 const { additionalLogDetails } = require('./logUtils');
@@ -11,7 +9,15 @@ const { additionalLogDetails } = require('./logUtils');
 const config = require('./config');
 const { ArgError, NpmPermissionsError } = require('../errors');
 const {
-    getCliLocation, isURL, downloadAndSave, getSource, getLocalFileSizeInMB, download, unzipFile, getSourcePath,
+    getCliLocation,
+    isURL,
+    downloadAndSave,
+    getSource,
+    getLocalFileSizeInMB,
+    download,
+    unzipFile,
+    getSourcePath,
+    promiseMap,
 } = require('../utils');
 const localRunnerCache = require('./runnerFileCache');
 const logger = require('./logger').getLogger('prepare runner and testim start');
@@ -31,63 +37,58 @@ module.exports = {
 /**
  * @param {string} location
  */
-function prepareCustomExtension(location, unlimitedSize = false) {
+async function prepareCustomExtension(location, unlimitedSize = false) {
     if (!location) {
-        return Promise.resolve();
+        return undefined;
     }
 
     if (isURL(location)) {
         const destFile = path.join(process.cwd(), location.replace(/^.*[\\\/]/, ''));
-        return getRemoteFileSizeInMB(location)
-            .then(contentLength => {
-                if (contentLength > MAX_CUSTOM_EXT_SIZE_MB && !unlimitedSize) {
-                    throw new ArgError(MAX_CUSTOM_SIZE_ERROR_MSG);
-                }
-                return downloadAndSave(location, destFile);
-            })
-            .then(() => destFile);
+        const contentLength = await getRemoteFileSizeInMB(location);
+        if (contentLength > MAX_CUSTOM_EXT_SIZE_MB && !unlimitedSize) {
+            throw new ArgError(MAX_CUSTOM_SIZE_ERROR_MSG);
+        }
+        await downloadAndSave(location, destFile);
+        return destFile;
     }
 
     const destFile = path.resolve(location);
     if (!fs.existsSync(destFile)) {
-        return Promise.reject(new ArgError(`Failed to find custom extension in location: ${destFile}`));
+        throw new ArgError(`Failed to find custom extension in location: ${destFile}`);
     }
     const fileSize = getLocalFileSizeInMB(destFile);
     if (fileSize > MAX_CUSTOM_EXT_SIZE_MB && !unlimitedSize) {
-        return Promise.reject(new ArgError(MAX_CUSTOM_SIZE_ERROR_MSG));
+        throw new ArgError(MAX_CUSTOM_SIZE_ERROR_MSG);
     }
-    return Promise.resolve(destFile);
+    return destFile;
 }
 
 
 /**
  * @param {string} url
  */
-function getRemoteFileSizeInMB(url) {
+async function getRemoteFileSizeInMB(url) {
     const httpRequest = require('./httpRequest');
-    return httpRequest.head(url)
-        .then(res => {
-            const contentLengthHeader = res.headers['content-length'];
-            const contentLengthBytes = contentLengthHeader ? parseInt(contentLengthHeader, 10) : 0;
-            return contentLengthBytes / 1000000;
-        })
-        .catch(err => {
-            logger.warn('failed to download custom extension', { err });
-            throw new ArgError(`Failed to download custom extension from location: ${url}`);
-        });
+    try {
+        const res = await httpRequest.head(url);
+        const contentLengthHeader = res.headers['content-length'];
+        const contentLengthBytes = contentLengthHeader ? parseInt(contentLengthHeader, 10) : 0;
+        return contentLengthBytes / 1000000;
+    } catch (err) {
+        logger.warn('failed to download custom extension', { err });
+        throw new ArgError(`Failed to download custom extension from location: ${url}`);
+    }
 }
 
 /**
- *
  * @param {string[]} locations
- *
  */
 function prepareExtension(locations) {
     logger.info('prepare extension', { locations });
 
     const fullLocations = locations.map(location => ({ location, path: getSourcePath(location) }));
     return localRunnerCache.memoize(
-        () => Promise.map(fullLocations, ({ location, path }) => getSource(location, path)),
+        () => promiseMap(fullLocations, ({ location, path }) => getSource(location, path)),
         'prepareExtension',
         MSEC_IN_HALF_DAY,
         fullLocations
@@ -131,25 +132,23 @@ async function prepareChromeDriver(userDetails = {}, driverOptions = {}, skipIsR
     }
 }
 
-function getPlayerVersion() {
+async function getPlayerVersion() {
     const url = `${config.BLOB_URL}/extension/sessionPlayer_LATEST_RELEASE`;
-    return download(url)
-        .then(res => res.body.toString('utf8'));
+    const res = await download(url);
+    return res.body.toString('utf8');
 }
 
 /**
  * @param {string} location
- * @param {string | undefined} canary
- *
- * @returns {Promise<string>}
+ * @param {boolean=} canary
  */
-function getPlayerLocation(location, canary) {
+async function getPlayerLocation(location, canary) {
     if (!isURL(location) || (isURL(location) && canary) || config.IS_ON_PREM) {
-        return Promise.resolve(location);
+        return location;
     }
 
-    return getPlayerVersion()
-        .then(ver => `${location}-${ver}`);
+    const ver = await getPlayerVersion();
+    return `${location}-${ver}`;
 }
 
 function getSessionPlayerFolder() {
@@ -178,13 +177,20 @@ async function downloadAndUnzip(loc, playerFileName, isRetry = false) {
     }
 }
 
-function preparePlayer(location, canary) {
+/**
+ * @param {string} location
+ * @param {boolean=} canary
+ */
+async function preparePlayer(location, canary) {
     logger.info('prepare player', { location, canary });
     const playerFileName = getPlayerDestination();
     return localRunnerCache.memoize(
-        () => getPlayerLocation(location, canary)
-            .then(loc => downloadAndUnzip(loc, playerFileName))
-            .then(() => ({})),
+        async () => {
+            const loc = await getPlayerLocation(location, canary);
+            await downloadAndUnzip(loc, playerFileName);
+            // return a truthy value, so the caching has a value, and doesn't ignore
+            return {};
+        },
         'preparePlayer',
         MSEC_IN_HALF_DAY,
         [location, canary, playerFileName]

package/commons/runnerFileCache.js

@@ -79,7 +79,15 @@ function decrypt(key, buffer) {
     const decrypted = decipher.update(encryptedText);
     return JSON.parse(Buffer.concat([decrypted, decipher.final()]));
 }
-// argument less memoize for functions with a global cache name
+/**
+ * argument-less memoize for functions with a global cache name
+ * @template T
+ * @param {() => PromiseLike<T>} fn
+ * @param {string} fnName
+ * @param {number=} duration
+ * @param {*} parameters
+ * @returns {() => Promise<Awaited<T>>}
+ */
 function memoize(fn, fnName, duration = THREE_HOURS, parameters = undefined) {
     return Promise.method(async () => {
         if (!cacheEnabled) {
@@ -96,7 +104,7 @@ function memoize(fn, fnName, duration = THREE_HOURS, parameters = undefined) {
         }
         logger.debug('cache miss:', { fnName });
         if (!cacheMissAllowed) {
-            throw new Error(`Attemped to rebuild cache for ${originalFnName}. cache miss is not allowed with current run configuration`);
+            throw new Error(`Attempted to rebuild cache for ${originalFnName}. cache miss is not allowed with current run configuration`);
         }
         const value = await fn();
         if (value) {

package/commons/testimServicesApi.js

@@ -192,6 +192,27 @@ async function getTestPlanTestList(projectId, names, planIds, branch, intersecti
     }), { retries: DEFAULT_REQUEST_RETRY });
 }
 
+/**
+ * @param {{
+ *   projectId: string;
+ *   labels: string[];
+ *   testIds: string[];
+ *   testNames: string[];
+ *   testConfigNames?: string[];
+ *   suiteNames: string[];
+ *   suiteIds: string[];
+ *   branch: string;
+ *   rerunFailedByRunId?: string;
+ *   testConfigIds?: string[];
+ *   intersections: import('../runOptions').RunnerOptions['intersections'];
+ * }} param0
+ * @returns {globalThis.Promise<{
+ *   tests: any[][];
+ *   branch?: string;
+ *   runName?: string;
+ *   runExists?: boolean;
+ * }>}
+ */
 function getSuiteTestList({
     projectId, labels, testIds, testNames, testConfigNames, suiteNames, suiteIds, branch, rerunFailedByRunId, testConfigIds, intersections,
 }) {
@@ -263,7 +284,17 @@ function getGridById(companyId, projectId, gridId, browser, executionId) {
     return pRetry(() => getWithAuth(`/grid/${gridId}`, { companyId, projectId, browser, executionId, reqId: utils.guid() }), { retries: DEFAULT_REQUEST_RETRY });
 }
 
-
+/**
+ * @param {{ projectId: string; token: string; branchName: string; lightweightMode?: import('../runOptions').LightweightSettings; localGrid: boolean; }} param0
+ * @returns {globalThis.Promise<{
+ *  authData: { token: string; refreshToken: string; uid: string; ngrokToken?: string; isNgrokWhitelisted?: boolean; };
+ *  editorConfig: { editorUrl: string };
+ *  companyByProjectId: Awaited<ReturnType<import('services/src/company/companyService')['getCompanyByProjectIdUsingCache']>>;
+ *  projectById: NonNullable<Awaited<ReturnType<import('services/src/commons/testimCache')['project']['getById']>>>;
+ *  allGrids: import('services/src/commons/mongo/models/grid').RawGrid[];
+ *  branchName: string | import('services/src/commons/mongo/models/branchesData').RawBranchesData | null;
+ * }>}
+ */
 async function initializeUserWithAuth({ projectId, token, branchName, lightweightMode, localGrid }) {
     try {
         return await pRetry(() => httpRequest.post({
@@ -278,14 +309,14 @@ async function initializeUserWithAuth({ projectId, token, branchName, lightweigh
         }), { retries: DEFAULT_REQUEST_RETRY });
     } catch (e) {
         logger.error('error initializing info from server', e);
-        if (e && e.message && e.message.includes('Bad Request')) {
+        if (e?.message?.includes('Bad Request')) {
             throw new ArgError(
                 'Error trying to retrieve CLI token. ' +
                 'Your CLI token and project might not match. ' +
                 'Please make sure to pass `--project` and `--token` that' +
                 ' match to each other or make sure they match in your ~/.testim file.');
         }
-        if (e && e.code && e.code.includes('ENOTFOUND')) {
+        if (e?.code?.includes('ENOTFOUND')) {
             throw new ArgError('Due to network connectivity issues, Testim CLI has been unable to connect to the Testim backend.');
         }
         throw e;
@@ -415,7 +446,7 @@ const updateTestDataArtifact = _.memoize(async (projectId, testId, testResultId,
     }
     const removeHiddenParamsInTestData = () => {
         const testDataValueClone = _.clone(testData);
-        if (projectDefaults && projectDefaults.hiddenParams) {
+        if (projectDefaults?.hiddenParams) {
             const { hiddenParams } = projectDefaults;
             (hiddenParams || []).forEach((param) => {
                 if (testDataValueClone[param]) {
@@ -521,7 +552,7 @@ module.exports = {
     getLabFeaturesByProjectId,
     uploadRunDataArtifact: Promise.method(uploadRunDataArtifact),
     updateTestDataArtifact: Promise.method(updateTestDataArtifact),
-    initializeUserWithAuth: Promise.method(initializeUserWithAuth),
+    initializeUserWithAuth,
     addTestRetry,
     getHybridGridProvider,
     loadSfdcCredential,

package/commons/testimTunnel.test.js

@@ -66,7 +66,8 @@ describe('testimTunnel', () => {
 
         it('should handle connect errors', async () => {
             ltConnectStub.rejects('error');
-            await expect(testimTunnel.connect({ tunnel: true, gridData: { type: 'testimLambdaTest', tunnel: 'lambdatest' } })).to.be.rejectedWith('Failed to start tunnel. Please contact support@testim.io');
+            const connectPromise = testimTunnel.connect({ tunnel: true, gridData: { type: 'testimLambdaTest', tunnel: 'lambdatest' } });
+            await expect(connectPromise).to.be.rejectedWith('Failed to start tunnel. Please contact support@testim.io');
         });
     });
 

package/coverage/SummaryToObjectReport.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const { ReportBase } = require('istanbul-lib-report');
-const _ = require('lodash');
 
 class SummaryToObjectReport extends ReportBase {
     constructor(opts) {

package/coverage/jsCoverage.js

@@ -1,19 +1,20 @@
 'use strict';
 
-const _ = require('lodash');
-const Bluebird = require('bluebird');
-const servicesApi = require('../commons/testimServicesApi'); const Promise = require('bluebird');
-const fs = Promise.promisifyAll(require('fs'));
+const servicesApi = require('../commons/testimServicesApi');
+const Promise = require('bluebird');
+const fs = require('fs');
+const fsPromises = require('fs/promises');
 const path = require('path');
 const mkdirp = require('mkdirp');
 const lazyRequire = require('../commons/lazyRequire');
 const libReport = require('istanbul-lib-report');
 const reports = require('istanbul-reports');
 const SummaryToObjectReport = require('./SummaryToObjectReport');
-const { ArgError } = require('../errors');
 const ora = require('ora');
 const moment = require('moment');
 const TestExclude = require('test-exclude');
+const { ArgError } = require('../errors');
+const { promiseMap } = require('../utils');
 
 const logger = require('../commons/logger').getLogger('test-run-status');
 
@@ -77,7 +78,7 @@ module.exports.remapCoverage = async (options, storagePath, sourceMaps) => {
             }
             const parsedPath = rewritePath(storagePath, sourcePath);
             await mkdirp(path.parse(parsedPath).dir);
-            await fs.writeFileAsync(parsedPath, sourceMapObject.sourcesContent[index]);
+            await fsPromises.writeFile(parsedPath, sourceMapObject.sourcesContent[index]);
         }));
     }));
 };
@@ -173,11 +174,11 @@ const collectAndMergeJsCoverageData = async (projectId, branch, runId) => {
     const realDataRes = await servicesApi.getRealData(projectId, 'testResult', `runId=${runId}`);
     const testResults = realDataRes.data.docs;
 
-    await Bluebird.map(
-        _.flatten(testResults.map((testResult) => testResult.JSCoverageURLS || [])),
+    await promiseMap(
+        testResults.flatMap((testResult) => testResult.JSCoverageURLS || []),
         async (coverageURL) => {
             const data = await servicesApi.getS3Artifact(coverageURL, 90000);
-            await Bluebird.map(data, async (cov) => {
+            await promiseMap(data, async (cov) => {
                 if (!covUrlMap.has(cov.url)) {
                     let text = cov.text;
                     if (cov.sourceUrl) {
@@ -195,7 +196,8 @@ const collectAndMergeJsCoverageData = async (projectId, branch, runId) => {
                 delete cov.text;
                 mergedCoverages = mergeProcessCovs([mergedCoverages, { result: [cov] }]);
             });
-        }, { concurrency: DOWNLOAD_COVERAGE_DATA_CONCURRENCY }
+        },
+        { concurrency: DOWNLOAD_COVERAGE_DATA_CONCURRENCY }
     );
 
     return { covUrlMap, mergedCoverages };

package/inputFileUtils.js

@@ -1,10 +1,12 @@
 'use strict';
 
 const httpRequest = require('./commons/httpRequest');
-const Promise = require('bluebird');
-const fs = Promise.promisifyAll(require('fs'));
+const fsPromises = require('fs/promises');
 const os = require('os');
-const logger = require('./commons/logger').getLogger('input-file-utils');
+const { promiseMap } = require('./utils');
+const { getLogger } = require('./commons/logger');
+
+const logger = getLogger('input-file-utils');
 
 function getVisibleElementScript(positionAndSize = {
     width: '2px', height: '2px', left: '0px', top: '400px',
@@ -77,22 +79,22 @@ async function downloadFile(fileUrl, fileName) {
     }
 
     const localFileLocation = `${os.tmpdir()}/${fileName}`;
-    await fs.writeFileAsync(localFileLocation, body);
+    await fsPromises.writeFile(localFileLocation, body);
     return localFileLocation;
 }
 
 function downloadFiles(fileUrls) {
-    return Promise.map(fileUrls, file => downloadFile(file.url, file.name));
+    return promiseMap(fileUrls, file => downloadFile(file.url, file.name));
 }
 
 function uploadFileToGrid(localFileLocation, uploadFileFn) {
     return uploadFileFn(localFileLocation);
 }
 
-function downloadFilesAndUploadToGrid(fileUrls, uploadFileFn) {
-    return downloadFiles(fileUrls)
-        .then(filesOnDisk => Promise.map(filesOnDisk, localFileLocation => uploadFileToGrid(localFileLocation, uploadFileFn)))
-        .then(gridLocalFiles => Array.isArray(gridLocalFiles) && gridLocalFiles.map(gridLocalFile => gridLocalFile && gridLocalFile.value));
+async function downloadFilesAndUploadToGrid(fileUrls, uploadFileFn) {
+    const filesOnDisk = await downloadFiles(fileUrls);
+    const gridLocalFiles = await promiseMap(filesOnDisk, localFileLocation => uploadFileToGrid(localFileLocation, uploadFileFn));
+    return Array.isArray(gridLocalFiles) && gridLocalFiles.map(gridLocalFile => gridLocalFile?.value);
 }
 
 module.exports = {