feat: validate objects

bin/console

@@ -6,5 +6,11 @@ use Zenstruck\Foundry\Tests\Fixture\TestKernel;
 
 require_once __DIR__ . '/../tests/bootstrap.php';
 
-$application = new Application(new TestKernel('test', true));
+foreach ($argv ?? [] as $i => $arg) {
+    if (($arg === '--env' || $arg === '-e') && isset($argv[$i + 1])) {
+        $_ENV['APP_ENV'] = $argv[$i + 1];
+        break;
+    }
+}
+$application = new Application(new TestKernel($_ENV['APP_ENV'], true));
 $application->run();

composer.json

@@ -35,8 +35,8 @@
         "doctrine/common": "^3.2.2",
         "doctrine/doctrine-bundle": "^2.10",
         "doctrine/doctrine-migrations-bundle": "^2.2|^3.0",
-        "doctrine/mongodb-odm-bundle": "^4.6|^5.0",
         "doctrine/mongodb-odm": "^2.4",
+        "doctrine/mongodb-odm-bundle": "^4.6|^5.0",
         "doctrine/orm": "^2.16|^3.0",
         "phpunit/phpunit": "^9.5.0 || ^10.0 || ^11.0",
         "symfony/console": "^6.4|^7.0",
@@ -46,6 +46,7 @@
         "symfony/runtime": "^6.4|^7.0",
         "symfony/translation-contracts": "^3.4",
         "symfony/uid": "^6.4|^7.0",
+        "symfony/validator": "^6.4|^7.0",
         "symfony/var-dumper": "^6.4|^7.0",
         "symfony/yaml": "^6.4|^7.0"
     },

config/services.php

@@ -5,7 +5,9 @@
 use Faker;
 use Zenstruck\Foundry\Configuration;
 use Zenstruck\Foundry\FactoryRegistry;
+use Zenstruck\Foundry\Object\Event\AfterInstantiate;
 use Zenstruck\Foundry\Object\Instantiator;
+use Zenstruck\Foundry\Object\ValidationListener;
 use Zenstruck\Foundry\StoryRegistry;
 
 return static function (ContainerConfigurator $container): void {
@@ -33,7 +35,13 @@
             service('.zenstruck_foundry.story_registry'),
             service('.zenstruck_foundry.persistence_manager')->nullOnInvalid(),
             service('event_dispatcher'),
+            param('.zenstruck_foundry.validation_enabled'),
+            abstract_arg('validation_available'),
         ])
         ->public()
+
+        ->set('.zenstruck_foundry.validation_listener', ValidationListener::class)
+        ->args([service('validator')])
+        ->tag('kernel.event_listener', ['event' => AfterInstantiate::class, 'method' => '__invoke'])
     ;
 };

src/Configuration.php

@@ -53,6 +53,8 @@ public function __construct(
         public readonly StoryRegistry $stories,
         private readonly ?PersistenceManager $persistence = null,
         private readonly ?EventDispatcherInterface $eventDispatcher = null,
+        public readonly bool $validationEnabled = false,
+        public readonly bool $validationAvailable = false,
     ) {
         $this->instantiator = $instantiator;
     }

src/Object/ValidationListener.php

@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Zenstruck\Foundry\Object;
+
+use Symfony\Component\Validator\Exception\ValidationFailedException;
+use Symfony\Component\Validator\Validator\ValidatorInterface;
+use Zenstruck\Foundry\Object\Event\AfterInstantiate;
+
+final class ValidationListener
+{
+    public function __construct(
+        private readonly ValidatorInterface $validator
+    ) {
+    }
+
+    public function __invoke(AfterInstantiate $event): void
+    {
+        if (!$event->factory->validationEnabled()) {
+            return;
+        }
+
+        $violations = $this->validator->validate($event->object);
+
+        if ($violations->count() > 0) {
+            throw new ValidationFailedException($event->object, $violations);
+        }
+    }
+}

src/ObjectFactory.php

@@ -35,6 +35,16 @@ abstract class ObjectFactory extends Factory
     /** @phpstan-var InstantiatorCallable|null */
     private $instantiator;
 
+    private bool $validationEnabled;
+
+    // keep an empty constructor for BC
+    public function __construct()
+    {
+        parent::__construct();
+
+        $this->validationEnabled = Configuration::instance()->validationEnabled;
+    }
+
     /**
      * @return class-string<T>
      */
@@ -105,6 +115,42 @@ public function afterInstantiate(callable $callback): static
         return $clone;
     }
 
+    /**
+     * @psalm-return static<T>
+     * @phpstan-return static
+     */
+    public function withValidation(): static
+    {
+        if (!Configuration::instance()->validationAvailable) {
+            throw new \LogicException('Validation is not available. Make sure the "symfony/validator" package is installed and validation enabled.');
+        }
+
+        $clone = clone $this;
+        $clone->validationEnabled = true;
+
+        return $clone;
+    }
+
+    /**
+     * @psalm-return static<T>
+     * @phpstan-return static
+     */
+    public function withoutValidation(): static
+    {
+        $clone = clone $this;
+        $clone->validationEnabled = false;
+
+        return $clone;
+    }
+
+    /**
+     * @internal
+     */
+    public function validationEnabled(): bool
+    {
+        return $this->validationEnabled;
+    }
+
     /**
      * @internal
      */

src/Persistence/PersistentObjectFactory.php

@@ -396,7 +396,7 @@ protected function normalizeObject(object $object): object
         }
     }
 
-    final protected function isPersisting(): bool
+    final public function isPersisting(): bool
     {
         $config = Configuration::instance();
 

src/ZenstruckFoundryBundle.php

@@ -14,9 +14,11 @@
 use Symfony\Component\Config\Definition\Configurator\DefinitionConfigurator;
 use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Exception\LogicException;
 use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
 use Symfony\Component\DependencyInjection\Reference;
 use Symfony\Component\HttpKernel\Bundle\AbstractBundle;
+use Symfony\Component\Validator\Validator\ValidatorInterface;
 use Zenstruck\Foundry\Mongo\MongoResetter;
 use Zenstruck\Foundry\Object\Instantiator;
 use Zenstruck\Foundry\ORM\ResetDatabase\MigrateDatabaseResetter;
@@ -87,6 +89,16 @@ public function configure(DefinitionConfigurator $definition): void
                             ->example('my_instantiator')
                             ->defaultNull()
                         ->end()
+                        ->arrayNode('validation')
+                            ->info('Automatically validate the objects created.')
+                            ->canBeEnabled()
+                            ->validate()
+                                ->ifTrue(function(array $validation): bool {
+                                    return $validation['enabled'] && !interface_exists(ValidatorInterface::class);
+                                })
+                                ->thenInvalid('Validation support cannot be enabled as the Validator component is not installed. Try running "composer require --dev symfony/validator".')
+                            ->end()
+                        ->end()
                     ->end()
                 ->end()
                 ->arrayNode('global_state')
@@ -188,19 +200,16 @@ public function configure(DefinitionConfigurator $definition): void
                         ->end()
                     ->end()
                 ->end()
+                ->booleanNode('enable_validation')->defaultFalse()->end()
             ->end()
         ;
     }
 
     public function loadExtension(array $config, ContainerConfigurator $configurator, ContainerBuilder $container): void // @phpstan-ignore missingType.iterableValue
     {
-        $container->registerForAutoconfiguration(Factory::class)
-            ->addTag('foundry.factory')
-        ;
+        $container->registerForAutoconfiguration(Factory::class)->addTag('foundry.factory');
 
-        $container->registerForAutoconfiguration(Story::class)
-            ->addTag('foundry.story')
-        ;
+        $container->registerForAutoconfiguration(Story::class)->addTag('foundry.story');
 
         $configurator->import('../config/services.php');
 
@@ -282,6 +291,8 @@ public function loadExtension(array $config, ContainerConfigurator $configurator
                 ->replaceArgument(0, $config['mongo']['reset']['document_managers'])
             ;
         }
+
+        $container->setParameter('.zenstruck_foundry.validation_enabled', $config['instantiator']['validation']['enabled']);
     }
 
     public function build(ContainerBuilder $container): void
@@ -300,6 +311,22 @@ public function process(ContainerBuilder $container): void
                 ->addMethodCall('addProvider', [new Reference($id)])
             ;
         }
+
+        // validation
+        $container->getDefinition('.zenstruck_foundry.configuration')
+            ->replaceArgument(7, $container->has('validator'));
+
+        if (!interface_exists(ValidatorInterface::class)) {
+            $container->removeDefinition('.zenstruck_foundry.validation_listener');
+        }
+
+        if ($container->has('.zenstruck_foundry.configuration') && !$container->has('validator')) {
+            if ($container->getParameter('.zenstruck_foundry.validation_enabled') === true) {
+                throw new LogicException('Validation support cannot be enabled because the validation is not enabled. Please, add enable validation with configuration "framework.validation: true".');
+            }
+
+            $container->removeDefinition('.zenstruck_foundry.validation_listener');
+        }
     }
 
     /**

tests/Fixture/Entity/EntityForValidation.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the zenstruck/foundry package.
+ *
+ * (c) Kevin Bond <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Zenstruck\Foundry\Tests\Fixture\Entity;
+
+use Doctrine\ORM\Mapping as ORM;
+use Zenstruck\Foundry\Tests\Fixture\Model\Base;
+use Symfony\Component\Validator\Constraints as Assert;
+
+#[ORM\Entity]
+class EntityForValidation extends Base
+{
+    public function __construct(
+        #[ORM\Column()]
+        #[Assert\NotBlank()]
+        public string $name = '',
+    ) {
+    }
+}

tests/Fixture/config/validation_available.yaml

@@ -0,0 +1,2 @@
+framework:
+    validation: true

tests/Fixture/config/validation_enabled.yaml

@@ -0,0 +1,6 @@
+framework:
+    validation: true
+
+zenstruck_foundry:
+    instantiator:
+        validation: true

tests/Fixture/config/validation_not_available.yaml

@@ -0,0 +1,3 @@
+zenstruck_foundry:
+    instantiator:
+        validation: true

tests/Integration/ValidationTest.php

@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Zenstruck\Foundry\Tests\Integration;
+
+use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
+use Symfony\Component\Validator\Exception\ValidationFailedException;
+use Zenstruck\Foundry\Test\Factories;
+use Zenstruck\Foundry\Tests\Fixture\Entity\EntityForValidation;
+
+use function Zenstruck\Foundry\factory;
+use function Zenstruck\Foundry\object;
+
+final class ValidationTest extends KernelTestCase
+{
+    use Factories;
+
+    public function test_it_does_not_validate_object_if_validation_not_enabled(): void
+    {
+        self::expectNotToPerformAssertions();
+
+        object(EntityForValidation::class);
+    }
+
+    public function test_it_throws_if_trying_to_validate_with_validation_not_available(): void
+    {
+        self::expectException(\LogicException::class);
+        self::expectExceptionMessage('Validation is not available.');
+
+        factory(EntityForValidation::class)->withValidation()->create();
+    }
+
+    public function test_it_throws_if_validation_enabled_in_foundry_but_disabled_in_symfony(): void
+    {
+        self::expectException(\LogicException::class);
+        self::expectExceptionMessage('Validation support cannot be enabled');
+
+        self::bootKernel(['environment' => 'validation_not_available']);
+
+        object(EntityForValidation::class);
+    }
+
+    public function test_it_validates_object_if_validation_forced(): void
+    {
+        self::expectException(ValidationFailedException::class);
+
+        self::bootKernel(['environment' => 'validation_available']);
+
+        factory(EntityForValidation::class)->withValidation()->create();
+    }
+
+    public function test_it_validates_object_if_validation_enabled_globally(): void
+    {
+        self::expectException(ValidationFailedException::class);
+
+        self::bootKernel(['environment' => 'validation_enabled']);
+
+        object(EntityForValidation::class);
+    }
+
+    public function test_validation_can_be_disabled(): void
+    {
+        self::expectNotToPerformAssertions();
+
+        self::bootKernel(['environment' => 'validation_enabled']);
+
+        factory(EntityForValidation::class)->withoutValidation()->create();
+    }
+}