WIP on DefaultSummaryPrinter

Author: mpkorstanje

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

@@ -1,21 +1,37 @@
 package io.cucumber.core.plugin;
 
+import io.cucumber.messages.types.Envelope;
+import io.cucumber.messages.types.Snippet;
+import io.cucumber.messages.types.Suggestion;
 import io.cucumber.plugin.ColorAware;
 import io.cucumber.plugin.ConcurrentEventListener;
 import io.cucumber.plugin.event.EventPublisher;
 import io.cucumber.plugin.event.SnippetsSuggestedEvent;
 import io.cucumber.plugin.event.TestRunFinished;
+import io.cucumber.query.Query;
+import io.cucumber.query.Repository;
 
 import java.io.OutputStream;
 import java.io.PrintStream;
+import java.util.Collection;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Locale;
+import java.util.Optional;
 import java.util.Set;
+import java.util.stream.Collectors;
+
+import static io.cucumber.query.Repository.RepositoryFeature.INCLUDE_GHERKIN_DOCUMENT;
+import static io.cucumber.query.Repository.RepositoryFeature.INCLUDE_SUGGESTIONS;
 
 public final class DefaultSummaryPrinter implements ColorAware, ConcurrentEventListener {
 
-    private final Set<String> snippets = new LinkedHashSet<>();
+    private final Repository repository = Repository.builder()
+            .feature(INCLUDE_GHERKIN_DOCUMENT, true)
+            .feature(INCLUDE_SUGGESTIONS, true)
+            .build();
+    private final Query query = new Query(repository);
+
     private final Stats stats;
     private final PrintStream out;
 
@@ -25,20 +41,15 @@ public DefaultSummaryPrinter() {
 
     DefaultSummaryPrinter(OutputStream out, Locale locale) {
         this.out = new PrintStream(out);
-        this.stats = new Stats(locale);
+        this.stats = new Stats(query, locale);
     }
 
     @Override
     public void setEventPublisher(EventPublisher publisher) {
-        stats.setEventPublisher(publisher);
-        publisher.registerHandlerFor(SnippetsSuggestedEvent.class, this::handleSnippetsSuggestedEvent);
+        publisher.registerHandlerFor(Envelope.class, repository::update);
         publisher.registerHandlerFor(TestRunFinished.class, event -> print());
     }
 
-    private void handleSnippetsSuggestedEvent(SnippetsSuggestedEvent event) {
-        this.snippets.addAll(event.getSuggestion().getSnippets());
-    }
-
     private void print() {
         out.println();
         printStats();
@@ -65,15 +76,25 @@ private void printErrors() {
     }
 
     private void printSnippets() {
+        Set<Snippet> snippets = query.findAllTestCaseFinished().stream()
+                .map(query::findPickleBy)
+                .filter(Optional::isPresent)
+                .map(Optional::get)
+                .map(query::findSuggestionsBy)
+                .flatMap(Collection::stream)
+                .map(Suggestion::getSnippets)
+                .flatMap(Collection::stream)
+                .collect(Collectors.toCollection(LinkedHashSet::new));
+
         if (snippets.isEmpty()) {
             return;
         }
 
         out.println();
         out.println("You can implement missing steps with the snippets below:");
         out.println();
-        for (String snippet : snippets) {
-            out.println(snippet);
+        for (Snippet snippet : snippets) {
+            out.println(snippet.getCode());
             out.println();
         }
     }

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

@@ -1,48 +1,40 @@
 package io.cucumber.core.plugin;
 
+import io.cucumber.messages.types.Location;
+import io.cucumber.messages.types.TestStepFinished;
+import io.cucumber.messages.types.TestStepResult;
+import io.cucumber.messages.types.TestStepResultStatus;
 import io.cucumber.plugin.ColorAware;
-import io.cucumber.plugin.ConcurrentEventListener;
-import io.cucumber.plugin.event.EventPublisher;
-import io.cucumber.plugin.event.PickleStepTestStep;
-import io.cucumber.plugin.event.Result;
-import io.cucumber.plugin.event.Status;
-import io.cucumber.plugin.event.TestCase;
-import io.cucumber.plugin.event.TestCaseFinished;
-import io.cucumber.plugin.event.TestRunFinished;
-import io.cucumber.plugin.event.TestRunStarted;
-import io.cucumber.plugin.event.TestStepFinished;
+import io.cucumber.query.Query;
 
 import java.io.PrintStream;
 import java.text.DecimalFormat;
 import java.text.DecimalFormatSymbols;
-import java.time.Duration;
-import java.time.Instant;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import java.util.Locale;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 
 import static io.cucumber.core.plugin.Formats.ansi;
 import static io.cucumber.core.plugin.Formats.monochrome;
 import static java.util.Locale.ROOT;
 import static java.util.concurrent.TimeUnit.SECONDS;
 
-class Stats implements ConcurrentEventListener, ColorAware {
+class Stats implements ColorAware {
 
     private static final long ONE_SECOND = SECONDS.toNanos(1);
     private static final long ONE_MINUTE = 60 * ONE_SECOND;
-    private final SubCounts scenarioSubCounts = new SubCounts();
-    private final SubCounts stepSubCounts = new SubCounts();
+    private final Query query;
     private final Locale locale;
-    private final List<TestCase> failedScenarios = new ArrayList<>();
-    private final List<TestCase> ambiguousScenarios = new ArrayList<>();
-    private final List<TestCase> pendingScenarios = new ArrayList<>();
-    private final List<TestCase> undefinedScenarios = new ArrayList<>();
     private final List<Throwable> errors = new ArrayList<>();
-    private Instant startTime = Instant.EPOCH;
-    private Duration totalDuration = Duration.ZERO;
     private Formats formats = ansi();
 
-    Stats(Locale locale) {
+    Stats(Query query, Locale locale) {
+        this.query = query;
         this.locale = locale;
     }
 
@@ -51,102 +43,14 @@ public void setMonochrome(boolean monochrome) {
         formats = monochrome ? monochrome() : ansi();
     }
 
-    @Override
-    public void setEventPublisher(EventPublisher publisher) {
-        publisher.registerHandlerFor(TestRunStarted.class, this::setStartTime);
-        publisher.registerHandlerFor(TestStepFinished.class, this::addStepResult);
-        publisher.registerHandlerFor(TestCaseFinished.class, this::addScenario);
-        publisher.registerHandlerFor(TestRunFinished.class, this::setFinishTime);
-    }
-
-    private void setStartTime(TestRunStarted event) {
-        setStartTime(event.getInstant());
-    }
-
-    private void addStepResult(TestStepFinished event) {
-        Result result = event.getResult();
-        if (result.getError() != null) {
-            addError(result.getError());
-        }
-        if (event.getTestStep() instanceof PickleStepTestStep) {
-            addStep(result.getStatus());
-        }
-    }
-
-    private void addScenario(TestCaseFinished event) {
-        TestCase testCase = event.getTestCase();
-        addScenario(event.getResult().getStatus(), testCase);
-    }
-
-    private void setFinishTime(TestRunFinished event) {
-        setFinishTime(event.getInstant());
-    }
-
-    void setStartTime(Instant startTime) {
-        this.startTime = startTime;
-    }
-
-    private void addError(Throwable error) {
-        errors.add(error);
-    }
-
-    void addStep(Status resultStatus) {
-        addResultToSubCount(stepSubCounts, resultStatus);
-    }
-
-    void addScenario(Status resultStatus, TestCase testCase) {
-        addResultToSubCount(scenarioSubCounts, resultStatus);
-        switch (resultStatus) {
-            case FAILED:
-                failedScenarios.add(testCase);
-                break;
-            case AMBIGUOUS:
-                ambiguousScenarios.add(testCase);
-                break;
-            case PENDING:
-                pendingScenarios.add(testCase);
-                break;
-            case UNDEFINED:
-                undefinedScenarios.add(testCase);
-                break;
-            default:
-                // intentionally left blank
-        }
-    }
-
-    void setFinishTime(Instant finishTime) {
-        this.totalDuration = Duration.between(startTime, finishTime);
-    }
-
-    private void addResultToSubCount(SubCounts subCounts, Status resultStatus) {
-        switch (resultStatus) {
-            case FAILED:
-                subCounts.failed++;
-                break;
-            case AMBIGUOUS:
-                subCounts.ambiguous++;
-                break;
-            case PENDING:
-                subCounts.pending++;
-                break;
-            case UNDEFINED:
-                subCounts.undefined++;
-                break;
-            case SKIPPED:
-                subCounts.skipped++;
-                break;
-            default:
-                subCounts.passed++;
-        }
-    }
-
     public List<Throwable> getErrors() {
         return errors;
     }
 
     void printStats(PrintStream out) {
         printNonZeroResultScenarios(out);
-        if (stepSubCounts.getTotal() == 0) {
+        List<TestStepFinished> testStepFinished = query.findAllTestStepFinished();
+        if (testStepFinished.isEmpty()) {
             out.println("0 Scenarios");
             out.println("0 Steps");
         } else {
@@ -157,30 +61,42 @@ void printStats(PrintStream out) {
     }
 
     private void printStepCounts(PrintStream out) {
-        out.print(stepSubCounts.getTotal());
+        List<io.cucumber.messages.types.TestStepFinished> testStepsFinished = query.findAllTestStepFinished();
+        Map<TestStepResultStatus, Long> testStepResultStatus = query.countMostSevereTestStepResultStatus();
+
+        out.print(testStepsFinished.size());
         out.print(" Steps (");
-        printSubCounts(out, stepSubCounts);
+        printSubCounts(out, testStepResultStatus);
         out.println(")");
     }
 
     private void printScenarioCounts(PrintStream out) {
-        out.print(scenarioSubCounts.getTotal());
+        Map<TestStepResultStatus, Long> scenarioSubCounts = query.findAllTestCaseFinished()
+                .stream()
+                .map(query::findMostSevereTestStepResultBy)
+                .filter(Optional::isPresent)
+                .map(Optional::get)
+                .map(TestStepResult::getStatus)
+                .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
+
+        out.print(query.findAllTestCaseFinished().size());
         out.print(" Scenarios (");
         printSubCounts(out, scenarioSubCounts);
         out.println(")");
     }
 
-    private void printSubCounts(PrintStream out, SubCounts subCounts) {
+    private void printSubCounts(PrintStream out, Map<TestStepResultStatus, Long> subCounts) {
         boolean addComma = false;
-        addComma = printSubCount(out, subCounts.failed, Status.FAILED, addComma);
-        addComma = printSubCount(out, subCounts.ambiguous, Status.AMBIGUOUS, addComma);
-        addComma = printSubCount(out, subCounts.skipped, Status.SKIPPED, addComma);
-        addComma = printSubCount(out, subCounts.pending, Status.PENDING, addComma);
-        addComma = printSubCount(out, subCounts.undefined, Status.UNDEFINED, addComma);
-        addComma = printSubCount(out, subCounts.passed, Status.PASSED, addComma);
+        addComma = printSubCount(out, subCounts, TestStepResultStatus.FAILED, addComma);
+        addComma = printSubCount(out, subCounts, TestStepResultStatus.AMBIGUOUS, addComma);
+        addComma = printSubCount(out, subCounts, TestStepResultStatus.SKIPPED, addComma);
+        addComma = printSubCount(out, subCounts, TestStepResultStatus.PENDING, addComma);
+        addComma = printSubCount(out, subCounts, TestStepResultStatus.UNDEFINED, addComma);
+        addComma = printSubCount(out, subCounts, TestStepResultStatus.PASSED, addComma);
     }
 
-    private boolean printSubCount(PrintStream out, int count, Status type, boolean addComma) {
+    private boolean printSubCount(PrintStream out, Map<TestStepResultStatus, Long> subCounts, TestStepResultStatus type, boolean addComma) {
+        long count = subCounts.getOrDefault(type, 0L);
         if (count != 0) {
             if (addComma) {
                 out.print(", ");
@@ -193,50 +109,44 @@ private boolean printSubCount(PrintStream out, int count, Status type, boolean a
     }
 
     private void printDuration(PrintStream out) {
-        out.print(String.format("%dm", (totalDuration.toNanos() / ONE_MINUTE)));
-        DecimalFormat format = new DecimalFormat("0.000", new DecimalFormatSymbols(locale));
-        out.println(format.format(((double) (totalDuration.toNanos() % ONE_MINUTE) / ONE_SECOND)) + "s");
+        query.findTestRunDuration().ifPresent(duration -> {
+            out.printf("%dm", (duration.toNanos() / ONE_MINUTE));
+            DecimalFormat format = new DecimalFormat("0.000", new DecimalFormatSymbols(locale));
+            out.println(format.format(((double) (duration.toNanos() % ONE_MINUTE) / ONE_SECOND)) + "s");            
+        });
     }
 
     private void printNonZeroResultScenarios(PrintStream out) {
-        printScenarios(out, failedScenarios, Status.FAILED);
-        printScenarios(out, ambiguousScenarios, Status.AMBIGUOUS);
-        printScenarios(out, pendingScenarios, Status.PENDING);
-        printScenarios(out, undefinedScenarios, Status.UNDEFINED);
+        Map<TestStepResultStatus, List<io.cucumber.messages.types.TestCaseFinished>> testCaseFinishedByStatus = query.findAllTestCaseFinished()
+                .stream()
+                .collect(Collectors.groupingBy(testCaseFinished -> query.findMostSevereTestStepResultBy(testCaseFinished).map(TestStepResult::getStatus).orElse(TestStepResultStatus.UNKNOWN)));
+
+        printScenarios(out, testCaseFinishedByStatus, TestStepResultStatus.FAILED);
+        printScenarios(out, testCaseFinishedByStatus, TestStepResultStatus.AMBIGUOUS);
+        printScenarios(out, testCaseFinishedByStatus, TestStepResultStatus.PENDING);
+        printScenarios(out, testCaseFinishedByStatus, TestStepResultStatus.UNDEFINED);
     }
 
-    private void printScenarios(PrintStream out, List<TestCase> scenarios, Status type) {
+    private void printScenarios(PrintStream out, Map<TestStepResultStatus, List<io.cucumber.messages.types.TestCaseFinished>> testCaseFinishedByStatus, TestStepResultStatus type) {
+        List<io.cucumber.messages.types.TestCaseFinished> scenarios = testCaseFinishedByStatus.getOrDefault(type, Collections.emptyList());
         Format format = formats.get(type.name().toLowerCase(ROOT));
         if (!scenarios.isEmpty()) {
             out.println(format.text(firstLetterCapitalizedName(type) + " scenarios:"));
         }
-        for (TestCase scenario : scenarios) {
-            String location = scenario.getUri() + ":" + scenario.getLocation().getLine();
-            out.println(location + " # " + scenario.getName());
+        for (io.cucumber.messages.types.TestCaseFinished testCaseFinished : scenarios) {
+            query.findPickleBy(testCaseFinished).ifPresent(pickle -> {
+                String location = pickle.getUri() + query.findLocationOf(pickle).map(Location::getLine).map(line -> ":" + line).orElse("");
+                out.println(location + " # " + pickle.getName());                
+            });
         }
         if (!scenarios.isEmpty()) {
             out.println();
         }
     }
 
-    private String firstLetterCapitalizedName(Status status) {
+    private String firstLetterCapitalizedName(TestStepResultStatus status) {
         String name = status.name();
-        return name.substring(0, 1) + name.substring(1).toLowerCase(ROOT);
-    }
-
-    static class SubCounts {
-
-        public int passed = 0;
-        public int failed = 0;
-        public int ambiguous = 0;
-        public int skipped = 0;
-        public int pending = 0;
-        public int undefined = 0;
-
-        int getTotal() {
-            return passed + failed + ambiguous + skipped + pending + undefined;
-        }
-
+        return name.charAt(0) + name.substring(1).toLowerCase(ROOT);
     }
 
 }