@testim/testim-cli 3.289.0 → 3.290.0

package/runners/TestPlanRunner.js

@@ -1,419 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-const utils = require('../utils');
-const Logger = require('../commons/logger');
-const config = require('../commons/config');
-const reporter = require('../reports/reporter');
-const constants = require('../commons/constants');
-const TestRunStatus = require('../testRunStatus');
-const perf = require('../commons/performance-logger');
-const gridService = require('../services/gridService');
-const branchService = require('../services/branchService');
-const ParallelWorkerManager = require('./ParallelWorkerManager');
-const analyticsService = require('../services/analyticsService');
-const testimServicesApi = require('../commons/testimServicesApi');
-const testimCustomToken = require('../commons/testimCustomToken');
-const RealDataService = require('../commons/socket/realDataService');
-const { StopRunOnError, ArgError } = require('../errors');
-const { getSuite, calcTestResultStatus, validateConfig } = require('./runnerUtils');
-
-const guid = utils.guid;
-const TESTIM_RUN_STATUS = constants.testRunStatus;
-const logger = Logger.getLogger('test-plan-runner');
-const TDK_CHILD_RESULTS_TIMEOUT = 1000 * 60 * 5;
-
-/** @typedef {Awaited<ReturnType<typeof getSuite>>['tests'][number]} ExecutionList */
-
-class TestPlanRunner {
-    /** @param {string=} customExtensionLocalLocation */
-    constructor(customExtensionLocalLocation) {
-        this.workerManager = new ParallelWorkerManager(customExtensionLocalLocation);
-        this.startTime = Date.now();
-    }
-
-    /**
-     * @private
-     * @param {ExecutionList} beforeTests
-     * @param {ExecutionList} tests
-     * @param {ExecutionList} afterTests
-     * @param {string} branchToUse
-     * @param {import('../runOptions').RunnerOptions} tpOptions
-     * @param {string} executionId
-     * @param {string} executionName
-     * @param {TestRunStatus} testStatus
-     */
-    async runTestAllPhases(beforeTests, tests, afterTests, branchToUse, tpOptions, executionId, executionName, testStatus) {
-        /** @type {{ [testResultId: string]: any; }} */
-        const executionResults = {};
-        const authData = testimCustomToken.getTokenV3UserData();
-
-        const runBeforeTests = async () => {
-            const workerCount = tpOptions.beforeParallel || 1;
-            const stopOnError = true;
-            const beforeTestsResults = await this.workerManager.runTests(beforeTests, testStatus, executionId, executionName, tpOptions, branchToUse, authData, workerCount, stopOnError);
-            Object.assign(executionResults, beforeTestsResults);
-        };
-
-        const runTestPlanTests = async () => {
-            const workerCount = config.TESTIM_CONCURRENT_WORKER_COUNT || tpOptions.parallel;
-            const stopOnError = false;
-            perf.log('right before this.workerManager.runTests');
-            const testsResults = await this.workerManager.runTests(tests, testStatus, executionId, executionName, tpOptions, branchToUse, authData, workerCount, stopOnError);
-            perf.log('right after this.workerManager.runTests');
-            Object.assign(executionResults, testsResults);
-        };
-
-        const runAfterTests = async () => {
-            const workerCount = tpOptions.afterParallel || 1;
-            const stopOnError = false;
-            const afterTestsResults = await this.workerManager.runTests(afterTests, testStatus, executionId, executionName, tpOptions, branchToUse, authData, workerCount, stopOnError);
-            Object.assign(executionResults, afterTestsResults);
-        };
-
-        const sessionType = utils.getSessionType(tpOptions);
-        analyticsService.analyticsExecsStart({ authData, executionId, projectId: tpOptions.project, sessionType });
-        perf.log('right before runBeforeTests');
-        try {
-            await runBeforeTests();
-            perf.log('right before runTestPlanTests');
-            await runTestPlanTests();
-            perf.log('right after runTestPlanTests');
-            await runAfterTests();
-            return executionResults;
-        } catch (err) {
-            logger.error('error running test plan', { err });
-            if (err instanceof StopRunOnError) {
-                return testStatus.markAllQueuedTests(executionId, constants.runnerTestStatus.ABORTED, 'aborted', false);
-            }
-            throw err;
-        } finally {
-            await handlePixelValidationBatches();
-        }
-
-        async function handlePixelValidationBatches() {
-            if (tpOptions.lightweightMode?.disablePixelValidation) {
-                return;
-            }
-            // When sessionPlayer is available, use it - as it only attempts to close batches that exist.
-            if (tpOptions.mode === constants.CLI_MODE.SELENIUM) {
-                const { EyeSdkBuilder } = require('../commons/getSessionPlayerRequire').getSessionPlayer();
-                await EyeSdkBuilder.closeBatch(executionId);
-                return;
-            }
-            /** @type {Awaited<ReturnType<typeof testimServicesApi['getApplitoolsIntegrationData']>>} */
-            let applitoolsIntegrationData;
-            try {
-                if (!tpOptions.company?.activePlan?.premiumFeatures?.applitools) {
-                    return;
-                }
-                applitoolsIntegrationData = await testimServicesApi.getApplitoolsIntegrationData(tpOptions.project);
-                if (_.isEmpty(applitoolsIntegrationData) || !executionId) {
-                    return;
-                }
-                const { runKey: apiKey, url: serverUrl } = applitoolsIntegrationData;
-                const tmpSDK = require('@applitools/eyes-sdk-core').makeSDK({ name: 'Testim.io', version: '4.0.0', spec: {} });
-                await tmpSDK.closeBatches({ settings: { batchIds: [executionId], serverUrl, apiKey } });
-            } catch (err) {
-                // If a batch with this name did not exist, do not log an error.
-                if (err.message && (err.message.startsWith('Request failed with status code 404') || err.message.startsWith('no batchIds were set'))) {
-                    return;
-                }
-                logger.error('Failed closing batch in extension mode', { err, projectId: tpOptions.project, applitoolsIntegrationData, batchIds: [executionId] });
-            }
-        }
-    }
-
-    /**
-     * @private
-     * @param {string} projectId
-     */
-    async initRealDataService(projectId) {
-        const realDataService = new RealDataService();
-        await realDataService.init(projectId);
-        return realDataService;
-    }
-
-    /**
-     * @private
-     * @param {RealDataService} realDataService
-     * @param {string} projectId
-     * @param {string} runId
-     * @param {TestRunStatus} testStatus
-     */
-    async listenToTestCreatedInFile(realDataService, projectId, runId, testStatus) {
-        const childTestResults = {};
-        realDataService.joinToTestResultsByRunId(runId, projectId);
-        let isPromisePending = true;
-        /** @type {Promise<any[]>} */
-        const promise = new Promise(_resolve => {
-            const resolve = (val) => {
-                isPromisePending = false;
-                _resolve(val);
-            };
-            realDataService.listenToTestResultsByRunId(runId, testResult => {
-                const resultId = testResult.id;
-                if (!testStatus.getTestResult(resultId)) {
-                    const prevTestResult = childTestResults[resultId];
-                    const mergedTestResult = _.merge({}, prevTestResult, testResult, { resultId });
-                    childTestResults[resultId] = mergedTestResult;
-                    if (!prevTestResult || prevTestResult.status !== testResult.status) {
-                        const parentTestResult = testStatus.getTestResult(mergedTestResult.parentResultId) || { workerId: 1 };
-                        const workerId = parentTestResult.workerId;
-                        if ([TESTIM_RUN_STATUS.RUNNING].includes(testResult.status)) {
-                            reporter.onTestStarted(mergedTestResult, workerId);
-                        }
-                        if ([TESTIM_RUN_STATUS.COMPLETED].includes(testResult.status)) {
-                            mergedTestResult.duration = (mergedTestResult.endTime - mergedTestResult.startTime) || 0;
-                            reporter.onTestFinished(mergedTestResult, workerId);
-                        }
-                    }
-                }
-
-                const allChildTestResultCompleted = !(Object.values(childTestResults)
-                    .some(result => ['QUEUED', 'RUNNING'].includes(result.runnerStatus)));
-
-                const allParentTestResultCompleted = !(Object.values(testStatus.getAllTestResults())
-                    .some(result => ['QUEUED', 'RUNNING'].includes(result.status)));
-
-                if (allChildTestResultCompleted && allParentTestResultCompleted) {
-                    return resolve(Object.values(childTestResults));
-                }
-
-                if (allParentTestResultCompleted && !allChildTestResultCompleted) {
-                    // wait 10 sec to handle race condition when parent test result (file) finished before child test result
-                    return utils.delay(10000)
-                        .then(() => {
-                            if (isPromisePending) {
-                                // TODO(Benji) we are missing the child test results here.
-                                // we are resolving here with partial data - we should consider fetching it
-                                // from the server
-                                resolve(childTestResults);
-                            }
-                        });
-                }
-                return undefined;
-            });
-        });
-
-        return await promise;
-    }
-
-    /**
-     * @private
-     * @param {string} projectId
-     * @param {string} executionId
-     * @param {TestRunStatus} testStatus
-     */
-    async initRealDataServiceAndListenToTestsCreatedInFile(projectId, executionId, testStatus) {
-        const realDataService = await this.initRealDataService(projectId);
-        return this.listenToTestCreatedInFile(realDataService, projectId, executionId, testStatus);
-    }
-
-    /**
-     * @private
-     * @param {ExecutionList} beforeTests
-     * @param {ExecutionList} tests
-     * @param {ExecutionList} afterTests
-     * @param {import('../runOptions').RunnerOptions} tpOptions
-     * @param {string} testPlanName
-     * @param {string | null} testPlanId
-     * @param {string} branch
-     * @param {boolean=} isAnonymous
-     */
-    async runTestPlan(beforeTests, tests, afterTests, tpOptions, testPlanName, testPlanId, branch, isAnonymous) {
-        const executionId = guid();
-        const projectId = tpOptions.project;
-        Logger.setExecutionId(executionId);
-        beforeTests.forEach(test => { test.isBeforeTestPlan = true; });
-        afterTests.forEach(test => { test.isAfterTestPlan = true; });
-        const testStatus = new TestRunStatus([].concat(beforeTests, tests, afterTests), tpOptions, testPlanId, branch);
-
-        const configs = _.chain([].concat(beforeTests, tests, afterTests))
-            .map(test => test.overrideTestConfig?.name || '')
-            .uniq()
-            .compact()
-            .value();
-        /** @type {string | null} */
-        const configName = configs?.length === 1 ? configs[0] : null;
-
-        const isCodeMode = tpOptions.files.length > 0;
-        const testNames = tpOptions.lightweightMode?.onlyTestIdsNoSuite ? [] : [].concat(beforeTests, tests, afterTests).map(test => test.name);
-
-        const testListInfoPromise = tpOptions.lightweightMode?.onlyTestIdsNoSuite ?
-            { beforeTests, tests, afterTests } :
-            testStatus.executionStart(executionId, projectId, this.startTime, testPlanName, testNames);
-        let childTestResults;
-        if (isCodeMode) {
-            childTestResults = this.initRealDataServiceAndListenToTestsCreatedInFile(projectId, executionId, testStatus);
-        }
-        perf.log('before testListInfoPromise');
-        const testListInfo = await testListInfoPromise;
-        if (!tpOptions.lightweightMode?.onlyTestIdsNoSuite) {
-            reporter.onTestPlanStarted(testListInfo.beforeTests, testListInfo.tests, testListInfo.afterTests, testPlanName, executionId, isAnonymous, configName, isCodeMode);
-        }
-
-        perf.log('before runTestAllPhases');
-        const results = await this.runTestAllPhases(testListInfo.beforeTests, testListInfo.tests, testListInfo.afterTests, branch, tpOptions, executionId, testPlanName || 'All Tests', testStatus);
-        const childResults = await utils.promiseTimeout(childTestResults, TDK_CHILD_RESULTS_TIMEOUT)
-            .catch(async () => {
-                logger.warn('timed out waiting for child results on websocket. using REST fallback', { projectId, executionId });
-                const testResults = await testimServicesApi.getRealData(projectId, 'testResult', `runId=${executionId}&sort=runOrder`);
-                return _.chain((testResults?.data?.docs) || [])
-                    .groupBy('parentResultId')
-                    .omit('undefined')
-                    .values()
-                    .flatten()
-                    .value();
-            });
-        perf.log('before executionEnd');
-        await testStatus.executionEnd(executionId);
-        perf.log('after executionEnd');
-        return { results, executionId, testPlanName, configName, childTestResults: childResults };
-    }
-
-    /**
-     * @private
-     * @param {import('../runOptions').RunnerOptions} options
-     * @param {string} branchToUse
-     */
-    async runTestPlans(options, branchToUse) {
-        logger.info('start to run test plan', {
-            options: Object.assign({}, options, { token: undefined, userParamsData: undefined }),
-            branchToUse,
-        });
-
-        function flattenTestListData(testPlansData) {
-            return _.flattenDeep(Object.values(testPlansData)).reduce((all, testRun) => all.concat(testRun.beforeTests, testRun.tests, testRun.afterTests), []);
-        }
-
-        const testPlansResults = {};
-        const testPlansTests = {};
-        const projectId = options.project;
-
-        const data = await testimServicesApi.getTestPlanTestList(projectId, options.testPlan, options.testPlanIds, branchToUse, options.intersections);
-        const testPlans = data.testPlans;
-        const testPlansData = data.testPlansData;
-        if (!testPlans || testPlans.length === 0) {
-            throw new ArgError(`no test plan to run ${options.testPlan}`);
-        }
-        if (!testPlansData || Object.keys(testPlansData).length === 0) {
-            if (options.passZeroTests) {
-                return [];
-            }
-            throw new ArgError(`no test to run in test plan ${options.testPlan}`);
-        }
-        await validateConfig(options, flattenTestListData(testPlansData));
-        return await utils.promiseMap(testPlans, async testPlan => {
-            const id = testPlan.testPlanId;
-            testPlansResults[id] = {};
-
-            const tpOptions = Object.assign({}, options);
-            tpOptions.baseUrl = options.baseUrl || testPlan.startUrl;
-            tpOptions.host = options.host;
-            tpOptions.port = options.port;
-            tpOptions.gridId = options.gridId || testPlan.gridId;
-
-            //if user pass --grid with test plan we want to use grid option instead of host and port
-            if (options.grid) {
-                delete tpOptions.gridId;
-            }
-
-
-            tpOptions.gridData = await gridService.getTestPlanGridData(options, testPlan);
-
-            const testPlanName = tpOptions.overrideExecutionName || testPlan.name;
-            return await utils.promiseMap(testPlansData[id], async testPlanTests => {
-                const res = await this.runTestPlan(testPlanTests.beforeTests, testPlanTests.tests, testPlanTests.afterTests, tpOptions, testPlanName, id, branchToUse);
-                const isCodeMode = options.files.length > 0;
-                reporter.onTestPlanFinished(res.results, testPlan.name, this.startTime, res.executionId, false, isCodeMode, res.childTestResults);
-                testPlansResults[id][res.executionId] = res.results;
-
-                const executions = Object.keys(testPlansResults[id]).map(exeId => ({
-                    executionId: exeId,
-                    status: calcTestResultStatus(testPlansResults[id][exeId]),
-                }));
-                const tests = Object.keys(testPlansResults[id]).map(exeId => testPlansResults[id][exeId]).reduce((testResult, test) => Object.assign(testResult, test), {});
-                const success = calcTestResultStatus(tests);
-                Object.assign(testPlansTests, tests);
-                const executionId = success ? executions[0].executionId : executions.find(exec => !exec.success).executionId;
-                await testimServicesApi.saveTestPlanResult(projectId, id, { success, executions, executionId });
-                return res;
-            });
-        });
-    }
-
-    /**
-     * @private
-     * @param {import('../runOptions').RunnerOptions} options
-     * @param {string} branchToUse
-     */
-    async runAnonymousTestPlan(options, branchToUse) {
-        logger.info('start to run anonymous', {
-            options: Object.assign({}, options, { token: undefined }),
-            branchToUse,
-        });
-
-        perf.log('before getSuite');
-        const suiteResult = await getSuite(options, branchToUse);
-        perf.log('after getSuite');
-
-        if (!suiteResult?.tests[0]?.length) {
-            if (options.rerunFailedByRunId) {
-                throw new ArgError('No failed tests found in the provided run');
-            }
-            if (options.passZeroTests) {
-                return [];
-            }
-            throw new ArgError('No tests to run');
-        }
-        branchToUse = suiteResult.branch || branchToUse;
-        if (options.rerunFailedByRunId && !suiteResult.runName) {
-            if (!suiteResult.runExists) {
-                throw new ArgError('Invalid run ID - no such run.');
-            }
-            const isAnonymouslyNamedRun = suiteResult.runName === '';
-            if (isAnonymouslyNamedRun) {
-                suiteResult.runName = `rerun-${options.rerunFailedByRunId}`;
-            }
-        }
-        const testPlanName = options.overrideExecutionName || suiteResult.runName || [].concat(options.label, options.name, options.suites).join(' ');
-        const isAnonymous = true;
-        perf.log('Right before validateConfig + runAnonymousTestPlan tests map');
-        return await utils.promiseMap(suiteResult.tests, async suiteTests => { // array of results per execution
-            //override result id for remote run mode and run only the first test data
-            if (options.resultId) {
-                const firstTest = suiteTests[0];
-                firstTest.resultId = options.resultId;
-                suiteTests = [firstTest];
-            }
-            await validateConfig(options, suiteTests);
-            perf.log('right before runTestPlan');
-            const res = await this.runTestPlan([], suiteTests, [], options, testPlanName, null, branchToUse, isAnonymous);
-            perf.log('right after runTestPlan');
-            const isCodeMode = options.files.length > 0;
-            await reporter.onTestPlanFinished(res.results, testPlanName, this.startTime, res.executionId, isAnonymous, isCodeMode, res.childTestResults);
-            return res;
-        });
-    }
-
-    /**
-     * @param {import('../runOptions').RunnerOptions} options
-     */
-    async run(options) {
-        const branchToUse = branchService.getCurrentBranch();
-        let results = [];
-        if (utils.hasTestPlanFlag(options)) {
-            results = await this.runTestPlans(options, branchToUse);
-        } else {
-            results = await this.runAnonymousTestPlan(options, branchToUse);
-        }
-        const flattenResults = _.flattenDeep(results);
-        perf.log('right before onAllTestPlansFinished');
-        await reporter.onAllTestPlansFinished(flattenResults);
-        perf.log('right after onAllTestPlansFinished');
-        return flattenResults.map(res => res.results).reduce((total, cur) => Object.assign(total, cur), {});
-    }
-}
-
-module.exports = TestPlanRunner;

package/runners/buildCodeTests.js

@@ -1,159 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-const path = require('path');
-const MemoryFS = require('memory-fs');
-const utils = require('../utils');
-const lazyRequire = require('../commons/lazyRequire');
-const { AbortError } = require('../commons/AbortError');
-
-// compiler instance we can reuse between calls
-const state = {
-    compiler: null,
-    webpackConfig: null,
-};
-
-exports.buildCodeTests = async function buildCodeTestsGuarded(
-    files,
-    webpackConfig,
-    runnerOptionsToMaybeCopyToTestEnvironment,
-    fileSystem,
-    optionalAbortSignal
-) {
-    try {
-        return await buildCodeTests(files, webpackConfig, runnerOptionsToMaybeCopyToTestEnvironment, fileSystem, optionalAbortSignal);
-    } catch (e) {
-        if (e && e.code === 'ENOENT') {
-            // this is a webpack config error - it means webpack didn't pick up on a file change and didn't generate the correct bundle
-            // according to the guid hash
-            state.compiler = null;
-            state.webpackConfig = null;
-            fileSystem.data = {}; // reset the memory filesystem in case we left a mess there in the previous invocation
-            return await buildCodeTests(files, webpackConfig, runnerOptionsToMaybeCopyToTestEnvironment, fileSystem, optionalAbortSignal);
-        }
-        throw e;
-    }
-};
-
-async function buildCodeTests(files, webpackConfig = { mode: 'development' }, runnerOptionsToMaybeCopyToTestEnvironment = undefined, fileSystem = undefined, optionalAbortSignal = undefined) {
-    const webpack = await lazyRequire('webpack');
-
-    const suite = {};
-    const webpackConfigBeforeOurChanges = _.cloneDeep(webpackConfig);
-
-    webpackConfig.externals = { // define testim as an external
-        testim: '__testim',
-        // 'chai': '__chai'
-    };
-    webpackConfig.devtool = webpackConfig.devtool || 'inline-source-map';
-
-    webpackConfig.plugins = webpackConfig.plugins || [];
-
-    webpackConfig.plugins.push(new webpack.DefinePlugin(getEnvironmentVariables(runnerOptionsToMaybeCopyToTestEnvironment)), new webpack.DefinePlugin({
-        'process.argv': JSON.stringify(process.argv),
-    }));
-    files = files.map(f => path.resolve(f));
-
-    const fileHashes = files.map(() => utils.guid(30));
-
-    webpackConfig.optimization = { minimize: false };
-
-    const majorNodeVersion = Number(process.versions.node.split('.')[0]);
-    if (majorNodeVersion >= 17) {
-        // TODO ugly hack to be removed once using Webpack 5 - https://stackoverflow.com/a/73465262 + https://github.com/webpack/webpack/issues/14532
-        const crypto = require('crypto');
-        const originalCryptoCreateHash = crypto.createHash;
-        crypto.createHash = (algorithm, options) => originalCryptoCreateHash(algorithm === 'md4' ? 'sha256' : algorithm, options);
-    }
-
-    webpackConfig.entry = Object.fromEntries(_.zip(files, fileHashes).map(([filename, hash]) => [hash, filename]));
-    webpackConfig.output = Object.assign({
-        devtoolModuleFilenameTemplate: (info) => `file:///${info.absoluteResourcePath}`,
-        filename: '[name].bundle.js',
-    }, webpackConfig.output);
-
-
-    let compiler;
-    // if we are passed a filesystem, assume reuse between calls and turn on watch mode
-    if (fileSystem) {
-        // were we passed a filesystem before to compile the same thing?
-        if (_.isEqual(state.webpackConfig, webpackConfigBeforeOurChanges) && state.compiler) {
-            // we already have a compiler up and running
-            compiler = state.compiler;
-        } else {
-            state.webpackConfig = webpackConfigBeforeOurChanges;
-            state.compiler = webpack(webpackConfig);
-            compiler = state.compiler;
-        }
-    } else {
-        compiler = webpack(webpackConfig); // no caching
-    }
-
-    const mfs = fileSystem || new MemoryFS();
-    compiler.outputFileSystem = mfs; // no need to write compiled tests to disk
-
-    // This can only reject
-    const abortSignalPromise = utils.promiseFromCallback(cb => {
-        if (optionalAbortSignal) {
-            optionalAbortSignal.addEventListener('abort', () => {
-                cb(new AbortError());
-            });
-        }
-    });
-
-    // run compiler:
-    try {
-        const stats = await Promise.race([utils.promiseFromCallback(cb => compiler.run(cb)), abortSignalPromise]);
-        if (stats.hasErrors()) {
-            throw new Error(stats.toJson().errors);
-        }
-    } catch (e) {
-        const { ArgError } = require('../errors');
-
-        const cantFindFile = e.message.match(/Entry module not found: Error: Can't resolve '(.*)'/);
-        if (cantFindFile && cantFindFile.length === 2) {
-            if (webpackConfig.output && webpackConfig.output.library === 'tdk') {
-                throw new ArgError(`Could not open dev-kit functions file in ${cantFindFile[1]}`);
-            }
-            throw new ArgError(`Can't find test files in: '${cantFindFile[1]}'`);
-        }
-
-        throw new ArgError(`Compilation Webpack Error in tests: ${e.message}`);
-    }
-
-    /** @type {{ code: string; name: string; }[]} */
-    const fileResults = files.map((file, i) => ({ code: mfs.readFileSync(path.resolve('./dist', `${fileHashes[i]}.bundle.js`)), name: file })); // read all files
-
-    suite.tests = [fileResults.map(({ code, name }) => ({
-        code: code.toString(),
-        baseUrl: '', // not supported at the moment
-        name: path.resolve(name),
-        testConfig: {},
-        testConfigId: null,
-        testId: utils.guid(),
-        resultId: utils.guid(),
-        isTestsContainer: true,
-    }))];
-    suite.runName = `Testim Dev Kit Run ${new Date().toLocaleString()}`;
-    return suite;
-}
-
-// copied mostly from facebook/create-react-app/blob/8b7b819b4b9e6ba457e011e92e33266690e26957/packages/react-scripts/config/env.js
-function getEnvironmentVariables(runnerOptionsToMaybeCopyToTestEnvironment) {
-    const fromEnvironment = _.fromPairs(
-        Object.keys(process.env)
-            .filter(key => /^TDK_/i.test(key) || key === 'BASE_URL')
-            .map(key => [key, process.env[key]])
-    );
-
-    const fromConfig = {
-        BASE_URL: runnerOptionsToMaybeCopyToTestEnvironment.baseUrl,
-    };
-
-    return {
-        'process.env': stringifyValues({ ...fromConfig, ...fromEnvironment }),
-    };
-}
-function stringifyValues(object) {
-    return _.fromPairs(Object.entries(object).map(([key, value]) => [key, JSON.stringify(value)]));
-}

package/runners/runnerUtils.js

@@ -1,81 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-const path = require('path');
-const utils = require('../utils');
-const analytics = require('../commons/testimAnalytics');
-const { ArgError } = require('../errors');
-
-
-/**
- * @param {import('../runOptions').RunnerOptions} options
- * @param {string} branchToUse
- */
-async function getSuite(options, branchToUse) {
-    if (options.lightweightMode?.onlyTestIdsNoSuite && options.testId) {
-        return { tests: [options.testId.map(testId => ({ testId, testConfig: {}, resultId: utils.guid() }))] };
-    }
-    // local code test
-    if (options.files.length > 0) {
-        const { buildCodeTests } = require('./buildCodeTests');
-        let webpackConfig = {};
-        if (options.webpackConfig) {
-            const webpackConfigPath = path.join(process.cwd(), options.webpackConfig);
-            webpackConfig = require(webpackConfigPath); // eslint-disable-line import/no-dynamic-require
-        }
-
-        return buildCodeTests(options.files, webpackConfig, { baseUrl: options.baseUrl });
-    }
-    // regular test
-    const servicesApi = require('../commons/testimServicesApi');
-    return await servicesApi.getSuiteTestList({
-        projectId: options.project,
-        labels: options.label,
-        testIds: options.testId,
-        testNames: options.name,
-        testConfigNames: options.testConfigNames,
-        suiteNames: options.suites,
-        suiteIds: options.suiteIds,
-        branch: branchToUse,
-        rerunFailedByRunId: options.rerunFailedByRunId,
-        testConfigIds: options.testConfigIds,
-        intersections: options.intersections,
-    });
-}
-
-
-function calcTestResultStatus(tests) {
-    const total = Object.keys(tests).length;
-    const passed = Object.keys(tests).reduce((count, resultId) => count + (tests[resultId].success === true ? 1 : 0), 0);
-    return total === passed;
-}
-
-
-/**
- * @param {import('../runOptions').RunnerOptions} options
- * @param {import('./TestPlanRunner').ExecutionList} testList
- */
-async function validateConfig(options, testList) {
-    const supportedBrowsers = options.mode === 'extension' ? [
-        'edge-chromium', 'chrome',
-    ] : [
-        'firefox', 'chrome', 'edge-chromium', 'safari', 'safari technology preview', 'browser', 'android', 'ios', 'iphone', 'ipad',
-    ];
-    const diff = _.difference(utils.getUniqBrowsers(options, testList), supportedBrowsers);
-
-    if (diff.length > 0) {
-        analytics.trackWithCIUser('invalid-config-run', {
-            browser: diff.join(', '),
-            mode: 'runner',
-        });
-        throw new ArgError(`browser type <${diff}> is not supported in ${options.mode} mode.`);
-    }
-
-    return testList;
-}
-
-module.exports = {
-    getSuite,
-    calcTestResultStatus,
-    validateConfig,
-};