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

"use strict";

const Promise = require('bluebird');
const _ = require('lodash');
const constants = require('../commons/constants');
const TESTIM_RUN_STATUS = constants.testStatus;
const {CLI_MODE} = constants;
const reporter = require("../reports/reporter");
const RealDataService = require('../commons/socket/realDataService');
const testimCustomToken = require('../commons/testimCustomToken');
const BaseRunner = require('./BaseRunner');
const TestRunStatus = require('../testRunStatus');
const config = require('../commons/config');
const utils = require('../utils');
const guid = utils.guid;
const {StopRunOnError} = require('../errors');
const Logger = require('../commons/logger');
const perf = require('../commons/performance-logger');

class BaseTestPlanRunner extends BaseRunner {
    constructor(strategy) {
        super(strategy);
        this.runTestPlan = Promise.method(this.runTestPlan);
    }
    runTestAllPhases(beforeTests, tests, afterTests, branchToUse, tpOptions, executionId, testStatus) {
        let executionResults = {};
        const authData = testimCustomToken.getTokenV3UserData();

        const runBeforeTests = (beforeTests, testStatus, executionId, tpOptions, branchToUse, authData) => {
            const workerCount = 1;
            const stopOnError = true;
            return this.strategy.runTests(beforeTests, testStatus, executionId, tpOptions, branchToUse, authData, workerCount, stopOnError)
                .then(beforeTestsResults => Object.assign(executionResults, beforeTestsResults));
        };

        const runTestPlanTests = (tests, testStatus, executionId, tpOptions, branchToUse, authData) => {
            const workerCount = config.TESTIM_CONCURRENT_WORKER_COUNT || tpOptions.parallel;
            const stopOnError = false;
            perf.log('right before this.strategy.runTests')
            return this.strategy.runTests(tests, testStatus, executionId, tpOptions, branchToUse, authData, workerCount, stopOnError)
                .log('right after this.strategy.runTests')
                .then(testsResults => Object.assign(executionResults, testsResults));
        };

        const runAfterTests = (afterTests, testStatus, executionId, tpOptions, branchToUse, authData) => {
            const workerCount = 1;
            const stopOnError = false;
            return this.strategy.runTests(afterTests, testStatus, executionId, tpOptions, branchToUse, authData, workerCount, stopOnError)
                .then(afterTestsResults => Object.assign(executionResults, afterTestsResults));
        };

        function catchBeforeTestsFailed(executionId) {
            return testStatus.markAllQueuedTests(executionId, utils.TestStatus.ABORTED, "aborted", false);
        }

        const sessionType = utils.getSessionType(tpOptions);
        this.analyticsExecsStart({authData, executionId, projectId: tpOptions.project, sessionType});
        perf.log('right before runBeforeTests');
        return runBeforeTests(beforeTests, testStatus, executionId, tpOptions, branchToUse, authData)
            .log('right before runTestPlanTests')
            .then(() => runTestPlanTests(tests, testStatus, executionId, tpOptions, branchToUse, authData))
            .log('right after runTestPlanTests')
            .then(() => runAfterTests(afterTests, testStatus, executionId, tpOptions, branchToUse, authData))
            .then(() => executionResults)
            .catch(StopRunOnError, () => catchBeforeTestsFailed(executionId));
    }

    prepareForTestResources(tpOptions) {
        if (tpOptions.mode !== CLI_MODE.APPIUM && !(this.strategy.constructor.name === 'DeviceFarmStrategy')) {
            return Promise.resolve();
        }
        const apkUploaderFactory = require('../commons/apkUploader/apkUploaderFactory');
        return apkUploaderFactory.uploadApk(tpOptions);
    }

    async initRealDataService(projectId) {
        const realDataService = new RealDataService();
        await realDataService.init(projectId);
        return realDataService;
    }

    async listenToTestCreatedInFile(realDataService, projectId, runId, testStatus) {
        const childTestResults = {};
        realDataService.joinToTestResultsByRunId(runId, projectId);
        const promise = new Promise(resolve => {

            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 Promise.delay(10000)
                        .then(() => {
                            if(promise.isPending()) {
                                // 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 await promise;
    };

    async runTestPlan(beforeTests, tests, afterTests, tpOptions, testPlanName, branch, isAnonymous) {
        const executionId = guid();
        const projectId = tpOptions.project;
        Logger.setExecutionId(executionId);
        beforeTests.map(test => test.isBeforeTestPlan = true);
        afterTests.map(test => test.isAfterTestPlan = true);
        const testStatus = new TestRunStatus(_.concat(beforeTests, tests, afterTests), tpOptions, branch);

        const configs = _(_.concat(beforeTests, tests, afterTests)).map(test => test.overrideTestConfig && test.overrideTestConfig.name || "").uniq().filter(Boolean).value();
        const configName = configs && configs.length === 1 ? configs[0] : null;

        const isCodeMode = tpOptions.files.length > 0;

        if (isCodeMode && tpOptions.mode === constants.CLI_MODE.SELENIUM) {
            // in selenium mode we don't need to wait for the runner and clickim to sync, so we don't need to wait for reports.
            testStatus.setAsyncReporting(true);
        }
        const testListInfoPromise = testStatus.executionStart(executionId, projectId, this.startTime, testPlanName);
        let childTestResults = Promise.resolve();
        if (isCodeMode) {
            childTestResults = Promise.try(async () => {
                const realDataService = await this.initRealDataService(projectId);
                return this.listenToTestCreatedInFile(realDataService, projectId, executionId, testStatus);
            });
        }
        const testListInfo = await testListInfoPromise;
        reporter.onTestPlanStarted(testListInfo.beforeTests, testListInfo.tests, testListInfo.afterTests, testPlanName, executionId, isAnonymous, configName, isCodeMode);
        const results = await this.runTestAllPhases(testListInfo.beforeTests, testListInfo.tests, testListInfo.afterTests, branch, tpOptions, executionId, testStatus);
        const childResults = await childTestResults;
        await testStatus.executionEnd(executionId);
        return {results, executionId, testPlanName, configName, childTestResults: childResults };
    }
}

module.exports = BaseTestPlanRunner;