skutter
Version:
Skutter: Opinionated BDD Browser based test framework
192 lines (191 loc) • 8 kB
JavaScript
;
const Lazy = require("lazy.js");
const fs = require("fs");
const path = require("path");
const reporter_base_1 = require("./reporter-base");
const run_totals_calculator_1 = require("../services/run-totals-calculator");
const result_types_1 = require("../result-aggregator/result-types");
const stop_watch_1 = require("../services/stop-watch");
const step_statuses_1 = require("../result-aggregator/step-statuses");
const directory_maker_1 = require("../services/directory-maker");
class RunDataReporter extends reporter_base_1.ReporterBase {
constructor(outputRootPath) {
super();
this.outputRootPath = outputRootPath;
this._runStartDate = null;
this._stopWatch = new stop_watch_1.StopWatch();
}
runStarting() {
this._stopWatch.start();
this._runStartDate = new Date();
}
runCompleted(results) {
this._stopWatch.stop();
let runEndDate = new Date();
let totals = run_totals_calculator_1.RunTotalsCalculator.get(results);
let json = {
start: this._runStartDate,
end: runEndDate,
status: this.getFeatureStatus(totals.scenarios.passed, totals.scenarios.failed, totals.scenarios.errored, totals.scenarios.skipped),
counts: {
features: {
total: totals.features.total,
passed: totals.features.passed,
failed: totals.features.failed,
errored: totals.features.errored,
skipped: totals.features.skipped
},
scenarios: {
total: totals.scenarios.total,
passed: totals.scenarios.passed,
failed: totals.scenarios.failed,
errored: totals.scenarios.errored,
skipped: totals.scenarios.skipped
}
},
duration: this._stopWatch.elapsedSeconds,
features: []
};
Lazy(results).each((featureResult) => {
let featureData = {
title: featureResult.feature.title,
filename: featureResult.feature.filename,
counts: {
scenarios: {
total: featureResult.feature.scenarios.length,
passed: featureResult.getScenarioCount(result_types_1.ResultTypes.Passed),
failed: featureResult.getScenarioCount(result_types_1.ResultTypes.Failed),
errored: featureResult.getScenarioCount(result_types_1.ResultTypes.Errored),
skipped: featureResult.getScenarioCount(result_types_1.ResultTypes.Skipped)
}
},
duration: featureResult.feature.durationMiliseconds / 1000,
scenarios: [],
setupLog: [],
teardownLog: [],
annotations: featureResult.feature.annotations
};
Lazy(featureResult.feature.scenarios).each((scenario) => {
let scenarioResult = featureResult.findScenarioResult(scenario.id);
let passedSteps = 0;
let failedSteps = 0;
let erroredSteps = 0;
let pendingSteps = 0;
Lazy(scenario.steps).each((step) => {
let stepResult = scenarioResult.findStepResult(step.id);
switch (stepResult.result) {
case step_statuses_1.StepStatuses.Passed:
passedSteps++;
break;
case step_statuses_1.StepStatuses.Failed:
failedSteps++;
break;
case step_statuses_1.StepStatuses.Errored:
erroredSteps++;
break;
case step_statuses_1.StepStatuses.Pending:
pendingSteps++;
break;
}
});
let scenarioData = {
title: scenario.title,
counts: {
steps: {
total: scenario.steps.length,
passed: passedSteps,
failed: failedSteps,
errored: erroredSteps,
pending: pendingSteps
}
},
status: this.getScenarioStatus(passedSteps, failedSteps, erroredSteps, pendingSteps),
duration: scenario.durationMiliseconds / 1000,
steps: [],
setupLog: [],
teardownLog: [],
annotations: scenario.annotations,
};
Lazy(scenario.steps).each((step) => {
let stepResult = scenarioResult.findStepResult(step.id);
let stepData = {
title: step.text,
duration: step.durationMiliseconds / 1000,
status: this.getStepStatus(stepResult.result),
log: stepResult.log,
screenshots: stepResult.screenshots,
depth: 0
};
scenarioData.steps.push(stepData);
Lazy(this.getSubStepData(stepResult.subSteps)).each((subStepResult) => {
let subStepRes = {
title: subStepResult.title,
duration: subStepResult.durationMiliseconds / 1000,
status: this.getStepStatus(subStepResult.result),
log: subStepResult.log,
screenshots: subStepResult.screenshots,
depth: subStepResult.depth
};
scenarioData.steps.push(subStepRes);
});
});
featureData.scenarios.push(scenarioData);
});
json.features.push(featureData);
});
let stringJson = JSON.stringify(json);
let outputDirectory = path.resolve(this.outputRootPath);
let outputFilename = path.join(outputDirectory, "skutter.json");
console.log("Writing 'Skutter.json' results file.");
directory_maker_1.DirectoryMaker.makePath(outputFilename);
fs.writeFileSync(outputFilename, stringJson);
}
getSubStepData(subSteps) {
let data = [];
Lazy(subSteps).each((subStep) => {
data.push(subStep);
Lazy(this.getSubStepData(subStep.subSteps)).each((subSubStep) => {
data.push(subStep);
});
});
return data;
}
getFeatureStatus(passed, failed, errored, skipped) {
if (errored) {
return "errored";
}
if (failed) {
return "failed";
}
if (skipped && !passed) {
return "skipped";
}
return "passed";
}
getScenarioStatus(passed, failed, errored, pending) {
if (errored) {
return "errored";
}
if (failed) {
return "failed";
}
if (pending) {
return "pending";
}
return "passed";
}
getStepStatus(result) {
switch (result) {
case step_statuses_1.StepStatuses.Errored:
return "errored";
case step_statuses_1.StepStatuses.Pending:
return "pending";
case step_statuses_1.StepStatuses.Failed:
return "failed";
case step_statuses_1.StepStatuses.Passed:
return "passed";
}
return "unknown";
}
}
exports.RunDataReporter = RunDataReporter;