Message based rerun formatter

Author: mpkorstanje

cucumber-bom/pom.xml

@@ -20,7 +20,7 @@
         <junit-xml-formatter.version>0.8.0</junit-xml-formatter.version>
         <messages.version>28.0.0</messages.version>
         <pretty-formatter.version>0.3.0</pretty-formatter.version>
-        <query.version>13.5.0</query.version>
+        <query.version>13.5.1-SNAPSHOT</query.version>
         <tag-expressions.version>6.1.2</tag-expressions.version>
         <testng-xml-formatter.version>0.4.0</testng-xml-formatter.version>
     </properties>

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

@@ -1,65 +1,48 @@
 package io.cucumber.core.plugin;
 
 import io.cucumber.core.feature.FeatureWithLines;
+import io.cucumber.messages.types.Envelope;
+import io.cucumber.messages.types.TestCaseFinished;
+import io.cucumber.messages.types.TestStepResult;
+import io.cucumber.messages.types.TestStepResultStatus;
 import io.cucumber.plugin.ConcurrentEventListener;
 import io.cucumber.plugin.event.EventPublisher;
-import io.cucumber.plugin.event.TestCase;
-import io.cucumber.plugin.event.TestCaseFinished;
-import io.cucumber.plugin.event.TestRunFinished;
+import io.cucumber.query.Query;
 
 import java.io.File;
 import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
 import java.net.URI;
 import java.net.URISyntaxException;
-import java.util.ArrayList;
-import java.util.Collection;
+import java.nio.charset.StandardCharsets;
+import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.Map;
+import java.util.Set;
 
 import static io.cucumber.core.feature.FeatureWithLines.create;
+import static java.util.Objects.requireNonNull;
 
 /**
  * Formatter for reporting all failed test cases and print their locations
  * Failed means: results that make the exit code non-zero.
  */
 public final class RerunFormatter implements ConcurrentEventListener {
 
-    private final UTF8PrintWriter out;
-    private final Map<URI, Collection<Integer>> featureAndFailedLinesMapping = new LinkedHashMap<>();
+    private final PrintWriter writer;
+    private final Map<String, Set<Integer>> featureAndFailedLinesMapping = new LinkedHashMap<>();
+    private final Query query = new Query();
 
     public RerunFormatter(OutputStream out) {
-        this.out = new UTF8PrintWriter(out);
+        this.writer = createPrintWriter(out);
     }
 
-    @Override
-    public void setEventPublisher(EventPublisher publisher) {
-        publisher.registerHandlerFor(TestCaseFinished.class, this::handleTestCaseFinished);
-        publisher.registerHandlerFor(TestRunFinished.class, event -> finishReport());
-    }
-
-    private void handleTestCaseFinished(TestCaseFinished event) {
-        if (!event.getResult().getStatus().isOk()) {
-            recordTestFailed(event.getTestCase());
-        }
-    }
-
-    private void finishReport() {
-        for (Map.Entry<URI, Collection<Integer>> entry : featureAndFailedLinesMapping.entrySet()) {
-            FeatureWithLines featureWithLines = create(relativize(entry.getKey()), entry.getValue());
-            out.println(featureWithLines.toString());
-        }
-
-        out.close();
-    }
-
-    private void recordTestFailed(TestCase testCase) {
-        URI uri = testCase.getUri();
-        Collection<Integer> failedTestCaseLines = getFailedTestCaseLines(uri);
-        failedTestCaseLines.add(testCase.getLocation().getLine());
-    }
-
-    private Collection<Integer> getFailedTestCaseLines(URI uri) {
-        return featureAndFailedLinesMapping.computeIfAbsent(uri, k -> new ArrayList<>());
+    private static PrintWriter createPrintWriter(OutputStream out) {
+        return new PrintWriter(
+            new OutputStreamWriter(
+                requireNonNull(out),
+                StandardCharsets.UTF_8));
     }
 
     static URI relativize(URI uri) {
@@ -79,4 +62,46 @@ static URI relativize(URI uri) {
             throw new IllegalArgumentException(e.getMessage(), e);
         }
     }
+
+    @Override
+    public void setEventPublisher(EventPublisher publisher) {
+        publisher.registerHandlerFor(Envelope.class, event -> {
+            query.update(event);
+            event.getTestCaseFinished().ifPresent(this::handleTestCaseFinished);
+            event.getTestRunFinished().ifPresent(testRunFinished -> finishReport());
+        });
+    }
+
+    private void handleTestCaseFinished(TestCaseFinished event) {
+        TestStepResultStatus testStepResultStatus = query.findMostSevereTestStepResultBy(event)
+                .map(TestStepResult::getStatus)
+                // By definition
+                .orElse(TestStepResultStatus.PASSED);
+
+        if (testStepResultStatus == TestStepResultStatus.PASSED
+                || testStepResultStatus == TestStepResultStatus.SKIPPED) {
+            return;
+        }
+
+        query.findPickleBy(event).ifPresent(pickle -> {
+            Set<Integer> lines = featureAndFailedLinesMapping
+                    .computeIfAbsent(pickle.getUri(), s -> new HashSet<>());
+            query.findLocationOf(pickle).ifPresent(location -> {
+                // TODO: Messages are silly
+                lines.add((int) (long) location.getLine());
+            });
+        });
+    }
+
+    private void finishReport() {
+        for (Map.Entry<String, Set<Integer>> entry : featureAndFailedLinesMapping.entrySet()) {
+            String key = entry.getKey();
+            // TODO: Should these be relative?
+            FeatureWithLines featureWithLines = create(relativize(URI.create(key)), entry.getValue());
+            writer.println(featureWithLines);
+        }
+
+        writer.close();
+    }
+
 }