feat: Add DataZip and DataCross attributes (#93)

Author: roxblnfk

src/Common/Reflection.php

@@ -201,7 +201,7 @@ public static function getAttributesFromCallStack(
                 $reflection = match (true) {
                     isset($frame['class'], $frame['function']) => new \ReflectionMethod(
                         $frame['class'],
-                        $frame['function']
+                        $frame['function'],
                     ),
                     isset($frame['function']) => new \ReflectionFunction($frame['function']),
                     default => null,

src/Data/DataCross.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Testo\Data;
+
+use Testo\Data\Internal\DataProviderAttribute;
+use Testo\Data\Internal\DataProviderInterceptor;
+use Testo\Pipeline\Attribute\FallbackInterceptor;
+use Testo\Pipeline\Attribute\Interceptable;
+
+/**
+ * Crosses multiple data providers together.
+ *
+ * Each data set will contain one value from each provider, combined into an array.
+ * All possible combinations of values from the providers will be generated.
+ *
+ * @api
+ */
+#[\Attribute(\Attribute::TARGET_METHOD | \Attribute::TARGET_FUNCTION | \Attribute::IS_REPEATABLE)]
+#[FallbackInterceptor(DataProviderInterceptor::class)]
+final class DataCross implements Interceptable, DataProviderAttribute
+{
+    /**
+     * @param array<DataProviderAttribute> $providers Data providers to cross together.
+     */
+    public readonly array $providers;
+
+    public function __construct(DataProviderAttribute ...$providers)
+    {
+        $this->providers = $providers;
+    }
+}

src/Data/DataZip.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Testo\Data;
+
+use Testo\Data\Internal\DataProviderAttribute;
+use Testo\Data\Internal\DataProviderInterceptor;
+use Testo\Pipeline\Attribute\FallbackInterceptor;
+use Testo\Pipeline\Attribute\Interceptable;
+
+/**
+ * Zips multiple data providers together.
+ *
+ * Each data set will contain one value from each provider, combined into an array.
+ * If the providers have different lengths, `null` will be used for missing values.
+ *
+ * @api
+ */
+#[\Attribute(\Attribute::TARGET_METHOD | \Attribute::TARGET_FUNCTION | \Attribute::IS_REPEATABLE)]
+#[FallbackInterceptor(DataProviderInterceptor::class)]
+final class DataZip implements Interceptable, DataProviderAttribute
+{
+    /**
+     * @param array<DataProvider> $providers Data providers to zip together.
+     */
+    public readonly array $providers;
+
+    public function __construct(DataProvider ...$providers)
+    {
+        $this->providers = $providers;
+    }
+}

src/Data/Internal/DataProviderInterceptor.php

@@ -9,8 +9,10 @@
 use Testo\Core\Context\TestResult;
 use Testo\Core\Filter\DataPointer;
 use Testo\Core\Value\Status;
+use Testo\Data\DataCross;
 use Testo\Data\DataProvider;
 use Testo\Data\DataSet;
+use Testo\Data\DataZip;
 use Testo\Data\MultipleResult;
 use Testo\Event\Test\TestBatchFinished;
 use Testo\Event\Test\TestBatchStarting;
@@ -26,6 +28,12 @@
 #[InterceptorOptions(order: InterceptorOptions::ORDER_DATA_PROVIDER, onConflict: ConflictPolicy::First)]
 final class DataProviderInterceptor implements TestRunInterceptor
 {
+    /** Key separator for DataZip (parallel combination). */
+    private const KEY_SEPARATOR_ZIP = '|';
+
+    /** Key separator for DataCross (cartesian product). */
+    private const KEY_SEPARATOR_CROSS = '×';
+
     public function __construct(
         private readonly EventDispatcherInterface $eventDispatcher,
     ) {}
@@ -55,11 +63,7 @@ public function runTest(TestInfo $info, callable $next): TestResult
 
                 $attr = $attribute->newInstance();
 
-                $datasets = match (true) {
-                    $attr instanceof DataProvider => self::fromDataProvider($info, $attr),
-                    $attr instanceof DataSet => [($attr->name ?? 0) => $attr->arguments],
-                    default => throw new \RuntimeException('Unknown Data Provider Attribute type.'),
-                };
+                $datasets = self::extractDataSets($info, $attr);
 
                 # Handle each data set
                 $results = [];
@@ -160,6 +164,17 @@ public function run(
         return $result;
     }
 
+    private static function extractDataSets(TestInfo $info, object $attr): iterable
+    {
+        return match (true) {
+            $attr instanceof DataProvider => self::fromDataProvider($info, $attr),
+            $attr instanceof DataSet => [($attr->name ?? 0) => $attr->arguments],
+            $attr instanceof DataCross => self::fromDataCross($info, $attr),
+            $attr instanceof DataZip => self::fromDataZip($info, $attr),
+            default => throw new \RuntimeException('Unknown Data Provider Attribute type.'),
+        };
+    }
+
     /**
      * Extract data sets from a DataProvider attribute.
      */
@@ -177,7 +192,7 @@ private static function fromDataProvider(TestInfo $info, DataProvider $attribute
                 $m = $class->getMethod($provider);
                 $provider = match (true) {
                     $m->isStatic() => $m->getClosure(null),
-                    default => static fn() => $m->getClosure($info->caseInfo->instance->getInstance()),
+                    default => static fn () => $m->getClosure($info->caseInfo->instance->getInstance()),
                 };
             }
 
@@ -194,4 +209,96 @@ private static function fromDataProvider(TestInfo $info, DataProvider $attribute
 
         return $datasets;
     }
+
+    /**
+     * Extract data sets from a DataZip attribute.
+     */
+    private static function fromDataZip(TestInfo $info, DataZip $attr): iterable
+    {
+        $generators = \array_map(
+            static fn ($providerAttr): DeferredGenerator => DeferredGenerator::fromHandler(
+                static function () use ($info, $providerAttr) {
+                    yield from self::fromDataProvider($info, $providerAttr);
+                },
+            ),
+            $attr->providers,
+        );
+
+        dataset:
+        $allFinished = true;
+        $dataSet = [];
+        $key = [];
+        foreach ($generators as $gen) {
+            if ($gen->valid()) {
+                $allFinished = false;
+                $dataSet[] = $gen->current();
+                $key[] = $gen->key();
+                $gen->next();
+            } else {
+                $key[] = '';
+                $dataSet[] = null;
+            }
+        }
+
+        if ($allFinished) {
+            return;
+        }
+
+        yield \implode(self::KEY_SEPARATOR_ZIP, $key) => \array_merge(...$dataSet);
+        goto dataset;
+    }
+
+    /**
+     * Extract data sets from a DataCross attribute (cartesian product).
+     */
+    private static function fromDataCross(TestInfo $info, DataCross $attr): iterable
+    {
+        // Collect all datasets from each provider into arrays
+        $allDatasets = [];
+        foreach ($attr->providers as $providerAttr) {
+            $datasets = [];
+            foreach (self::extractDataSets($info, $providerAttr) as $key => $dataset) {
+                $datasets[$key] = $dataset;
+            }
+            if ($datasets === []) {
+                return; // If any provider is empty, no combinations possible
+            }
+            $allDatasets[] = $datasets;
+        }
+
+        if ($allDatasets === []) {
+            return;
+        }
+
+        yield from self::cartesianProduct($allDatasets);
+    }
+
+    /**
+     * Generate the cartesian product of multiple arrays of datasets.
+     *
+     * @param list<array<array-key, array>> $arrays Arrays of datasets from each provider.
+     * @param int<0, max> $index Current provider index.
+     * @param list<array> $currentData Accumulated dataset arguments.
+     * @param list<string> $currentKeys Accumulated dataset keys.
+     */
+    private static function cartesianProduct(
+        array $arrays,
+        int $index = 0,
+        array $currentData = [],
+        array $currentKeys = [],
+    ): iterable {
+        if ($index === \count($arrays)) {
+            yield \implode(self::KEY_SEPARATOR_CROSS, $currentKeys) => \array_merge(...$currentData);
+            return;
+        }
+
+        foreach ($arrays[$index] as $key => $dataset) {
+            yield from self::cartesianProduct(
+                $arrays,
+                $index + 1,
+                [...$currentData, $dataset],
+                [...$currentKeys, (string) $key],
+            );
+        }
+    }
 }

src/Data/Internal/DeferredGenerator.php

@@ -0,0 +1,156 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Testo\Data\Internal;
+
+/**
+ * A wrapper around a generator that doesn't start the wrapped generator ASAP.
+ *
+ * @implements \Iterator<mixed, mixed>
+ */
+final class DeferredGenerator implements \Iterator
+{
+    private bool $started = false;
+    private bool $finished = false;
+    private \Generator $generator;
+    private \Closure $handler;
+
+    private function __construct() {}
+
+    /**
+     * @param \Closure(): mixed $handler
+     */
+    public static function fromHandler(\Closure $handler): self
+    {
+        $self = new self();
+        $self->handler = $handler;
+        return $self;
+    }
+
+    /**
+     * Throw an exception into the generator.
+     *
+     * @note doesn't throw generator's exceptions; use {@see catch()} to handle them.
+     */
+    public function throw(\Throwable $exception): void
+    {
+        $this->started or throw new \LogicException('Cannot throw exception into a generator that was not started.');
+        $this->finished and throw new \LogicException(
+            'Cannot throw exception into a generator that was already finished.',
+        );
+        $this->generator->throw($exception);
+    }
+
+    /**
+     * Send a value to the generator.
+     *
+     * @note doesn't throw generator's exceptions; use {@see catch()} to handle them.
+     */
+    public function send(mixed $value): mixed
+    {
+        $this->start();
+        $this->finished and throw new \LogicException('Cannot send value to a generator that was already finished.');
+        return $this->generator->send($value);
+    }
+
+    /**
+     * Get the return value of the generator if it was finished.
+     */
+    public function getReturn(): mixed
+    {
+        $this->finished or throw new \LogicException('Cannot get return value of a generator that was not finished.');
+        return $this->generator->getReturn();
+    }
+
+    /**
+     * Get the current value of the generator.
+     */
+    public function current(): mixed
+    {
+        $this->start();
+        return $this->generator->current();
+    }
+
+    /**
+     * Get the current key of the generator.
+     */
+    public function key(): mixed
+    {
+        $this->start();
+        return $this->generator->key();
+    }
+
+    /**
+     * Start or resume the generator.
+     */
+    public function next(): void
+    {
+        if (!$this->started || $this->finished) {
+            $this->finished or $this->start();
+            return;
+        }
+
+        $this->generator->next();
+    }
+
+    /**
+     * Check if the generator is not finished.
+     *
+     * @note It starts the Generator.
+     */
+    public function valid(): bool
+    {
+        $this->start();
+        $result = $this->generator->valid() or $this->finished = true;
+        return $result;
+    }
+
+    public function rewind(): void
+    {
+        $this->generator->rewind();
+    }
+
+    private static function getDummyGenerator(): \Generator
+    {
+        static $generator;
+
+        if ($generator === null) {
+            $generator = (static function (): \Generator {
+                yield;
+            })();
+            $generator->current();
+        }
+
+        return $generator;
+    }
+
+    private function start(): void
+    {
+        if ($this->started) {
+            return;
+        }
+
+        $this->started = true;
+        try {
+            $result = ($this->handler)();
+
+            if ($result instanceof \Generator) {
+                $this->generator = $result;
+                return;
+            }
+
+            /** @psalm-suppress all */
+            $this->generator = (static function (mixed $result): \Generator {
+                return $result;
+                yield;
+            })($result);
+            $this->finished = true;
+        } catch (\Throwable $e) {
+            $this->generator = self::getDummyGenerator();
+            throw $e;
+        } finally {
+            unset($this->handler, $this->values);
+        }
+    }
+}