@testim/testim-cli 3.254.0 → 3.256.0

package/utils/index.js

@@ -1,18 +1,17 @@
+// @ts-check
+
 'use strict';
 
 const os = require('os');
 const _ = require('lodash');
 const path = require('path');
-const moment = require('moment');
-const pRetry = require('p-retry');
-const Promise = require('bluebird');
-const decompress = require('decompress');
-const fs = Promise.promisifyAll(require('fs'));
+const fsUtils = require('./fsUtils');
+const argsUtils = require('./argsUtils');
+const timeUtils = require('./timeUtils');
 const stringUtils = require('./stringUtils');
 const promiseUtils = require('./promiseUtils');
 const httpRequest = require('../commons/httpRequest');
 const { W3C_ELEMENT_ID } = require('../player/constants');
-const { sessionType, testStatus: testStatusConst } = require('../commons/constants');
 
 const HOMEDIR = os.homedir();
 const TESTIM_BROWSER_DIR = path.join(HOMEDIR, '.testim-browser-profile');
@@ -78,56 +77,10 @@ function getRunConfigByBrowserName(browser, saucelabs, browserstack) {
     return _.merge(selectedBrowser, selectedOS);
 }
 
-function getDuration(ms) {
-    const duration = moment.duration(ms);
-    return `${duration.hours()}:${duration.minutes()}:${duration.seconds()}.${duration.milliseconds()}`;
-}
-
-function getDurationSec(ms) {
-    return moment.duration(ms).asSeconds();
-}
-
-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 fs.readFileAsync(`${__dirname}/../package.json`));
-        return pack.engines.node;
-    } catch (err) {
-        return '';
-    }
-}
-
 function getEnvironmentGitBranch() {
     return process.env.GIT_BRANCH || process.env.CIRCLE_BRANCH || process.env.TRAVIS_BRANCH || process.env.CI_BRANCH;
 }
 
-function getUniqBrowsers(options, testList) {
-    if ((options.testConfigNames.length || options.testConfigIds.length || options.testPlan.length || options.testPlanIds.length) && !options.browser) {
-        return _.uniq(testList.map(t => t.runConfig.browserValue));
-    }
-    return [options.browser.toLowerCase()];
-}
-
 function removePropertyFromObject(obj, propName, cmpFunction) {
     for (const prop in obj) {
         if (obj.hasOwnProperty(prop)) {
@@ -140,79 +93,10 @@ function removePropertyFromObject(obj, propName, cmpFunction) {
     }
 }
 
-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;
-}
-
 function extractElementId(element) {
     return element.ELEMENT || element[W3C_ELEMENT_ID];
 }
 
-const DOWNLOAD_RETRY = 3;
-const download = async (url) => pRetry(() => httpRequest.download(url), { retries: DOWNLOAD_RETRY });
-
-const downloadAndSave = async (url, saveToLocation) => {
-    const res = await download(url);
-    return fs.writeFileAsync(saveToLocation, res.body);
-};
-
-const copy = async (readFile, destFile) => new Promise((resolve, reject) => {
-    try {
-        const file = fs.createWriteStream(destFile);
-        fs.createReadStream(readFile).pipe(file);
-        file.on('finish', () => {
-            file.close(resolve);
-        });
-    } catch (err) {
-        reject(err);
-    }
-});
-function getSourcePath(location, fileName) {
-    if (stringUtils.isURL(location)) {
-        return fileName || path.join(process.cwd(), location.replace(/^.*[\\\/]/, ''));
-    }
-
-    return fileName || path.basename(location);
-}
-
-const getSource = async (location, fileName) => {
-    const destFile = getSourcePath(location, fileName);
-    if (stringUtils.isURL(location)) {
-        return downloadAndSave(location, destFile);
-    }
-
-    return copy(location, destFile);
-};
-
-const getSourceAsBuffer = async (location) => {
-    if (stringUtils.isURL(location)) {
-        return download(location);
-    }
-    return fs.readFileAsync(location);
-};
-
-const unzipFile = async (srcZipFile, destZipPath) => await decompress(srcZipFile, destZipPath);
-
-const getLocalFileSizeInMB = (fileLocation) => {
-    const stats = fs.statSync(fileLocation);
-    const fileSizeInBytes = stats.size;
-    return fileSizeInBytes / 1000000;
-};
-
-function getSessionType(options) {
-    return options.files.length > 0 ? sessionType.CODEFUL : sessionType.CODELESS;
-}
-
 function getPlanType(plan) {
     plan = plan || {};
     const now = Date.now();
@@ -240,17 +124,11 @@ const calcPercentile = (arr, percentile) => {
     return arr[index];
 };
 
-const hasTestPlanFlag = (options) => Boolean(options.testPlan?.length || options.testPlanIds?.length);
-
-const isRemoteRun = (options) => options.resultId && options.source === 'remote-run';
-
-const isQuarantineAndNotRemoteRun = (test, options) => test.testStatus === testStatusConst.QUARANTINE && !isRemoteRun(options) && !options.runQuarantinedTests;
-
 function groupTestsByRetries(testResults = []) { // NOTE: This duplicates a function in services (stream-data/result/resultService.js) since we can't share code between packages.
     return _.chain(testResults)
         .groupBy((tr) => tr.originalTestResultId || tr.resultId)
         .values()
-        .reduce((all, current) => {
+        .reduce((/** @type {any[]} */ all, current) => {
             if (!current) {
                 return all;
             }
@@ -269,7 +147,7 @@ function groupTestsByRetries(testResults = []) { // NOTE: This duplicates a func
             all.push(last);
             return all;
         }, [])
-        .filter(Boolean)
+        .compact()
         .value();
 }
 
@@ -293,49 +171,20 @@ async function getCdpAddressForHost(browserInstanceHost, timeout) {
     }
 }
 
-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],
-    };
-}
-
 
 module.exports = {
     TESTIM_BROWSER_DIR,
     removePropertyFromObject,
-    getDuration,
-    getDurationSec,
-    getRunnerVersion,
-    getEnginesVersion,
-    getEnginesVersionAsync,
     getEnvironmentGitBranch,
-    getUniqBrowsers,
     getRunConfigByBrowserName,
     extractElementId,
-    getCliLocation,
-    download,
-    downloadAndSave,
-    copy,
-    unzipFile,
-    getLocalFileSizeInMB,
-    getSource,
-    getSourceAsBuffer,
-    getSessionType,
-    getSourcePath,
     calcPercentile,
-    hasTestPlanFlag,
-    isRemoteRun,
-    isQuarantineAndNotRemoteRun,
     groupTestsByRetries,
     getPlanType,
     getCdpAddressForHost,
-    getArgsOnRemoteRunFailure,
+    ...fsUtils,
+    ...argsUtils,
+    ...timeUtils,
     ...promiseUtils,
     ...stringUtils,
 };

package/utils/promiseUtils.js

@@ -1,5 +1,7 @@
 // @ts-check
 
+'use strict';
+
 const Bluebird = require('bluebird');
 const { TimeoutError } = require('../errors');
 
@@ -43,13 +45,22 @@ function promiseTimeout(promise, timeout, errMsg = 'Timeout Error') {
     ]);
 }
 
+/** @type {import('p-limit').default} */
+let pLimit;
+
 /**
  * @template T, U
  * @param {ArrayLike<T> | Iterable<T>} arr
  * @param {(item: T, index: number) => PromiseLike<U>} handler
+ * @param {{ concurrency?: number }} options
  */
-function promiseMap(arr, handler) {
-    return Promise.all(Array.from(arr, handler));
+async function promiseMap(arr, handler, { concurrency } = {}) {
+    pLimit = pLimit || (await import('p-limit')).default;
+    if (concurrency) {
+        const limit = pLimit(concurrency);
+        return await Promise.all(Array.from(arr, (item, index) => limit(() => handler(item, index))));
+    }
+    return await Promise.all(Array.from(arr, handler));
 }
 
 /**

package/utils/stringUtils.js

@@ -1,5 +1,7 @@
 // @ts-check
 
+'use strict';
+
 /**
  * @param {number} length
  * @returns {string}
@@ -14,8 +16,8 @@ function randomString(length) {
  * @param {string} editorUrl
  * @param {string} projectId
  * @param {string} testId
- * @param {string | undefined} resultId
- * @param {string} branch
+ * @param {string=} resultId
+ * @param {string=} branch
  */
 function getTestUrl(editorUrl, projectId, testId, resultId, branch) {
     let testUrl = '';

package/utils/stringUtils.test.js

@@ -0,0 +1,22 @@
+const chai = require('chai'); // eslint-disable-line import/no-extraneous-dependencies
+const stringUtils = require('./stringUtils');
+
+const expect = chai.expect;
+
+describe('stringUtils', () => {
+    describe('getTestUrl', () => {
+        it('should create properly escaped test URL', () => {
+            expect(stringUtils.getTestUrl('http://localhost:8080', 'project', 'test')).to.equal('http://localhost:8080/#/project/project/branch/master/test/test');
+            expect(stringUtils.getTestUrl('http://localhost:8080', 'project', 'test', 'result')).to.equal('http://localhost:8080/#/project/project/branch/master/test/test?result-id=result');
+            expect(stringUtils.getTestUrl('http://localhost:8080', 'project', 'test', 'result', null)).to.equal('http://localhost:8080/#/project/project/branch/master/test/test?result-id=result');
+            expect(stringUtils.getTestUrl('http://localhost:8080', 'project', 'test', 'result', 'normal-branch-name'))
+                .to.equal('http://localhost:8080/#/project/project/branch/normal-branch-name/test/test?result-id=result');
+            expect(stringUtils.getTestUrl('http://localhost:8080', 'project', 'test', 'result', 'branch/with/slashes'))
+                .to.equal('http://localhost:8080/#/project/project/branch/branch%2Fwith%2Fslashes/test/test?result-id=result');
+            expect(stringUtils.getTestUrl('http://localhost:8080', 'project', 'test', 'result', 'branch with spaces'))
+                .to.equal('http://localhost:8080/#/project/project/branch/branch%20with%20spaces/test/test?result-id=result');
+            expect(stringUtils.getTestUrl('http://localhost:8080', 'project', 'test', 'result', 'encoded%20branch'))
+                .to.equal('http://localhost:8080/#/project/project/branch/encoded%2520branch/test/test?result-id=result');
+        });
+    });
+});

package/utils/timeUtils.js

@@ -0,0 +1,25 @@
+//@ts-check
+
+'use strict';
+
+const moment = require('moment');
+
+/**
+ * @param {moment.DurationInputArg1} ms
+ */
+function getDuration(ms) {
+    const duration = moment.duration(ms);
+    return `${duration.hours()}:${duration.minutes()}:${duration.seconds()}.${duration.milliseconds()}`;
+}
+
+/**
+ * @param {moment.DurationInputArg1} ms
+ */
+function getDurationSec(ms) {
+    return moment.duration(ms).asSeconds();
+}
+
+module.exports = {
+    getDuration,
+    getDurationSec,
+};

package/utils/utils.test.js

@@ -24,45 +24,4 @@ describe('utils', () => {
             expect(p100).to.eql(10);
         });
     });
-    describe('getTestUrl', () => {
-        it('should create properly escaped test URL', () => {
-            expect(utils.getTestUrl('http://localhost:8080', 'project', 'test')).to.equal('http://localhost:8080/#/project/project/branch/master/test/test');
-            expect(utils.getTestUrl('http://localhost:8080', 'project', 'test', 'result')).to.equal('http://localhost:8080/#/project/project/branch/master/test/test?result-id=result');
-            expect(utils.getTestUrl('http://localhost:8080', 'project', 'test', 'result', null)).to.equal('http://localhost:8080/#/project/project/branch/master/test/test?result-id=result');
-            expect(utils.getTestUrl('http://localhost:8080', 'project', 'test', 'result', 'normal-branch-name'))
-                .to.equal('http://localhost:8080/#/project/project/branch/normal-branch-name/test/test?result-id=result');
-            expect(utils.getTestUrl('http://localhost:8080', 'project', 'test', 'result', 'branch/with/slashes'))
-                .to.equal('http://localhost:8080/#/project/project/branch/branch%2Fwith%2Fslashes/test/test?result-id=result');
-            expect(utils.getTestUrl('http://localhost:8080', 'project', 'test', 'result', 'branch with spaces'))
-                .to.equal('http://localhost:8080/#/project/project/branch/branch%20with%20spaces/test/test?result-id=result');
-            expect(utils.getTestUrl('http://localhost:8080', 'project', 'test', 'result', 'encoded%20branch'))
-                .to.equal('http://localhost:8080/#/project/project/branch/encoded%2520branch/test/test?result-id=result');
-        });
-    });
-
-    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(utils.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(utils.getArgsOnRemoteRunFailure()).to.eql({
-                remoteRunId: 'remote-run-id',
-                projectId: 'project-id',
-                token: 'token',
-            });
-        });
-    });
 });

package/workers/WorkerExtension.js

@@ -10,7 +10,6 @@ const ExtensionTestPlayer = require('../player/extensionTestPlayer');
 const ChromeLauncherTestPlayer = require('../player/chromeLauncherTestPlayer');
 const reporter = require('../reports/reporter');
 
-const TEST_START_TIMEOUT_MS = parseInt(process.env.TESTIM_TEST_START_TIMEOUT, 10) || (2 * 60 * 1000);
 
 class WorkerExtension extends BaseWorker {
     initPlayer() {
@@ -65,7 +64,7 @@ class WorkerExtension extends BaseWorker {
             if (this.options.useChromeLauncher) {
                 const testTimeout = this.options.timeoutWasGiven ?
                     Math.max(10000, this.options.timeout) :
-                    TEST_START_TIMEOUT_MS;
+                    this.options.testStartTimeout;
 
                 reporter.onWaitToTestStart(this.id);
                 reporter.onWaitToTestComplete(this.id, this.isCodeMode);
@@ -82,20 +81,20 @@ class WorkerExtension extends BaseWorker {
                     });
             }
 
-            const startStausDetails = { driverUrlFinished: false, testRunHandlerStartedFinished: false }; //for logging / debugging purposes
+            const startStatusDetails = { driverUrlFinished: false, testRunHandlerOnStartedHadFinished: false }; //for logging / debugging purposes
             return new Promise((resolve, reject) => testRunHandler.getRunTestUrl()
                 .then(url => {
                     reporter.onWaitToTestStart(this.id);
                     return Promise.all([
-                        driver.url(url).tap(() => { startStausDetails.driverUrlFinished = true; }).catch(err => {
+                        driver.url(url).tap(() => { startStatusDetails.driverUrlFinished = true; }).catch(err => {
                             logger.error('error from driver.url', { err, testResultId, executionId, testId, url, urlLength: url.length });
                             throw err;
                         }),
-                        testRunHandler.onStarted(TEST_START_TIMEOUT_MS).tap(() => { startStausDetails.testRunHandlerStartedFinished = true; }),
+                        testRunHandler.onStarted(this.options.testStartTimeout).tap(() => { startStatusDetails.testRunHandlerOnStartedHadFinished = true; }),
                     ])
-                        .timeout(TEST_START_TIMEOUT_MS, timeoutMessages.TEST_START_TIMEOUT_MSG)
+                        .timeout(this.options.testStartTimeout, timeoutMessages.TEST_START_TIMEOUT_MSG)
                         .catch(Promise.TimeoutError, () => {
-                            logger.warn('timeout occurred (see log\'s payload). Running checkViaRestAPIIfTestStarted', { testResultId, executionId, testId, ...startStausDetails });
+                            logger.warn('timeout occurred (see log\'s payload). Running checkViaRestAPIIfTestStarted', { testResultId, executionId, testId, ...startStatusDetails });
                             return testRunHandler.checkViaRestAPIIfTestStarted();
                         });
                 })