@testim/testim-cli 3.289.0 → 3.290.1-beta

package/testRunStatus.js

@@ -1,567 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-const utils = require('./utils');
-const reporter = require('./reports/reporter');
-const constants = require('./commons/constants');
-const gridService = require('./services/gridService');
-const featureFlags = require('./commons/featureFlags');
-const servicesApi = require('./commons/testimServicesApi');
-const OverrideTestDataBuilder = require('./OverrideTestDataBuilder');
-const featureAvailabilityService = require('./commons/featureAvailabilityService');
-const { ArgError } = require('./errors');
-const { getLogger } = require('./commons/logger');
-const { registerExitHook } = require('./processHandler');
-const { calculateCoverage } = require('./coverage/jsCoverage');
-const { SeleniumPerfStats } = require('./commons/SeleniumPerfStats');
-const { mapFilesToLocalDrive } = require('./services/localRCASaver');
-const { TESTIM_CONCURRENT_WORKER_COUNT } = require('./commons/config');
-
-const logger = getLogger('test-run-status');
-const gitBranch = utils.getEnvironmentGitBranch();
-const gitCommit = process.env.GIT_COMMIT || process.env.CIRCLE_SHA1 || process.env.TRAVIS_COMMIT;
-const gitRepoUrl = process.env.GIT_URL || process.env.CIRCLE_REPOSITORY_URL;
-const runnerVersion = utils.getRunnerVersion();
-
-
-async function runHook(fn, ...args) {
-    if (!fn || typeof fn !== 'function') {
-        return undefined;
-    }
-
-    try {
-        const res = await fn(...args);
-        return res || {};
-    } catch (err) {
-        logger.warn('failed to run hook', { err });
-        throw new ArgError(`failed to run hook promise ${err.message}`);
-    }
-}
-
-class RunStatus {
-    /**
-     * @param {any[]} testInfoList
-     * @param {import('./runOptions').RunnerOptions} options
-     * @param {string} testPlanId
-     * @param {string} branchToUse
-     */
-    constructor(testInfoList, options, testPlanId, branchToUse) {
-        this.options = options;
-        this.options.runParams = this.options.runParams || {};
-        this.startTime = null;
-        this.fileUserParamsData = this.options.userParamsData;
-        this.beforeSuiteParams = {};
-        this.branchToUse = branchToUse;
-        this.exportsGlobal = {};
-        this.testInfoList = testInfoList;
-
-        this.executionStartedPromise = Promise.resolve();
-
-        const browserNames = utils.getUniqBrowsers(options, testInfoList);
-        const runnerMode = options.lightweightMode ? options.lightweightMode.type : options.mode;
-        this.execConfig = {
-            parallel: TESTIM_CONCURRENT_WORKER_COUNT || options.parallel || 1,
-            browser: browserNames,
-            gitBranch,
-            gitCommit,
-            gitRepoUrl,
-            runnerVersion,
-            gridHost: options.host || options.gridData.host,
-            testimBranch: branchToUse,
-            canaryMode: options.canary,
-            source: options.source,
-            schedulerId: options.schedulerId,
-            testPlanId,
-            testPlans: options.testPlan,
-            testLabels: options.label,
-            testSuites: [...new Set(testInfoList.flatMap(test => test.testSuites))],
-            testNames: options.name,
-            testIds: options.testId,
-            testConfigs: options.testConfigNames,
-            testConfigIds: options.testConfigIds,
-            port: options.port,
-            browserTimeout: options.browserTimeout,
-            timeout: options.timeout,
-            newBrowserWaitTimeout: options.newBrowserWaitTimeout,
-            tunnel: options.tunnel,
-            tunnelPort: options.tunnelPort,
-            tunnelHostHeader: options.tunnelHostHeader,
-            runnerMode,
-            gridId: options.gridId || options.gridData.gridId,
-            gridName: options.grid || options.gridData.name,
-            gridType: options.gridData.type,
-            retentionDays: options.retentionDays,
-            codeCoverageReportPath: options.codeCoverageReportPath,
-            collectCodeCoverage: options.codeCoverageUrlFilter || options.collectCodeCoverage,
-            sessionType: utils.getSessionType(options),
-        };
-
-        this.seleniumPerfStats = new SeleniumPerfStats();
-        this.calcTestRunStatus();
-    }
-
-    waitForExecutionStartedFinished() {
-        return this.executionStartedPromise;
-    }
-
-    getTestResult(resultId) {
-        return this.testRunStatus[resultId];
-    }
-
-    async addRetryTestResult({
-        newResultId, originalTestResultId, previousTestResultId, projectId, executionId, retryCount = 1,
-    }) {
-        const orgTestResult = this.testRunStatus[originalTestResultId] || {};
-        const {
-            config,
-            isTestsContainer,
-            testId,
-            name,
-            testStatus,
-            testCreatorName,
-            testCreatorEmail,
-            testOwnerName,
-            testOwnerEmail,
-            testLabels,
-            testSuites,
-            allLabels,
-        } = orgTestResult;
-
-        const newTestResult = {
-            originalTestResultId,
-            previousTestResultId,
-            config: _.cloneDeep(config),
-            testId,
-            status: 'QUEUED',
-            name,
-            resultId: newResultId,
-            isTestsContainer,
-            retryCount,
-            testStatus,
-        };
-
-        this.testRunStatus[newResultId] = Object.assign({}, newTestResult, {
-            testCreatorName,
-            testCreatorEmail,
-            testOwnerName,
-            testOwnerEmail,
-            testLabels,
-            testSuites,
-            allLabels,
-        });
-
-        return servicesApi.addTestRetry({
-            projectId,
-            runId: executionId,
-            testId,
-            newResultId,
-            originalTestResultId,
-            previousTestResultId,
-            testResult: newTestResult,
-        });
-    }
-
-    getAllTestResults() {
-        return this.testRunStatus;
-    }
-
-    testStart(wid, executionId, resultId, isRerun) {
-        const test = this.getTestResult(resultId);
-        test.workerId = wid;
-        const isCodeMode = this.options.files.length > 0;
-        reporter.onTestStarted(test, wid, isRerun, isCodeMode, resultId);
-
-        return test;
-    }
-
-    async updateTestStatusRunning(test, executionId, testRetryKey) {
-        const { project: projectId, remoteRunId, projectData } = this.options;
-        if (this.options.lightweightMode?.onlyTestIdsNoSuite) {
-            return this.executionStartedPromise;
-        }
-
-        let testDataUrl = '';
-
-        try {
-            testDataUrl = await servicesApi.updateTestDataArtifact(projectId, test.testId, test.resultId, test.config.testData, projectData.defaults);
-        } catch (err) {
-            logger.error('failed to upload test data artifact (runner)', { err });
-        }
-        const testConfig = _.cloneDeep(test.config);
-        delete testConfig.testData;
-        testConfig.testDataUrl = testDataUrl;
-        await this.executionStartedPromise;
-        return servicesApi.updateTestStatus(projectId, executionId, test.testId, test.resultId, 'RUNNING', { startTime: test.startTime, config: testConfig, remoteRunId, testRetryKey });
-    }
-
-    async testStartReport(test, executionId, testRetryKey) {
-        if (utils.isQuarantineAndNotRemoteRun(test, this.options)) {
-            return undefined;
-        }
-        const globalParameters = this.exportsGlobal;
-        try {
-            const params = await runHook(this.options.beforeTest, Object.assign({}, test, { exportsGlobal: globalParameters, globalParameters }), this.options.userData.loginData.token);
-
-            test.config.testData = Object.assign({}, test.config.testData, this.exportsGlobal, this.fileUserParamsData, this.beforeSuiteParams, params);
-            this.options.runParams[test.resultId] = test.config.testData;
-            test.startTime = Date.now();
-            await this.updateTestStatusRunning(test, executionId, testRetryKey);
-
-            return test;
-        } catch (err) {
-            logger.error('Failed to start test', { err });
-            throw err;
-        }
-    }
-
-    testStartAndReport(wid, executionId, resultId, isRerun, testRetryKey) {
-        const test = this.testStart(wid, executionId, resultId, isRerun);
-        return this.testStartReport(test, executionId, testRetryKey);
-    }
-
-    /**
-     * @param {string} resultId
-     * @param {Awaited<ReturnType<typeof import('./services/gridService')['getGridSlot']>>} gridInfo
-     */
-    onGridSlot(resultId, gridInfo) {
-        const test = this.getTestResult(resultId);
-        test.config.gridInfo = Object.assign({}, gridInfo, { key: undefined, user: undefined });
-        logger.info('on get grid info', { gridInfo: test.config.gridInfo });
-    }
-
-    reportTestStatus(workerId, result, test, isRerun) {
-        const { name, testId, testStatus } = test;
-        const { resultId, success } = result;
-        if (testStatus === constants.testStatus.EVALUATING && featureAvailabilityService.isTestStatusEnabled) {
-            reporter.onTestIgnored(workerId, test, `test in ${constants.testStatus.EVALUATING} status`);
-            return;
-        }
-        if (success) {
-            reporter.onTestPassed(name);
-            return;
-        }
-        reporter.onTestFailed(
-            test,
-            test.failureReason,
-            utils.getTestUrl(this.options.editorUrl, this.options.project, testId, resultId, this.branchToUse),
-            testId,
-            isRerun,
-            resultId,
-        );
-    }
-
-    calcResultText(result) {
-        return result.success ? constants.runnerTestStatus.PASSED : constants.runnerTestStatus.FAILED;
-    }
-
-    /**
-     * @param {number} wid
-     * @param {Parameters<ConstructorParameters<typeof import('./workers/BaseWorker')>[7]>[1]} resultId
-     */
-    onTestIgnored(wid, resultId) {
-        const test = this.getTestResult(resultId);
-        reporter.onTestIgnored(wid, test, `test in ${constants.testStatus.QUARANTINE}`);
-    }
-
-    testEnd(wid, result, executionId, sessionId, isRerun) {
-        const test = this.testRunStatus[result.resultId];
-
-        const duration = (result.endTime - result.startTime) || 0;
-        test.sessionId = sessionId;
-        test.startTime = result.startTime || test.startTime || Date.now();
-        test.duration = duration;
-        result.duration = duration;
-        test.failureReason = result.failureReason || result.reason;
-        result.failureReason = test.failureReason;
-        test.failurePath = result.failurePath;
-        test.resultId = result.resultId;
-        test.success = result.success;
-
-        if (this.options.saveRCALocally) {
-            mapFilesToLocalDrive(test, logger);
-        }
-
-        test.resultUrl = utils.getTestUrl(this.options.editorUrl, this.options.project, test.testId, test.resultId, this.branchToUse);
-        test.status = this.calcResultText(result);
-
-        result.status = test.status;
-        result.name = test.name;
-        result.testStatus = test.testStatus;
-        result.testId = result.testId || test.testId;
-        result.testCreatorName = test.testCreatorName;
-        result.testCreatorEmail = test.testCreatorEmail;
-        result.testOwnerName = test.testOwnerName;
-        result.testOwnerEmail = test.testOwnerEmail;
-        result.testData = test.config && typeof test.config.testDataTotal === 'number' ? {
-            total: test.config.testDataTotal,
-            index: test.config.testDataIndex,
-        } : {};
-
-        this.reportTestStatus(wid, result, test, isRerun);
-        const isCodeMode = this.options.files.length > 0;
-        reporter.onTestFinished(test, wid, isRerun, isCodeMode);
-
-        const afterMerge = Object.assign({}, this.exportsGlobal, result.exportsGlobal);
-
-        this.exportsGlobal = afterMerge;
-        return test;
-    }
-
-    async testEndReport(test, executionId, result, testResultUpdates) {
-        const globalParameters = result.exportsGlobal;
-        try {
-            try {
-                await runHook(this.options.afterTest, Object.assign({}, test, { exportsGlobal: globalParameters, globalParameters }), this.options.userData.loginData.token);
-            } catch (err) {
-                logger.error('HOOK threw an error', { test: test.testId, err });
-                // eslint-disable-next-line no-console
-                console.error('HOOK threw an error', err); // show the customer that his hook failed.
-            }
-            if (this.options.lightweightMode?.onlyTestIdsNoSuite) {
-                return undefined;
-            }
-
-            return await servicesApi.updateTestStatus(this.options.project, executionId, test.testId, test.resultId, 'FINISHED', {
-                startTime: test.startTime,
-                endTime: result.endTime,
-                success: test.success,
-                failureReason: test.failureReason,
-                remoteRunId: this.options.remoteRunId,
-                ...testResultUpdates,
-            }, 5);
-        } catch (err) {
-            logger.error('Failed to update test finished', { err });
-            throw err;
-        }
-    }
-
-    testEndAndReport(wid, result, executionId, sessionId, isRerun, testResultUpdates) {
-        const test = this.testEnd(wid, result, executionId, sessionId, isRerun);
-        return this.testEndReport(test, executionId, result, testResultUpdates);
-    }
-
-    calcTestRunStatus() {
-        const { options, testInfoList } = this;
-        const companyId = options.company.companyId;
-        this.testRunStatus = testInfoList.reduce((resultStatus, testInfo) => {
-            resultStatus[testInfo.resultId] = {
-                testId: testInfo.testId,
-                status: utils.isQuarantineAndNotRemoteRun(testInfo, options) ? constants.runnerTestStatus.SKIPPED : constants.runnerTestStatus.QUEUED,
-                name: testInfo.name,
-                resultId: testInfo.resultId,
-                isTestsContainer: testInfo.isTestsContainer,
-                testStatus: testInfo.testStatus || constants.testStatus.DRAFT,
-                testCreatorName: testInfo.creatorName,
-                testCreatorEmail: testInfo.creatorEmail,
-                testOwnerName: testInfo.testOwnerName,
-                testOwnerEmail: testInfo.testOwnerEmail,
-                testLabels: testInfo.testLabels,
-                testSuites: testInfo.testSuites,
-                allLabels: testInfo.allLabels,
-            };
-
-            const runConfig = options.browser ? utils.getRunConfigByBrowserName(options.browser, options.saucelabs, options.browserstack) : testInfo.runConfig;
-
-            if (runConfig && featureFlags.flags.dec2022eolBrowsers.isEnabled() && utils.getBrowserInfo(runConfig.browserValue)?.eol) {
-                throw new ArgError(`Unsupported Browser: ${runConfig.browserName}`);
-            }
-
-            resultStatus[testInfo.resultId].config = Object.assign({}, this.execConfig, {
-                companyId,
-                testData: testInfo.testData?.value ? testInfo.testData.value : null,
-            });
-            resultStatus[testInfo.resultId].config.isBeforeTestPlan = testInfo.isBeforeTestPlan;
-            resultStatus[testInfo.resultId].config.isAfterTestPlan = testInfo.isAfterTestPlan;
-            resultStatus[testInfo.resultId].config.testDataTotal = testInfo.testData?.total || null;
-            resultStatus[testInfo.resultId].config.testDataIndex = testInfo.testData?.index || null;
-            resultStatus[testInfo.resultId].config.baseUrl = options.baseUrl || testInfo.baseUrl || testInfo.testConfig.baseUrl;
-            resultStatus[testInfo.resultId].config.testConfig = testInfo.overrideTestConfig || testInfo.testConfig;
-            resultStatus[testInfo.resultId].config.browser = runConfig.browserValue.toLowerCase();
-            return resultStatus;
-        }, {});
-    }
-
-    async executionStart(executionId, projectId, startTime, testPlanName, testNames) {
-        logger.info('execution started', { executionId });
-        const { options } = this;
-        const { remoteRunId, projectData } = options;
-
-        registerExitHook(() => Promise.all([
-            gridService.keepAlive.end(projectId),
-            servicesApi.reportExecutionFinished(
-                'ABORTED',
-                executionId,
-                projectId,
-                false,
-                undefined,
-                remoteRunId,
-                undefined,
-            ),
-        ]));
-
-        this.startTime = startTime || Date.now();
-        const runHooksProps = {
-            projectId,
-            executionId,
-            ...(featureFlags.flags.testNamesToBeforeSuiteHook.isEnabled() && { testNames }),
-        };
-        const params = await runHook(options.beforeSuite, runHooksProps);
-        const overrideTestDataBuilder = new OverrideTestDataBuilder(params, _.cloneDeep(this.testInfoList), projectId);
-        this.testInfoList = overrideTestDataBuilder.overrideTestData();
-        this.calcTestRunStatus();
-        this.beforeSuiteParams = params;
-
-        const { testInfoList } = this;
-        const beforeTests = [];
-        const tests = [];
-        const afterTests = [];
-        for (const test of testInfoList) {
-            if (test.isBeforeTestPlan) {
-                beforeTests.push(test);
-                continue;
-            }
-            if (test.isAfterTestPlan) {
-                afterTests.push(test);
-                continue;
-            }
-            tests.push(test);
-        }
-
-        const reportExecutionStarted = async () => {
-            const testResults = _.cloneDeep(this.testRunStatus);
-            await utils.promiseMap(Object.keys(testResults), async testResultId => {
-                const test = testResults[testResultId];
-                const testData = test.config?.testData;
-                const testId = test.testId;
-                const testDataUrl = await servicesApi.updateTestDataArtifact(projectId, testId, testResultId, testData, projectData.defaults);
-                if (!testDataUrl) {
-                    return;
-                }
-                delete test.config.testData;
-                test.config.testDataUrl = testDataUrl;
-            });
-            const isLocalRun = Boolean(options.useLocalChromeDriver || options.useChromeLauncher);
-            const data = {
-                executionId,
-                projectId,
-                labels: testPlanName || [],
-                startTime,
-                executions: testResults,
-                config: this.execConfig,
-                resultLabels: options.resultLabels,
-                remoteRunId: options.remoteRunId,
-                localRunUserId: options.user,
-                isLocalRun,
-                intersections: options.intersections,
-            };
-            const ret = servicesApi.reportExecutionStarted(data);
-            this.executionStartedPromise = ret;
-            ret.catch(e => logger.error(e));
-            return ret;
-        };
-
-        try {
-            await reportExecutionStarted();
-        } catch (err) {
-            logger.error('Failed to start suite', { err });
-            // eslint-disable-next-line no-console
-            console.error('Failed to start test run. Please contact support@testim.io');
-        }
-        return { beforeTests, tests, afterTests };
-    }
-
-    concatSeleniumPerfMarks(marks) {
-        _.chain(marks)
-            .keys()
-            .each((key) => {
-                if (this.seleniumPerfStats.marks[key]) {
-                    this.seleniumPerfStats.marks[key] = [...this.seleniumPerfStats.marks[key], ...marks[key]];
-                }
-            })
-            .value();
-    }
-
-    async executionEnd(executionId) {
-        const tests = utils.groupTestsByRetries(this.testRunStatus);
-        const total = tests.length;
-
-        let passed = 0;
-        let skipped = 0;
-        let failedInEvaluatingStatus = 0;
-        for (const { status, testStatus } of tests) {
-            if (status === constants.runnerTestStatus.PASSED) {
-                passed++;
-            }
-            if (status === constants.runnerTestStatus.SKIPPED) {
-                skipped++;
-            }
-            if (status === constants.runnerTestStatus.FAILED && testStatus === constants.testStatus.EVALUATING) {
-                failedInEvaluatingStatus++;
-            }
-        }
-
-        const { seleniumPerfMarks, ...resultExtraData } = this.seleniumPerfStats.getStats();
-
-        try {
-            await runHook(this.options.afterSuite, {
-                exportsGlobal: this.exportsGlobal,
-                tests,
-                total,
-                passed,
-                skipped,
-            });
-        } catch (err) {
-            // eslint-disable-next-line no-console
-            console.log('check your callback handler on afterSuite Hook for syntax or exception errors');
-            logger.warn('error while running afterSuite Hook', { err, projectId: this.options.projectData.projectId, executionId: this.options.executionId });
-        }
-        const coverageSummary = await calculateCoverage(this.options, this.branchToUse, total, executionId);
-        resultExtraData.coverageSummary = coverageSummary;
-
-        if (this.options.lightweightMode?.onlyTestIdsNoSuite) {
-            return undefined;
-        }
-        try {
-            return await servicesApi.reportExecutionFinished(
-                'FINISHED',
-                executionId,
-                this.options.project,
-                total === (passed + skipped + failedInEvaluatingStatus),
-                {
-                    tmsSuppressReporting: this.options.tmsSuppressReporting,
-                    tmsRunId: this.options.tmsRunId,
-                    tmsCustomFields: this.options.tmsCustomFields,
-                },
-                this.options.remoteRunId,
-                resultExtraData,
-            );
-        } catch (err) {
-            logger.error('Failed to update suite finished', { err });
-            throw err;
-        }
-    }
-
-    async markAllQueuedTests(executionId, status, failureReason, success) {
-        const queuedResultIds = Object.keys(this.testRunStatus).filter(resultId => this.getTestResult(resultId).status === 'QUEUED');
-
-        await servicesApi.updateExecutionTests(
-            executionId,
-            ['QUEUED'],
-            status,
-            failureReason,
-            success,
-            this.startTime,
-            null,
-            this.options.project,
-        );
-        for (const resultId of queuedResultIds) {
-            const test = this.getTestResult(resultId);
-            test.status = status;
-            test.failureReason = failureReason;
-            test.success = success;
-        }
-        return this.testRunStatus;
-    }
-}
-
-module.exports = RunStatus;

package/testimNpmDriver.js

@@ -1,52 +0,0 @@
-// @ts-check
-
-/* eslint-disable no-console */
-const semver = require('semver');
-const config = require('./commons/config');
-const fs = require('fs');
-const logger = require('./commons/logger').getLogger('npm-driver');
-const localRunnerCache = require('./commons/runnerFileCache');
-const npmWrapper = require('./commons/npmWrapper');
-const chalk = require('chalk');
-const utils = require('./utils');
-
-const getNpmVersion = localRunnerCache.memoize(() => npmWrapper.getLatestPackageVersion('@testim/testim-cli'), 'getNpmVersion');
-
-function getPackageVersion() {
-    try {
-        logger.debug('Get package version');
-        const path = `${__dirname}/package.json`;
-        if (!fs.existsSync(path)) {
-            // This usually means that the program runs from a dev environment (in which __dirname
-            // is the src/ directory which, obviously, does not contain a package.json file).
-            return null;
-        }
-        const packageJson = require(path);
-        return packageJson.version;
-    } catch (err) {
-        logger.warn('Failed to get package version', { err });
-        return null;
-    }
-}
-
-async function checkNpmVersion() {
-    if (config.IS_ON_PREM) {
-        return;
-    }
-    try {
-        const latestVersion = await utils.promiseTimeout(getNpmVersion(), 5000, 'The API call to NPM timed out');
-        const packVersion = getPackageVersion();
-        if (packVersion && semver.lt(packVersion, latestVersion)) {
-            console.log(chalk.yellow(
-                `Warning: You are using version ${packVersion}, a newer version is available. To update please run npm install (npm install -g @testim/testim-cli)`)
-            );
-        }
-    } catch (err) {
-        logger.warn('Failed to get NPM version', { err });
-    }
-}
-
-module.exports = {
-    checkNpmVersion,
-    getPackageVersion,
-};