@testim/testim-cli 3.289.0 → 3.290.0

package/reports/junitReporter.js

@@ -1,183 +0,0 @@
-/* eslint-disable no-console */
-
-'use strict';
-
-const xml2js = require('xml2js');
-const fsPromises = require('fs/promises');
-const utils = require('../utils');
-const {
-    isAbortedTest, isSkippedTest, getFailedTests, isFailedTest, getFailureEvaluatingCount, getSkippedCount, getAbortedTests,
-} = require('./reporterUtils');
-const featureAvailabilityService = require('../commons/featureAvailabilityService');
-
-class JunitReporter {
-    constructor(options, branchToUse) {
-        this.options = options;
-        this.classname = 'testim.io.test';
-        if (options.reportFileClassname) {
-            this.classname = options.reportFileClassname;
-        }
-        if (options.reportFileClassname === true) {
-            this.classname = ''; // specific case for passing empty string which makes junit-viewer display test name
-        }
-
-        this.branchToUse = branchToUse;
-    }
-
-    async createResultsReport(testResults) {
-        const reportFile = this.options.reportFile;
-        const projectId = this.options.project;
-
-        const reportText = await report(this.options.editorUrl, testResults, projectId, this.branchToUse, this.classname, this.options);
-        if (!reportFile) {
-            return undefined;
-        }
-        try {
-            await fsPromises.writeFile(reportFile, reportText);
-            console.log('JUnit XML file saved to', reportFile);
-            return testResults;
-        } catch (err) {
-            console.error('could not save report file', reportFile, err);
-            return testResults;
-        }
-    }
-
-    onAllTestPlansFinished(testPlanResults) {
-        return this.createResultsReport(testPlanResults);
-    }
-}
-
-function getPrintName(testResult) {
-    const testData = testResult.testData || {};
-    const testDataNumber = typeof testData.total === 'number' ? ` - ${testData.index} / ${testData.total} Data set` : '';
-    return `${testResult.name}${testDataNumber}`;
-}
-function getVisitedUrlsList(testResult) {
-    if (!testResult.visitedUrlsList) {
-        console.log('No URLs found:', 'Please contact our support team or remove the --urls flag from the CLI command');
-    }
-    const visitedUrls = testResult.visitedUrlsList || '';
-    return `${visitedUrls}`;
-}
-function getVisitedUrlsJson(testResult) {
-    const visitedUrls = testResult.visitedUrlsJson || '';
-    return `${visitedUrls}`;
-}
-async function report(editorUrl, testPlanResults, projectId, branch, classname, options) {
-    function createTestCaseObject(testResult) {
-        const testResultUrl = utils.getTestUrl(editorUrl, projectId, testResult.testId, testResult.resultId, branch);
-        const testResultObject = {
-            $: {
-                name: getPrintName(testResult),
-                classname,
-                time: utils.getDurationSec(testResult.duration),
-            },
-        };
-
-        testResultObject.$.ownedBy = testResult.testOwnerName;
-        testResultObject.$.ownerEmail = testResult.testOwnerEmail;
-
-        if (isFailedTest(testResult) || isAbortedTest(testResult)) {
-            const prefixMessage = `Step Failed: ${testResult.failureReason || testResult.reason}`;
-            const message = isFailedTest(testResult) ? `${prefixMessage} More info at: ${testResultUrl}` : prefixMessage;
-            testResultObject.failure = {
-                $: {
-                    message,
-                },
-            };
-        }
-        if (isSkippedTest(testResult) && utils.isQuarantineAndNotRemoteRun(testResult, options) && featureAvailabilityService.isTestStatusEnabled) {
-            testResultObject.skipped = {};
-        }
-
-        testResultObject['system-out'] = testResultUrl;
-
-        if (options.urls) {
-            testResultObject['visited-urls-list'] = getVisitedUrlsList(testResult);
-            testResultObject['visited-urls-json'] = getVisitedUrlsJson(testResult);
-        }
-
-        return testResultObject;
-    }
-
-    function createTestSuiteObject(testPlanResult) {
-        const { results, testPlanName, configName } = testPlanResult;
-        const testResults = results || {};
-        const suiteName = configName && testPlanName ? `${testPlanName} with config '${configName}'` : testPlanName;
-        const testSuiteAttributes = {
-            name: suiteName || 'selenium run',
-            tests: getTestCount(testResults),
-            failure: getFailedCount(testResults),
-            timestamp: getSuiteTimestamp(testPlanResults),
-        };
-        if (featureAvailabilityService.isTestStatusEnabled) {
-            testSuiteAttributes.skipped = getSkippedCount(testResults, options);
-            const failureEvaluatingCount = getFailureEvaluatingCount(testResults);
-            testSuiteAttributes.failure -= failureEvaluatingCount;
-            testSuiteAttributes['failure-evaluating'] = failureEvaluatingCount;
-        }
-        return {
-            $: testSuiteAttributes,
-            testcase: Object.keys(testResults).map(resultId => createTestCaseObject(testResults[resultId])),
-        };
-    }
-
-    function getSuiteTimestamp(testResults) {
-        const startTimeArr = Object.keys(testResults).map(resultId => testResults[resultId].startTime);
-        const minTestStartTime = Math.min.apply(null, startTimeArr);
-        return minTestStartTime ? new Date(minTestStartTime).toISOString() : new Date().toISOString();
-    }
-
-    function getTestCount(testResults) {
-        return Object.keys(testResults).length;
-    }
-
-    function getFailedCount(testResults) {
-        return getFailedTests(testResults).length + getAbortedTests(testResults).length;
-    }
-
-    const testResultObject = {
-        testsuites: {
-            testsuite: testPlanResults.map(testPlanResult => createTestSuiteObject(testPlanResult)),
-        },
-    };
-
-
-    try {
-        const builder = new xml2js.Builder();
-        const jUnitXmlReporter = builder.buildObject(testResultObject);
-        return jUnitXmlReporter;
-    } catch (err) {
-        return createErrorjUnitReporter(err);
-    }
-}
-
-function createErrorjUnitReporter(err) {
-    const builder = new xml2js.Builder();
-    const errorJunitObject = {
-        testsuites: {
-            testsuite: {
-                $: {
-                    name: 'selenium run',
-                    tests: 1,
-                    failure: 1,
-                    timestamp: Date.now(),
-                },
-                testcase: {
-                    $: {
-                        name: 'junit reporter generator failed',
-                        classname: 'testim.io.jUnitXmlReporter',
-                    },
-                    error: {
-                        $: {
-                            message: err.message,
-                        },
-                    },
-                },
-            },
-        },
-    };
-    return builder.buildObject(errorJunitObject);
-}
-
-module.exports = JunitReporter;

package/reports/reporter.js

@@ -1,166 +0,0 @@
-'use strict';
-
-const logger = require('../commons/logger').getLogger('reporter');
-
-class Reporter {
-    setOptions(options, branchToUse) {
-        this.reporters = [];
-        const optReporters = options.reporters;
-
-        const DebugReporter = require('./debugReporter');
-        this.reporters.push(new DebugReporter(options));
-
-        if (optReporters === undefined || optReporters.length === 0) {
-            const ConsoleReporter = require('./consoleReporter');
-            this.reporters.push(new ConsoleReporter(options, branchToUse));
-            if (options?.reportFile !== undefined) {
-                const JunitReporter = require('./junitReporter');
-                this.reporters.push(new JunitReporter(options, branchToUse));
-            }
-        } else {
-            if (optReporters.includes('teamcity')) {
-                const TeamCityReporter = require('./teamCityReporter');
-                this.reporters.push(new TeamCityReporter(options));
-            }
-
-            if (optReporters.includes('console')) {
-                const ConsoleReporter = require('./consoleReporter');
-                this.reporters.push(new ConsoleReporter(options, branchToUse));
-            }
-
-            if (optReporters.includes('junit')) {
-                const JunitReporter = require('./junitReporter');
-                this.reporters.push(new JunitReporter(options, branchToUse));
-            }
-
-            if (optReporters.includes('json')) {
-                const JsonReporter = require('./jsonReporter');
-                this.reporters.push(new JsonReporter(options));
-            }
-
-            if (optReporters.includes('chrome')) {
-                const { ChromeReporter } = require('./chromeReporter');
-                this.reporters.push(new ChromeReporter(options, branchToUse));
-            }
-        }
-    }
-
-    async onTestPlanFinished(testResults, testPlanName, startTime, executionId, isAnonymous, isCodeMode, childTestResults) {
-        let results = {};
-
-        // TODO: remove mutation of testResults from the Reporter
-        if (childTestResults) {
-            const childValues = Object.values(childTestResults);
-            if (childValues.length > 0) {
-                for (const child of Object.values(childTestResults)) {
-                    results[child.id] = child;
-                }
-                for (const parent of Object.keys(testResults)) {
-                    if (!childValues.some(c => c.parentResultId !== parent)) {
-                        results[parent] = testResults[parent];
-                    }
-                }
-            } else {
-                logger.warn('childTestResults is not array');
-                results = testResults;
-            }
-        } else {
-            results = testResults;
-        }
-        for (const reporter of this.reporters) {
-            if (reporter?.onTestPlanFinished) {
-                const duration = Date.now() - (startTime || 0);
-                await reporter.onTestPlanFinished(results, testPlanName, duration, executionId, isAnonymous, isCodeMode);
-            }
-        }
-    }
-
-    async onTestPlanStarted(beforeTests, tests, afterTests, testPlanName, executionId, isAnonymous, configName, isCodeMode) {
-        for (const reporter of this.reporters) {
-            if (reporter?.onTestPlanStarted) {
-                await reporter.onTestPlanStarted(beforeTests, tests, afterTests, testPlanName, executionId, isAnonymous, configName, isCodeMode);
-            }
-        }
-    }
-
-    async onGetSlot(workerId, browser) {
-        for (const reporter of this.reporters) {
-            if (reporter?.onGetSlot) {
-                await reporter.onGetSlot(workerId, browser);
-            }
-        }
-    }
-
-    async onGetSession(workerId, testName, mode) {
-        for (const reporter of this.reporters) {
-            if (reporter?.onGetSession) {
-                await reporter.onGetSession(workerId, testName, mode);
-            }
-        }
-    }
-
-    async onWaitToTestComplete(workerId, isCodeMode, debuggerAddress) {
-        for (const reporter of this.reporters) {
-            if (reporter?.onWaitToTestComplete) {
-                await reporter.onWaitToTestComplete(workerId, isCodeMode, debuggerAddress);
-            }
-        }
-    }
-
-    async onWaitToTestStart(workerId) {
-        for (const reporter of this.reporters) {
-            if (reporter?.onWaitToTestStart) {
-                await reporter.onWaitToTestStart(workerId);
-            }
-        }
-    }
-
-    async onAllTestPlansFinished(testPlanResults) {
-        // TODO: remove mutation of testPlanResults from the Reporter
-        for (const result of testPlanResults) {
-            if (result.childTestResults) {
-                result.results = {};
-                const childValues = Object.values(result.childTestResults);
-                for (const child of childValues) {
-                    result.results[child.id] = child;
-                }
-                for (const parent of Object.keys(testPlanResults)) {
-                    if (!childValues.some(c => c.parentResultId !== parent)) {
-                        result.results[parent] = testPlanResults[parent];
-                    }
-                }
-            }
-        }
-
-        for (const reporter of this.reporters) {
-            if (reporter?.onAllTestPlansFinished) {
-                await reporter.onAllTestPlansFinished(testPlanResults);
-            }
-        }
-    }
-}
-
-function addHook(name) {
-    Reporter.prototype[name] = async function (...args) {
-        for (const reporter of this.reporters) {
-            if (reporter?.[name]) {
-                await reporter[name](...args);
-            }
-        }
-    };
-}
-
-addHook('onGetBrowserFailure');
-addHook('onGetBrowserSuccess');
-addHook('onTestPlanStarted');
-addHook('onGetSlot');
-addHook('onGetSession');
-addHook('onTestFinished');
-addHook('onTestFailed');
-addHook('onTestPassed');
-addHook('onTestStarted');
-addHook('onTestIgnored');
-addHook('onWaitToTestStart');
-addHook('onWaitToTestComplete');
-
-module.exports = new Reporter();

package/reports/reporterUtils.js

@@ -1,54 +0,0 @@
-'use strict';
-
-const utils = require('../utils');
-const constants = require('../commons/constants');
-
-const isFailedTest = (testResult) => {
-    const { status, sessionType, success } = testResult;
-    return status === constants.runnerTestStatus.FAILED || (sessionType === constants.sessionType.CODEFUL && success === false);
-};
-
-const isAbortedTest = (testResult) => {
-    const { status } = testResult;
-    return status === constants.runnerTestStatus.ABORTED;
-};
-
-const isPassedTest = (testResult) => {
-    const { status, sessionType, success } = testResult;
-    return status === constants.runnerTestStatus.PASSED || (sessionType === constants.sessionType.CODEFUL && success === true);
-};
-
-const isSkippedTest = (testResult) => testResult.runnerStatus === constants.runnerTestStatus.SKIPPED;
-
-const isContainer = (testResult, isCodeMode) => {
-    if (!isCodeMode) {
-        return false;
-    }
-    return !testResult.runConfig;
-};
-
-const isEvaluatingTest = (testResult) => testResult.testStatus === constants.testStatus.EVALUATING;
-
-const getSkippedCount = (testResults, options) => Object.values(testResults).filter(testResult => isSkippedTest(testResult) && utils.isQuarantineAndNotRemoteRun(testResult, options)).length;
-
-const getFailureEvaluatingCount = (testResults) => Object.values(testResults).filter(testResult => isFailedTest(testResult) && isEvaluatingTest(testResult)).length;
-
-const getFailedTests = (testResults, isCodeMode) => Object.values(testResults).filter(testResult => isFailedTest(testResult) && !isContainer(testResult, isCodeMode));
-
-const getPassedTests = (testResults, isCodeMode) => Object.values(testResults).filter(testResult => isPassedTest(testResult) && !isContainer(testResult, isCodeMode));
-
-const getAbortedTests = (testResults, isCodeMode) => Object.values(testResults).filter(testResult => isAbortedTest(testResult) && !isContainer(testResult, isCodeMode));
-
-module.exports = {
-    isFailedTest,
-    isAbortedTest,
-    isPassedTest,
-    isEvaluatingTest,
-    isSkippedTest,
-
-    getFailedTests,
-    getPassedTests,
-    getAbortedTests,
-    getSkippedCount,
-    getFailureEvaluatingCount,
-};

package/reports/teamCityReporter.js

@@ -1,73 +0,0 @@
-/* eslint-disable no-console */
-const logger = require('../commons/logger').getLogger('team-city-reporter');
-
-function tidy(text) {
-    if (!text) {
-        return '';
-    }
-    return text
-        .replace(/\|/g, '||')
-        .replace(/'/g, "|'")
-        .replace(/\n/g, '|n')
-        .replace(/\r/g, '|r')
-        .replace(/\u0085/g, '|x')
-        .replace(/\u2028/g, '|l')
-        .replace(/\u2029/g, '|p')
-        .replace(/\[/g, '|[')
-        .replace(/\]/g, '|]');
-}
-
-class TeamCityReporter {
-    constructor(options) {
-        this.options = options;
-    }
-
-    getPrintName(test) {
-        const testConfig = test.config || {};
-        const testDataNumber = typeof testConfig.testDataTotal === 'number' ? ` - ${testConfig.testDataIndex} / ${testConfig.testDataTotal} Data set` : '';
-        const teamCityName = `${test.name} (${test.testId})${testDataNumber}`;
-        return tidy(teamCityName);
-    }
-
-    onTestStarted(test, workerId, isRerun, isCodeMode, resultId) {
-        if (isRerun) {
-            logger.debug('skip report test started because is rerun');
-            return;
-        }
-        const name = this.getPrintName(test);
-        console.log(`##teamcity[testStarted name='${name}' captureStandardOutput='true' flowId='${resultId}']`);
-    }
-
-    onTestFailed(test, failureReason, testurl, testId, isRerun, resultId) {
-        if (isRerun) {
-            logger.debug('skip report test failed because is rerun');
-            return;
-        }
-        const name = this.getPrintName(test);
-        console.log(`##teamcity[testFailed name='${name}' message='${tidy(failureReason)}' details='${tidy(testurl)}' flowId='${resultId}']`);
-    }
-
-    onTestFinished(test, workerId, isRerun) {
-        if (isRerun) {
-            logger.debug('skip report test finished because is rerun');
-            return;
-        }
-        const name = this.getPrintName(test);
-        console.log(`##teamcity[testFinished name='${name}' duration='${test.duration}' flowId='${test.resultId}']`);
-    }
-
-    onTestIgnored(workerId, test, message = 'ignore') {
-        const name = this.getPrintName(test);
-        console.log(`##teamcity[testIgnored name='${name}' message='${tidy(message)}']`);
-    }
-
-    onTestPlanStarted(beforeTests, tests, afterTests, testPlanName) {
-        console.log(`##teamcity[testSuiteStarted name='${tidy(testPlanName)}']`);
-    }
-
-    onTestPlanFinished(testResults, testPlanName) {
-        console.log(`##teamcity[testSuiteFinished name='${tidy(testPlanName)}']`);
-    }
-}
-
-module.exports = TeamCityReporter;