diff --git a/.gitignore b/.gitignore index bf5c05e..43b99a5 100644 --- a/.gitignore +++ b/.gitignore @@ -24,3 +24,6 @@ hs_err_pid* # explicit include !gradle/wrapper/gradle-wrapper.jar + +*/target +*/out diff --git a/build.gradle b/build.gradle index af8600f..dea2501 100644 --- a/build.gradle +++ b/build.gradle @@ -4,10 +4,19 @@ version '0.1.4' allprojects { repositories { jcenter() + mavenCentral() } apply plugin: 'maven' apply plugin: 'maven-publish' apply plugin: 'java' + + sourceCompatibility = 1.8 +} + +subprojects{ + dependencies{ + testCompile 'junit:junit:4.12' + } } ext { @@ -42,8 +51,9 @@ buildscript { classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.7' } } + apply plugin: 'com.jfrog.bintray' -sourceCompatibility = 1.8 +//sourceCompatibility = 1.8 task javadocJar(type: Jar, dependsOn: javadoc) { classifier = 'javadoc' @@ -104,45 +114,33 @@ publishing { } // Bintray -Properties properties = new Properties() -properties.load(project.rootProject.file('local.properties').newDataInputStream()) - -bintray { - user = properties.getProperty("bintray.user") - key = properties.getProperty("bintray.apikey") - publications =['MavenPub'] - configurations = ['archives'] - pkg { - repo = bintrayRepo - userOrg = 'testmonkeys' - name = bintrayName - desc = libraryDescription - websiteUrl = siteUrl - vcsUrl = gitUrl - licenses = allLicenses - publish = false - publicDownloadNumbers = true - version { - desc = libraryDescription - gpg { - sign = true //Determines whether to GPG sign the files. The default is false - passphrase = properties.getProperty("bintray.gpg.password") - //Optional. The passphrase for GPG signing' - } - } - } -} - - +//Properties properties = new Properties() +//properties.load(project.rootProject.file('local.properties').newDataInputStream()) +// +//bintray { +// user = properties.getProperty("bintray.user") +// key = properties.getProperty("bintray.apikey") +// publications =['MavenPub'] +// configurations = ['archives'] +// pkg { +// repo = bintrayRepo +// userOrg = 'testmonkeys' +// name = bintrayName +// desc = libraryDescription +// websiteUrl = siteUrl +// vcsUrl = gitUrl +// licenses = allLicenses +// publish = false +// publicDownloadNumbers = true +// version { +// desc = libraryDescription +// gpg { +// sign = true //Determines whether to GPG sign the files. The default is false +// passphrase = properties.getProperty("bintray.gpg.password") +// //Optional. The passphrase for GPG signing' +// } +// } +// } +//} -repositories { - mavenCentral() -} - -dependencies { - compile 'info.cukes:gherkin:2.12.2','info.cukes:gherkin-jvm-deps:1.0.3' - testCompile 'junit:junit:4.11', - 'info.cukes:cucumber-java:1.2.4', - 'info.cukes:cucumber-junit:1.2.4' -} diff --git a/cucumber1-formatter/build.gradle b/cucumber1-formatter/build.gradle new file mode 100644 index 0000000..2ad76d9 --- /dev/null +++ b/cucumber1-formatter/build.gradle @@ -0,0 +1,9 @@ +group 'org.testmonkeys' +version '0.1.4' + +dependencies { + compile 'info.cukes:gherkin:2.12.2','info.cukes:gherkin-jvm-deps:1.0.3' + testCompile 'junit:junit:4.11', + 'info.cukes:cucumber-java:1.2.4', + 'info.cukes:cucumber-junit:1.2.4' +} diff --git a/src/main/java/org/testmonkeys/cucumber/ext/formatters/JsonFormatter.java b/cucumber1-formatter/src/main/java/org/testmonkeys/cucumber/ext/formatters/JsonFormatter.java similarity index 94% rename from src/main/java/org/testmonkeys/cucumber/ext/formatters/JsonFormatter.java rename to cucumber1-formatter/src/main/java/org/testmonkeys/cucumber/ext/formatters/JsonFormatter.java index d43b8ff..7913587 100644 --- a/src/main/java/org/testmonkeys/cucumber/ext/formatters/JsonFormatter.java +++ b/cucumber1-formatter/src/main/java/org/testmonkeys/cucumber/ext/formatters/JsonFormatter.java @@ -3,23 +3,13 @@ import gherkin.deps.com.google.gson.Gson; import gherkin.deps.com.google.gson.GsonBuilder; import gherkin.deps.net.iharder.Base64; -import gherkin.formatter.model.Background; -import gherkin.formatter.model.Examples; -import gherkin.formatter.model.Feature; -import gherkin.formatter.model.Match; -import gherkin.formatter.model.Result; -import gherkin.formatter.model.Scenario; -import gherkin.formatter.model.ScenarioOutline; -import gherkin.formatter.model.Step; import gherkin.formatter.Formatter; import gherkin.formatter.Reporter; -import gherkin.formatter.NiceAppendable; +import gherkin.formatter.model.*; import java.io.BufferedWriter; import java.io.File; -import java.io.FileOutputStream; import java.io.FileWriter; -import java.nio.file.Files; import java.util.ArrayList; import java.util.HashMap; import java.util.List; @@ -70,7 +60,7 @@ private enum Phase {step, match, embedding, output, result} * @return the correct step for the current operation based on past method calls to the formatter interface */ private Map getCurrentStep(Phase phase) { - String target = phase.ordinal() <= Phase.match.ordinal()?Phase.match.name():Phase.result.name(); + String target = phase.ordinal() <= Phase.match.ordinal()? Phase.match.name(): Phase.result.name(); Map lastWithValue = null; for (Map stepOrHook : getSteps()) { if (stepOrHook.get(target) == null) { diff --git a/src/main/java/org/testmonkeys/cucumber/ext/formatters/json/PerFeatureFormatter.java b/cucumber1-formatter/src/main/java/org/testmonkeys/cucumber/ext/formatters/json/PerFeatureFormatter.java similarity index 100% rename from src/main/java/org/testmonkeys/cucumber/ext/formatters/json/PerFeatureFormatter.java rename to cucumber1-formatter/src/main/java/org/testmonkeys/cucumber/ext/formatters/json/PerFeatureFormatter.java diff --git a/src/test/java/RunCuke.java b/cucumber1-formatter/src/test/java/RunCuke.java similarity index 100% rename from src/test/java/RunCuke.java rename to cucumber1-formatter/src/test/java/RunCuke.java diff --git a/src/test/java/StepHooks.java b/cucumber1-formatter/src/test/java/StepHooks.java similarity index 100% rename from src/test/java/StepHooks.java rename to cucumber1-formatter/src/test/java/StepHooks.java diff --git a/src/test/resources/Feature1.feature b/cucumber1-formatter/src/test/resources/Feature1.feature similarity index 100% rename from src/test/resources/Feature1.feature rename to cucumber1-formatter/src/test/resources/Feature1.feature diff --git a/src/test/resources/Feature2.feature b/cucumber1-formatter/src/test/resources/Feature2.feature similarity index 100% rename from src/test/resources/Feature2.feature rename to cucumber1-formatter/src/test/resources/Feature2.feature diff --git a/cucumber2-formatter/build.gradle b/cucumber2-formatter/build.gradle new file mode 100644 index 0000000..668f24d --- /dev/null +++ b/cucumber2-formatter/build.gradle @@ -0,0 +1,10 @@ +group 'org.testmonkeys' +version '0.1.4' + +dependencies { + + compile 'io.cucumber:cucumber-core:3.0.2' + + testCompile 'io.cucumber:cucumber-java:3.0.2', + 'io.cucumber:cucumber-junit:3.0.2' +} diff --git a/cucumber2-formatter/src/main/java/org/testmonkeys/cucumber/ext/formatters/Nodes.java b/cucumber2-formatter/src/main/java/org/testmonkeys/cucumber/ext/formatters/Nodes.java new file mode 100644 index 0000000..af028fd --- /dev/null +++ b/cucumber2-formatter/src/main/java/org/testmonkeys/cucumber/ext/formatters/Nodes.java @@ -0,0 +1,48 @@ +package org.testmonkeys.cucumber.ext.formatters; + +public enum Nodes { + + ELEMENTS("elements"), + STEPS("steps"), + MATCH("match"), + RESULT("result"), + URI("uri"), + KEYWORD("keyword"), + NAME("name"), + DESCRIPTION("description"), + LINE("line"), + ID("id"), + TAGS("tags"), + TYPE("type"), + BACKGROUND("background"), + SCENARIO("SCENARIO"), + DOC_STRING("doc_string"), + ROWS("rows"), + VAL("val"), + OFFSET("offset"), + ARGUMENTS("arguments"), + LOCATION("location"), + VALUE("value"), + CONTENT_TYPE("content_type"), + STATUS("status"), + ERROR_MESSAGE("error_message"), + DURATION("duration"), + AFTER("after"), + BEFORE("before"), + CELLS("cells"), + MIME_TYPE("mime_type"), + DATA("data"), + EMBEDDINGS("embeddings"), + OUTPUT("output"); + + public String value; + + Nodes(String value){ + this.value = value; + } + + @Override + public String toString() { + return this.value; + } +} diff --git a/cucumber2-formatter/src/main/java/org/testmonkeys/cucumber/ext/formatters/PerFeatureFormatter.java b/cucumber2-formatter/src/main/java/org/testmonkeys/cucumber/ext/formatters/PerFeatureFormatter.java new file mode 100644 index 0000000..9fe6551 --- /dev/null +++ b/cucumber2-formatter/src/main/java/org/testmonkeys/cucumber/ext/formatters/PerFeatureFormatter.java @@ -0,0 +1,442 @@ +package org.testmonkeys.cucumber.ext.formatters; + +import cucumber.api.*; +import cucumber.api.event.*; +import cucumber.api.formatter.Formatter; +import gherkin.AstBuilder; +import gherkin.Parser; +import gherkin.ParserException; +import gherkin.TokenMatcher; +import gherkin.ast.*; +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.*; + +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileWriter; +import java.util.*; + +import static cucumber.api.HookType.Before; +import static org.testmonkeys.cucumber.ext.formatters.Nodes.*; + +public class PerFeatureFormatter implements Formatter { + + private static Map readEventMap = new HashMap<>(); + private final File outFolder; + private final Gson gson = new GsonBuilder().setPrettyPrinting().create(); + private Map backgroundMap; + private Map currentElementMap; + private Map currentTestCaseMap; + private List> currentStepsList; + private Map currentStepOrHookMap; + private Map currentBeforeStepHookList = new HashMap<>(); + private Map currentFeatureMap; + private Feature currentFeature; + private Background background; + private String currentFeatureUri; + private ScenarioDefinition currentScenario; + private int scenarioCount; + + public PerFeatureFormatter(File outFolder) { + this.outFolder = outFolder; + } + + private static Background getBackgroundForTestCase(Feature feature) { + ScenarioDefinition backgound = feature.getChildren().get(0); + if (backgound instanceof Background) { + return (Background) backgound; + } else { + return null; + } + } + + /* + * Handle methods + * */ + + @Override + public void setEventPublisher(EventPublisher publisher) { + publisher.registerHandlerFor(TestSourceRead.class, this::handleTestSourceRead); + publisher.registerHandlerFor(TestCaseStarted.class, this::handleTestCaseStarted); + publisher.registerHandlerFor(TestStepStarted.class, this::handleTestStepStarted); + publisher.registerHandlerFor(TestStepFinished.class, this::handleTestStepFinished); + publisher.registerHandlerFor(TestRunFinished.class, event -> finishReport()); + publisher.registerHandlerFor(EmbedEvent.class, this::handleEmbedding); + publisher.registerHandlerFor(WriteEvent.class, this::handleWrite); + } + + private void handleTestSourceRead(TestSourceRead event) { + readEventMap.put(event.uri, event); + } + + private void handleTestCaseStarted(TestCaseStarted event) { + List> currentElementsList; + if (currentFeature == null || !currentFeatureUri.equals(event.testCase.getUri())) { + if (currentFeatureUri != null) { + flushCurrentFeature(); + } + currentFeatureUri = event.testCase.getUri(); + currentFeature = getFeature(readEventMap.get(event.testCase.getUri()).source); + currentFeatureMap = createFeatureMap(currentFeature, event.testCase.getUri()); + + background = getBackgroundForTestCase(currentFeature); + if (background != null) + backgroundMap = createBackground(background); + else if (backgroundMap != null) backgroundMap.clear(); + } + + currentElementsList = (List>) currentFeatureMap.get(ELEMENTS.value); + + currentTestCaseMap = createTestCase(event.testCase); + + if (backgroundMap != null && !backgroundMap.isEmpty()) { + backgroundMap.put(STEPS.value, new ArrayList>()); + currentElementMap = backgroundMap; + currentElementsList.add(currentElementMap); + } else + currentElementMap = currentTestCaseMap; + + currentElementsList.add(currentTestCaseMap); + currentStepsList = (List>) currentElementMap.get(STEPS.value); + } + + 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.value); + } + currentStepOrHookMap = createTestStep(testStep); + + if (currentBeforeStepHookList.containsKey(Before.toString())) { + currentStepOrHookMap.put(Before.toString(), currentBeforeStepHookList.get(Before.toString())); + currentBeforeStepHookList.clear(); + } + currentStepsList.add(currentStepOrHookMap); + } else if (event.testStep instanceof HookTestStep) { + HookTestStep hookTestStep = (HookTestStep) event.testStep; + currentStepOrHookMap = new HashMap<>(); + addHookStepToTestCaseMap(currentStepOrHookMap, hookTestStep.getHookType()); + } else { + throw new IllegalStateException(); + } + + } + + private void handleTestStepFinished(TestStepFinished event) { + currentStepOrHookMap.put(MATCH.value, createMatchMap(event.testStep, event.result)); + currentStepOrHookMap.put(RESULT.value, createResultMap(event.result)); + } + + private void handleEmbedding(EmbedEvent event) { + addEmbeddingToHookMap(event.data, event.mimeType); + } + + private void handleWrite(WriteEvent event) { + addOutputToHookMap(event.text); + } + + private void finishReport() { + flushCurrentFeature(); + } + + /* + * Feature processing methods + * */ + public Map createFeatureMap(Feature feature, String uri) { + Map featureMap = new HashMap<>(); + featureMap.put(URI.value, uri); + featureMap.put(ELEMENTS.value, new ArrayList>()); + if (feature != null) { + featureMap.put(KEYWORD.value, feature.getKeyword()); + featureMap.put(NAME.value, feature.getName()); + featureMap.put(DESCRIPTION.value, feature.getDescription() != null ? feature.getDescription() : ""); + featureMap.put(LINE.value, feature.getLocation().getLine()); + featureMap.put(ID.value, convertToId(feature.getName())); + featureMap.put(TAGS.value, feature.getTags()); + + } + return featureMap; + } + + public Feature getFeature(String source) { + Parser parser = new Parser<>(new AstBuilder()); + TokenMatcher matcher = new TokenMatcher(); + GherkinDocument gherkinDocument; + try { + gherkinDocument = parser.parse(source, matcher); + } catch (ParserException e) { + return null; + } + return gherkinDocument.getFeature(); + } + + private void flushCurrentFeature() { + File outFile = new File(outFolder, "Feature" + scenarioCount + "_cucumber.json"); + scenarioCount++; + + createDirectory(outFile); + + try (BufferedWriter writer = new BufferedWriter(new FileWriter(outFile))) { + writer.write(gson.toJson(Collections.singletonList(currentFeatureMap))); + } catch (Exception e) { + e.printStackTrace(); + } + } + + /* + * Background processing methods + * */ + + private void createDirectory(File file) { + try { + if (!outFolder.exists()) + file.getParentFile().mkdirs(); + } catch (Exception e) { + e.printStackTrace(); + } + } + + private Map createBackground(Background background) { + Map map = new HashMap<>(); + map.put(NAME.value, background.getName()); + map.put(LINE.value, background.getLocation().getLine()); + map.put(TYPE.value, BACKGROUND.value); + map.put(KEYWORD.value, background.getKeyword()); + map.put(DESCRIPTION.value, background.getDescription() != null ? background.getDescription() : ""); + map.put(STEPS.value, new ArrayList>()); + return map; + } + + private boolean isBackgroundStep(PickleStepTestStep testStep) { + return this.background.getSteps() + .stream().anyMatch(s -> s.getText().equals(testStep.getStepText()) && + s.getLocation().getLine() == testStep.getStepLine()); + } + + private boolean isFirstStepAfterBackground(PickleStepTestStep testStep) { + return currentElementMap != currentTestCaseMap && !isBackgroundStep(testStep); + } + + /* + * TestCase/Scenario processing methods + * */ + + private Map createTestCase(TestCase testCase) { + Map testCaseMap = new HashMap<>(); + testCaseMap.put(NAME.value, testCase.getName()); + testCaseMap.put(LINE.value, testCase.getLine()); + testCaseMap.put(TYPE.value, SCENARIO.value); + + testCaseMap.put(ID.value, calculateId(testCase)); + currentScenario = getScenario(testCase); + testCaseMap.put(KEYWORD.value, currentScenario.getKeyword()); + testCaseMap.put(DESCRIPTION.value, currentScenario.getDescription() != null ? currentScenario.getDescription() : ""); + + testCaseMap.put(STEPS.value, new ArrayList>()); + if (!testCase.getTags().isEmpty()) { + List> tagList = new ArrayList<>(); + for (PickleTag tag : testCase.getTags()) { + Map tagMap = new HashMap<>(); + tagMap.put(NAME.value, tag.getName()); + tagList.add(tagMap); + } + testCaseMap.put(TAGS.value, tagList); + } + return testCaseMap; + } + + private T getScenario(TestCase testCase) { + List featureScenarios = currentFeature.getChildren(); + for (ScenarioDefinition scenario : featureScenarios) { + if (scenario instanceof Background) { + continue; + } + if (testCase.getLine() == scenario.getLocation().getLine() && testCase.getName().equals(scenario.getName())) { + return (T) scenario; + } else { + if (scenario instanceof ScenarioOutline) { + for (Examples example : ((ScenarioOutline) scenario).getExamples()) { + for (TableRow tableRow : example.getTableBody()) { + if (tableRow.getLocation().getLine() == testCase.getLine()) { + return (T) scenario; + } + } + } + } + } + } + throw new IllegalStateException("Scenario can't be null!"); + } + + private String calculateId(TestCase testCase) { + return currentFeatureMap.get(ID.value) + ";" + convertToId(testCase.getName()) + testCase.getLine(); + } + + /* + * Step processing methods + * */ + + private Map createTestStep(PickleStepTestStep testStep) { + Map stepMap = new HashMap<>(); + stepMap.put(NAME.value, testStep.getStepText()); + stepMap.put(LINE.value, testStep.getStepLine()); + + Optional first = currentScenario.getSteps().stream() + .filter(s -> s.getLocation().getLine() == testStep.getStepLine()).findFirst(); + + if (!first.isPresent() && background != null) { + first = background.getSteps().stream() + .filter(s -> s.getLocation().getLine() == testStep.getStepLine()).findFirst(); + } + + if (!first.isPresent()) { + throw new RuntimeException("Undefined step[" + testStep.getStepText() + "]"); + } + + if (!testStep.getStepArgument().isEmpty()) { + Argument argument = testStep.getStepArgument().get(0); + if (argument instanceof PickleString) { + stepMap.put(DOC_STRING.value, createDocStringMap(argument, first.get())); + } else if (argument instanceof PickleTable) { + stepMap.put(ROWS.value, createDataTableList(argument)); + } + } + + stepMap.put(KEYWORD.value, first.get().getKeyword()); + + return stepMap; + } + + 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.value, argument.getValue()); + argumentMap.put(OFFSET.value, argument.getStart()); + } + argumentList.add(argumentMap); + } + matchMap.put(ARGUMENTS.value, argumentList); + } + } + if (!result.is(Result.Type.UNDEFINED)) { + matchMap.put(LOCATION.value, step.getCodeLocation()); + } + return matchMap; + } + + private Map createDocStringMap(Argument argument, Step step) { + Map docStringMap = new HashMap<>(); + PickleString docString = ((PickleString) argument); + docStringMap.put(VALUE.value, docString.getContent()); + docStringMap.put(LINE.value, docString.getLocation().getLine()); + + docStringMap.put(CONTENT_TYPE.value, ((DocString) step.getArgument()).getContentType()); + + return docStringMap; + } + + private Map createResultMap(Result result) { + Map resultMap = new HashMap<>(); + resultMap.put(STATUS.value, result.getStatus().lowerCaseName()); + if (result.getErrorMessage() != null) { + resultMap.put(ERROR_MESSAGE.value, result.getErrorMessage()); + } + if (result.getDuration() != null && result.getDuration() != 0) { + resultMap.put(DURATION.value, result.getDuration()); + } + return resultMap; + } + + private void addHookStepToTestCaseMap(Map currentStepOrHookMap, HookType hookType) { + String hookName; + if (hookType.toString().contains(AFTER.value)) + hookName = AFTER.value; + else + hookName = BEFORE.value; + + + Map map; + switch (hookType) { + case Before: + map = currentTestCaseMap; + break; + case After: + map = currentTestCaseMap; + break; + case BeforeStep: + map = currentBeforeStepHookList; + break; + case AfterStep: + map = currentStepsList.get(currentStepsList.size() - 1); + break; + default: + map = currentTestCaseMap; + } + + if (!map.containsKey(hookName)) { + map.put(hookName, new ArrayList>()); + } + ((List>) map.get(hookName)).add(currentStepOrHookMap); + } + + private List> createDataTableList(Argument argument) { + List> rowList = new ArrayList<>(); + for (PickleRow row : ((PickleTable) argument).getRows()) { + Map rowMap = new HashMap<>(); + rowMap.put(CELLS.value, 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; + } + + /* + * Embedding/Write processing methods + * */ + private Map createEmbeddingMap(byte[] data, String mimeType) { + Map embedMap = new HashMap<>(); + embedMap.put(MIME_TYPE.value, mimeType); + embedMap.put(DATA.value, Base64.encodeBytes(data)); + return embedMap; + } + + private void addEmbeddingToHookMap(byte[] data, String mimeType) { + if (!currentStepOrHookMap.containsKey(EMBEDDINGS.value)) { + currentStepOrHookMap.put(EMBEDDINGS.value, new ArrayList>()); + } + Map embedMap = createEmbeddingMap(data, mimeType); + ((List>) currentStepOrHookMap.get(EMBEDDINGS.value)).add(embedMap); + } + + private void addOutputToHookMap(String text) { + if (!currentStepOrHookMap.containsKey(OUTPUT.value)) { + currentStepOrHookMap.put(OUTPUT.value, new ArrayList()); + } + ((List) currentStepOrHookMap.get(OUTPUT.value)).add(text); + } + + + public String convertToId(String name) { + return name.replaceAll("[\\s'_,!]", "-").toLowerCase(); + } + +} diff --git a/cucumber2-formatter/src/test/java/RunCuke.java b/cucumber2-formatter/src/test/java/RunCuke.java new file mode 100644 index 0000000..2a1b822 --- /dev/null +++ b/cucumber2-formatter/src/test/java/RunCuke.java @@ -0,0 +1,10 @@ +import cucumber.api.CucumberOptions; +import cucumber.api.junit.Cucumber; +import org.junit.runner.RunWith; + +@RunWith(Cucumber.class) +@CucumberOptions( + features = {"src/test/resources/"}, + plugin = {"org.testmonkeys.cucumber.ext.formatters.PerFeatureFormatter:target/"}) +public class RunCuke { +} diff --git a/cucumber2-formatter/src/test/java/StepHooks.java b/cucumber2-formatter/src/test/java/StepHooks.java new file mode 100644 index 0000000..74f4ce8 --- /dev/null +++ b/cucumber2-formatter/src/test/java/StepHooks.java @@ -0,0 +1,22 @@ +import cucumber.api.java.en.Given; +import cucumber.api.java.en.Then; +import cucumber.api.java.en.When; + +public class StepHooks { + + @Given("something") + public void something(){ + + } + + @When("action") + public void action(){ + + } + + @Then("result") + public void result(){ + + } + +} diff --git a/cucumber2-formatter/src/test/resources/Feature1.feature b/cucumber2-formatter/src/test/resources/Feature1.feature new file mode 100644 index 0000000..1dea962 --- /dev/null +++ b/cucumber2-formatter/src/test/resources/Feature1.feature @@ -0,0 +1,11 @@ +Feature: Test Feature 1 + + Scenario: scenario a + Given something + When action + Then result + + Scenario: scenario b + Given something + When action + Then result \ No newline at end of file diff --git a/cucumber2-formatter/src/test/resources/Feature2.feature b/cucumber2-formatter/src/test/resources/Feature2.feature new file mode 100644 index 0000000..8ecefd1 --- /dev/null +++ b/cucumber2-formatter/src/test/resources/Feature2.feature @@ -0,0 +1,11 @@ +Feature: Test Feature 2 + + Scenario: scenario a + Given something + When action + Then result + + Scenario: scenario b + Given something + When action + Then result \ No newline at end of file diff --git a/settings.gradle b/settings.gradle index b955a73..0cd6bcb 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1 +1,4 @@ rootProject.name = 'cukejvm-ext-formatter' +include 'cucumber1-formatter' +include 'cucumber2-formatter' +