@testim/testim-cli 3.253.0 → 3.255.0

package/codim/template.js/tests/examples/03-using-hooks.test.js

@@ -7,30 +7,28 @@ const { go, test, describe, before, beforeEach, afterEach, after, text } = requi
 const { expect } = require('chai');
 
 describe('Using hooks', () => {
+    before(() => {
+        // runs before all tests in this block
+    });
 
-	before(function() {
-		// runs before all tests in this block
-  });
+    beforeEach(async () => {
+        // runs before each test in this block
+        await go('http://demo.testim.io');
+    });
 
-	beforeEach(async () => {
-		// runs before each test in this block
-		await go('http://demo.testim.io');
-	});
-
-	afterEach(function() {
+    afterEach(() => {
     // runs after each test in this block
-  });
+    });
 
-  after(function() {
+    after(() => {
     // runs after all tests in this block
-  });
+    });
 
-	test('finds text element', async () => {
+    test('finds text element', async () => {
     // Find an element using a vanilla CSS selector and extract its text
-    const title = await text('.theme__title___35Wsy');
-    
-    // Validate the extracted text
-		expect(title).to.eq('Madan');
-  });
-  
+        const title = await text('.theme__title___35Wsy');
+
+        // Validate the extracted text
+        expect(title).to.eq('Madan');
+    });
 });

package/codim/template.js/tests/examples/04-skip-and-only.test.js

@@ -8,25 +8,24 @@ const { expect } = require('chai');
 
 // Using `.only()`
 describe.only('Test suite', () => {
+    beforeEach(async () => {
+        await go('http://demo.testim.io');
+    });
 
-	beforeEach(async () => {
-		await go('http://demo.testim.io');
-	});
+    test('finds text element', async () => {
+        const title = await text('.theme__title___35Wsy');
+        expect(title).to.eq('Madan');
+    });
 
-	test('finds text element', async () => {
-		const title = await text('.theme__title___35Wsy');
-		expect(title).to.eq('Madan');
-	});
-
-	// Using `skip()`
-	test.skip('skips this test', async () => {
-		// this test will not be run
-		const title = await text('.Gallery__headline-1___2lHj5');
-		expect(title).to.eq('Your next destination');
-	});
+    // Using `skip()`
+    test.skip('skips this test', async () => {
+        // this test will not be run
+        const title = await text('.Gallery__headline-1___2lHj5');
+        expect(title).to.eq('Your next destination');
+    });
 });
 
-describe('Just another test', async() => {
-	// this describe will not be run since the first describe
-	// above is using `.only()`
+describe('Just another test', async () => {
+    // this describe will not be run since the first describe
+    // above is using `.only()`
 });

package/codim/template.js/tests/examples/05-multiple-windows.test.js

@@ -1,4 +1,4 @@
-"use strict";
+'use strict';
 
 // Import Testim Dev Kit methods
 const { go, click, waitForText, withContext, test, l, Locator } = require('testim');
@@ -7,26 +7,25 @@ const { go, click, waitForText, withContext, test, l, Locator } = require('testi
 Locator.set(require('./locators/locators.js'));
 
 test('Working with multiple windows', async () => {
-  await go("https://the-internet.herokuapp.com/");
+    await go('https://the-internet.herokuapp.com/');
 
-  await click(l("Multiple_Windows"));
+    await click(l('Multiple_Windows'));
 
-  // Open a new tab
-  await click(l("Click_Here"));
+    // Open a new tab
+    await click(l('Click_Here'));
 
-  // Run validation on the main tab
-  await waitForText(l("Opening_a_new_window"), 'Opening a new window');
-  
-  // Import a `waitForText` method in the context of the newly opened tab
-  // using the `withContext` method (@see https://help.testim.io/docs/with-context)
-  // Please note we're using an alias since we've already imported `waitForText`
-  // to be used in the context of the main tab.
-  const { waitForText: waitForTextForTab } = withContext({
-    tabUrl: 'https://the-internet.herokuapp.com/windows/new'
-  });
+    // Run validation on the main tab
+    await waitForText(l('Opening_a_new_window'), 'Opening a new window');
 
-  // Run validation on the newly opened tab
-  await waitForTextForTab(l("New_Window"), 'New Window');
+    // Import a `waitForText` method in the context of the newly opened tab
+    // using the `withContext` method (@see https://help.testim.io/docs/with-context)
+    // Please note we're using an alias since we've already imported `waitForText`
+    // to be used in the context of the main tab.
+    const { waitForText: waitForTextForTab } = withContext({
+        tabUrl: 'https://the-internet.herokuapp.com/windows/new',
+    });
 
+    // Run validation on the newly opened tab
+    await waitForTextForTab(l('New_Window'), 'New Window');
 }); // end of test
 

package/codim/template.js/webpack.config.js

@@ -1,4 +1,4 @@
 module.exports = {
     mode: 'development', // always run with development and source maps
     devtool: 'inline-source-map', // always debuggable
-};
+};

package/codim/template.ts/webpack.config.js

@@ -8,9 +8,9 @@ module.exports = {
                 loader: 'ts-loader',
                 exclude: /node_modules/,
             },
-        ]
+        ],
     },
     resolve: {
-        extensions: [".tsx", ".ts", ".js"]
+        extensions: ['.tsx', '.ts', '.js'],
     },
-};
+};

package/commons/AbortError.js

@@ -1,12 +1,12 @@
 'use strict';
 
 class AbortError extends Error {
-    constructor(message = "aborted") {
+    constructor(message = 'aborted') {
         super(message);
-        this.name = "AbortError";
+        this.name = 'AbortError';
     }
 }
 
 module.exports = {
-    AbortError
-}
+    AbortError,
+};

package/commons/detectDebugger.js

@@ -1,4 +1,5 @@
-"use strict";
+'use strict';
+
 const { DISABLE_DEBUGGER_INFINITE_TIMEOUT } = require('./config');
 
 module.exports.isDebuggerConnected = () => {
@@ -12,6 +13,7 @@ module.exports.isDebuggerConnected = () => {
             return true;
         }
     } catch (e) {
-        return false;
+        /* empty */
     }
+    return false;
 };

package/commons/featureFlags.js

@@ -67,6 +67,14 @@ class FeatureFlagsService {
         Rox.setCustomStringProperty('projectId', projectId);
     }
 
+    setProjectType(projectType) {
+        Rox.setCustomStringProperty('projectType', projectType);
+    }
+
+    setCompanyProductType(productType) {
+        Rox.setCustomStringProperty('productType', productType);
+    }
+
     setCompanyId(companyId) {
         Rox.setCustomStringProperty('companyId', companyId);
     }

package/commons/httpRequest.js

@@ -79,7 +79,7 @@ function post({
         .catch(logErrorAndRethrow('failed to post request', { url }));
 }
 
-function postFullRes(url, body, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT, retry) {
+function postFullRes(url, body, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT, retry = 0) {
     const request = superagent
         .post(url)
         .send(body)
@@ -215,6 +215,10 @@ function put(url, body, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT) {
         .catch(logErrorAndRethrow('failed to put request', { url }));
 }
 
+/**
+ * @param {string} url
+ * @returns {Promise<superagent.Response>}
+ */
 function download(url) {
     logger.info('start to download', { url });
 

package/commons/httpRequestCounters.js

@@ -1,10 +1,11 @@
-'use strit';
+'use strict';
 
-const { sum } = require('lodash');
-const Bluebird = require('bluebird');
-const dns = require('dns');
 const _ = require('lodash');
 const config = require('./config');
+const dns = require('dns').promises;
+const Bluebird = require('bluebird');
+const { sum } = require('lodash');
+const { promiseMap } = require('../utils/promiseUtils');
 
 const logger = require('./logger').getLogger('http-request-counters');
 
@@ -18,7 +19,7 @@ const testNetworkConnectivity = async () => {
     const hostnames = ['www.google.com', 'www.facebook.com', 'www.microsoft.com', 'testim.io'];
     try {
         // If any of these domains resolve we consider the connectivity to be ok
-        const result = Boolean(await Bluebird.any(hostnames.map(host => dns.promises.lookup(host))));
+        const result = Boolean(await promiseMap(hostnames, host => dns.lookup(host)));
         if (!result) {
             networkConnectivityTestFailed = true;
         }
@@ -40,18 +41,28 @@ const ttl = 60 * 1000 * 15;
 
 module.exports.makeCounters = () => {
     const counters = {
-        call: new Map(),
-        success: new Map(),
-        fail: new Map(),
+        /** @type {Map<string, number>} */ call: new Map(),
+        /** @type {Map<string, number>} */ success: new Map(),
+        /** @type {Map<string, number>} */ fail: new Map(),
     };
+    /**
+     * @param {counters[keyof counters]} counter
+     * @param {string} key
+     */
     function update(counter, key) {
         const result = counter.get(key) || 0;
         counter.set(key, result + 1);
         setTimeout(() => {
-            const result = counter.get(key) || 1;
-            counter.set(key, result - 1);
+            const _result = counter.get(key) || 1;
+            counter.set(key, _result - 1);
         }, ttl);
     }
+    /**
+     * @template T, TArgs
+     * @param {(...args: TArgs) => T} fn
+     * @param {string=} name
+     * @return {(...args: TArgs) => Bluebird<Awaited<T>>}
+     */
     function wrapWithMonitoring(fn, name = fn.name) {
         return Bluebird.method(async function (...args) {
             update(counters.call, name);

package/commons/lazyRequire.js

@@ -1,13 +1,13 @@
-"use strict";
+'use strict';
 
-const Bluebird = require('bluebird');
 const npmWrapper = require('./npmWrapper');
 const ora = require('ora');
 const path = require('path');
-const logger = require('./logger').getLogger("lazy-require");
+const logger = require('./logger').getLogger('lazy-require');
 const { getCliLocation } = require('../utils');
-const { requireWithFallback } = require("./requireWithFallback")
+const { requireWithFallback } = require('./requireWithFallback');
 
+// eslint-disable-next-line import/no-dynamic-require
 const packageJson = require(path.resolve(getCliLocation(), 'package.json'));
 const ongoingCalls = new Map();
 
@@ -29,14 +29,14 @@ module.exports = async function memoizedLazyRequireApi(dependency, options = {})
         }
         return requiredModule;
     } catch (error) {
-        logger.warn("failed to install dependency lazily", {dependency, err: error});
+        logger.warn('failed to install dependency lazily', { dependency, err: error });
         const depVersionToInstall = getVersionOfLazyDep(dependency);
         const depWithVersions = `${dependency}@${depVersionToInstall}`;
 
         const removeGlobal = process.argv.includes('npx');
-        const globalFlag = removeGlobal ? '' : '-g '
+        const globalFlag = removeGlobal ? '' : '-g ';
         const errorMessage = `Installation of ${dependency} failed. This typically means you are running an out-of-date version of Node.js or NPM.` +
-        `Please manually install by running the following command: npm install ${globalFlag}${depWithVersions}`
+        `Please manually install by running the following command: npm install ${globalFlag}${depWithVersions}`;
 
         if (spinner) {
             spinner.fail(errorMessage);
@@ -52,12 +52,12 @@ async function memoizedLazyRequire(identifier, options = {}) {
     }
 
     ongoingCalls.set(identifier, lazyRequireImpl(identifier, options));
-    ongoingCalls.get(identifier).catch(err => {
+    ongoingCalls.get(identifier).catch(() => {
         ongoingCalls.delete(identifier);
     });
 
     return ongoingCalls.get(identifier);
-};
+}
 
 async function lazyRequireImpl(dependency) {
     const packageLocally = npmWrapper.getPackageIfInstalledLocally(dependency);
@@ -75,10 +75,12 @@ async function lazyRequireImpl(dependency) {
     return requireWithFallback(dependency);
 }
 
-function installAllLazyDependencies() {
+async function installAllLazyDependencies() {
     const allLazyDependencies = Object.keys(packageJson.lazyDependencies);
 
-    return Bluebird.each(allLazyDependencies, dep => lazyRequireImpl(dep));
+    for (const dep of allLazyDependencies) {
+        await lazyRequireImpl(dep);
+    }
 }
 
 if (require.main === module) {
@@ -94,7 +96,7 @@ function getVersionOfLazyDep(dependencyToFind) {
         .find(([dep]) => dep === dependencyToFind);
 
     if (!depEntry) {
-        throw new Error("The given package name is not lazyDependencies");
+        throw new Error('The given package name is not lazyDependencies');
     }
 
     return depEntry[1];

package/commons/logger.js

@@ -53,7 +53,7 @@ function getStreamsAndWaitForFlushPromise() {
 const [transports, waitForFlush] = getStreamsAndWaitForFlushPromise();
 const level = config.LOGGER_DEBUG ? 'debug' : 'info';
 const defaultMeta = {};
-if (isLocal.indexOf('@echo') === -1) {
+if (!isLocal.includes('@echo')) {
     Object.assign(defaultMeta, devFlags());
 
 } else {
@@ -149,13 +149,13 @@ class Logger {
         this.innerLog('crit', msg, data);
     }
 
-    innerLog(level, msg, data = {}) {
+    innerLog(logLevel, msg, data = {}) {
         try {
-            this._logger.log(level, Object.assign({ meta: data }, { message: msg }, addExecutionMetadata(data.executionId)));
+            this._logger.log(logLevel, Object.assign({ meta: data }, { message: msg }, addExecutionMetadata(data.executionId)));
         } catch (err) {
             try {
                 this._logger.log('crit', Object.assign({ message: `failed to log message ${err.message}, ${err.stack}` }, addExecutionMetadata(data.executionId)));
-            } catch (err) {
+            } catch (_err) {
                 // well what can we do
             }
         }

package/commons/performance-logger.js

@@ -1,7 +1,9 @@
-"use strict";
+/* eslint-disable no-console */
+
+'use strict';
 
 const MEASURE_TESTIM_CLI_PERFORMANCE = process.env.MEASURE_TESTIM_CLI_PERFORMANCE;
-let epoch = Date.now();
+const epoch = Date.now();
 let last = Date.now();
 
 module.exports = {
@@ -9,7 +11,7 @@ module.exports = {
         if (!MEASURE_TESTIM_CLI_PERFORMANCE) {
             return;
         }
-        let time = Date.now();
+        const time = Date.now();
         console.log(`${time - epoch}\t\t\t${time - last}\t\t\t`, ...args);
         last = time;
     },
@@ -25,7 +27,9 @@ module.exports = {
         }
     },
     patchPromisePrototype() {
-        Promise.prototype.log = function log (message) {
+        // TODO: Stop monkey patching shit
+        // eslint-disable-next-line no-extend-native
+        Promise.prototype.log = function log(message) {
             if (!MEASURE_TESTIM_CLI_PERFORMANCE) {
                 return this;
             }
@@ -40,7 +44,7 @@ module.exports = {
                 return this;
             }
             return this.tap(() => module.exports.log(message));
-        }
+        };
     },
     measureRequireTimes() {
         if (!MEASURE_TESTIM_CLI_PERFORMANCE) {
@@ -48,12 +52,14 @@ module.exports = {
         }
         const {
             performance,
-            PerformanceObserver
+            PerformanceObserver,
         } = require('perf_hooks');
         const mod = require('module');
 
         // Monkey patch the require function
         mod.Module.prototype.require = performance.timerify(mod.Module.prototype.require);
+        // TODO: Stop monkey patching shit
+        // eslint-disable-next-line no-global-assign
         require = performance.timerify(require);
 
         // Activate the observer
@@ -65,8 +71,8 @@ module.exports = {
             obs.disconnect();
         });
         obs.observe({ entryTypes: ['function'], buffered: true });
-    }
-}
+    },
+};
 
 // ew ~ Benji
 module.exports.patchPromisePrototype();

package/commons/preloadTests.js

@@ -1,5 +1,5 @@
-const Promise = require('bluebird');
 const _ = require('lodash');
+const { promiseMap } = require('../utils');
 const localRunnerCache = require('./runnerFileCache');
 const servicesApi = require('./testimServicesApi.js');
 
@@ -15,7 +15,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

@@ -24,7 +24,7 @@ Promise.resolve().then(() => {
 
 async function prepare(options) {
     /**
-     * @type {Promise}
+     * @type {globalThis.Promise<void>}
      */
     let chromedriverPromise = Promise.resolve();
 
@@ -35,7 +35,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,6 +61,8 @@ async function prepare(options) {
 
 async function prepareMockNetwork(location) {
     logger.info('prepare MockNetwork', { location });
+    /** @type {Buffer} */
+    // @ts-expect-error There seems to be an actual bug in case the location is a URL.
     const rulesJsonBuf = await utils.getSourceAsBuffer(location);
     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`);

package/commons/prepareRunnerAndTestimStartUtils.js

@@ -1,10 +1,7 @@
 // @ts-check
 
-// @ts-ignore
-const Promise = require('bluebird');
 const path = require('path');
-const os = require('os');
-const fs = Promise.promisifyAll(require('fs'));
+const fs = require('fs');
 const ms = require('ms');
 const { serializeError } = require('serialize-error');
 const { additionalLogDetails } = require('./logUtils');
@@ -12,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');
@@ -32,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) {
-                    return Promise.reject(new ArgError(MAX_CUSTOM_SIZE_ERROR_MSG));
-                }
-                return downloadAndSave(location, destFile);
-            })
-            .then(() => Promise.resolve(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 Promise.resolve(contentLengthBytes / 1000000);
-        })
-        .catch(err => {
-            logger.warn('failed to download custom extension', { err });
-            return Promise.reject(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
@@ -132,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 => Promise.resolve(res.body.toString('utf8')));
+    const res = await download(url);
+    return res.body.toString('utf8');
 }
 
 /**
  * @param {string} location
  * @param {string | undefined} canary
- *
- * @returns {Promise<string>}
  */
-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 => Promise.resolve(`${location}-${ver}`));
+    const ver = await getPlayerVersion();
+    return `${location}-${ver}`;
 }
 
 function getSessionPlayerFolder() {
@@ -179,7 +177,7 @@ async function downloadAndUnzip(loc, playerFileName, isRetry = false) {
     }
 }
 
-function preparePlayer(location, canary) {
+async function preparePlayer(location, canary) {
     logger.info('prepare player', { location, canary });
     const playerFileName = getPlayerDestination();
     return localRunnerCache.memoize(