@testim/testim-cli/runners/AnonymousTestPlanRunner.js

"use strict";

const path = require('path');
const Promise = require('bluebird');

const _ = require('lodash');

const reporter = require("../reports/reporter");
const logger = require('../commons/logger').getLogger('suite-runner');
const {ArgError} = require('../errors');
const perf = require('../commons/performance-logger');

const BaseTestPlanRunner = require('./BaseTestPlanRunner');

class AnonymousTestPlanRunner extends BaseTestPlanRunner {
    runAnonymousTestPlan(options, branchToUse) {
        logger.info("start to run anonymous", {
            options: Object.assign({}, options, {token: undefined}),
            branchToUse
        });

        return this.prepareForTestResources(options)
            .log('after prepareForTestResoutces')
            .then(() => getSuite(options, branchToUse))
            .log('after getSuite')
            .then((suiteResult) => {
                if (!suiteResult.tests[0] || suiteResult.tests[0].length === 0) {
                    if (options.rerunFailedByRunId) {
                        throw new ArgError("No failed tests found in the provided run");
                    }
                    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 + runTestPlan Promise.map');
                return Promise.map(suiteResult.tests, suiteTests => {
                    //override result id for remote run mode and run only the first test data
                    if(options.resultId) {
                        const firstTest = _.first(suiteTests);
                        firstTest.resultId = options.resultId;
                        suiteTests = [firstTest];
                    }
                    return this.validateConfig(options, suiteTests)
                        .log('right before runTestPlan')
                        .then(() => this.runTestPlan([], suiteTests, [], options, testPlanName, branchToUse, isAnonymous))
                        .log('right after runTestPlan')
                        .tap(async res => {
                            const isCodeMode = options.files.length > 0;
                            await reporter.onTestPlanFinished(res.results, testPlanName, this.startTime, res.executionId, isAnonymous, isCodeMode, res.childTestResults);
                        });
                }).then(async results => { // array of results per execution
                    const flattenResults = _(results).flattenDeep().value();
                    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), {});
                });
            });
    }
}

async function getSuite(options, branchToUse) {
    // 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);
        }

        return buildCodeTests(options.files, webpackConfig, { baseUrl: options.baseUrl });
    }
    // regular test
    const servicesApi = require('../commons/testimServicesApi');
    return await servicesApi.getSuiteTestList(
        options.project,
        options.label,
        options.testId,
        options.name,
        options.testConfigNames,
        options.suites,
        branchToUse,
        options.rerunFailedByRunId,
        options.testConfigIds
    );
}
module.exports = AnonymousTestPlanRunner;