@testim/testim-cli 3.289.0 → 3.290.1-beta

package/runOptionsAgentFlow.js

@@ -1,87 +0,0 @@
-// @ts-check
-
-'use strict';
-
-const { ArgError } = require('./errors');
-const _ = require('lodash');
-const runOptionsUtils = require('./runOptionsUtils');
-const analytics = require('./commons/testimAnalytics');
-
-/**
- *
- * @param {import("commander").CommanderStatic} program
- */
-function isAgentFlow(program) {
-    if (program.start) {
-        analytics.track(null, 'cli-start-command', { downloadBrowser: Boolean(program.downloadBrowser) });
-    }
-    if (program.startV2 || program.start || program.agent) {
-        return true;
-    }
-
-    return false;
-}
-
-/**
- *
- * @param {Readonly<import("commander").CommanderStatic>} program
- */
-async function runAgentFlow(program) {
-    const agentModes = ['playground-playwright', 'playground-puppeteer', 'playground-selenium'];
-    let installPlaygroundPlaywrightDeps = false;
-    let installPlaygroundPuppeteerDeps = false;
-    let installPlaygroundSeleniumDeps = false;
-
-    let startTestimBrowser = false;
-
-    if (program.start) {
-        startTestimBrowser = true;
-    }
-
-    if (_.isNaN(program.agentPort)) {
-        return Promise.reject(new ArgError('Agent port is not number'));
-    }
-
-    if (typeof program.agent === 'string' && agentModes.some(mode => program.agent.includes(mode))) {
-        const selectedModes = program.agent.split(',').map(mode => mode.trim());
-        if (selectedModes.includes('playground-playwright')) {
-            installPlaygroundPlaywrightDeps = true;
-        }
-
-        if (selectedModes.includes('playground-puppeteer')) {
-            installPlaygroundPuppeteerDeps = true;
-        }
-
-        if (selectedModes.includes('playground-selenium')) {
-            installPlaygroundSeleniumDeps = true;
-        }
-    }
-
-    const playerUrl = runOptionsUtils.getPlayerUrl(program);
-
-    console.log('Start Testim CLI on Agent mode');
-    return {
-        project: program.project,
-        token: program.token,
-        agentMode: true,
-        agentPort: program.agentPort,
-        agentBind: program.agentBind,
-        openEditor: program.openEditor,
-        installPlaygroundPlaywrightDeps,
-        installPlaygroundPuppeteerDeps,
-        installPlaygroundSeleniumDeps,
-        startTestimBrowser,
-        ext: program.ext,
-        extensionPath: program.extensionPath,
-        playerLocation: program.playerPath || playerUrl,
-        canary: program.canary,
-        playerPath: program.playerPath,
-        playerRequirePath: program.playerRequirePath,
-        downloadBrowser: Boolean(program.downloadBrowser),
-    };
-}
-
-module.exports = {
-    isAgentFlow,
-    runAgentFlow,
-};

package/runOptionsUtils.js

@@ -1,60 +0,0 @@
-// @ts-check
-
-'use strict';
-
-const config = require('./commons/config');
-
-module.exports = {
-    getExtensionsUrl,
-    getResolvedExtensionUrl,
-    getPlayerUrl,
-};
-
-/**
- *
- * @param {Readonly<import("commander").CommanderStatic>} program
- */
-function getExtensionsUrl(program, useCanonicalURL) {
-    const zipFileSuffix = program.canary ? '-master.zip' : '.zip';
-    let firefox;
-    let chrome;
-    if (!useCanonicalURL) {
-        firefox = `${config.BLOB_URL}/extension/testim-firefox-profile${zipFileSuffix}`;
-        chrome = `${config.BLOB_URL}/extension/testim-headless${zipFileSuffix}`;
-    } else {
-        firefox = `${config.CANONICAL_BLOB_URL}/extension/testim-firefox-profile${zipFileSuffix}`;
-        chrome = `${config.CANONICAL_EDGE_URL}/extension/testim-headless${zipFileSuffix}`;
-    }
-    return {
-        firefox,
-        chrome,
-        'edge-chromium': chrome,
-    };
-}
-
-/**
- *
- * @param {Readonly<import("commander").CommanderStatic>} program
- */
-function getResolvedExtensionUrl(program) {
-    const { chrome, firefox } = getExtensionsUrl(program, false);
-
-    if (program.browser === 'firefox') {
-        return firefox;
-    }
-    if (program.browser === 'chrome') {
-        return chrome;
-    }
-    return [chrome, firefox];
-}
-
-/**
- *
- * @param {Readonly<import("commander").CommanderStatic>} program
- */
-function getPlayerUrl(program) {
-    const playerUrlPrefix = `${config.BLOB_URL}/extension/sessionPlayer`;
-    const playerUrl = program.canary ? `${playerUrlPrefix}-master` : playerUrlPrefix;
-
-    return playerUrl;
-}

package/runner.js

@@ -1,355 +0,0 @@
-'use strict';
-
-/* eslint-disable no-console */
-const _ = require('lodash');
-const utils = require('./utils');
-const reporter = require('./reports/reporter');
-const npmDriver = require('./testimNpmDriver');
-const tunnel = require('./commons/testimTunnel');
-const perf = require('./commons/performance-logger');
-const gridService = require('./services/gridService');
-const analytics = require('./commons/testimAnalytics');
-const featureFlags = require('./commons/featureFlags');
-const branchService = require('./services/branchService');
-const servicesApi = require('./commons/testimServicesApi');
-const TestPlanRunner = require('./runners/TestPlanRunner');
-const socketService = require('./commons/socket/socketService');
-const testimCustomToken = require('./commons/testimCustomToken');
-const labFeaturesService = require('./services/labFeaturesService');
-const featureAvailabilityService = require('./commons/featureAvailabilityService');
-const { getLogger } = require('./commons/logger');
-const { EDITOR_URL } = require('./commons/config');
-const { CLI_MODE } = require('./commons/constants');
-const { ArgError, QuotaDepletedError } = require('./errors');
-const { prepareMockNetwork, initializeUserWithAuth } = require('./commons/prepareRunner');
-
-const FREE_PLAN_MINIMUM_BROWSER_TIMEOUT = 30 * 60 * 1000;
-
-
-const logger = getLogger('runner');
-
-/** @param {import('./runOptions').RunnerOptions} options */
-function validateCLIRunsAreAllowed(options) {
-    const hasCliAccess = _.get(options, 'company.activePlan.premiumFeatures.allowCLI');
-
-    if (!hasCliAccess) {
-        const projectId = options.project;
-        analytics.track(options.authData.uid, 'cli-not-supported', { projectId });
-        console.warn('Testim CLI is not supported in this plan');
-        // TODO: shouldn't this throw an error? 🤔
-    }
-}
-
-/** @param {import('./runOptions').RunnerOptions} options */
-async function validateProjectQuotaNotDepleted(options) {
-    const projectId = options.project;
-
-    const usage = await servicesApi.getUsageForCurrentBillingPeriod(projectId);
-    const isExecutionBlocked = usage?.isExecutionBlocked;
-    if (!isExecutionBlocked) {
-        return;
-    }
-
-    console.error('You have reached the limit of runs for the billing month, please upgrade your plan at https://www.testim.io/upgrade-contact-us?source=cli');
-    analytics.track(options.authData.uid, 'execution-quota-surpassed', { projectId });
-    throw new QuotaDepletedError();
-}
-
-/**
- * @param {import('./runOptions').RunnerOptions} options
- * @param {Awaited<ReturnType<initializeUserWithAuth>>['companyByProjectId']} company
- */
-function validateOptionsForCompany(options, company) {
-    const optionsRetention = options.retentionDays;
-    if (!optionsRetention) {
-        return;
-    }
-
-    const companyRetention = _.get(company, 'activePlan.premiumFeatures.resultRetention');
-    if (optionsRetention > companyRetention) {
-        throw new ArgError(`Retention days (${optionsRetention}) cannot be greater than the company's retention days (${companyRetention}). Run aborted`);
-    }
-}
-
-/** @param {import('./runOptions').RunnerOptions} options */
-async function validateCliAccount(options) {
-    if (options.lightweightMode?.disableQuotaBlocking) {
-        return;
-    }
-    try {
-        await Promise.all([
-            validateProjectQuotaNotDepleted(options),
-            validateCLIRunsAreAllowed(options),
-        ]);
-    } catch (err) {
-        if ([ArgError, QuotaDepletedError].some(errType => err instanceof errType)) {
-            throw err;
-        }
-        logger.error('could not validate cli account', { err });
-    }
-}
-
-/** @param {string} projectId */
-function analyticsIdentify(projectId) {
-    const authData = testimCustomToken.getTokenV3UserData();
-    return analytics.identify({
-        userId: authData.uid,
-        name: authData.uid,
-        traits: {
-            projectId,
-            company: {
-                id: projectId,
-                lastCIRun: Math.floor(Date.now() / 1000), // unix timestamp
-            },
-        },
-    });
-}
-
-/** @param {string} projectId */
-function initSocketServices(projectId, { disableResults = false, disableRemoteStep = false }) {
-    if (featureFlags.flags.useNewWSCLI.isEnabled() && !disableResults && !disableRemoteStep) {
-        return socketService.connect(projectId);
-    }
-    if (!disableRemoteStep) {
-        const remoteStepService = require('./commons/socket/remoteStepService');
-        remoteStepService.init(projectId);
-    }
-    if (!disableResults) {
-        const testResultService = require('./commons/socket/testResultService');
-        testResultService.init(projectId);
-    }
-    return undefined;
-}
-
-/**
- * @param {import('./runOptions').RunnerOptions} options
- * @param {Awaited<ReturnType<initializeUserWithAuth>>['branchName']} branchInfoFromServer
- */
-function setBranch(options, branchInfoFromServer) {
-    const { branch, autoDetect } = options;
-    branchService.setCurrentBranch(branchInfoFromServer, autoDetect);
-    if (!branchInfoFromServer && !autoDetect) {
-        throw new ArgError(`branch ${branch} does not exist, run aborted.`);
-    }
-}
-
-/** @param {import('./runOptions').RunnerOptions} options */
-async function setSfdcCredential(options) {
-    const { projectData: { projectId } = {} } = options;
-    const branch = branchService.getCurrentBranch();
-    if (_.get(options, 'company.activePlan.premiumFeatures.ttaForSalesforce')) {
-        options.sfdcCredential = await servicesApi.loadSfdcCredential({ projectId, branch });
-    }
-}
-
-/**
- * @param {import('./runOptions').RunnerOptions} options
- * @param {Awaited<ReturnType<initializeUserWithAuth>>['companyByProjectId']} company
- */
-function setCompany(options, company) {
-    const { onprem, id, storageBaseUrl, storageType, name, activePlan = {} } = company;
-    if (onprem) {
-        const { mode, extensionPath, ext, playerPath } = options;
-        if ([CLI_MODE.SELENIUM].includes(mode) && !playerPath) {
-            throw new ArgError('in selenium on prem mode --player-path must be provided');
-        }
-        if (mode === 'extension' && !extensionPath && !ext) {
-            throw new ArgError('In extension on prem mode --ext or --extension-path must be provided');
-        }
-    }
-    const isPOC = Boolean(activePlan.isPoc);
-    const isStartUp = Boolean(activePlan.isStartUp);
-    const planType = utils.getPlanType(activePlan);
-    if (planType === 'free') {
-        options.newBrowserWaitTimeout = options.newBrowserWaitTimeout < FREE_PLAN_MINIMUM_BROWSER_TIMEOUT ? FREE_PLAN_MINIMUM_BROWSER_TIMEOUT : options.newBrowserWaitTimeout;
-    }
-    featureFlags.setCompanyId(id);
-    featureFlags.setIsPOC(isPOC);
-    featureFlags.setIsStartUp(isStartUp);
-    featureFlags.setPlanType(planType);
-    featureAvailabilityService.setPlanType(planType);
-    options.company = {
-        companyId: id,
-        onprem,
-        storageBaseUrl,
-        storageType,
-        name,
-        planType,
-        isPOC,
-        isStartUp,
-        activePlan,
-    };
-}
-
-/**
- * @param {import('./runOptions').RunnerOptions} options
- * @param {Awaited<ReturnType<initializeUserWithAuth>>['editorConfig']} editorConfig
- */
-function setSystemInfo(options, editorConfig) {
-    if (EDITOR_URL) {
-        options.editorUrl = EDITOR_URL;
-        return;
-    }
-    options.editorUrl = editorConfig.editorUrl;
-}
-
-/**
- * @param {import('./runOptions').RunnerOptions} options
- * @param {Awaited<ReturnType<initializeUserWithAuth>>['allGrids']} allGrids
- */
-function setAllGrids(options, allGrids) {
-    options.allGrids = allGrids;
-}
-
-/**
- * @param {import('./runOptions').RunnerOptions} options
- * @param {Awaited<ReturnType<initializeUserWithAuth>>['authData']} authData
- */
-function setAuthData(options, authData) {
-    options.authData = authData;
-}
-
-/**
- * @param {import('./runOptions').RunnerOptions} options
- * @param {Awaited<ReturnType<initializeUserWithAuth>>['projectById']} project
- */
-function setProject(options, project) {
-    const { id, name, type, defaults } = project;
-    featureFlags.setProjectId(id);
-    featureFlags.setProjectType(type);
-    options.projectData = {
-        projectId: id,
-        type,
-        name,
-        defaults,
-    };
-}
-
-/** @param {import('./runOptions').RunnerOptions} options */
-async function setGrid(options) {
-    options.gridData = await gridService.getGridData(options);
-}
-
-/** @param {import('./runOptions').RunnerOptions} options */
-async function setMockNetworkRules(options) {
-    const { project } = options;
-    const props = { projectId: project };
-
-    if (options.overrideMappingFile) {
-        analytics.trackWithCIUser('user-override-file', props);
-        options.mockNetworkRules = await prepareMockNetwork(options.overrideMappingFile);
-    }
-}
-
-/**
- * @param {import('./runOptions').RunnerOptions} options
- * @param {string=} customExtensionLocalLocation
- */
-async function runRunner(options, customExtensionLocalLocation) {
-    perf.log('in runner.js runRunner');
-
-    const { project, remoteRunId, useLocalChromeDriver, useChromeLauncher } = options;
-
-    if (!remoteRunId) {
-        options.source = (useLocalChromeDriver || useChromeLauncher) ? 'cli-local' : 'cli';
-    }
-
-    await npmDriver.checkNpmVersion();
-    perf.log('in runner.js after checkNpmVersion');
-
-    await validateCliAccount(options);
-
-    perf.log('in runRunner before tunnel.connect');
-    await tunnel.connect(options);
-    perf.log('in runRunner after tunnel.connect');
-
-    const testPlanRunner = new TestPlanRunner(customExtensionLocalLocation);
-    const results = await testPlanRunner.run(options);
-
-    perf.log('before tunnel.disconnect');
-    await tunnel.disconnect(options);
-    await gridService.keepAlive.end(project);
-    perf.log('after tunnel.disconnect and gridService.keepAlive.end');
-
-    return results;
-}
-
-/** @param {import('./runOptions').RunnerOptions} options */
-function showFreeGridRunWarningIfNeeded(options) {
-    if (featureAvailabilityService.shouldShowFreeGridRunWarning(options.gridData?.type)) {
-        const CYAN = '\x1b[36m';
-        const UNDERSCORE = '\x1b[4m';
-        const RESET = '\x1b[0m';
-        const MESSAGE = 'Our Free grid offers basic service performance.\nIf you need faster results, contact us to upgrade your plan and dramatically improve your tests’ run times.';
-        console.log(`\n${UNDERSCORE}${CYAN}${MESSAGE}${RESET}\n`);
-    }
-}
-
-/**
- * This method initializes the Testim CLI with all the information it needs to start executing, it takes care of:
- *
- * - Reporting the user to analytics
- * - Authenticating the user and exchanging their token for a jwt
- * - Sets the grids for the company and validates the user has permission to run the CLI
- * @param {import('./runOptions').RunnerOptions} options - the run options passed to the CLI, namely the project and token
- */
-async function init(options) {
-    perf.log('start runner init');
-    const { project, lightweightMode, useChromeLauncher, mode, disableSockets } = options;
-    const featureFlagsReady = featureFlags.fetch();
-    const socketConnected = initSocketServices(project, {
-        disableResults: disableSockets || Boolean(lightweightMode?.disableResults && (useChromeLauncher || mode !== 'extension')),
-        disableRemoteStep: disableSockets || Boolean(lightweightMode?.disableRemoteStep),
-    });
-
-    featureFlagsReady.catch(() => {}); // suppress unhandled rejection
-    Promise.resolve(socketConnected).catch(() => {}); // only sometimes a promise
-
-    const { authData, editorConfig, companyByProjectId, projectById, branchName, allGrids } = await initializeUserWithAuth(options);
-
-    validateOptionsForCompany(options, companyByProjectId);
-    await Promise.all([featureFlagsReady, socketConnected]);
-
-    if (options.browser && featureFlags.flags.dec2022eolBrowsers.isEnabled()) {
-        const browser = utils.getBrowserInfo(options.browser);
-        if (browser.eol) {
-            throw new ArgError(`Unsupported browser: ${browser.browserName}`);
-        }
-    }
-
-    perf.log('after featureFlagsReady and socketConnected');
-    setSystemInfo(options, editorConfig);
-    setCompany(options, companyByProjectId);
-    setProject(options, projectById);
-    setBranch(options, branchName);
-    setAllGrids(options, allGrids);
-    setAuthData(options, authData);
-    await setSfdcCredential(options);
-
-    if (!options.lightweightMode?.disableLabs) {
-        await labFeaturesService.loadLabFeatures(projectById.id, companyByProjectId.activePlan);
-    }
-
-    if (options.lightweightMode && options.lightweightMode.type === 'turboMode' && (featureFlags.flags.highSpeedMode.getValue() === 'disabled' || options.company.planType === 'free')) {
-        delete options.lightweightMode;
-    }
-
-    if (options.lightweightMode && options.lightweightMode.type === 'turboMode') {
-        // eslint-disable-next-line max-len
-        console.log('\nTurbo mode will ignore step delays. Test artifacts like screenshots and logs will only be saved for failed runs. For more information see our docs: https://help.testim.io/docs/turbo-mode');
-    }
-
-    gridService.keepAlive.start(project);
-    analyticsIdentify(project);
-    await setMockNetworkRules(options);
-    await setGrid(options);
-    showFreeGridRunWarningIfNeeded(options);
-
-    const branchToUse = branchService.getCurrentBranch();
-    reporter.setOptions(options, branchToUse);
-}
-
-module.exports = {
-    run: runRunner,
-    init,
-};