@testim/testim-cli 3.289.0 → 3.290.0

package/commons/httpRequest.js

@@ -1,261 +0,0 @@
-'use strict';
-
-const logger = require('./logger').getLogger('http-request');
-const superagent = require('superagent');
-const { makeCounters } = require('./httpRequestCounters');
-const { promiseFromCallback } = require('../utils/promiseUtils');
-
-const wrapWithMonitoring = makeCounters();
-
-const DEFAULT_REQUEST_TIMEOUT = process.env.DEFAULT_REQUEST_TIMEOUT || 30000; //30sec timeout
-const DOWNLOAD_REQUEST_TIMEOUT = 60000; //1min timeout
-
-function getCaFile() {
-    return global.caFileContent;
-}
-
-function binaryParser(res, fn) {
-    const data = [];
-
-    res.on('data', (chunk) => {
-        data.push(chunk); // Append Buffer object
-    });
-    res.on('end', () => {
-        fn(null, Buffer.concat(data)); // Merge the chunks and return
-    });
-}
-
-function getProxy() {
-    if (!superagent.Request.prototype.proxy && global.SuperagentProxy) {
-        global.SuperagentProxy(superagent);
-    }
-    return global.proxyUri;
-}
-
-const logErrorAndRethrow = (logMsg, data) => err => {
-    logger.error(logMsg, { ...data, error: err });
-    throw err;
-};
-
-function deleteMethod(url, body, headers, timeout) {
-    return deleteFullRes(url, body, headers, timeout)
-        .then(res => {
-            if (res.type === 'text/plain') {
-                return res.text;
-            }
-            return res.body;
-        })
-        .catch(logErrorAndRethrow('failed to delete request', { url }));
-}
-
-function deleteFullRes(url, body = {}, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT) {
-    const request = superagent
-        .delete(url)
-        .send(body)
-        .timeout(timeout)
-        .set(headers);
-
-    if (getCaFile()) {
-        request.ca(getCaFile());
-    }
-
-    if (getProxy()) {
-        request.proxy(getProxy());
-    }
-
-    return promiseFromCallback((callback) => request.end(callback));
-}
-
-function post({
-    url, body, headers, timeout, retry,
-}) {
-    return postFullRes(url, body, headers, timeout, retry)
-        .then(res => {
-            if (res.type === 'text/plain') {
-                return res.text;
-            }
-            return res.body;
-        })
-        .catch(logErrorAndRethrow('failed to post request', { url }));
-}
-
-function postFullRes(url, body, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT, retry = 0) {
-    const request = superagent
-        .post(url)
-        .send(body)
-        .timeout(timeout)
-        .set(headers);
-
-    if (getCaFile()) {
-        request.ca(getCaFile());
-    }
-
-    if (getProxy()) {
-        request.proxy(getProxy());
-    }
-
-    if (retry) {
-        request.retry(retry);
-    }
-
-    return promiseFromCallback((callback) => request.end(callback)).catch(e => {
-        e.url = url;
-        e.originalRequestTimeout = timeout;
-        e.additionalSetHeaders = headers;
-        throw e;
-    });
-}
-
-function postForm(url, fields, files, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT) {
-    const request = superagent
-        .post(url)
-        .type('form')
-        .timeout(timeout)
-        .set(headers);
-
-    request.field(fields);
-
-    Object.keys(files).forEach(file => {
-        request.attach(file, files[file].buffer, files[file].fileName);
-    });
-
-    if (getCaFile()) {
-        request.ca(getCaFile());
-    }
-
-    if (getProxy()) {
-        request.proxy(getProxy());
-    }
-
-    return promiseFromCallback((callback) => request.end(callback))
-        .then((res) => {
-            if (res.type === 'text/plain') {
-                return res.text;
-            }
-            return res.body;
-        })
-        .catch(logErrorAndRethrow('failed to post request', { url }));
-}
-
-function _get(url, query, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT, { isBinary = false, skipProxy = false } = {}) {
-    const request = superagent
-        .get(url)
-        .query(query)
-        .timeout(timeout)
-        .set(headers);
-
-    if (isBinary) {
-        request.buffer(true);
-    }
-
-    if (getCaFile()) {
-        request.ca(getCaFile());
-    }
-
-    if (!skipProxy && getProxy()) {
-        request.proxy(getProxy());
-    }
-
-    return promiseFromCallback((callback) => request.end(callback));
-}
-
-function getText(url, query, headers) {
-    return _get(url, query, headers)
-        .then((res) => res.text)
-        .catch(logErrorAndRethrow('failed to getText request', { url, query }));
-}
-
-function get(url, query, headers, timeout, options) {
-    return _get(url, query, headers, timeout, options)
-        .then((res) => res.body)
-        .catch(err => {
-            logger.warn('failed to get request', { url, query, error: err });
-            throw err;
-        });
-}
-
-function getFullRes(url, query, headers, timeout) {
-    return _get(url, query, headers, timeout);
-}
-
-function head(url) {
-    const request = superagent
-        .head(url)
-        .timeout(DEFAULT_REQUEST_TIMEOUT);
-
-    if (getCaFile()) {
-        request.ca(getCaFile());
-    }
-
-    if (getProxy()) {
-        request.proxy(getProxy());
-    }
-
-    return promiseFromCallback((callback) => request.end(callback))
-        .catch(logErrorAndRethrow('failed to head request', { url }));
-}
-
-function put(url, body, headers = {}, timeout = DEFAULT_REQUEST_TIMEOUT) {
-    const request = superagent
-        .put(url)
-        .send(body)
-        .timeout(timeout)
-        .set(headers);
-
-    if (getCaFile()) {
-        request.ca(getCaFile());
-    }
-
-    if (getProxy()) {
-        request.proxy(getProxy());
-    }
-
-    return promiseFromCallback((callback) => request.end(callback))
-        .then((res) => res.body)
-        .catch(logErrorAndRethrow('failed to put request', { url }));
-}
-
-/**
- * @param {string} url
- * @returns {Promise<Omit<superagent.Response, 'body'> & { body: Buffer }>}
- */
-function download(url) {
-    logger.info('start to download', { url });
-
-    const request = superagent
-        .get(url)
-        .timeout(DOWNLOAD_REQUEST_TIMEOUT)
-        .buffer(true)
-        .parse(binaryParser);
-
-    if (getCaFile()) {
-        request.ca(getCaFile());
-    }
-
-    if (getProxy()) {
-        request.proxy(getProxy());
-    }
-
-    return promiseFromCallback((callback) => request.end(callback))
-        .then(response => {
-            logger.info('finished to download', { url });
-            return response;
-        })
-        .catch(logErrorAndRethrow('failed to download', { url }));
-}
-
-module.exports = {
-    delete: wrapWithMonitoring(deleteMethod),
-    deleteFullRes: wrapWithMonitoring(deleteFullRes),
-    put: wrapWithMonitoring(put),
-    get: wrapWithMonitoring(get),
-    getText: wrapWithMonitoring(getText),
-    post: wrapWithMonitoring(post),
-    postFullRes: wrapWithMonitoring(postFullRes),
-    getFullRes: wrapWithMonitoring(getFullRes),
-    postForm: wrapWithMonitoring(postForm),
-    head: wrapWithMonitoring(head),
-    download: wrapWithMonitoring(download),
-    isNetworkHealthy: wrapWithMonitoring.isNetworkHealthy,
-    didNetworkConnectivityTestFail: wrapWithMonitoring.didNetworkConnectivityTestFail,
-};

package/commons/httpRequestCounters.js

@@ -1,98 +0,0 @@
-// @ts-check
-
-'use strict';
-
-const _ = require('lodash');
-const config = require('./config');
-const dns = require('dns').promises;
-const { sum } = require('lodash');
-const { promiseMap } = require('../utils/promiseUtils');
-
-const logger = require('./logger').getLogger('http-request-counters');
-
-let networkConnectivityTestFailed = false;
-
-/** Tests network connectivity with DNS resolution (a basic test for a 7 later stack parallel but essential to most HTTP requests) */
-const testNetworkConnectivity = async () => {
-    if (config.IS_ON_PREM) {
-        return true;
-    }
-    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 promiseMap(hostnames, host => dns.lookup(host)));
-        if (!result) {
-            networkConnectivityTestFailed = true;
-        }
-        return result;
-    } catch (e) {
-        logger.error('network connectivity test failed');
-        networkConnectivityTestFailed = true;
-        return false;
-    }
-};
-const throttledTestNetworkConnectivity = _.throttle(testNetworkConnectivity, 10 * 1000);
-
-// we remove entries after 15 minutes, note that this isn't accurate because
-// we remove the "fail"/"success" 10 minutes after we add them (and not the "call")
-// this is fine since these values are an estimation and not an accurate representation
-// we poll them when a test fails - so values older than 15 minutes (10 minutes is
-// the default timeout) are hardly relevant.
-const ttl = 60 * 1000 * 15;
-
-module.exports.makeCounters = () => {
-    const counters = {
-        /** @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);
-        }, ttl);
-    }
-    /**
-     * @template T, TArgs
-     * @param {(...args: TArgs[]) => T} fn
-     * @param {string=} name
-     * @return {(...args: TArgs[]) => Promise<T>}
-     */
-    function wrapWithMonitoring(fn, name = fn.name) {
-        return async function (...args) {
-            update(counters.call, name);
-            try {
-                const result = await fn.call(null, ...args);
-                update(counters.success, name);
-                return result;
-            } catch (e) {
-                update(counters.fail, name);
-                if (!networkConnectivityTestFailed) {
-                    throttledTestNetworkConnectivity();
-                }
-                throw e;
-            }
-        };
-    }
-    wrapWithMonitoring.isNetworkHealthy = async function isNetworkHealthy() {
-        if (networkConnectivityTestFailed || !(await testNetworkConnectivity())) {
-            return false;
-        }
-        const allFailed = sum([...counters.fail.values()]);
-        const allCalls = sum([...counters.call.values()]);
-        // we declare a test unhealthy network wise if
-        // 10% or more of requests (out of finished requests) failed
-        // note that the network can be unhealthy but the test would still pass
-        return allFailed < allCalls * 0.1;
-    };
-    wrapWithMonitoring.counters = counters; // expose the counters used to the outside
-    wrapWithMonitoring.isNetworkHealthy.counters = wrapWithMonitoring.counters;
-    wrapWithMonitoring.didNetworkConnectivityTestFail = () => networkConnectivityTestFailed;
-    return wrapWithMonitoring;
-};

package/commons/httpRequestCounters.test.js

@@ -1,38 +0,0 @@
-const pRetry = require('p-retry');
-const { makeCounters } = require('./httpRequestCounters');
-const { rejects, doesNotReject, strictEqual } = require('assert');
-
-describe('the http request counters', () => {
-    let wrapWithMonitoring;
-    beforeEach(() => {
-        wrapWithMonitoring = makeCounters();
-    });
-
-    it('marks an always failing network as unhealthy', async () => {
-        const fn = pRetry(wrapWithMonitoring(() => { throw new Error('bad network'); }), { retries: 30, minTimeout: 0, maxTimeout: 0 });
-        await rejects(fn);
-        strictEqual(await wrapWithMonitoring.isNetworkHealthy(), false);
-    });
-
-    it('marks an unstable network as unhealthy', async () => {
-        const fn = pRetry(wrapWithMonitoring(() => { throw new Error('bad network'); }), { retries: 30, minTimeout: 0, maxTimeout: 0 });
-        const fn2 = pRetry(wrapWithMonitoring(() => 'hello'), { retries: 20, minTimeout: 0, maxTimeout: 0 });
-        await rejects(fn);
-        await doesNotReject(fn2);
-        strictEqual(await wrapWithMonitoring.isNetworkHealthy(), false);
-    });
-
-    it('marks a trivial amount of failed requests as healthy', async () => {
-        const fn = pRetry(wrapWithMonitoring(() => { throw new Error('bad network'); }), { retries: 30, minTimeout: 0, maxTimeout: 0 });
-        await rejects(fn);
-        const fn2 = wrapWithMonitoring(() => 'hello');
-        await Promise.all(Array(290).fill().map(fn2));
-        strictEqual(await wrapWithMonitoring.isNetworkHealthy(), true);
-    });
-
-    it('marks a healthy network as healthy', async () => {
-        const fn2 = wrapWithMonitoring(() => 'hello');
-        await Promise.all(Array(200).fill().map(fn2));
-        strictEqual(await wrapWithMonitoring.isNetworkHealthy(), true);
-    });
-});

package/commons/initializeUserWithAuth.js

@@ -1,55 +0,0 @@
-const perf = require('./performance-logger');
-const servicesApi = require('./testimServicesApi');
-const localRunnerCache = require('./runnerFileCache');
-const testimCustomToken = require('./testimCustomToken');
-const { CLI_MODE } = require('./constants');
-
-const FIVE_MINUTES_MS = 1000 * 60 * 5;
-const TEN_HOURS_MS = 1000 * 60 * 60 * 10;
-
-/** @param {import('../runOptions').RunnerOptions['mode']} mode */
-function preloadSlowRequires(mode) {
-    process.nextTick(() => {
-        if (![CLI_MODE.SELENIUM, CLI_MODE.APPIUM].includes(mode)) {
-            return;
-        }
-        // heuristic to pay the cost of loading the sessionPlayer here while we are waiting for the backend
-        try {
-            require('./getSessionPlayerRequire').getSessionPlayer();
-            // jsdom for the same reason, we don't require workerSelenium here since it actually takes longer to load
-            // then it takes for the backend to return 🤯
-            require('jsdom');
-        } catch (e) {
-            //silent catch
-        }
-    });
-}
-
-/** @param {import('../runOptions').RunnerOptions} options */
-async function initializeUserWithAuth(options) {
-    const { project, token, lightweightMode, useLocalChromeDriver, useChromeLauncher, mode } = options;
-
-    const lightweightModeGeneral = Boolean(lightweightMode?.general);
-    const localGrid = Boolean(useLocalChromeDriver || useChromeLauncher);
-    const memoizationTTL = lightweightModeGeneral ? TEN_HOURS_MS : FIVE_MINUTES_MS;
-
-    perf.log('before initializeUserWithAuth');
-    const result = await localRunnerCache.memoize(async () => {
-        preloadSlowRequires(mode);
-        return await servicesApi.initializeUserWithAuth({
-            projectId: project,
-            token,
-            branchName: options.branch,
-            lightweightMode,
-            localGrid,
-        });
-    }, 'initializeUserWithAuth', memoizationTTL, { project, token, branchName: options.branch, lightweightModeGeneral, localGrid })();
-    perf.log('after initializeUserWithAuth');
-
-    testimCustomToken.initFromData(result.authData, options.project, options.token);
-    return result;
-}
-
-module.exports = {
-    initializeUserWithAuth,
-};

package/commons/lazyRequire.js

@@ -1,105 +0,0 @@
-'use strict';
-
-const ora = require('ora');
-const path = require('path');
-const npmWrapper = require('./npmWrapper');
-const { getLogger } = require('./logger');
-const { getCliLocation } = require('../utils');
-const { requireWithFallback } = require('./requireWithFallback');
-
-const logger = getLogger('lazy-require');
-// eslint-disable-next-line import/no-dynamic-require
-const packageJson = require(path.resolve(getCliLocation(), 'package.json'));
-const ongoingCalls = new Map();
-
-module.exports = async function memoizedLazyRequireApi(dependency, options = {}) {
-    const packageLocally = npmWrapper.getPackageIfInstalledLocally(dependency);
-    if (packageLocally) {
-        return packageLocally;
-    }
-
-    let spinner;
-    if (!options.silent) {
-        spinner = ora(`Installing ${dependency} before first usage...`).start();
-    }
-
-    try {
-        const requiredModule = await memoizedLazyRequire(dependency);
-        if (spinner) {
-            spinner.succeed();
-        }
-        return requiredModule;
-    } catch (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 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}`;
-
-        if (spinner) {
-            spinner.fail(errorMessage);
-        }
-
-        throw error;
-    }
-};
-
-async function memoizedLazyRequire(identifier, options = {}) {
-    if (ongoingCalls.has(identifier)) {
-        return ongoingCalls.get(identifier);
-    }
-
-    ongoingCalls.set(identifier, lazyRequireImpl(identifier, options));
-    ongoingCalls.get(identifier).catch(() => {
-        ongoingCalls.delete(identifier);
-    });
-
-    return ongoingCalls.get(identifier);
-}
-
-async function lazyRequireImpl(dependency) {
-    const packageLocally = npmWrapper.getPackageIfInstalledLocally(dependency);
-
-    if (packageLocally) {
-        return packageLocally;
-    }
-
-    const depVersionToInstall = getVersionOfLazyDep(dependency);
-
-    const depWithVersions = `${dependency}@${depVersionToInstall}`;
-
-    await npmWrapper.installPackageLocally(getCliLocation(), depWithVersions);
-
-    return requireWithFallback(dependency);
-}
-
-module.exports.installAllLazyDependencies = async function installAllLazyDependencies() {
-    const allLazyDependencies = Object.keys(packageJson.lazyDependencies);
-
-    for (const dep of allLazyDependencies) {
-        await lazyRequireImpl(dep);
-    }
-};
-
-// TODO: remove this once docker-build-tool is not using it
-if (require.main === module) {
-    module.exports.installAllLazyDependencies();
-}
-
-/**
- *
- * @param {string} dependencyToFind
- */
-function getVersionOfLazyDep(dependencyToFind) {
-    const depEntry = Object.entries(packageJson.lazyDependencies)
-        .find(([dep]) => dep === dependencyToFind);
-
-    if (!depEntry) {
-        throw new Error('The given package name is not lazyDependencies');
-    }
-
-    return depEntry[1];
-}

package/commons/logUtils.js

@@ -1,15 +0,0 @@
-const os = require('os');
-const { getCliLocation } = require('../utils');
-
-function additionalLogDetails() {
-    return {
-        cliLocation: getCliLocation(),
-        userInfo: os.userInfo(),
-        platform: os.platform(),
-        release: os.release(),
-    };
-}
-
-module.exports = {
-    additionalLogDetails,
-};

package/commons/logUtils.test.js

@@ -1,21 +0,0 @@
-const { expect } = require('chai');
-const os = require('os');
-const { additionalLogDetails } = require('./logUtils');
-const { getCliLocation } = require('../utils');
-
-describe('logUtils', () => {
-    describe('additionalLogDetails', () => {
-        it('should return the expected unformation', () => {
-            const expected = {
-                cliLocation: getCliLocation(),
-                userInfo: os.userInfo(),
-                platform: os.platform(),
-                release: os.release(),
-            };
-
-            const result = additionalLogDetails();
-
-            expect(result).to.eql(expected);
-        });
-    });
-});