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

"use strict";

const Promise = require('bluebird');
const _ = require('lodash');

const reporter = require("../reports/reporter");
const servicesApi = require('../commons/testimServicesApi');
const BaseTestPlanRunner = require('./BaseTestPlanRunner');
const { ArgError } = require('../errors');
const Logger = require('../commons/logger');
const logger = Logger.getLogger('test-plan-runner');

class TestPlanRunner extends BaseTestPlanRunner {
    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;
    }

    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.keys(testPlansData).map(tpId => testPlansData[tpId])).reduce((all, testRun) => _.concat(all, testRun.beforeTests, testRun.tests, testRun.afterTests), []);
        }

        const testPlansResults = {};
        const testPlansTests = {};
        const projectId = options.project;

        return this.prepareForTestResources(options)
            .then(() => servicesApi.getTestPlanTestList(projectId, options.testPlan, branchToUse))
            .then(data => {
                const testPlans = data.testPlans;
                const testPlansData = data.testPlansData;
                if (!testPlans || testPlans.length === 0) {
                    return Promise.reject(new ArgError("no test plan to run " + options.testPlan));
                }
                if (!testPlansData || Object.keys(testPlansData).length === 0) {
                    return Promise.reject(new ArgError("no test to run in test plan " + options.testPlan));
                }
                return this.validateConfig(options, flattenTestListData(testPlansData))
                    .then(() => {
                        return Promise.map(testPlans, testPlan => {
                            let id = testPlan.testPlanId;
                            testPlansResults[id] = {};

                            const tpOptions = Object.assign({}, options);
                            tpOptions.baseUrl = options.baseUrl || testPlan.startUrl;
                            tpOptions.host = options.host || testPlan.host;
                            tpOptions.port = options.port || testPlan.port;
                            tpOptions.gridId = options.gridId || testPlan.gridId;

                            if (options.gridId) {
                                delete tpOptions.host;
                                delete tpOptions.port;
                            }

                            //if user pass --grid with test plan we want to use grid option instead of host and port
                            if (options.grid) {
                                delete tpOptions.host;
                                delete tpOptions.port;
                                delete tpOptions.gridId;
                            }

                            const testPlanName = tpOptions.overrideExecutionName || testPlan.name;

                            return Promise.map(testPlansData[id], testPlanTests => {
                                return this.runTestPlan(testPlanTests.beforeTests, testPlanTests.tests, testPlanTests.afterTests, tpOptions, testPlanName, branchToUse)
                                    .tap(res => {
                                        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;
                                    });
                            }).tap(() => {
                                const executions = Object.keys(testPlansResults[id]).map(exeId => {
                                    return {
                                        executionId: exeId,
                                        status: this.calcTestResultStatus(testPlansResults[id][exeId])
                                    };
                                });
                                let tests = Object.keys(testPlansResults[id]).map(exeId => testPlansResults[id][exeId]).reduce((testResult, test) => Object.assign(testResult, test), {});
                                let success = this.calcTestResultStatus(tests);
                                Object.assign(testPlansTests, tests);
                                const executionId = success ? executions[0].executionId : executions.find(exec => !exec.success).executionId;
                                return servicesApi.saveTestPlanResult(projectId, id, {
                                    success: success,
                                    executions: executions,
                                    executionId: executionId
                                });
                            });
                        });
                    });
            }).then(async results => {
                const flattenResults = _(results).flattenDeep().value();
                await reporter.onAllTestPlansFinished(flattenResults);
                return flattenResults.map(res => res.results).reduce((total, cur) => Object.assign(total, cur), {});
            });
    }
}

module.exports = TestPlanRunner;