Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
cucumber.runtime.formatter.JSONFormatter Maven / Gradle / Ivy
package cucumber.runtime.formatter;
import cucumber.api.HookTestStep;
import cucumber.api.HookType;
import cucumber.api.Result;
import cucumber.api.TestStep;
import cucumber.api.TestCase;
import cucumber.api.PickleStepTestStep;
import cucumber.api.event.EmbedEvent;
import cucumber.api.event.EventHandler;
import cucumber.api.event.EventPublisher;
import cucumber.api.event.TestCaseStarted;
import cucumber.api.event.TestRunFinished;
import cucumber.api.event.TestSourceRead;
import cucumber.api.event.TestStepFinished;
import cucumber.api.event.TestStepStarted;
import cucumber.api.event.WriteEvent;
import cucumber.api.formatter.Formatter;
import cucumber.api.formatter.NiceAppendable;
import gherkin.ast.Background;
import gherkin.ast.DocString;
import gherkin.ast.Feature;
import gherkin.ast.ScenarioDefinition;
import gherkin.ast.Step;
import gherkin.deps.com.google.gson.Gson;
import gherkin.deps.com.google.gson.GsonBuilder;
import gherkin.deps.net.iharder.Base64;
import gherkin.pickles.Argument;
import gherkin.pickles.PickleCell;
import gherkin.pickles.PickleRow;
import gherkin.pickles.PickleString;
import gherkin.pickles.PickleTable;
import gherkin.pickles.PickleTag;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
final class JSONFormatter implements Formatter {
private String currentFeatureFile;
private List> featureMaps = new ArrayList>();
private List> currentElementsList;
private Map currentElementMap;
private Map currentTestCaseMap;
private List> currentStepsList;
private Map currentStepOrHookMap;
private Map currentBeforeStepHookList = new HashMap();
private final Gson gson = new GsonBuilder().setPrettyPrinting().create();
private final NiceAppendable out;
private final TestSourcesModel testSources = new TestSourcesModel();
private EventHandler testSourceReadHandler = new EventHandler() {
@Override
public void receive(TestSourceRead event) {
handleTestSourceRead(event);
}
};
private EventHandler caseStartedHandler = new EventHandler() {
@Override
public void receive(TestCaseStarted event) {
handleTestCaseStarted(event);
}
};
private EventHandler stepStartedHandler = new EventHandler() {
@Override
public void receive(TestStepStarted event) {
handleTestStepStarted(event);
}
};
private EventHandler stepFinishedHandler = new EventHandler() {
@Override
public void receive(TestStepFinished event) {
handleTestStepFinished(event);
}
};
private EventHandler runFinishedHandler = new EventHandler() {
@Override
public void receive(TestRunFinished event) {
finishReport();
}
};
private EventHandler writeEventhandler = new EventHandler() {
@Override
public void receive(WriteEvent event) {
handleWrite(event);
}
};
private EventHandler embedEventhandler = new EventHandler() {
@Override
public void receive(EmbedEvent event) {
handleEmbed(event);
}
};
@SuppressWarnings("WeakerAccess") // Used by PluginFactory
public JSONFormatter(Appendable out) {
this.out = new NiceAppendable(out);
}
@Override
public void setEventPublisher(EventPublisher publisher) {
publisher.registerHandlerFor(TestSourceRead.class, testSourceReadHandler);
publisher.registerHandlerFor(TestCaseStarted.class, caseStartedHandler);
publisher.registerHandlerFor(TestStepStarted.class, stepStartedHandler);
publisher.registerHandlerFor(TestStepFinished.class, stepFinishedHandler);
publisher.registerHandlerFor(WriteEvent.class, writeEventhandler);
publisher.registerHandlerFor(EmbedEvent.class, embedEventhandler);
publisher.registerHandlerFor(TestRunFinished.class, runFinishedHandler);
}
private void handleTestSourceRead(TestSourceRead event) {
testSources.addTestSourceReadEvent(event.uri, event);
}
private void handleTestCaseStarted(TestCaseStarted event) {
if (currentFeatureFile == null || !currentFeatureFile.equals(event.testCase.getUri())) {
currentFeatureFile = event.testCase.getUri();
Map currentFeatureMap = createFeatureMap(event.testCase);
featureMaps.add(currentFeatureMap);
currentElementsList = (List>) currentFeatureMap.get("elements");
}
currentTestCaseMap = createTestCase(event.testCase);
if (testSources.hasBackground(currentFeatureFile, event.testCase.getLine())) {
currentElementMap = createBackground(event.testCase);
currentElementsList.add(currentElementMap);
} else {
currentElementMap = currentTestCaseMap;
}
currentElementsList.add(currentTestCaseMap);
currentStepsList = (List>) currentElementMap.get("steps");
}
private void handleTestStepStarted(TestStepStarted event) {
if (event.testStep instanceof PickleStepTestStep) {
PickleStepTestStep testStep = (PickleStepTestStep) event.testStep;
if (isFirstStepAfterBackground(testStep)) {
currentElementMap = currentTestCaseMap;
currentStepsList = (List>) currentElementMap.get("steps");
}
currentStepOrHookMap = createTestStep(testStep);
//add beforeSteps list to current step
if (currentBeforeStepHookList.containsKey(HookType.Before.toString())) {
currentStepOrHookMap.put(HookType.Before.toString(), currentBeforeStepHookList.get(HookType.Before.toString()));
currentBeforeStepHookList.clear();
}
currentStepsList.add(currentStepOrHookMap);
} else if(event.testStep instanceof HookTestStep) {
HookTestStep hookTestStep = (HookTestStep) event.testStep;
currentStepOrHookMap = createHookStep(hookTestStep);
addHookStepToTestCaseMap(currentStepOrHookMap, hookTestStep.getHookType());
} else {
throw new IllegalStateException();
}
}
private void handleWrite(WriteEvent event) {
addOutputToHookMap(event.text);
}
private void handleEmbed(EmbedEvent event) {
addEmbeddingToHookMap(event.data, event.mimeType);
}
private void handleTestStepFinished(TestStepFinished event) {
currentStepOrHookMap.put("match", createMatchMap(event.testStep, event.result));
currentStepOrHookMap.put("result", createResultMap(event.result));
}
private void finishReport() {
out.append(gson.toJson(featureMaps));
out.close();
}
private Map createFeatureMap(TestCase testCase) {
Map featureMap = new HashMap();
featureMap.put("uri", testCase.getUri());
featureMap.put("elements", new ArrayList>());
Feature feature = testSources.getFeature(testCase.getUri());
if (feature != null) {
featureMap.put("keyword", feature.getKeyword());
featureMap.put("name", feature.getName());
featureMap.put("description", feature.getDescription() != null ? feature.getDescription() : "");
featureMap.put("line", feature.getLocation().getLine());
featureMap.put("id", TestSourcesModel.convertToId(feature.getName()));
featureMap.put("tags", feature.getTags());
}
return featureMap;
}
private Map createTestCase(TestCase testCase) {
Map testCaseMap = new HashMap();
testCaseMap.put("name", testCase.getName());
testCaseMap.put("line", testCase.getLine());
testCaseMap.put("type", "scenario");
TestSourcesModel.AstNode astNode = testSources.getAstNode(currentFeatureFile, testCase.getLine());
if (astNode != null) {
testCaseMap.put("id", TestSourcesModel.calculateId(astNode));
ScenarioDefinition scenarioDefinition = TestSourcesModel.getScenarioDefinition(astNode);
testCaseMap.put("keyword", scenarioDefinition.getKeyword());
testCaseMap.put("description", scenarioDefinition.getDescription() != null ? scenarioDefinition.getDescription() : "");
}
testCaseMap.put("steps", new ArrayList>());
if (!testCase.getTags().isEmpty()) {
List> tagList = new ArrayList>();
for (PickleTag tag : testCase.getTags()) {
Map tagMap = new HashMap();
tagMap.put("name", tag.getName());
tagList.add(tagMap);
}
testCaseMap.put("tags", tagList);
}
return testCaseMap;
}
private Map createBackground(TestCase testCase) {
TestSourcesModel.AstNode astNode = testSources.getAstNode(currentFeatureFile, testCase.getLine());
if (astNode != null) {
Background background = TestSourcesModel.getBackgroundForTestCase(astNode);
Map testCaseMap = new HashMap();
testCaseMap.put("name", background.getName());
testCaseMap.put("line", background.getLocation().getLine());
testCaseMap.put("type", "background");
testCaseMap.put("keyword", background.getKeyword());
testCaseMap.put("description", background.getDescription() != null ? background.getDescription() : "");
testCaseMap.put("steps", new ArrayList>());
return testCaseMap;
}
return null;
}
private boolean isFirstStepAfterBackground(PickleStepTestStep testStep) {
TestSourcesModel.AstNode astNode = testSources.getAstNode(currentFeatureFile, testStep.getStepLine());
if (astNode != null) {
if (currentElementMap != currentTestCaseMap && !TestSourcesModel.isBackgroundStep(astNode)) {
return true;
}
}
return false;
}
private Map createTestStep(PickleStepTestStep testStep) {
Map stepMap = new HashMap();
stepMap.put("name", testStep.getStepText());
stepMap.put("line", testStep.getStepLine());
TestSourcesModel.AstNode astNode = testSources.getAstNode(currentFeatureFile, testStep.getStepLine());
if (!testStep.getStepArgument().isEmpty()) {
Argument argument = testStep.getStepArgument().get(0);
if (argument instanceof PickleString) {
stepMap.put("doc_string", createDocStringMap(argument, astNode));
} else if (argument instanceof PickleTable) {
stepMap.put("rows", createDataTableList(argument));
}
}
if (astNode != null) {
Step step = (Step) astNode.node;
stepMap.put("keyword", step.getKeyword());
}
return stepMap;
}
private Map createDocStringMap(Argument argument, TestSourcesModel.AstNode astNode) {
Map docStringMap = new HashMap();
PickleString docString = ((PickleString)argument);
docStringMap.put("value", docString.getContent());
docStringMap.put("line", docString.getLocation().getLine());
if (astNode != null) {
docStringMap.put("content_type", ((DocString)((Step)astNode.node).getArgument()).getContentType());
}
return docStringMap;
}
private List> createDataTableList(Argument argument) {
List> rowList = new ArrayList>();
for (PickleRow row : ((PickleTable)argument).getRows()) {
Map rowMap = new HashMap();
rowMap.put("cells", createCellList(row));
rowList.add(rowMap);
}
return rowList;
}
private List createCellList(PickleRow row) {
List cells = new ArrayList();
for (PickleCell cell : row.getCells()) {
cells.add(cell.getValue());
}
return cells;
}
private Map createHookStep(HookTestStep hookTestStep) {
return new HashMap();
}
private void addHookStepToTestCaseMap(Map currentStepOrHookMap, HookType hookType) {
String hookName;
if (hookType.toString().contains("after"))
hookName = "after";
else
hookName = "before";
Map mapToAddTo;
switch (hookType) {
case Before:
mapToAddTo = currentTestCaseMap;
break;
case After:
mapToAddTo = currentTestCaseMap;
break;
case BeforeStep:
mapToAddTo = currentBeforeStepHookList;
break;
case AfterStep:
mapToAddTo = currentStepsList.get(currentStepsList.size() - 1);
break;
default:
mapToAddTo = currentTestCaseMap;
}
if (!mapToAddTo.containsKey(hookName)) {
mapToAddTo.put(hookName, new ArrayList>());
}
((List>)mapToAddTo.get(hookName)).add(currentStepOrHookMap);
}
private void addOutputToHookMap(String text) {
if (!currentStepOrHookMap.containsKey("output")) {
currentStepOrHookMap.put("output", new ArrayList());
}
((List)currentStepOrHookMap.get("output")).add(text);
}
private void addEmbeddingToHookMap(byte[] data, String mimeType) {
if (!currentStepOrHookMap.containsKey("embeddings")) {
currentStepOrHookMap.put("embeddings", new ArrayList>());
}
Map embedMap = createEmbeddingMap(data, mimeType);
((List>)currentStepOrHookMap.get("embeddings")).add(embedMap);
}
private Map createEmbeddingMap(byte[] data, String mimeType) {
Map embedMap = new HashMap();
embedMap.put("mime_type", mimeType);
embedMap.put("data", Base64.encodeBytes(data));
return embedMap;
}
private Map createMatchMap(TestStep step, Result result) {
Map matchMap = new HashMap();
if(step instanceof PickleStepTestStep) {
PickleStepTestStep testStep = (PickleStepTestStep) step;
if (!testStep.getDefinitionArgument().isEmpty()) {
List> argumentList = new ArrayList>();
for (cucumber.api.Argument argument : testStep.getDefinitionArgument()) {
Map argumentMap = new HashMap();
if (argument.getValue() != null) {
argumentMap.put("val", argument.getValue());
argumentMap.put("offset", argument.getStart());
}
argumentList.add(argumentMap);
}
matchMap.put("arguments", argumentList);
}
}
if (!result.is(Result.Type.UNDEFINED)) {
matchMap.put("location", step.getCodeLocation());
}
return matchMap;
}
private Map createResultMap(Result result) {
Map resultMap = new HashMap();
resultMap.put("status", result.getStatus().lowerCaseName());
if (result.getErrorMessage() != null) {
resultMap.put("error_message", result.getErrorMessage());
}
if (result.getDuration() != null && result.getDuration() != 0) {
resultMap.put("duration", result.getDuration());
}
return resultMap;
}
}
