From 93091309e07f19f510328e4c071df32aa545ae90 Mon Sep 17 00:00:00 2001 From: Nicholas DiPiazza Date: Wed, 5 Feb 2020 11:22:27 -0600 Subject: [PATCH 1/3] new ReducingMethod KEEP_ONLY_LATEST_SCENARIO_RUNS add a new reducer that can keep only the latest scenario run. useful for times when you have flaky scenarios and you do retries on the given scenario, but don't want the flaked attempts to appear in report. --- .../masterthought/cucumber/ReportParser.java | 44 ++ .../cucumber/generators/AbstractPage.java | 1 + .../masterthought/cucumber/json/Element.java | 10 +- .../masterthought/cucumber/json/Feature.java | 4 + .../cucumber/reducers/ReducingMethod.java | 8 +- .../RemoveFailuresDueToRetriesTest.java | 69 ++ src/test/resources/json/with-retries.json | 597 ++++++++++++++++++ 7 files changed, 731 insertions(+), 2 deletions(-) create mode 100644 src/test/java/net/masterthought/cucumber/RemoveFailuresDueToRetriesTest.java create mode 100644 src/test/resources/json/with-retries.json diff --git a/src/main/java/net/masterthought/cucumber/ReportParser.java b/src/main/java/net/masterthought/cucumber/ReportParser.java index 0e1164378..422bf0316 100755 --- a/src/main/java/net/masterthought/cucumber/ReportParser.java +++ b/src/main/java/net/masterthought/cucumber/ReportParser.java @@ -5,6 +5,9 @@ import com.fasterxml.jackson.databind.JsonMappingException; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule; +import com.google.common.collect.Lists; + +import net.masterthought.cucumber.json.Element; import net.masterthought.cucumber.json.Feature; import net.masterthought.cucumber.reducers.ReducingMethod; import org.apache.commons.configuration.ConfigurationException; @@ -22,6 +25,8 @@ import java.util.Arrays; import java.util.Iterator; import java.util.List; +import java.util.ListIterator; +import java.util.Optional; import java.util.logging.Level; import java.util.logging.Logger; @@ -71,6 +76,9 @@ public List parseJsonFiles(List jsonFiles) { continue; } Feature[] features = parseForFeature(jsonFile); + if (configuration.containsReducingMethod(ReducingMethod.KEEP_ONLY_LATEST_SCENARIO_RUNS)) { + keepOnlyLatestScenarioRuns(features); + } LOG.log(Level.INFO, String.format("File '%s' contains %d features", jsonFile, features.length)); featureResults.addAll(Arrays.asList(features)); } @@ -82,6 +90,42 @@ public List parseJsonFiles(List jsonFiles) { return featureResults; } + + /** + * If the JSON file has the same scenarios run multiple times, keep only the + * latest scenario's run. + */ + private void keepOnlyLatestScenarioRuns(Feature[] features) { + for (Feature feature : features) { + Element[] elements = feature.getElements(); + List elementList = Lists.newArrayList(elements); + ListIterator li = elementList.listIterator(elementList.size()); + Optional lastElement = Optional.empty(); + int numRemoved = 0; + while (li.hasPrevious()) { + Element element = li.previous(); + if (lastElement.isPresent() && element.getId().equals(lastElement.get().getId())) { + if (LOG.isLoggable(Level.FINE)) { + LOG.log(Level.FINE, String.format("Reducing method KEEP_ONLY_EARLIEST_SCENARIO_RUNS is removing an earlier test result of scenario %s", feature.getName())); + } + li.remove(); + ++numRemoved; + } else { + addRetryNumberToElmIfNeeded(lastElement, numRemoved); + lastElement = Optional.of(element); + numRemoved = 0; + } + } + addRetryNumberToElmIfNeeded(lastElement, numRemoved); + feature.setElements(elementList.toArray(new Element[0])); + } + } + + private void addRetryNumberToElmIfNeeded(Optional lastElement, int numRemoved) { + if (lastElement.isPresent() && numRemoved > 0) { + lastElement.get().appendToName(" [Retry count " + (numRemoved + 1) + "]"); + } + } /** * Reads passed file and returns parsed features. diff --git a/src/main/java/net/masterthought/cucumber/generators/AbstractPage.java b/src/main/java/net/masterthought/cucumber/generators/AbstractPage.java index aec6631c6..cf6b26a38 100644 --- a/src/main/java/net/masterthought/cucumber/generators/AbstractPage.java +++ b/src/main/java/net/masterthought/cucumber/generators/AbstractPage.java @@ -106,6 +106,7 @@ private void buildGeneralParameters() { context.put("run_with_jenkins", configuration.containsPresentationMode(PresentationMode.RUN_WITH_JENKINS)); context.put("expand_all_steps", configuration.containsPresentationMode(PresentationMode.EXPAND_ALL_STEPS)); context.put("hide_empty_hooks", configuration.containsReducingMethod(ReducingMethod.HIDE_EMPTY_HOOKS)); + context.put("keep_only_earliest_scenario_runs", configuration.containsReducingMethod(ReducingMethod.KEEP_ONLY_LATEST_SCENARIO_RUNS)); context.put("trends_available", configuration.isTrendsAvailable()); context.put("build_project_name", configuration.getProjectName()); diff --git a/src/main/java/net/masterthought/cucumber/json/Element.java b/src/main/java/net/masterthought/cucumber/json/Element.java index ca0a64b8e..218081d99 100644 --- a/src/main/java/net/masterthought/cucumber/json/Element.java +++ b/src/main/java/net/masterthought/cucumber/json/Element.java @@ -15,7 +15,7 @@ public class Element implements Durationable { // Start: attributes from JSON file report private final String id = null; - private final String name = null; + private String name = null; private final String type = null; private final String description = null; private final String keyword = null; @@ -157,4 +157,12 @@ private void calculateDuration() { duration += step.getResult().getDuration(); } } + + /** + * Append a string to the name. + * @param str The string to append. + */ + public void appendToName(String str) { + name += str; + } } diff --git a/src/main/java/net/masterthought/cucumber/json/Feature.java b/src/main/java/net/masterthought/cucumber/json/Feature.java index 7ce8da574..1cbe4a90a 100755 --- a/src/main/java/net/masterthought/cucumber/json/Feature.java +++ b/src/main/java/net/masterthought/cucumber/json/Feature.java @@ -52,6 +52,10 @@ public void addElements(Element[] newElements) { System.arraycopy(newElements, 0, both, elements.length, newElements.length); elements = both; } + + public void setElements(Element[] elements) { + this.elements = elements; + } public Element[] getElements() { return elements; diff --git a/src/main/java/net/masterthought/cucumber/reducers/ReducingMethod.java b/src/main/java/net/masterthought/cucumber/reducers/ReducingMethod.java index f9eb2443e..ef52f934f 100644 --- a/src/main/java/net/masterthought/cucumber/reducers/ReducingMethod.java +++ b/src/main/java/net/masterthought/cucumber/reducers/ReducingMethod.java @@ -71,5 +71,11 @@ public enum ReducingMethod { /** * Does not display hooks (@Before and @After) which do not have attachment or error message. */ - HIDE_EMPTY_HOOKS + HIDE_EMPTY_HOOKS, + + /** + * Keep only the very latest scenario runs. This is useful in situations where you did retries of a + * flaky scenario and the subsequent attempt(s) passed. In this case you will want to disregard the first few failures. + */ + KEEP_ONLY_LATEST_SCENARIO_RUNS } \ No newline at end of file diff --git a/src/test/java/net/masterthought/cucumber/RemoveFailuresDueToRetriesTest.java b/src/test/java/net/masterthought/cucumber/RemoveFailuresDueToRetriesTest.java new file mode 100644 index 000000000..c88dc864d --- /dev/null +++ b/src/test/java/net/masterthought/cucumber/RemoveFailuresDueToRetriesTest.java @@ -0,0 +1,69 @@ +package net.masterthought.cucumber; + +import java.io.File; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.UUID; + +import org.apache.commons.io.FileUtils; +import org.junit.After; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +import net.masterthought.cucumber.json.support.Status; +import net.masterthought.cucumber.presentation.PresentationMode; +import net.masterthought.cucumber.reducers.ReducingMethod; + +public class RemoveFailuresDueToRetriesTest { + private static final String WITH_RETRIES_JSON = "with-retries.json"; + + File reportDir; + File jsonFile; + + @Before + public void before() throws IOException { + File target = new File("target"); + reportDir = new File(target, UUID.randomUUID().toString()); + reportDir.mkdirs(); + jsonFile = new File(reportDir, WITH_RETRIES_JSON); + + FileUtils.copyInputStreamToFile(this.getClass().getResourceAsStream("/json/" + WITH_RETRIES_JSON), jsonFile); + } + + @After + public void after() throws IOException { + FileUtils.deleteDirectory(reportDir); + } + + @Test + public void testRetryRemoval() throws IOException { + + File reportOutputDirectory = reportDir; + List jsonFiles = new ArrayList<>(); + jsonFiles.add(jsonFile.getAbsolutePath()); + + String buildNumber = "1"; + String projectName = "cucumberProject"; + + Configuration configuration = new Configuration(reportOutputDirectory, projectName); + // optional configuration - check javadoc for details + configuration.addPresentationModes(PresentationMode.RUN_WITH_JENKINS); + // do not make scenario failed when step has status SKIPPED + configuration.setNotFailingStatuses(Collections.singleton(Status.SKIPPED)); + configuration.setBuildNumber(buildNumber); + // addidtional metadata presented on main page + configuration.addClassifications("Platform", "Windows"); + configuration.addClassifications("Browser", "Google Chrome"); + configuration.addClassifications("Branch", "release/1.0"); + configuration.addReducingMethod(ReducingMethod.KEEP_ONLY_LATEST_SCENARIO_RUNS); + + + ReportBuilder reportBuilder = new ReportBuilder(jsonFiles, configuration); + Reportable result = reportBuilder.generateReports(); + + Assert.assertEquals("Should not report the retried steps as failures!", 0, result.getFailedSteps()); + } +} diff --git a/src/test/resources/json/with-retries.json b/src/test/resources/json/with-retries.json new file mode 100644 index 000000000..95f101532 --- /dev/null +++ b/src/test/resources/json/with-retries.json @@ -0,0 +1,597 @@ +[ + { + "line": 1, + "elements": [ + { + "start_timestamp": "2020-02-05T15:15:03.527Z", + "before": [ + { + "result": { + "duration": 1957400, + "status": "passed" + }, + "match": { + "location": "IAmGroot.before(Scenario)" + } + }, + { + "result": { + "duration": 14812094400, + "status": "passed" + }, + "match": { + "location": "ServiceHooks.initializeTest(Scenario)" + } + }, + { + "result": { + "duration": 46000, + "status": "passed" + }, + "match": { + "location": "CoolGuyStepDefs.before(Scenario)" + } + }, + { + "result": { + "duration": 25200, + "status": "passed" + }, + "match": { + "location": "MoreStepsDocs.before(Scenario)" + } + }, + { + "result": { + "duration": 22000, + "status": "passed" + }, + "match": { + "location": "MoreStepDepsHereWee.before(Scenario)" + } + }, + { + "result": { + "duration": 19700, + "status": "passed" + }, + "match": { + "location": "IDoctoredThisStepDefs.before(Scenario)" + } + }, + { + "result": { + "duration": 19600, + "status": "passed" + }, + "match": { + "location": "MyGoodnessStepDefs.before(Scenario)" + } + }, + { + "result": { + "duration": 13700, + "status": "passed" + }, + "match": { + "location": "FunPageStepDefinitions.before(Scenario)" + } + }, + { + "result": { + "duration": 16300, + "status": "passed" + }, + "match": { + "location": "RockingStepDefs.before(Scenario)" + } + }, + { + "result": { + "duration": 14100, + "status": "passed" + }, + "match": { + "location": "WoahThisisAStepDef.before(Scenario)" + } + }, + { + "result": { + "duration": 44900, + "status": "passed" + }, + "match": { + "location": "GoodGoshStepDefs.before(Scenario)" + } + }, + { + "result": { + "duration": 11200, + "status": "passed" + }, + "match": { + "location": "NavigationBarDefinitions.before(Scenario)" + } + }, + { + "result": { + "duration": 15200, + "status": "passed" + }, + "match": { + "location": "NeatStepDefs.before(Scenario)" + } + } + ], + "line": 11, + "name": "My Accounts - My Page: Main form is ready", + "description": "", + "id": "my-page;my-accounts---my-page:-main-form-is-ready;;2", + "after": [ + { + "embeddings": [ + { + "data": "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", + "mime_type": "image/png" + } + ], + "result": { + "duration": 5652853000, + "status": "passed" + }, + "match": { + "location": "ServiceHooks.embedScreenshot(Scenario)" + } + } + ], + "type": "scenario", + "keyword": "Scenario Outline", + "steps": [ + { + "result": { + "duration": 12733256400, + "status": "passed" + }, + "line": 5, + "name": "the user logs in to the my page and impersonates MYUSER", + "match": { + "arguments": [ + { + "val": "MYUSER", + "offset": 52 + } + ], + "location": "NeatStepDefs.the_user_login_into_my_portal_and_Impersonates_an_User(String)" + }, + "keyword": "Given " + }, + { + "result": { + "duration": 1103957300, + "status": "passed" + }, + "line": 6, + "name": "Clicks on the My Page link", + "match": { + "location": "RockingStepDefs.click_on_message_center_link()" + }, + "keyword": "When " + }, + { + "result": { + "error_message": "java.lang.AssertionError: Fail!\r\n\tat org.testng.Assert.fail(Assert.java:94)\r\n", + "duration": 2660540700, + "status": "failed" + }, + "line": 7, + "name": "the My Page main form is ready", + "match": { + "location": "RockingStepDefs.messageCenterMainFormIsReady()" + }, + "keyword": "Then " + } + ], + "tags": [ + { + "name": "@SmokeTest" + } + ] + }, + { + "start_timestamp": "2020-02-05T15:15:44.411Z", + "before": [ + { + "result": { + "duration": 24900, + "status": "passed" + }, + "match": { + "location": "IAmGroot.before(Scenario)" + } + }, + { + "result": { + "duration": 14444572900, + "status": "passed" + }, + "match": { + "location": "ServiceHooks.initializeTest(Scenario)" + } + }, + { + "result": { + "duration": 20200, + "status": "passed" + }, + "match": { + "location": "CoolGuyStepDefs.before(Scenario)" + } + }, + { + "result": { + "duration": 5900, + "status": "passed" + }, + "match": { + "location": "MoreStepsDocs.before(Scenario)" + } + }, + { + "result": { + "duration": 5900, + "status": "passed" + }, + "match": { + "location": "MoreStepDepsHereWee.before(Scenario)" + } + }, + { + "result": { + "duration": 6300, + "status": "passed" + }, + "match": { + "location": "IDoctoredThisStepDefs.before(Scenario)" + } + }, + { + "result": { + "duration": 4700, + "status": "passed" + }, + "match": { + "location": "MyGoodnessStepDefs.before(Scenario)" + } + }, + { + "result": { + "duration": 5000, + "status": "passed" + }, + "match": { + "location": "FunPageStepDefinitions.before(Scenario)" + } + }, + { + "result": { + "duration": 4500, + "status": "passed" + }, + "match": { + "location": "RockingStepDefs.before(Scenario)" + } + }, + { + "result": { + "duration": 4600, + "status": "passed" + }, + "match": { + "location": "WoahThisisAStepDef.before(Scenario)" + } + }, + { + "result": { + "duration": 4600, + "status": "passed" + }, + "match": { + "location": "GoodGoshStepDefs.before(Scenario)" + } + }, + { + "result": { + "duration": 3700, + "status": "passed" + }, + "match": { + "location": "NavigationBarDefinitions.before(Scenario)" + } + }, + { + "result": { + "duration": 4700, + "status": "passed" + }, + "match": { + "location": "NeatStepDefs.before(Scenario)" + } + } + ], + "line": 11, + "name": "My Accounts - My Page: Main form is ready", + "description": "", + "id": "my-page;my-accounts---my-page:-main-form-is-ready;;2", + "after": [ + { + "embeddings": [ + { + "data": "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", + "mime_type": "image/png" + } + ], + "result": { + "duration": 6946694600, + "status": "passed" + }, + "match": { + "location": "ServiceHooks.embedScreenshot(Scenario)" + } + } + ], + "type": "scenario", + "keyword": "Scenario Outline", + "steps": [ + { + "result": { + "duration": 11811818900, + "status": "passed" + }, + "line": 5, + "name": "the user logs in to the my page and impersonates MYUSER", + "match": { + "arguments": [ + { + "val": "MYUSER", + "offset": 52 + } + ], + "location": "NeatStepDefs.the_user_login_into_my_portal_and_Impersonates_an_User(String)" + }, + "keyword": "Given " + }, + { + "result": { + "duration": 1025320300, + "status": "passed" + }, + "line": 6, + "name": "Clicks on the My Page link", + "match": { + "location": "RockingStepDefs.click_on_message_center_link()" + }, + "keyword": "When " + }, + { + "result": { + "error_message": "java.lang.AssertionError: Fail!\r\n\tat org.testng.Assert.fail(Assert.java:94)\r\n", + "duration": 220443351600, + "status": "failed" + }, + "line": 7, + "name": "the My Page main form is ready", + "match": { + "location": "RockingStepDefs.messageCenterMainFormIsReady()" + }, + "keyword": "Then " + } + ], + "tags": [ + { + "name": "@SmokeTest" + } + ] + }, + { + "start_timestamp": "2020-02-05T15:19:59.084Z", + "before": [ + { + "result": { + "duration": 29900, + "status": "passed" + }, + "match": { + "location": "IAmGroot.before(Scenario)" + } + }, + { + "result": { + "duration": 14668076700, + "status": "passed" + }, + "match": { + "location": "ServiceHooks.initializeTest(Scenario)" + } + }, + { + "result": { + "duration": 29100, + "status": "passed" + }, + "match": { + "location": "CoolGuyStepDefs.before(Scenario)" + } + }, + { + "result": { + "duration": 6500, + "status": "passed" + }, + "match": { + "location": "MoreStepsDocs.before(Scenario)" + } + }, + { + "result": { + "duration": 6600, + "status": "passed" + }, + "match": { + "location": "MoreStepDepsHereWee.before(Scenario)" + } + }, + { + "result": { + "duration": 6900, + "status": "passed" + }, + "match": { + "location": "IDoctoredThisStepDefs.before(Scenario)" + } + }, + { + "result": { + "duration": 5200, + "status": "passed" + }, + "match": { + "location": "MyGoodnessStepDefs.before(Scenario)" + } + }, + { + "result": { + "duration": 5400, + "status": "passed" + }, + "match": { + "location": "FunPageStepDefinitions.before(Scenario)" + } + }, + { + "result": { + "duration": 4900, + "status": "passed" + }, + "match": { + "location": "RockingStepDefs.before(Scenario)" + } + }, + { + "result": { + "duration": 4900, + "status": "passed" + }, + "match": { + "location": "WoahThisisAStepDef.before(Scenario)" + } + }, + { + "result": { + "duration": 5000, + "status": "passed" + }, + "match": { + "location": "GoodGoshStepDefs.before(Scenario)" + } + }, + { + "result": { + "duration": 3700, + "status": "passed" + }, + "match": { + "location": "NavigationBarDefinitions.before(Scenario)" + } + }, + { + "result": { + "duration": 5000, + "status": "passed" + }, + "match": { + "location": "NeatStepDefs.before(Scenario)" + } + } + ], + "line": 11, + "name": "My Accounts - My Page: Main form is ready", + "description": "", + "id": "my-page;my-accounts---my-page:-main-form-is-ready;;2", + "after": [ + { + "embeddings": [ + { + "data": "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", + "mime_type": "image/png" + } + ], + "result": { + "duration": 5692770800, + "status": "passed" + }, + "match": { + "location": "ServiceHooks.embedScreenshot(Scenario)" + } + } + ], + "type": "scenario", + "keyword": "Scenario Outline", + "steps": [ + { + "result": { + "duration": 12232457900, + "status": "passed" + }, + "line": 5, + "name": "the user logs in to the my page and impersonates MYUSER", + "match": { + "arguments": [ + { + "val": "MYUSER", + "offset": 52 + } + ], + "location": "NeatStepDefs.the_user_login_into_my_portal_and_Impersonates_an_User(String)" + }, + "keyword": "Given " + }, + { + "result": { + "duration": 1461029700, + "status": "passed" + }, + "line": 6, + "name": "Clicks on stuff", + "match": { + "location": "RockingStepDefs.click_on_message_center_link()" + }, + "keyword": "When " + }, + { + "result": { + "duration": 466620400, + "status": "passed" + }, + "line": 7, + "name": "the stuff is ready", + "match": { + "location": "RockingStepDefs.messageCenterMainFormIsReady()" + }, + "keyword": "Then " + } + ], + "tags": [ + { + "name": "@SmokeTest" + } + ] + } + ], + "name": "My Page", + "description": "", + "id": "my-page", + "keyword": "Feature", + "uri": "file:src/main/resources/features/MessageCenter.feature", + "tags": [] + } +] \ No newline at end of file From 69d2cb1945e6b10018ebf6aa6848ea33ea6694ea Mon Sep 17 00:00:00 2001 From: Nicholas DiPiazza Date: Wed, 5 Feb 2020 11:32:37 -0600 Subject: [PATCH 2/3] fix unit tests --- .../cucumber/generators/AbstractPageTest.java | 10 +++++----- .../cucumber/generators/ErrorPageTest.java | 2 +- .../cucumber/generators/FailuresOverviewPageTest.java | 2 +- .../cucumber/generators/FeatureReportPageTest.java | 2 +- .../cucumber/generators/FeaturesOverviewPageTest.java | 2 +- .../cucumber/generators/StepsOverviewPageTest.java | 2 +- .../cucumber/generators/TagReportPageTest.java | 2 +- .../cucumber/generators/TagsOverviewPageTest.java | 2 +- .../cucumber/generators/TrendsOverviewPageTest.java | 2 +- 9 files changed, 13 insertions(+), 13 deletions(-) diff --git a/src/test/java/net/masterthought/cucumber/generators/AbstractPageTest.java b/src/test/java/net/masterthought/cucumber/generators/AbstractPageTest.java index 800643b29..b7b342368 100644 --- a/src/test/java/net/masterthought/cucumber/generators/AbstractPageTest.java +++ b/src/test/java/net/masterthought/cucumber/generators/AbstractPageTest.java @@ -121,7 +121,7 @@ public void buildGeneralParameters_AddsCommonProperties() { // then VelocityContext context = page.context; - assertThat(context.getKeys()).hasSize(10); + assertThat(context.getKeys()).hasSize(11); Object obj = context.get("counter"); assertThat(obj).isInstanceOf(Counter.class); @@ -152,7 +152,7 @@ public void buildGeneralParameters_OnInvalidBuildNumber_SkipsBuildPreviousNumber // then VelocityContext context = page.context; - assertThat(context.getKeys()).hasSize(10); + assertThat(context.getKeys()).hasSize(11); assertThat(context.get("build_time")).isNotNull(); } @@ -168,7 +168,7 @@ public void buildGeneralParameters_OnBuildNumber_AddsBuildPreviousNumberProperty // then VelocityContext context = page.context; - assertThat(context.getKeys()).hasSize(10); + assertThat(context.getKeys()).hasSize(11); assertThat(context.get("build_time")).isNotNull(); } @@ -184,7 +184,7 @@ public void buildGeneralParameters_OnErrorPage_AddsExtraProperties() { // then VelocityContext context = page.context; - assertThat(context.getKeys()).hasSize(10); + assertThat(context.getKeys()).hasSize(11); assertThat(context.get("build_previous_number")).isNull(); } @@ -201,7 +201,7 @@ public void buildGeneralParameters_OnInvalidBuildNumber_DoesNotAddPreviousBuildN // then VelocityContext context = page.context; - assertThat(context.getKeys()).hasSize(11); + assertThat(context.getKeys()).hasSize(12); assertThat(context.get("build_previous_number")).isEqualTo(33); } diff --git a/src/test/java/net/masterthought/cucumber/generators/ErrorPageTest.java b/src/test/java/net/masterthought/cucumber/generators/ErrorPageTest.java index 08e7b49d0..5bc7de786 100644 --- a/src/test/java/net/masterthought/cucumber/generators/ErrorPageTest.java +++ b/src/test/java/net/masterthought/cucumber/generators/ErrorPageTest.java @@ -33,7 +33,7 @@ public void prepareReport_AddsCustomProperties() { // then VelocityContext context = page.context; - assertThat(context.getKeys()).hasSize(13); + assertThat(context.getKeys()).hasSize(14); assertThat(context.get("classifications")).isInstanceOf(List.class); assertThat(context.get("output_message")).isEqualTo(ExceptionUtils.getStackTrace(exception)); assertThat(context.get("json_files")).isEqualTo(jsonReports); diff --git a/src/test/java/net/masterthought/cucumber/generators/FailuresOverviewPageTest.java b/src/test/java/net/masterthought/cucumber/generators/FailuresOverviewPageTest.java index c4c9db8bf..2985d0b56 100644 --- a/src/test/java/net/masterthought/cucumber/generators/FailuresOverviewPageTest.java +++ b/src/test/java/net/masterthought/cucumber/generators/FailuresOverviewPageTest.java @@ -62,7 +62,7 @@ public void prepareReport_AddsCustomProperties() { // then VelocityContext context = page.context; - assertThat(context.getKeys()).hasSize(11); + assertThat(context.getKeys()).hasSize(12); List elements = (List) context.get("failures"); assertThat(elements).hasSameElementsAs(failures); diff --git a/src/test/java/net/masterthought/cucumber/generators/FeatureReportPageTest.java b/src/test/java/net/masterthought/cucumber/generators/FeatureReportPageTest.java index 213dcbb65..86771bd38 100644 --- a/src/test/java/net/masterthought/cucumber/generators/FeatureReportPageTest.java +++ b/src/test/java/net/masterthought/cucumber/generators/FeatureReportPageTest.java @@ -48,7 +48,7 @@ public void prepareReport_AddsCustomProperties() { // then VelocityContext context = page.context; - assertThat(context.getKeys()).hasSize(11); + assertThat(context.getKeys()).hasSize(12); assertThat(context.get("feature")).isEqualTo(feature); } diff --git a/src/test/java/net/masterthought/cucumber/generators/FeaturesOverviewPageTest.java b/src/test/java/net/masterthought/cucumber/generators/FeaturesOverviewPageTest.java index 007772548..9afef9cf9 100644 --- a/src/test/java/net/masterthought/cucumber/generators/FeaturesOverviewPageTest.java +++ b/src/test/java/net/masterthought/cucumber/generators/FeaturesOverviewPageTest.java @@ -43,7 +43,7 @@ public void prepareReport_AddsCustomProperties() { // then VelocityContext context = page.context; - assertThat(context.getKeys()).hasSize(13); + assertThat(context.getKeys()).hasSize(14); assertThat(context.get("all_features")).isEqualTo(features); assertThat(context.get("report_summary")).isEqualTo(reportResult.getFeatureReport()); diff --git a/src/test/java/net/masterthought/cucumber/generators/StepsOverviewPageTest.java b/src/test/java/net/masterthought/cucumber/generators/StepsOverviewPageTest.java index 39a43e195..fc81db3e2 100644 --- a/src/test/java/net/masterthought/cucumber/generators/StepsOverviewPageTest.java +++ b/src/test/java/net/masterthought/cucumber/generators/StepsOverviewPageTest.java @@ -44,7 +44,7 @@ public void prepareReport_AddsCustomProperties() { // then VelocityContext context = page.context; - assertThat(context.getKeys()).hasSize(15); + assertThat(context.getKeys()).hasSize(16); assertThat(context.get("all_steps")).isEqualTo(steps); int allOccurrences = 0; diff --git a/src/test/java/net/masterthought/cucumber/generators/TagReportPageTest.java b/src/test/java/net/masterthought/cucumber/generators/TagReportPageTest.java index 0e67f3d59..14d4f9139 100644 --- a/src/test/java/net/masterthought/cucumber/generators/TagReportPageTest.java +++ b/src/test/java/net/masterthought/cucumber/generators/TagReportPageTest.java @@ -45,7 +45,7 @@ public void prepareReport_AddsCustomProperties() { // then VelocityContext context = page.context; - assertThat(context.getKeys()).hasSize(11); + assertThat(context.getKeys()).hasSize(12); assertThat(context.get("tag")).isEqualTo(tag); } } diff --git a/src/test/java/net/masterthought/cucumber/generators/TagsOverviewPageTest.java b/src/test/java/net/masterthought/cucumber/generators/TagsOverviewPageTest.java index 095bc41c7..2de32b14e 100644 --- a/src/test/java/net/masterthought/cucumber/generators/TagsOverviewPageTest.java +++ b/src/test/java/net/masterthought/cucumber/generators/TagsOverviewPageTest.java @@ -45,7 +45,7 @@ public void prepareReport_AddsCustomProperties() { // then VelocityContext context = page.context; - assertThat(context.getKeys()).hasSize(14); + assertThat(context.getKeys()).hasSize(15); assertThat(context.get("all_tags")).isEqualTo(tags); assertThat(context.get("report_summary")).isEqualTo(reportResult.getTagReport()); diff --git a/src/test/java/net/masterthought/cucumber/generators/TrendsOverviewPageTest.java b/src/test/java/net/masterthought/cucumber/generators/TrendsOverviewPageTest.java index be4bb72b9..655eeb519 100644 --- a/src/test/java/net/masterthought/cucumber/generators/TrendsOverviewPageTest.java +++ b/src/test/java/net/masterthought/cucumber/generators/TrendsOverviewPageTest.java @@ -59,7 +59,7 @@ public void prepareReport_AddsCustomProperties() { // then VelocityContext context = page.context; - assertThat(context.getKeys()).hasSize(21); + assertThat(context.getKeys()).hasSize(22); assertThat(context.get("buildNumbers")).isEqualTo(new String[]{"01_first", "other build", "05last"}); assertThat(context.get("failedFeatures")).isEqualTo(new int[]{1, 2, 5}); From f6661469b87e5f5aae663554a130f783c7c6d2bd Mon Sep 17 00:00:00 2001 From: Nicholas DiPiazza Date: Wed, 5 Feb 2020 11:33:55 -0600 Subject: [PATCH 3/3] clean up text --- src/test/resources/json/with-retries.json | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/test/resources/json/with-retries.json b/src/test/resources/json/with-retries.json index 95f101532..b61fc7302 100644 --- a/src/test/resources/json/with-retries.json +++ b/src/test/resources/json/with-retries.json @@ -161,7 +161,7 @@ "offset": 52 } ], - "location": "NeatStepDefs.the_user_login_into_my_portal_and_Impersonates_an_User(String)" + "location": "NeatStepDefs.do_login_as(String)" }, "keyword": "Given " }, @@ -173,7 +173,7 @@ "line": 6, "name": "Clicks on the My Page link", "match": { - "location": "RockingStepDefs.click_on_message_center_link()" + "location": "RockingStepDefs.click_on_mypage()" }, "keyword": "When " }, @@ -186,7 +186,7 @@ "line": 7, "name": "the My Page main form is ready", "match": { - "location": "RockingStepDefs.messageCenterMainFormIsReady()" + "location": "RockingStepDefs.myMainFormIsReady()" }, "keyword": "Then " } @@ -356,7 +356,7 @@ "offset": 52 } ], - "location": "NeatStepDefs.the_user_login_into_my_portal_and_Impersonates_an_User(String)" + "location": "NeatStepDefs.do_login_as(String)" }, "keyword": "Given " }, @@ -368,7 +368,7 @@ "line": 6, "name": "Clicks on the My Page link", "match": { - "location": "RockingStepDefs.click_on_message_center_link()" + "location": "RockingStepDefs.click_on_mypage()" }, "keyword": "When " }, @@ -381,7 +381,7 @@ "line": 7, "name": "the My Page main form is ready", "match": { - "location": "RockingStepDefs.messageCenterMainFormIsReady()" + "location": "RockingStepDefs.myMainFormIsReady()" }, "keyword": "Then " } @@ -551,7 +551,7 @@ "offset": 52 } ], - "location": "NeatStepDefs.the_user_login_into_my_portal_and_Impersonates_an_User(String)" + "location": "NeatStepDefs.do_login_as(String)" }, "keyword": "Given " }, @@ -563,7 +563,7 @@ "line": 6, "name": "Clicks on stuff", "match": { - "location": "RockingStepDefs.click_on_message_center_link()" + "location": "RockingStepDefs.click_on_mypage()" }, "keyword": "When " }, @@ -575,7 +575,7 @@ "line": 7, "name": "the stuff is ready", "match": { - "location": "RockingStepDefs.messageCenterMainFormIsReady()" + "location": "RockingStepDefs.myMainFormIsReady()" }, "keyword": "Then " } @@ -591,7 +591,7 @@ "description": "", "id": "my-page", "keyword": "Feature", - "uri": "file:src/main/resources/features/MessageCenter.feature", + "uri": "file:src/main/resources/features/MyPageArea.feature", "tags": [] } ] \ No newline at end of file