strest/dist/executer.js

"use strict";
require("reflect-metadata");
var rxjs_1 = require("rxjs");
var reports_1 = require("./reports");
var path = require("path");
var exeution_error_1 = require("./exeution-error");
var log_1 = require("./log");
var noop = function () {
};
if (global && global['jasmine']) {
    global['jasmine']['DEFAULT_TIMEOUT_INTERVAL'] = Math.pow(2, 31) - 1;
}
var observifyFromPromiseWithContext = function (func, context) {
    var args = [];
    for (var _i = 2; _i < arguments.length; _i++) {
        args[_i - 2] = arguments[_i];
    }
    return rxjs_1.Observable.fromPromise(new Promise(function (resolve) {
        resolve(func.apply(context, args));
    }));
};
var wrapWithExecution = function (index) {
    var setupStartTime, setupEndTime;
    return {
        startTime: function () {
            setupStartTime = Date.now();
        },
        stopTime: function () {
            setupEndTime = Date.now();
        },
        totalTime: function () {
            if (!setupStartTime || !setupEndTime) {
                return 0;
            }
            return setupEndTime - setupStartTime;
        },
        instanceNumber: index
    };
};
var buildFlowStream = function (reports, testClass) {
    return function (index) {
        reports._setStep(reports_1.EExecutionStep.INIT);
        reports._setInstanceNumber(index);
        var context = new testClass(index, reports);
        var setupFunction = context.$$setup || noop;
        var setupReportFunction = context.$$setupReport || noop;
        var scenarioFunction = context.$$scenario || noop;
        var scenarioReportFunction = context.$$scenarioReport || noop;
        var teardownFunction = context.$$teardown || noop;
        var teardownReportFunction = context.$$teardownReport || noop;
        var methods = {
            setup: setupFunction,
            scenario: scenarioFunction,
            teardown: teardownFunction
        };
        var reportMethods = {
            setup: setupReportFunction,
            scenario: scenarioReportFunction,
            teardown: teardownReportFunction
        };
        var setupData = wrapWithExecution(index);
        var scenarioData = wrapWithExecution(index);
        var teardownData = wrapWithExecution(index);
        var teardownSetupResult, teardownScenarioResult;
        return {
            instance: context,
            setupAndScenario: // Setup
            observifyFromPromiseWithContext(methods.setup, context, setupData)
                .flatMap(function (result) {
                log_1.logDebug("\t\t\u2319 DONE SETUP (" + (index + 1) + ")", 'blue');
                var setupResult = {
                    get executionTime() {
                        return setupData.totalTime();
                    },
                    executionResult: result
                };
                teardownSetupResult = setupResult;
                // Setup Report
                reports._setInstanceNumber(index);
                reports._setStep(reports_1.EExecutionStep.SETUP);
                reports._setTest({
                    result: result,
                    instance: context,
                });
                return observifyFromPromiseWithContext(reportMethods.setup, context, reports, setupResult).map(function () { return setupResult; });
            })
                .flatMap(function (setupResult) {
                // Scenario
                return observifyFromPromiseWithContext(methods.scenario, context, scenarioData, setupResult);
            })
                .flatMap(function (res) {
                log_1.logDebug("\t\t\u2319 DONE SCENARIO (" + (index + 1) + ")", 'blue');
                var stepResult = {
                    get executionTime() {
                        return scenarioData.totalTime();
                    },
                    executionResult: res
                };
                teardownScenarioResult = stepResult;
                // Scenario Report
                reports._setInstanceNumber(index);
                reports._setStep(reports_1.EExecutionStep.SCENARIO);
                reports._setTest({
                    result: res,
                    instance: context,
                });
                return observifyFromPromiseWithContext(reportMethods.scenario, context, reports, stepResult).map(function () { return stepResult; });
            }),
            teardown: function () {
                // Teardown
                return observifyFromPromiseWithContext(methods.teardown, context, teardownData, teardownSetupResult, teardownScenarioResult)
                    .flatMap(function (result) {
                    log_1.logDebug("\t\t\u2319 DONE TEARDOWN (" + (index + 1) + ")", 'blue');
                    var tdResult = {
                        get executionTime() {
                            return teardownData.totalTime();
                        },
                        executionResult: result
                    };
                    // Teardown Report
                    reports._setInstanceNumber(index);
                    reports._setStep(reports_1.EExecutionStep.TEARDOWN);
                    reports._setTest({
                        result: result,
                        instance: context,
                    });
                    return observifyFromPromiseWithContext(reportMethods.teardown, context, reports, teardownSetupResult, teardownScenarioResult, tdResult).map(function () { return tdResult; });
                });
            }
        };
    };
};
var resolveExecutor = function (singleLogic, stopOnError, executor, counter, teardownInstances) {
    if (typeof executor === 'number') {
        executor = {
            parallel: false,
            totalCount: executor,
        };
    }
    if (executor['totalCount']) {
        var times = executor['totalCount'];
        var parallel = executor['parallel'] || false;
        var obs = rxjs_1.Observable.of(null);
        var failedExecutions_1 = [];
        var buildExec_1 = function (ind) {
            var instance = singleLogic(ind);
            teardownInstances.push(instance.teardown);
            return rxjs_1.Observable.of(ind).do(function (ind) { return log_1.log("\t\u2319 Executing instance #" + (ind + 1) + "...", 'blue'); }).flatMap(function () {
                return instance.setupAndScenario
                    .catch(function (err) {
                    log_1.log('\t\t⌙ ' + String(err), 'red');
                    if (stopOnError) {
                        throw err;
                    }
                    failedExecutions_1.push({
                        index: ind + 1,
                        error: err
                    });
                    return rxjs_1.Observable.of(null);
                });
            });
        };
        if (parallel) {
            counter.count = counter.count + times;
            obs = obs.flatMapTo(rxjs_1.Observable.forkJoin(new Array(times).fill(null).map(function (dummy, ind) { return buildExec_1(ind); })));
        }
        else {
            var _loop_1 = function (i) {
                counter.count++;
                obs = obs.flatMap(function () { return buildExec_1(i); });
            };
            for (var i = 0; i < times; i++) {
                _loop_1(i);
            }
        }
        return obs.do(function () {
            if (failedExecutions_1.length > 0) {
                throw new exeution_error_1.ExecutionErrors('Some of instances failed to execute!', failedExecutions_1);
            }
        });
    }
    else if (executor['timeToWait']) {
        var time_1 = executor['timeToWait'];
        return rxjs_1.Observable.of(null).do(function () { return log_1.log("\t\u2319 Waiting " + time_1 + "ms before next execution...", 'cyan'); }).delay(time_1);
    }
};
exports.execute = function () {
    var classes = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        classes[_i] = arguments[_i];
    }
    (classes || []).forEach(function (testClass) {
        var classConfig = testClass.$$config;
        var strestConfig = testClass.$$configFile;
        if (!classConfig) {
            throw new Error("Class " + testClass.name + " is not decorated with @StressTest()!");
        }
        var reports = new reports_1.Reports();
        var testName = classConfig.name || testClass.name;
        var executionsOrder = classConfig.instances;
        var stopOnError = classConfig.stopOnError;
        var repeatExecution = classConfig.repeat || 1;
        var singleFlow = buildFlowStream(reports, testClass);
        describe("[" + testName + "]", function () {
            executionsOrder.forEach(function (executionOrderIns) {
                var executionOrder = executionOrderIns.getArr();
                var executionStr = executionOrderIns.asString();
                var _loop_2 = function (i) {
                    var title = "[ #" + i + " ][ " + executionStr + " ]";
                    it(title, function () {
                        return new Promise(function (resolve, reject) {
                            var counter = {
                                count: 0
                            };
                            var teardownInstances = [];
                            var obsRes = rxjs_1.Observable.of(null).do(function () {
                                log_1.bgLog(title + " - EXEC...", 'yellow');
                            });
                            executionOrder.forEach(function (executor) {
                                obsRes = obsRes.flatMapTo(resolveExecutor(singleFlow, stopOnError, executor, counter, teardownInstances));
                            });
                            obsRes
                                .do(function () { return log_1.log("\t\u2319 Flow execution is done, running teardown methods...", 'green'); })
                                .flatMap(function () {
                                return rxjs_1.Observable.merge.apply(rxjs_1.Observable, teardownInstances.map(function (tearndownFn) { return tearndownFn(); }));
                            })
                                .subscribe(function () {
                                setTimeout(resolve, 100);
                            }, function (e) {
                                setTimeout(function () {
                                    reject(e);
                                }, 100);
                            });
                        });
                    });
                };
                for (var i = 1; i <= repeatExecution; i++) {
                    _loop_2(i);
                }
            });
            afterAll(function () {
                log_1.logDebug('afterAll called: executing reporters...');
                reports.saveReport(reports, testName, strestConfig.reporters, path.resolve(process.cwd(), strestConfig.reportDirectory));
            });
        });
    });
};
exports.addToTestSuite = exports.execute;
//# sourceMappingURL=executer.js.map