1 | "use strict";
|
2 | require("reflect-metadata");
|
3 | var rxjs_1 = require("rxjs");
|
4 | var reports_1 = require("./reports");
|
5 | var rawConsole = require("console");
|
6 | var chalk = require("chalk");
|
7 | var path = require("path");
|
8 | var exeution_error_1 = require("./exeution-error");
|
9 | var DEBUG = !!process.env.DEBUG;
|
10 | var log = function (text, color) {
|
11 | if (color === void 0) { color = 'white'; }
|
12 | rawConsole.info(chalk[color](text));
|
13 | };
|
14 | var logDebug = function (text, color) {
|
15 | if (color === void 0) { color = 'white'; }
|
16 | if (!DEBUG) {
|
17 | return;
|
18 | }
|
19 | rawConsole.info(chalk[color](text));
|
20 | };
|
21 | var bgLog = function (text, color) {
|
22 | if (color === void 0) { color = 'white'; }
|
23 | rawConsole.info(chalk[color].inverse(text));
|
24 | };
|
25 | var noop = function () {
|
26 | };
|
27 | if (global && global['jasmine']) {
|
28 | global['jasmine']['DEFAULT_TIMEOUT_INTERVAL'] = Math.pow(2, 31) - 1;
|
29 | }
|
30 | var observifyFromPromiseWithContext = function (func, context) {
|
31 | var args = [];
|
32 | for (var _i = 2; _i < arguments.length; _i++) {
|
33 | args[_i - 2] = arguments[_i];
|
34 | }
|
35 | return rxjs_1.Observable.fromPromise(new Promise(function (resolve) {
|
36 | resolve(func.apply(context, args));
|
37 | }));
|
38 | };
|
39 | var wrapWithExecution = function (index) {
|
40 | var setupStartTime, setupEndTime;
|
41 | return {
|
42 | startTime: function () {
|
43 | setupStartTime = Date.now();
|
44 | },
|
45 | stopTime: function () {
|
46 | setupEndTime = Date.now();
|
47 | },
|
48 | totalTime: function () {
|
49 | if (!setupStartTime || !setupEndTime) {
|
50 | return 0;
|
51 | }
|
52 | return setupEndTime - setupStartTime;
|
53 | },
|
54 | instanceNumber: index
|
55 | };
|
56 | };
|
57 | var buildFlowStream = function (reports, testClass) {
|
58 | return function (index) {
|
59 | reports._setStep(reports_1.EExecutionStep.INIT);
|
60 | reports._setInstanceNumber(index);
|
61 | var context = new testClass(index, reports);
|
62 | var setupFunction = context.$$setup || noop;
|
63 | var setupReportFunction = context.$$setupReport || noop;
|
64 | var scenarioFunction = context.$$scenario || noop;
|
65 | var scenarioReportFunction = context.$$scenarioReport || noop;
|
66 | var teardownFunction = context.$$teardown || noop;
|
67 | var teardownReportFunction = context.$$teardownReport || noop;
|
68 | var methods = {
|
69 | setup: setupFunction,
|
70 | scenario: scenarioFunction,
|
71 | teardown: teardownFunction
|
72 | };
|
73 | var reportMethods = {
|
74 | setup: setupReportFunction,
|
75 | scenario: scenarioReportFunction,
|
76 | teardown: teardownReportFunction
|
77 | };
|
78 | var setupData = wrapWithExecution(index);
|
79 | var scenarioData = wrapWithExecution(index);
|
80 | var teardownData = wrapWithExecution(index);
|
81 | var teardownSetupResult, teardownScenarioResult;
|
82 | return {
|
83 | instance: context,
|
84 | setupAndScenario:
|
85 | observifyFromPromiseWithContext(methods.setup, context, setupData)
|
86 | .flatMap(function (result) {
|
87 | logDebug("\t\t\u2319 DONE SETUP (" + (index + 1) + ")", 'blue');
|
88 | var setupResult = {
|
89 | get executionTime() {
|
90 | return setupData.totalTime();
|
91 | },
|
92 | executionResult: result
|
93 | };
|
94 | teardownSetupResult = setupResult;
|
95 |
|
96 | reports._setInstanceNumber(index);
|
97 | reports._setStep(reports_1.EExecutionStep.SETUP);
|
98 | reports._setTest({
|
99 | result: result,
|
100 | instance: context,
|
101 | });
|
102 | return observifyFromPromiseWithContext(reportMethods.setup, context, reports, setupResult).map(function () { return setupResult; });
|
103 | })
|
104 | .flatMap(function (setupResult) {
|
105 |
|
106 | return observifyFromPromiseWithContext(methods.scenario, context, scenarioData, setupResult);
|
107 | })
|
108 | .flatMap(function (res) {
|
109 | logDebug("\t\t\u2319 DONE SCENARIO (" + (index + 1) + ")", 'blue');
|
110 | var stepResult = {
|
111 | get executionTime() {
|
112 | return scenarioData.totalTime();
|
113 | },
|
114 | executionResult: res
|
115 | };
|
116 | teardownScenarioResult = stepResult;
|
117 |
|
118 | reports._setInstanceNumber(index);
|
119 | reports._setStep(reports_1.EExecutionStep.SCENARIO);
|
120 | reports._setTest({
|
121 | result: res,
|
122 | instance: context,
|
123 | });
|
124 | return observifyFromPromiseWithContext(reportMethods.scenario, context, reports, stepResult).map(function () { return stepResult; });
|
125 | }),
|
126 | teardown: function () {
|
127 |
|
128 | return observifyFromPromiseWithContext(methods.teardown, context, teardownData, teardownSetupResult, teardownScenarioResult)
|
129 | .flatMap(function (result) {
|
130 | logDebug("\t\t\u2319 DONE TEARDOWN (" + (index + 1) + ")", 'blue');
|
131 | var tdResult = {
|
132 | get executionTime() {
|
133 | return teardownData.totalTime();
|
134 | },
|
135 | executionResult: result
|
136 | };
|
137 |
|
138 | reports._setInstanceNumber(index);
|
139 | reports._setStep(reports_1.EExecutionStep.TEARDOWN);
|
140 | reports._setTest({
|
141 | result: result,
|
142 | instance: context,
|
143 | });
|
144 | return observifyFromPromiseWithContext(reportMethods.teardown, context, reports, teardownSetupResult, teardownScenarioResult, tdResult).map(function () { return tdResult; });
|
145 | });
|
146 | }
|
147 | };
|
148 | };
|
149 | };
|
150 | var resolveExecutor = function (singleLogic, stopOnError, executor, counter, teardownInstances) {
|
151 | if (typeof executor === 'number') {
|
152 | executor = {
|
153 | parallel: false,
|
154 | totalCount: executor,
|
155 | };
|
156 | }
|
157 | if (executor['totalCount']) {
|
158 | var times = executor['totalCount'];
|
159 | var parallel = executor['parallel'] || false;
|
160 | var obs = rxjs_1.Observable.of(null);
|
161 | var failedExecutions_1 = [];
|
162 | var buildExec_1 = function (ind) {
|
163 | var instance = singleLogic(ind);
|
164 | teardownInstances.push(instance.teardown);
|
165 | return rxjs_1.Observable.of(ind).do(function (ind) { return log("\t\u2319 Executing instance #" + (ind + 1) + "...", 'blue'); }).flatMap(function () {
|
166 | return instance.setupAndScenario
|
167 | .catch(function (err) {
|
168 | log('\t\t⌙ ' + String(err), 'red');
|
169 | if (stopOnError) {
|
170 | throw err;
|
171 | }
|
172 | failedExecutions_1.push({
|
173 | index: ind + 1,
|
174 | error: err
|
175 | });
|
176 | return rxjs_1.Observable.of(null);
|
177 | });
|
178 | });
|
179 | };
|
180 | if (parallel) {
|
181 | counter.count = counter.count + times;
|
182 | obs = obs.flatMapTo(rxjs_1.Observable.forkJoin(new Array(times).fill(null).map(function (dummy, ind) { return buildExec_1(ind); })));
|
183 | }
|
184 | else {
|
185 | var _loop_1 = function (i) {
|
186 | counter.count++;
|
187 | obs = obs.flatMap(function () { return buildExec_1(i); });
|
188 | };
|
189 | for (var i = 0; i < times; i++) {
|
190 | _loop_1(i);
|
191 | }
|
192 | }
|
193 | return obs.do(function () {
|
194 | if (failedExecutions_1.length > 0) {
|
195 | throw new exeution_error_1.ExecutionErrors('Some of instances failed to execute!', failedExecutions_1);
|
196 | }
|
197 | });
|
198 | }
|
199 | else if (executor['timeToWait']) {
|
200 | var time_1 = executor['timeToWait'];
|
201 | return rxjs_1.Observable.of(null).do(function () { return log("\t\u2319 Waiting " + time_1 + "ms before next execution...", 'cyan'); }).delay(time_1);
|
202 | }
|
203 | };
|
204 | exports.execute = function () {
|
205 | var classes = [];
|
206 | for (var _i = 0; _i < arguments.length; _i++) {
|
207 | classes[_i] = arguments[_i];
|
208 | }
|
209 | (classes || []).forEach(function (testClass) {
|
210 | var classConfig = testClass.$$config;
|
211 | var strestConfig = testClass.$$configFile;
|
212 | if (!classConfig) {
|
213 | throw new Error("Class " + testClass.name + " is not decorated with @StressTest()!");
|
214 | }
|
215 | var reports = new reports_1.Reports();
|
216 | var testName = classConfig.name || testClass.name;
|
217 | var executionsOrder = classConfig.instances;
|
218 | var stopOnError = classConfig.stopOnError;
|
219 | var repeatExecution = classConfig.repeat || 1;
|
220 | var singleFlow = buildFlowStream(reports, testClass);
|
221 | describe("[" + testName + "]", function () {
|
222 | executionsOrder.forEach(function (executionOrderIns) {
|
223 | var executionOrder = executionOrderIns.getArr();
|
224 | var executionStr = executionOrderIns.asString();
|
225 | var _loop_2 = function (i) {
|
226 | var title = "[ #" + i + " ][ " + executionStr + " ]";
|
227 | it(title, function () {
|
228 | return new Promise(function (resolve, reject) {
|
229 | var counter = {
|
230 | count: 0
|
231 | };
|
232 | var teardownInstances = [];
|
233 | var obsRes = rxjs_1.Observable.of(null).do(function () {
|
234 | bgLog(title + " - EXEC...", 'yellow');
|
235 | });
|
236 | executionOrder.forEach(function (executor) {
|
237 | obsRes = obsRes.flatMapTo(resolveExecutor(singleFlow, stopOnError, executor, counter, teardownInstances));
|
238 | });
|
239 | obsRes
|
240 | .do(function () { return log("\t\u2319 Flow execution is done, running teardown methods...", 'green'); })
|
241 | .flatMap(function () {
|
242 | return rxjs_1.Observable.merge.apply(rxjs_1.Observable, teardownInstances.map(function (tearndownFn) { return tearndownFn(); }));
|
243 | })
|
244 | .subscribe(function () {
|
245 | setTimeout(resolve, 100);
|
246 | }, function (e) {
|
247 | setTimeout(function () {
|
248 | reject(e);
|
249 | }, 100);
|
250 | });
|
251 | });
|
252 | });
|
253 | };
|
254 | for (var i = 1; i <= repeatExecution; i++) {
|
255 | _loop_2(i);
|
256 | }
|
257 | });
|
258 | afterAll(function () {
|
259 | reports.saveReport(reports, testName, strestConfig.reporters, path.resolve(process.cwd(), strestConfig.reportDirectory));
|
260 | });
|
261 | });
|
262 | });
|
263 | };
|
264 | exports.addToTestSuite = exports.execute;
|
265 |
|
\ | No newline at end of file |