Write test cases in canonical order

Author: mpkorstanje

java/src/test/java/io/cucumber/junitxmlformatter/MessageOrderer.java

@@ -0,0 +1,99 @@
+package io.cucumber.junitxmlformatter;
+
+import io.cucumber.messages.types.Envelope;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+import java.util.function.Consumer;
+
+class MessageOrderer {
+
+    /**
+     * Make test cases deterministically reproducible.
+     */
+    private static final Random random = new Random(202509171740L);
+
+    static Consumer<List<Envelope>> originalOrder() {
+        return envelopes -> {
+        };
+    }
+
+    /**
+     * Simulates parallel execution of testcases by interleaving the
+     * execution of different test cases.
+     */
+    static Consumer<List<Envelope>> simulateParallelExecution() {
+        return messages -> {
+            List<Envelope> testCaseMessagesInSerial = testCasesSubList(messages);
+            List<List<Envelope>> testCaseMessagesGrouped = groupTestCasesIntoBuckets(testCaseMessagesInSerial);
+            List<Envelope> testCaseMessagesInterleaved = interleafMessagesFromTestCases(testCaseMessagesGrouped);
+            replaceAll(testCaseMessagesInSerial, testCaseMessagesInterleaved);
+        };
+    }
+
+    private static void replaceAll(List<Envelope> testCaseMessagesInSerial, List<Envelope> envelopes) {
+        for (int i = 0; i < testCaseMessagesInSerial.size(); i++) {
+            testCaseMessagesInSerial.set(i, envelopes.get(i));
+        }
+    }
+
+    private static List<Envelope> interleafMessagesFromTestCases(List<List<Envelope>> messagesGroupedByTestCase) {
+        List<Envelope> serial = new ArrayList<>();
+        while (!messagesGroupedByTestCase.isEmpty()) {
+            Collections.shuffle(messagesGroupedByTestCase, random);
+            Iterator<List<Envelope>> bucketIterator = messagesGroupedByTestCase.iterator();
+            while (bucketIterator.hasNext()) {
+                List<Envelope> bucket = bucketIterator.next();
+                if (bucket.isEmpty()) {
+                    bucketIterator.remove();
+                } else {
+                    serial.add(bucket.remove(0));
+                }
+            }
+        }
+        return serial;
+    }
+
+    private static List<List<Envelope>> groupTestCasesIntoBuckets(List<Envelope> testCaseMessages) {
+        List<List<Envelope>> buckets = new ArrayList<>();
+        List<Envelope> currentBucket = new ArrayList<>();
+        for (Envelope middleMessage : testCaseMessages) {
+            if (middleMessage.getTestCaseStarted().isPresent()) {
+                buckets.add(currentBucket);
+                currentBucket = new ArrayList<>();
+            }
+            currentBucket.add(middleMessage);
+        }
+        buckets.add(currentBucket);
+        return buckets;
+    }
+
+    private static List<Envelope> testCasesSubList(List<Envelope> messages) {
+        int testRunStartedIndex = findTestRunStartedIndex(messages);
+        int testRunFinishedIndex = findTestRunFinishedIndex(messages);
+        return messages.subList(testRunStartedIndex + 1, testRunFinishedIndex - 1);
+    }
+
+    private static int findTestRunFinishedIndex(List<Envelope> messages) {
+        int testRunFinishedIndex = messages.size() - 1;
+        for (; testRunFinishedIndex >= 0; testRunFinishedIndex--) {
+            if (messages.get(testRunFinishedIndex).getTestRunFinished().isPresent()) {
+                break;
+            }
+        }
+        return testRunFinishedIndex;
+    }
+
+    private static int findTestRunStartedIndex(List<Envelope> messages) {
+        int testRunStartedIndex = 0;
+        for (; testRunStartedIndex < messages.size(); testRunStartedIndex++) {
+            if (messages.get(testRunStartedIndex).getTestRunStarted().isPresent()) {
+                break;
+            }
+        }
+        return testRunStartedIndex;
+    }
+}

java/src/test/java/io/cucumber/junitxmlformatter/MessagesToJunitXmlWriterAcceptanceTest.java

@@ -24,10 +24,13 @@
 import java.util.Comparator;
 import java.util.List;
 import java.util.Objects;
+import java.util.function.Consumer;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import static io.cucumber.junitxmlformatter.Jackson.OBJECT_MAPPER;
+import static io.cucumber.junitxmlformatter.MessageOrderer.simulateParallelExecution;
+import static java.nio.file.Files.readAllBytes;
 import static org.xmlunit.assertj.XmlAssert.assertThat;
 
 class MessagesToJunitXmlWriterAcceptanceTest {
@@ -51,6 +54,16 @@ void test(TestCase testCase) throws IOException {
         Source actual = Input.fromByteArray(bytes.toByteArray()).build();
         assertThat(actual).and(expected).ignoreWhitespace().areIdentical();
     }
+    
+    @ParameterizedTest
+    @MethodSource("acceptance")
+    void testWithSimulatedParallelExecution(TestCase testCase) throws IOException {
+        ByteArrayOutputStream bytes = writeJunitXmlReport(testCase, new ByteArrayOutputStream(), simulateParallelExecution());
+        Source expected = Input.fromPath(testCase.expected).build();
+        Source actual = Input.fromByteArray(bytes.toByteArray()).build();
+        assertThat(actual).and(expected).ignoreWhitespace().areIdentical();
+    }
+
 
     @ParameterizedTest
     @MethodSource("acceptance")
@@ -81,7 +94,7 @@ void validateAgainstSurefire(TestCase testCase) throws IOException {
         Iterable<ValidationProblem> problems = validationResult.getProblems();
         Assertions.assertThat(problems).extracting(ValidationProblem::getMessage).containsAll(expectedProblems);
     }
-
+    
     @ParameterizedTest
     @MethodSource("acceptance")
     @Disabled
@@ -90,19 +103,30 @@ void updateExpectedXmlReportFiles(TestCase testCase) throws IOException {
             writeJunitXmlReport(testCase, out);
         }
     }
-
-    private static <T extends OutputStream> T writeJunitXmlReport(TestCase testCase, T out) throws IOException {
+    
+    private static <T extends OutputStream> T writeJunitXmlReport(TestCase testCase, T out, Consumer<List<Envelope>> orderer) throws IOException {
+        List<Envelope> messages = new ArrayList<>();
         try (InputStream in = Files.newInputStream(testCase.source)) {
             try (NdjsonToMessageIterable envelopes = new NdjsonToMessageIterable(in, deserializer)) {
-                try (MessagesToJunitXmlWriter writer = new MessagesToJunitXmlWriter(out)) {
-                    for (Envelope envelope : envelopes) {
-                        writer.write(envelope);
-                    }
+                for (Envelope envelope : envelopes) {
+                    messages.add(envelope);
                 }
             }
         }
+        orderer.accept(messages);
+
+        try (MessagesToJunitXmlWriter writer = new MessagesToJunitXmlWriter(out)) {
+            for (Envelope envelope : messages) {
+                writer.write(envelope);
+            }
+        }
+        
         return out;
     }
+    
+    private static <T extends OutputStream> T writeJunitXmlReport(TestCase testCase, T out) throws IOException {
+        return writeJunitXmlReport(testCase, out, MessageOrderer.originalOrder());
+    }
 
     static class TestCase {
         private final Path source;