Run the repetitions of a repeated test and the attempts of a retried test through their IterativeTestSuite when tests are run in parallel

Author: sebastianbergmann

phpunit.xml

@@ -53,6 +53,7 @@
             <exclude>tests/end-to-end/parallel/phpt-coverage/_files</exclude>
             <exclude>tests/end-to-end/parallel/phpt-conflicts/_files</exclude>
             <exclude>tests/end-to-end/parallel/phpt-with-classes/_files</exclude>
+            <exclude>tests/end-to-end/parallel/repeat-retry/_files</exclude>
             <exclude>tests/end-to-end/repeat/_files</exclude>
             <exclude>tests/end-to-end/retry/_files</exclude>
             <exclude>tests/end-to-end/self-direct-indirect/_files</exclude>

src/Event/Dispatcher/CollectingDispatcher.php

@@ -9,6 +9,7 @@
  */
 namespace PHPUnit\Event;
 
+use function assert;
 use PHPUnit\Runner\DeprecationCollector\Facade as DeprecationCollector;
 use PHPUnit\Runner\DeprecationCollector\TestTriggeredDeprecationSubscriber;
 
@@ -21,6 +22,7 @@ final class CollectingDispatcher implements Dispatcher
 {
     private EventCollection $events;
     private DirectDispatcher $isolatedDirectDispatcher;
+    private ?EventCollection $collectedEvents = null;
 
     public function __construct(DirectDispatcher $directDispatcher)
     {
@@ -32,6 +34,12 @@ public function __construct(DirectDispatcher $directDispatcher)
 
     public function dispatch(Event $event): void
     {
+        if ($this->collectedEvents !== null) {
+            $this->collectedEvents->add($event);
+
+            return;
+        }
+
         $this->events->add($event);
 
         try {
@@ -41,6 +49,31 @@ public function dispatch(Event $event): void
         }
     }
 
+    /**
+     * Open a collection window: until stopCollectingEvents() is called, events
+     * are diverted into a separate collection instead of being recorded and
+     * dispatched. This mirrors the collection window of the DeferringDispatcher
+     * so that a RetryTestSuite can suppress the events of a failed attempt when
+     * it runs in a process whose event facade was initialized for isolation.
+     */
+    public function startCollectingEvents(): void
+    {
+        assert($this->collectedEvents === null);
+
+        $this->collectedEvents = new EventCollection;
+    }
+
+    public function stopCollectingEvents(): EventCollection
+    {
+        assert($this->collectedEvents !== null);
+
+        $events = $this->collectedEvents;
+
+        $this->collectedEvents = null;
+
+        return $events;
+    }
+
     public function flush(): EventCollection
     {
         $events = $this->events;

src/Event/Facade.php

@@ -24,9 +24,10 @@ final class Facade
 {
     private static ?self $instance = null;
     private Emitter $emitter;
-    private ?TypeMap $typeMap                         = null;
-    private ?DeferringDispatcher $deferringDispatcher = null;
-    private bool $sealed                              = false;
+    private ?TypeMap $typeMap                          = null;
+    private ?DeferringDispatcher $deferringDispatcher  = null;
+    private ?CollectingDispatcher $isolationDispatcher = null;
+    private bool $sealed                               = false;
 
     public static function instance(): self
     {
@@ -108,6 +109,8 @@ public function initForIsolation(HRTime $offset): CollectingDispatcher
 
         $this->sealed = true;
 
+        $this->isolationDispatcher = $dispatcher;
+
         return $dispatcher;
     }
 
@@ -135,20 +138,41 @@ public function collectingEmitter(): CollectingEmitter
 
     public function forward(EventCollection $events): void
     {
-        $dispatcher = $this->deferredDispatcher();
+        if ($this->isolationDispatcher !== null) {
+            $dispatcher = $this->isolationDispatcher;
+        } else {
+            $dispatcher = $this->deferredDispatcher();
+        }
 
         foreach ($events as $event) {
             $dispatcher->dispatch($event);
         }
     }
 
+    /**
+     * In a process whose event facade was initialized for isolation — a
+     * parallel test runner worker, for example — the collection window is
+     * opened on the isolation dispatcher, because that is the dispatcher the
+     * emitter dispatches to there; the deferring dispatcher is unused in such
+     * a process.
+     */
     public function startCollectingEvents(): void
     {
+        if ($this->isolationDispatcher !== null) {
+            $this->isolationDispatcher->startCollectingEvents();
+
+            return;
+        }
+
         $this->deferredDispatcher()->startCollectingEvents();
     }
 
     public function stopCollectingEvents(): EventCollection
     {
+        if ($this->isolationDispatcher !== null) {
+            return $this->isolationDispatcher->stopCollectingEvents();
+        }
+
         return $this->deferredDispatcher()->stopCollectingEvents();
     }
 

src/Framework/RepeatTestSuite.php

@@ -46,6 +46,14 @@ public static function fromTests(string $name, array $tests, int $failureThresho
         return $suite;
     }
 
+    /**
+     * @return positive-int
+     */
+    public function failureThreshold(): int
+    {
+        return $this->failureThreshold;
+    }
+
     /**
      * @param list<Test> $tests
      */

src/Runner/Parallel/PersistentWorker.php

@@ -12,6 +12,7 @@
 use function assert;
 use function base64_encode;
 use function bin2hex;
+use function count;
 use function defined;
 use function file_get_contents;
 use function get_include_path;
@@ -26,6 +27,9 @@
 use function unlink;
 use function var_export;
 use PHPUnit\Event\Facade as EventFacade;
+use PHPUnit\Framework\RepeatTestSuite;
+use PHPUnit\Framework\RetryTestSuite;
+use PHPUnit\Framework\TestCase;
 use PHPUnit\Runner\CodeCoverage;
 use PHPUnit\TextUI\Configuration\Registry as ConfigurationRegistry;
 use PHPUnit\TextUI\Configuration\SourceMapper;
@@ -263,31 +267,43 @@ private function testClassCommand(TestClassWorkUnit $unit, array $offset, string
         $tests = [];
 
         foreach ($unit->tests() as $test) {
-            try {
-                $data            = base64_encode(serialize($test->providedData()));
-                $dependencyInput = base64_encode(serialize($test->dependencyInput()));
-            } catch (Throwable $t) {
-                @unlink($resultFile);
-
-                throw new WorkerException(
-                    sprintf(
-                        'The tests of class %s cannot be run in parallel because their data cannot be serialized: %s',
-                        $unit->className(),
-                        $t->getMessage(),
-                    ),
-                );
+            if ($test instanceof RetryTestSuite) {
+                $aggregated = $test->tests();
+
+                assert(count($aggregated) === 1 && $aggregated[0] instanceof TestCase);
+
+                $tests[] = [
+                    'type'        => 'retry',
+                    'name'        => $test->name(),
+                    'maxAttempts' => $test->maxAttempts(),
+                    'test'        => $this->testDescriptor($aggregated[0], $unit->className(), $resultFile),
+                ];
+
+                continue;
+            }
+
+            if ($test instanceof RepeatTestSuite) {
+                $repetitions = [];
+
+                foreach ($test->tests() as $repetition) {
+                    assert($repetition instanceof TestCase);
+
+                    $repetitions[] = $this->testDescriptor($repetition, $unit->className(), $resultFile);
+                }
+
+                $tests[] = [
+                    'type'             => 'repeat',
+                    'name'             => $test->name(),
+                    'failureThreshold' => $test->failureThreshold(),
+                    'tests'            => $repetitions,
+                ];
+
+                continue;
             }
 
-            $tests[] = [
-                'methodName'       => $test->name(),
-                'data'             => $data,
-                'dataName'         => $test->dataName(),
-                'dependencyInput'  => $dependencyInput,
-                'repetition'       => $test->repetition(),
-                'totalRepetitions' => $test->totalRepetitions(),
-                'attempt'          => $test->attempt(),
-                'maxAttempts'      => $test->maxAttempts(),
-            ];
+            assert($test instanceof TestCase);
+
+            $tests[] = $this->testDescriptor($test, $unit->className(), $resultFile);
         }
 
         return [
@@ -303,6 +319,47 @@ private function testClassCommand(TestClassWorkUnit $unit, array $offset, string
         ];
     }
 
+    /**
+     * The transportable description of a single test case, from which the
+     * worker reconstructs it.
+     *
+     * @param class-string     $className
+     * @param non-empty-string $resultFile
+     *
+     * @throws WorkerException
+     *
+     * @return array<string, mixed>
+     */
+    private function testDescriptor(TestCase $test, string $className, string $resultFile): array
+    {
+        try {
+            $data            = base64_encode(serialize($test->providedData()));
+            $dependencyInput = base64_encode(serialize($test->dependencyInput()));
+        } catch (Throwable $t) {
+            @unlink($resultFile);
+
+            throw new WorkerException(
+                sprintf(
+                    'The tests of class %s cannot be run in parallel because their data cannot be serialized: %s',
+                    $className,
+                    $t->getMessage(),
+                ),
+            );
+        }
+
+        return [
+            'type'             => 'test',
+            'methodName'       => $test->name(),
+            'data'             => $data,
+            'dataName'         => $test->dataName(),
+            'dependencyInput'  => $dependencyInput,
+            'repetition'       => $test->repetition(),
+            'totalRepetitions' => $test->totalRepetitions(),
+            'attempt'          => $test->attempt(),
+            'maxAttempts'      => $test->maxAttempts(),
+        ];
+    }
+
     /**
      * Harvest the result of the unit the worker has just reported as finished.
      */

src/Runner/Parallel/TestClassWorkUnit.php

@@ -9,6 +9,7 @@
  */
 namespace PHPUnit\Runner\Parallel;
 
+use PHPUnit\Framework\IterativeTestSuite;
 use PHPUnit\Framework\TestCase;
 
 /**
@@ -17,6 +18,11 @@
  * #[AfterClass]) and intra-class ordering are preserved when the unit is run by
  * a single worker.
  *
+ * A member of the unit is either a single test case or an IterativeTestSuite
+ * that aggregates the repetitions of a repeated test method or the attempts of
+ * a retried test method; such a suite travels as one atomic member so that its
+ * repetition and retry orchestration runs inside the worker.
+ *
  * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit
  *
  * @internal This class is not covered by the backward compatibility promise for PHPUnit
@@ -34,14 +40,14 @@
     private string $className;
 
     /**
-     * @var list<TestCase>
+     * @var list<IterativeTestSuite|TestCase>
      */
     private array $tests;
 
     /**
-     * @param non-negative-int       $index
-     * @param class-string<TestCase> $className
-     * @param list<TestCase>         $tests
+     * @param non-negative-int                  $index
+     * @param class-string<TestCase>            $className
+     * @param list<IterativeTestSuite|TestCase> $tests
      */
     public function __construct(int $index, string $className, array $tests)
     {
@@ -67,7 +73,7 @@ public function className(): string
     }
 
     /**
-     * @return list<TestCase>
+     * @return list<IterativeTestSuite|TestCase>
      */
     public function tests(): array
     {