feat: trigger persistence from data providers without Factories trait

nikophil · nikophil · commit be8f6295aa72 · 2025-10-27T10:07:04.000+01:00
diff --git a/phpstan.neon b/phpstan.neon
@@ -30,10 +30,6 @@ parameters:
         - identifier: missingType.iterableValue
           path: tests/
 
-        # We support both PHPUnit versions (this method changed in PHPUnit 10)
-        - identifier: function.impossibleType
-          path: src/Test/Factories.php
-
         # PHPStan does not understand PHP version checks
         - message: '#Comparison operation "(<|>|<=|>=)" between int<80\d+, 80\d+> and 80\d+ is always (false|true).#'
 
diff --git a/phpunit-deprecation-baseline.xml b/phpunit-deprecation-baseline.xml
@@ -12,8 +12,8 @@
             <issue><![CDATA[Since zenstruck/foundry 2.7: Proxy usage is deprecated in PHP 8.4. You should extend directly PersistentObjectFactory in your factories.
 Foundry now leverages the native PHP lazy system to auto-refresh objects (it can be enabled with "zenstruck_foundry.enable_auto_refresh_with_lazy_objects" configuration).
 See https://github.com/zenstruck/foundry/blob/2.x/UPGRADE-2.7.md to upgrade.]]></issue>
-            <issue><![CDATA[Since zenstruck/foundry 2.7: Trait Zenstruck\Foundry\Test\Factories is deprecated and will be removed in Foundry 3.]]></issue>
-            <issue><![CDATA[Since zenstruck/foundry 2.7: Not using Foundry's PHPUnit extension is deprecated and will throw an error in Foundry 3.]]></issue>
+            <issue><![CDATA[Since zenstruck/foundry 2.8: Trait Zenstruck\Foundry\Test\Factories is deprecated and will be removed in Foundry 3.]]></issue>
+            <issue><![CDATA[Since zenstruck/foundry 2.8: Not using Foundry's PHPUnit extension is deprecated and will throw an error in Foundry 3.]]></issue>
         </line>
     </file>
     <file path="vendor/doctrine/deprecations/src/Deprecation.php">
diff --git a/src/Configuration.php b/src/Configuration.php
@@ -137,7 +137,7 @@ public static function boot(\Closure|self $configuration): void
         self::$instance = $configuration;
 
         if (FoundryExtension::shouldBeEnabled()) {
-            trigger_deprecation('zenstruck/foundry', '2.7', 'Not using Foundry\'s PHPUnit extension is deprecated and will throw an error in Foundry 3.');
+            trigger_deprecation('zenstruck/foundry', '2.8', 'Not using Foundry\'s PHPUnit extension is deprecated and will throw an error in Foundry 3.');
         }
     }
 
diff --git a/src/PHPUnit/BootFoundryOnPreparationStarted.php b/src/PHPUnit/BootFoundryOnPreparationStarted.php
@@ -27,11 +27,14 @@ final class BootFoundryOnPreparationStarted implements Event\Test\PreparationSta
 {
     public function notify(Event\Test\PreparationStarted $event): void
     {
-        if (!$event->test()->isTestMethod()) {
+        $test = $event->test();
+
+        if (!$test->isTestMethod()) {
             return;
         }
+        /** @var Event\Code\TestMethod $test */
 
-        $this->bootFoundry($event->test()->className());
+        $this->bootFoundry($test->className());
     }
 
     /**
diff --git a/src/PHPUnit/BuildStoryOnTestPrepared.php b/src/PHPUnit/BuildStoryOnTestPrepared.php
@@ -47,7 +47,9 @@ public function notify(Event\Test\Prepared $event): void
             throw new \InvalidArgumentException(\sprintf('The test class "%s" must extend "%s" to use the "%s" attribute.', $test->className(), KernelTestCase::class, WithStory::class));
         }
 
-        FactoriesTraitNotUsed::throwIfClassDoesNotHaveFactoriesTrait($test->className());
+        if (!FoundryExtension::isEnabled()) {
+            FactoriesTraitNotUsed::throwIfClassDoesNotHaveFactoriesTrait($test->className());
+        }
 
         foreach ($withStoryAttributes as $withStoryAttribute) {
             $withStoryAttribute->newInstance()->story::load();
diff --git a/src/PHPUnit/DataProvider/BootFoundryOnDataProviderMethodCalled.php b/src/PHPUnit/DataProvider/BootFoundryOnDataProviderMethodCalled.php
@@ -11,13 +11,15 @@
  * file that was distributed with this source code.
  */
 
-namespace Zenstruck\Foundry\PHPUnit;
+namespace Zenstruck\Foundry\PHPUnit\DataProvider;
 
 use PHPUnit\Event;
 use PHPUnit\Framework\TestCase;
 use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
 use Zenstruck\Foundry\Configuration;
 use Zenstruck\Foundry\InMemory\AsInMemoryTest;
+use Zenstruck\Foundry\Persistence\PersistentObjectFromDataProviderRegistry;
+use Zenstruck\Foundry\PHPUnit\KernelTestCaseHelper;
 use Zenstruck\Foundry\Test\UnitTestConfig;
 
 /**
@@ -30,6 +32,12 @@ public function notify(Event\Test\DataProviderMethodCalled $event): void
     {
         $this->bootFoundryForDataProvider($event->testMethod()->className());
 
+        PersistentObjectFromDataProviderRegistry::instance()->addDataset(
+            $event->testMethod()->className(),
+            $event->testMethod()->methodName(),
+            "{$event->dataProviderMethod()->className()}::{$event->dataProviderMethod()->methodName()}"(...) // @phpstan-ignore callable.nonCallable
+        );
+
         $testMethod = $event->testMethod();
 
         if (AsInMemoryTest::shouldEnableInMemory($testMethod->className(), $testMethod->methodName())) {
diff --git a/src/PHPUnit/DataProvider/ShutdownFoundryOnDataProviderMethodFinished.php b/src/PHPUnit/DataProvider/ShutdownFoundryOnDataProviderMethodFinished.php
@@ -11,10 +11,11 @@
  * file that was distributed with this source code.
  */
 
-namespace Zenstruck\Foundry\PHPUnit;
+namespace Zenstruck\Foundry\PHPUnit\DataProvider;
 
 use PHPUnit\Event;
 use Zenstruck\Foundry\Configuration;
+use Zenstruck\Foundry\PHPUnit\KernelTestCaseHelper;
 
 /**
  * @internal
diff --git a/src/PHPUnit/DataProvider/TriggerDataProviderPersistenceOnTestPrepared.php b/src/PHPUnit/DataProvider/TriggerDataProviderPersistenceOnTestPrepared.php
@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the zenstruck/foundry package.
+ *
+ * (c) Kevin Bond <kevinbond@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Zenstruck\Foundry\PHPUnit\DataProvider;
+
+use PHPUnit\Event;
+use Zenstruck\Foundry\Persistence\PersistentObjectFromDataProviderRegistry;
+
+/**
+ * @internal
+ * @author Nicolas PHILIPPE <nikophil@gmail.com>
+ */
+final class TriggerDataProviderPersistenceOnTestPrepared implements Event\Test\PreparedSubscriber
+{
+    public function notify(Event\Test\Prepared $event): void
+    {
+        $test = $event->test();
+
+        if (!$test->isTestMethod()) {
+            return;
+        }
+        /** @var Event\Code\TestMethod $test */
+
+        if (!$test->testData()->hasDataFromDataProvider() || $test->metadata()->isDataProvider()->isEmpty()) {
+            return;
+        }
+
+        PersistentObjectFromDataProviderRegistry::instance()->triggerPersistenceForDataset(
+            $test->className(),
+            $test->methodName(),
+            $test->testData()->dataFromDataProvider()->dataSetName(),
+        );
+    }
+}
diff --git a/src/PHPUnit/FoundryExtension.php b/src/PHPUnit/FoundryExtension.php
@@ -17,6 +17,9 @@
 use PHPUnit\Runner;
 use PHPUnit\TextUI;
 use Zenstruck\Foundry\Configuration;
+use Zenstruck\Foundry\PHPUnit\DataProvider\BootFoundryOnDataProviderMethodCalled;
+use Zenstruck\Foundry\PHPUnit\DataProvider\ShutdownFoundryOnDataProviderMethodFinished;
+use Zenstruck\Foundry\PHPUnit\DataProvider\TriggerDataProviderPersistenceOnTestPrepared;
 
 /**
  * @internal
@@ -50,6 +53,7 @@ public function bootstrap(
                 // those deal with data provider events which can be useful only if PHPUnit >=11.4 is used
                 $subscribers[] = new BootFoundryOnDataProviderMethodCalled();
                 $subscribers[] = new ShutdownFoundryOnDataProviderMethodFinished();
+                $subscribers[] = new TriggerDataProviderPersistenceOnTestPrepared();
             }
 
             $facade->registerSubscribers(...$subscribers);
diff --git a/src/Persistence/PersistentObjectFactory.php b/src/Persistence/PersistentObjectFactory.php
@@ -238,7 +238,7 @@ public function create(callable|array $attributes = []): object
             && $this->isPersisting()
             && !$this instanceof PersistentProxyObjectFactory
         ) {
-            return ProxyGenerator::wrapFactoryNativeProxy($this, $attributes);
+            return PersistentObjectFromDataProviderRegistry::instance()->deferObjectCreation($this->with($attributes));
         }
 
         $object = parent::create($attributes);
diff --git a/src/Persistence/PersistentObjectFromDataProviderRegistry.php b/src/Persistence/PersistentObjectFromDataProviderRegistry.php
@@ -0,0 +1,102 @@
+<?php
+
+namespace Zenstruck\Foundry\Persistence;
+
+/**
+ * If a persistent object has been created in a data provider, we need to initialize the proxy object,
+ * which will trigger the object to be persisted.
+ *
+ * Otherwise, such test would not pass:
+ * ```php
+ * #[DataProvider('provide')]
+ * public function testSomething(MyEntity $entity): void
+ * {
+ *     MyEntityFactory::assert()->count(1);
+ * }
+ *
+ * public static function provide(): iterable
+ * {
+ *     yield [MyEntityFactory::createOne()];
+ * }
+ * ```
+ *
+ * Sadly, this cannot be done directly a subscriber, since PHPUnit does not give access to the actual tests instances.
+ *
+ * This class is highly hacky!
+ * We collect all the "datasets" and we trigger the persistence for each one before the test is executed.
+ * This means that de data providers are called twice.
+ * To prevent the persisted object from being different from the one returned by the data provider, we use a "buffer" so
+ * that we can return the same object for each data provider call.
+ *
+ * @internal
+ */
+final class PersistentObjectFromDataProviderRegistry
+{
+    private static ?self $instance = null;
+
+    /** @var array<string, array<array-key, mixed>> */
+    private array $datasets = [];
+
+    /** @var list<object> */
+    private array $objectsBuffer = [];
+
+    private bool $shouldReturnExistingObject = false;
+
+    public static function instance(): self
+    {
+        return self::$instance ?? self::$instance = new self();
+    }
+
+    /**
+     * @param callable():iterable<array-key, mixed> $dataProviderResult
+     */
+    public function addDataset(string $className, string $methodName, callable $dataProviderResult): void
+    {
+        $this->shouldReturnExistingObject = false;
+
+        $dataProviderResult = $dataProviderResult();
+
+        if (!is_array($dataProviderResult)) {
+            $dataProviderResult = iterator_to_array($dataProviderResult);
+        }
+
+        $testCaseContext = $this->testCaseContext($className, $methodName);
+        $this->datasets[$testCaseContext] = $dataProviderResult;
+
+        $this->shouldReturnExistingObject = true;
+    }
+
+    /**
+     * @template T of object
+     *
+     * @param PersistentObjectFactory<T> $factory
+     *
+     * @return ($factory is PersistentProxyObjectFactory<T> ? T&Proxy<T> : T)
+     */
+    public function deferObjectCreation(PersistentObjectFactory $factory): object
+    {
+        if (!$this->shouldReturnExistingObject) {
+            return $this->objectsBuffer[] = ProxyGenerator::wrapFactory($factory);
+        }
+
+        return array_shift($this->objectsBuffer); // @phpstan-ignore return.type
+    }
+
+    public function triggerPersistenceForDataset(string $className, string $methodName, int|string $dataSetName): void
+    {
+        $testCaseContext = $this->testCaseContext($className, $methodName);
+
+        if (!isset($this->datasets[$testCaseContext][$dataSetName])) {
+            throw new \LogicException("No data found for test case context \"{$testCaseContext}\" with dataset name \"{$dataSetName}\".");
+        }
+
+        initialize_proxy_object($this->datasets[$testCaseContext][$dataSetName]);
+
+        unset($this->datasets[$testCaseContext][$dataSetName]);
+    }
+
+    private function testCaseContext(string $className, string $methodName): string
+    {
+        return "{$className}::{$methodName}";
+    }
+}
diff --git a/src/Persistence/PersistentProxyObjectFactory.php b/src/Persistence/PersistentProxyObjectFactory.php
@@ -42,7 +42,7 @@ final public function create(callable|array $attributes = []): object
     {
         $configuration = Configuration::instance();
         if ($configuration->inADataProvider() && $this->isPersisting()) {
-            return ProxyGenerator::wrapFactory($this, $attributes);
+            return PersistentObjectFromDataProviderRegistry::instance()->deferObjectCreation($this->with($attributes));
         }
 
         return proxy(parent::create($attributes)); // @phpstan-ignore function.unresolvableReturnType
diff --git a/src/Persistence/ProxyGenerator.php b/src/Persistence/ProxyGenerator.php
@@ -47,47 +47,37 @@ public static function wrap(object $object): Proxy
         return self::generateClassFor($object)::createLazyProxy(static fn() => $object); // @phpstan-ignore staticMethod.unresolvableReturnType
     }
 
-    /**
-     * @template T of object
-     *
-     * @param PersistentProxyObjectFactory<T> $factory
-     * @phpstan-param Attributes $attributes
-     *
-     * @return T&Proxy<T>
-     */
-    public static function wrapFactory(PersistentProxyObjectFactory $factory, callable|array $attributes): Proxy
-    {
-        return self::generateClassFor($factory)::createLazyProxy(static function() use ($factory, $attributes) { // @phpstan-ignore staticMethod.notFound
-            if (Configuration::instance()->inADataProvider() && $factory->isPersisting()) {
-                throw new \LogicException('Cannot access to a persisted object from a data provider.');
-            }
-
-            return self::unwrap($factory->create($attributes));
-        });
-    }
-
     /**
      * @template T of object
      *
      * @param PersistentObjectFactory<T> $factory
-     * @phpstan-param Attributes $attributes
      *
-     * @return T
+     * @return ($factory is PersistentProxyObjectFactory<T> ? T&Proxy<T> : T)
      */
-    public static function wrapFactoryNativeProxy(PersistentObjectFactory $factory, callable|array $attributes): object
+    public static function wrapFactory(PersistentObjectFactory $factory): object
     {
+        if ($factory instanceof PersistentProxyObjectFactory) {
+            return self::generateClassFor($factory)::createLazyProxy(static function() use ($factory) { // @phpstan-ignore staticMethod.notFound
+                if (Configuration::instance()->inADataProvider() && $factory->isPersisting()) {
+                    throw new \LogicException('Cannot access to a persisted object from a data provider.');
+                }
+
+                return ProxyGenerator::unwrap($factory->create());
+            });
+        }
+
         if (\PHP_VERSION_ID < 80400) {
             throw new \LogicException('Native proxy generation requires PHP 8.4 or higher.');
         }
 
         $reflector = new \ReflectionClass($factory::class());
 
-        return $reflector->newLazyProxy(static function() use ($factory, $attributes) {
+        return $reflector->newLazyProxy(static function() use ($factory) {
             if (Configuration::instance()->inADataProvider() && $factory->isPersisting()) {
                 throw new \LogicException('Cannot access to a persisted object from a data provider.');
             }
 
-            return $factory->create($attributes);
+            return $factory->create();
         });
     }
 
diff --git a/src/Test/Factories.php b/src/Test/Factories.php
@@ -32,15 +32,14 @@ trait Factories
     #[Before(5)]
     public function _beforeHook(): void
     {
-        if (!FoundryExtension::isEnabled()) {
-            $this->_bootFoundry();
+        if (FoundryExtension::isEnabled()) {
+            trigger_deprecation('zenstruck/foundry', '2.8', sprintf('Trait %s is deprecated and will be removed in Foundry 3.', Factories::class));
 
             return;
         }
 
-        trigger_deprecation('zenstruck/foundry', '2.7', sprintf('Trait %s is deprecated and will be removed in Foundry 3.', Factories::class));
-
-        $this->_loadDataProvidedProxies(); // todo remove
+        $this->_bootFoundry();
+        $this->_loadDataProvidedProxies();
     }
 
     /**
@@ -107,7 +106,9 @@ private function _loadDataProvidedProxies(): void
             return;
         }
 
-        $providedData = \method_exists($this, 'getProvidedData') ? $this->getProvidedData() : $this->providedData(); // @phpstan-ignore method.notFound, method.internal
+        $providedData = \method_exists($this, 'getProvidedData') // @phpstan-ignore function.impossibleType
+            ? $this->getProvidedData() // @phpstan-ignore method.notFound
+            : $this->providedData();
 
         initialize_proxy_object($providedData);
     }
diff --git a/tests/Integration/DataProvider/DataProviderWithPersistentFactoryInKernelTestCase.php b/tests/Integration/DataProvider/DataProviderWithPersistentFactoryInKernelTestCase.php
diff --git a/tests/Integration/DataProvider/GenericDocumentFactoryTest.php b/tests/Integration/DataProvider/GenericDocumentFactoryTest.php
diff --git a/tests/Integration/DataProvider/GenericEntityFactoryTest.php b/tests/Integration/DataProvider/GenericEntityFactoryTest.php

Original file line number	Diff line number	Diff line change
`@@ -137,7 +137,7 @@ public static function boot(\Closure\|self $configuration): void`
`137`	`137`	`self::$instance = $configuration;`
`138`	`138`
`139`	`139`	`if (FoundryExtension::shouldBeEnabled()) {`
`140`		`- trigger_deprecation('zenstruck/foundry', '2.7', 'Not using Foundry\'s PHPUnit extension is deprecated and will throw an error in Foundry 3.');`
	`140`	`+ trigger_deprecation('zenstruck/foundry', '2.8', 'Not using Foundry\'s PHPUnit extension is deprecated and will throw an error in Foundry 3.');`
`141`	`141`	`}`
`142`	`142`	`}`
`143`	`143`
Original file line number	Diff line number	Diff line change
`@@ -27,11 +27,14 @@ final class BootFoundryOnPreparationStarted implements Event\Test\PreparationSta`
`27`	`27`	`{`
`28`	`28`	`public function notify(Event\Test\PreparationStarted $event): void`
`29`	`29`	`{`
`30`		`- if (!$event->test()->isTestMethod()) {`
	`30`	`+ $test = $event->test();`
	`31`	`+`
	`32`	`+ if (!$test->isTestMethod()) {`
`31`	`33`	`return;`
`32`	`34`	`}`
	`35`	`+ /** @var Event\Code\TestMethod $test */`
`33`	`36`
`34`		`- $this->bootFoundry($event->test()->className());`
	`37`	`+ $this->bootFoundry($test->className());`
`35`	`38`	`}`
`36`	`39`
`37`	`40`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,9 @@ public function notify(Event\Test\Prepared $event): void`
`47`	`47`	`throw new \InvalidArgumentException(\sprintf('The test class "%s" must extend "%s" to use the "%s" attribute.', $test->className(), KernelTestCase::class, WithStory::class));`
`48`	`48`	`}`
`49`	`49`
`50`		`- FactoriesTraitNotUsed::throwIfClassDoesNotHaveFactoriesTrait($test->className());`
	`50`	`+ if (!FoundryExtension::isEnabled()) {`
	`51`	`+ FactoriesTraitNotUsed::throwIfClassDoesNotHaveFactoriesTrait($test->className());`
	`52`	`+ }`
`51`	`53`
`52`	`54`	`foreach ($withStoryAttributes as $withStoryAttribute) {`
`53`	`55`	`$withStoryAttribute->newInstance()->story::load();`
Original file line number	Diff line number	Diff line change
`@@ -238,7 +238,7 @@ public function create(callable\|array $attributes = []): object`
`238`	`238`	`&& $this->isPersisting()`
`239`	`239`	`&& !$this instanceof PersistentProxyObjectFactory`
`240`	`240`	`) {`
`241`		`- return ProxyGenerator::wrapFactoryNativeProxy($this, $attributes);`
	`241`	`+ return PersistentObjectFromDataProviderRegistry::instance()->deferObjectCreation($this->with($attributes));`
`242`	`242`	`}`
`243`	`243`
`244`	`244`	`$object = parent::create($attributes);`