skutter
Version:
Skutter: Opinionated BDD Browser based test framework
186 lines (185 loc) • 8.3 kB
JavaScript
"use strict";
const Lazy = require("lazy.js");
const result_types_1 = require("./result-types");
const sub_step_result_1 = require("./sub-step-result");
class ResultAggregator {
constructor(featureInfoProvider, featureResultFactory, reporters) {
this.featureInfoProvider = featureInfoProvider;
this.featureResultFactory = featureResultFactory;
this.featureResults = new Map();
this.reporters = reporters;
this.nonStepErrors = [];
}
ensureFeature(threadId, featureId) {
let featureResult = this.featureResults.get(featureId);
if (featureResult) {
return featureResult;
}
else {
this.featureStarted(threadId, featureId);
}
return this.featureResults.get(featureId);
}
featureStarted(threadId, featureId) {
let feature = this.featureInfoProvider.getFeature(featureId);
this.featureResults.set(featureId, this.featureResultFactory.create(feature));
feature.start();
for (let reporter of this.reporters) {
reporter.onFeatureStart(threadId, featureId);
}
}
featureSkipped(threadId, featureId) {
let feature = this.featureInfoProvider.getFeature(featureId);
let featureResult = this.featureResultFactory.create(feature);
featureResult.setSkipped();
this.featureResults.set(featureId, featureResult);
for (let reporter of this.reporters) {
reporter.onFeatureSkipped(threadId, featureId);
}
}
scenarioStarted(threadId, featureId, scenarioId) {
let featureResult = this.ensureFeature(threadId, featureId);
let scenarioResult = featureResult.findScenarioResult(scenarioId);
scenarioResult.scenario.start();
for (let reporter of this.reporters) {
reporter.onScenarioStart(threadId, featureId, scenarioId);
}
}
scenarioSkipped(threadId, featureId, scenarioId) {
let featureResult = this.ensureFeature(threadId, featureId);
let scenarioResult = featureResult.findScenarioResult(scenarioId);
scenarioResult.setSkipped();
for (let reporter of this.reporters) {
reporter.onScenarioSkipped(threadId, featureId, scenarioId);
}
}
stepStarted(threadId, featureId, scenarioId, stepId) {
let featureResult = this.ensureFeature(threadId, featureId);
let scenarioResult = featureResult.findScenarioResult(scenarioId);
let stepResult = scenarioResult.findStepResult(stepId);
stepResult.step.start();
for (let reporter of this.reporters) {
reporter.onBeforeStep(threadId, featureId, scenarioId, stepId);
}
}
stepFinished(threadId, featureId, scenarioId, stepId, result, stepLog, error) {
let featureResult = this.ensureFeature(threadId, featureId);
let scenarioResult = featureResult.findScenarioResult(scenarioId);
let stepResult = scenarioResult.findStepResult(stepId);
stepResult.step.stop();
switch (result) {
case result_types_1.ResultTypes.Passed:
stepResult.setPassed();
break;
case result_types_1.ResultTypes.Failed:
stepResult.setFailed(error);
break;
case result_types_1.ResultTypes.Errored:
stepResult.setError(error);
break;
default:
throw new Error("Unknown result type received.");
}
stepResult.appendLog(stepLog);
for (let reporter of this.reporters) {
reporter.onAfterStep(threadId, featureId, scenarioId, stepId, stepResult);
}
}
subStepStarted(threadId, featureId, scenarioId, ancestorStepId, parentStepId, subStepId, title) {
let featureResult = this.ensureFeature(threadId, featureId);
let scenarioResult = featureResult.findScenarioResult(scenarioId);
let stepResult = scenarioResult.findStepResult(ancestorStepId);
let subStepContainer = stepResult.subSteps;
let depth = 0;
if (ancestorStepId !== parentStepId) {
let containers = Lazy(subStepContainer).map((subStep) => { return subStep.findSubStepResult(parentStepId); }).flatten().compact().toArray();
if (containers && containers.length === 1) {
depth = containers[0].depth;
subStepContainer = containers[0].subSteps;
}
}
subStepContainer.push(new sub_step_result_1.SubStepResult(subStepId, title, depth + 1));
for (let reporter of this.reporters) {
reporter.onBeforeSubStep(threadId, featureId, scenarioId, subStepId, title);
}
}
subStepFinished(threadId, featureId, scenarioId, subStepId, result, stepLog, error) {
let featureResult = this.ensureFeature(threadId, featureId);
let scenarioResult = featureResult.findScenarioResult(scenarioId);
let containers = Lazy(scenarioResult.scenario.steps).map((step) => {
let stepResult = scenarioResult.findStepResult(step.id);
return Lazy(stepResult.subSteps).map((subStepResult) => { return subStepResult.findSubStepResult(subStepId); }).toArray();
}).flatten().compact().toArray();
let subStepResult = null;
if (containers && containers.length === 1) {
subStepResult = containers[0];
}
else {
throw new Error("Unable to locate correct sub step.");
}
switch (result) {
case result_types_1.ResultTypes.Passed:
subStepResult.setPassed();
break;
case result_types_1.ResultTypes.Failed:
subStepResult.setFailed(error);
break;
case result_types_1.ResultTypes.Errored:
subStepResult.setError(error);
break;
default:
throw new Error("Unknown result type received.");
}
subStepResult.appendLog(stepLog);
for (let reporter of this.reporters) {
reporter.onAfterSubStep(threadId, featureId, scenarioId, subStepId, subStepResult);
}
}
scenarioFinished(threadId, featureId, scenarioId) {
let featureResult = this.ensureFeature(threadId, featureId);
let scenarioResult = featureResult.findScenarioResult(scenarioId);
scenarioResult.scenario.stop();
for (let reporter of this.reporters) {
reporter.onAfterScenario(threadId, featureId, scenarioId, scenarioResult.scenario.durationMiliseconds, scenarioResult.result, null);
}
}
featureFinished(threadId, featureId) {
let featureResult = this.ensureFeature(threadId, featureId);
featureResult.feature.stop();
for (let reporter of this.reporters) {
reporter.onAfterFeature(threadId, featureId, featureResult.feature.durationMiliseconds, featureResult.result, null);
}
}
stepScreenshotted(threadId, featureId, scenarioId, stepId, filename) {
let featureResult = this.ensureFeature(threadId, featureId);
let scenarioResult = featureResult.findScenarioResult(scenarioId);
let stepResult = scenarioResult.findStepResult(stepId);
if (!stepResult) {
let containers = Lazy(scenarioResult.scenario.steps).map((step) => {
let stepResult = scenarioResult.findStepResult(step.id);
return Lazy(stepResult.subSteps).map((subStepResult) => { return subStepResult.findSubStepResult(stepId); }).toArray();
}).flatten().compact().toArray();
if (containers && containers.length === 1) {
stepResult = containers[0];
}
else {
throw new Error("Unable to locate correct sub step.");
}
}
stepResult.appendScreenshot(filename);
}
getResults() {
let results = [];
this.featureResults.forEach((value, kay, map) => {
results.push(value);
});
return results;
}
nonStepError(threadId, error) {
this.nonStepErrors.push(error);
}
getErrors() {
return this.nonStepErrors;
}
}
exports.ResultAggregator = ResultAggregator;