Simplify with better messages

Author: mpkorstanje

cucumber-bom/pom.xml

@@ -15,10 +15,10 @@
     <properties>
         <ci-environment.version>10.0.1</ci-environment.version>
         <cucumber-expressions.version>18.0.1</cucumber-expressions.version>
-        <gherkin.version>33.0.0</gherkin.version>
+        <gherkin.version>33.0.1-SNAPSHOT</gherkin.version>
         <html-formatter.version>21.13.0</html-formatter.version>
         <junit-xml-formatter.version>0.8.0</junit-xml-formatter.version>
-        <messages.version>28.0.0</messages.version>
+        <messages.version>28.0.1-SNAPSHOT</messages.version>
         <pretty-formatter.version>0.3.0</pretty-formatter.version>
         <query.version>13.5.1-SNAPSHOT</query.version>
         <tag-expressions.version>6.1.2</tag-expressions.version>

cucumber-core/src/main/java/io/cucumber/core/plugin/RerunFormatter.java

@@ -2,12 +2,15 @@
 
 import io.cucumber.core.feature.FeatureWithLines;
 import io.cucumber.messages.types.Envelope;
+import io.cucumber.messages.types.Pickle;
+import io.cucumber.messages.types.TestCase;
 import io.cucumber.messages.types.TestCaseFinished;
-import io.cucumber.messages.types.TestStepResult;
+import io.cucumber.messages.types.TestCaseStarted;
+import io.cucumber.messages.types.TestRunFinished;
+import io.cucumber.messages.types.TestStepFinished;
 import io.cucumber.messages.types.TestStepResultStatus;
 import io.cucumber.plugin.ConcurrentEventListener;
 import io.cucumber.plugin.event.EventPublisher;
-import io.cucumber.query.Query;
 
 import java.io.File;
 import java.io.OutputStream;
@@ -16,12 +19,21 @@
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
 import java.util.HashSet;
-import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 
 import static io.cucumber.core.feature.FeatureWithLines.create;
+import static io.cucumber.messages.types.TestStepResultStatus.PASSED;
+import static io.cucumber.messages.types.TestStepResultStatus.SKIPPED;
+import static java.util.Collections.emptyList;
+import static java.util.Comparator.comparing;
 import static java.util.Objects.requireNonNull;
 
 /**
@@ -30,9 +42,9 @@
  */
 public final class RerunFormatter implements ConcurrentEventListener {
 
-    private final PrintWriter writer;
-    private final Map<String, Set<Integer>> featureAndFailedLinesMapping = new LinkedHashMap<>();
     private final Query query = new Query();
+    private final Map<String, Set<Integer>> featureAndFailedLinesMapping = new HashMap<>();
+    private final PrintWriter writer;
 
     public RerunFormatter(OutputStream out) {
         this.writer = createPrintWriter(out);
@@ -68,32 +80,30 @@ public void setEventPublisher(EventPublisher publisher) {
         publisher.registerHandlerFor(Envelope.class, event -> {
             query.update(event);
             event.getTestCaseFinished().ifPresent(this::handleTestCaseFinished);
-            event.getTestRunFinished().ifPresent(testRunFinished -> finishReport());
+            event.getTestRunFinished().ifPresent(this::handleTestRunFinished);
         });
     }
 
+
     private void handleTestCaseFinished(TestCaseFinished event) {
-        TestStepResultStatus testStepResultStatus = query.findMostSevereTestStepResultBy(event)
-                .map(TestStepResult::getStatus)
+        TestStepResultStatus status = query.findMostSevereTestStepResultBy(event)
                 // By definition
-                .orElse(TestStepResultStatus.PASSED);
-
-        if (testStepResultStatus == TestStepResultStatus.PASSED
-                || testStepResultStatus == TestStepResultStatus.SKIPPED) {
+                .orElse(PASSED);
+        if (status == PASSED || status == SKIPPED) {
             return;
         }
-
         query.findPickleBy(event).ifPresent(pickle -> {
-            Set<Integer> lines = featureAndFailedLinesMapping
-                    .computeIfAbsent(pickle.getUri(), s -> new HashSet<>());
-            query.findLocationOf(pickle).ifPresent(location -> {
+            // Adds the entire feature for rerunning
+            Set<Integer> lines = featureAndFailedLinesMapping.computeIfAbsent(pickle.getUri(), s -> new HashSet<>());
+            pickle.getLocation().ifPresent(location -> {
+                // Adds the specific scenarios
                 // TODO: Messages are silly
                 lines.add((int) (long) location.getLine());
             });
         });
     }
 
-    private void finishReport() {
+    private void handleTestRunFinished(TestRunFinished testRunFinished) {
         for (Map.Entry<String, Set<Integer>> entry : featureAndFailedLinesMapping.entrySet()) {
             String key = entry.getKey();
             // TODO: Should these be relative?
@@ -104,4 +114,65 @@ private void finishReport() {
         writer.close();
     }
 
+    /**
+     * Miniaturized version of Cucumber Query.
+     * <p>
+     * The rerun plugin only needs a few things.
+     */
+    private static class Query {
+
+        private final Map<String, TestCase> testCaseById = new HashMap<>();
+        private final Map<String, List<TestStepResultStatus>> testStepsResultStatusByTestCaseStartedId = new HashMap<>();
+        private final Map<String, TestCaseStarted> testCaseStartedById = new HashMap<>();
+        private final Map<String, Pickle> pickleById = new HashMap<>();
+
+        void update(Envelope envelope) {
+            envelope.getPickle().ifPresent(this::updatePickle);
+            envelope.getTestCase().ifPresent(this::updateTestCase);
+            envelope.getTestCaseStarted().ifPresent(this::updateTestCaseStarted);
+            envelope.getTestStepFinished().ifPresent(this::updateTestStepFinished);
+        }
+
+        private void updatePickle(Pickle event) {
+            pickleById.put(event.getId(), event);
+        }
+
+        private void updateTestCase(TestCase event) {
+            testCaseById.put(event.getId(), event);
+        }
+
+        private void updateTestCaseStarted(TestCaseStarted testCaseStarted) {
+            testCaseStartedById.put(testCaseStarted.getId(), testCaseStarted);
+        }
+
+        private void updateTestStepFinished(TestStepFinished event) {
+            String testCaseStartedId = event.getTestCaseStartedId();
+            testStepsResultStatusByTestCaseStartedId.computeIfAbsent(testCaseStartedId, s -> new ArrayList<>())
+                    .add(event.getTestStepResult().getStatus());
+        }
+
+        public Optional<TestStepResultStatus> findMostSevereTestStepResultBy(TestCaseFinished testCaseFinished) {
+            List<TestStepResultStatus> statuses = testStepsResultStatusByTestCaseStartedId
+                    .getOrDefault(testCaseFinished.getTestCaseStartedId(), emptyList());
+            if (statuses.isEmpty()) {
+                return Optional.empty();
+            }
+            return Optional.of(Collections.max(statuses, comparing(Enum::ordinal)));
+        }
+
+        public Optional<Pickle> findPickleBy(TestCaseFinished testCaseFinished) {
+            String testCaseStartedId = testCaseFinished.getTestCaseStartedId();
+            TestCaseStarted testCaseStarted = testCaseStartedById.get(testCaseStartedId);
+            if (testCaseStarted == null) {
+                return Optional.empty();
+            }
+            TestCase testCase = testCaseById.get(testCaseStarted.getTestCaseId());
+            if (testCase == null) {
+                return Optional.empty();
+            }
+            return Optional.ofNullable(pickleById.get(testCase.getPickleId()));
+        }
+
+    }
+
 }

cucumber-core/src/main/java/io/cucumber/core/plugin/TeamCityPlugin.java

@@ -379,7 +379,7 @@ private static String getHookName(Hook hook) {
     }
 
     private Optional<String> findSnippets(Pickle pickle) {
-        return query.findLocationOf(pickle)
+        return pickle.getLocation()
                 .map(location -> {
                     URI uri = URI.create(pickle.getUri());
                     List<Suggestion> suggestionForTestCase = suggestions.stream()