feat: implement faker testing support

Author: wilcorrea

src/Testing/Extension/BuilderExtension.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Constructo\Testing\Extension;
+
+use Constructo\Core\Serialize\Builder;
+
+trait BuilderExtension
+{
+    private ?Builder $builder = null;
+
+    protected function builder(): Builder
+    {
+        if ($this->builder === null) {
+            $this->builder = $this->make(Builder::class);
+        }
+        return $this->builder;
+    }
+
+    /**
+     * @template T of mixed
+     * @param class-string<T> $class
+     * @param array<string, mixed> $args
+     *
+     * @return T
+     */
+    abstract protected function make(string $class, array $args = []): mixed;
+}

src/Testing/Extension/FakerExtension.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Constructo\Testing\Extension;
+
+use Constructo\Testing\Faker\Faker;
+use Faker\Generator;
+
+trait FakerExtension
+{
+    private ?Faker $faker = null;
+
+    protected function faker(): Faker
+    {
+        if ($this->faker === null) {
+            $this->faker = $this->make(Faker::class);
+        }
+        return $this->faker;
+    }
+
+    protected function generator(): Generator
+    {
+        return $this->faker()->generator();
+    }
+
+    /**
+     * @template T of mixed
+     * @param class-string<T> $class
+     * @param array<string, mixed> $args
+     *
+     * @return T
+     */
+    abstract protected function make(string $class, array $args = []): mixed;
+}

src/Testing/Extension/MakeExtension.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Constructo\Testing\Extension;
+
+use Constructo\Support\Reflective\Factory\Target;
+use ReflectionClass;
+use ReflectionException;
+
+/**
+ * @phpstan-ignore trait.unused
+ */
+trait MakeExtension
+{
+    /**
+     * @template T of mixed
+     * @param class-string<T> $class
+     * @param array<string, mixed> $args
+     *
+     * @return T
+     * @throws ReflectionException
+     */
+    protected function make(string $class, array $args = []): mixed
+    {
+        $target = Target::createFrom($class);
+        return (new ReflectionClass($class))->newInstanceArgs(array_values($args));
+    }
+}

src/Testing/Extension/ManagedExtension.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Constructo\Testing\Extension;
+
+use Constructo\Support\Managed;
+
+trait ManagedExtension
+{
+    private ?Managed $managed = null;
+
+    protected function managed(): Managed
+    {
+        if ($this->managed === null) {
+            $this->managed = $this->make(class: Managed::class);
+        }
+        return $this->managed;
+    }
+
+    /**
+     * @template T of mixed
+     * @param class-string<T> $class
+     * @param array<string, mixed> $args
+     *
+     * @return T
+     */
+    abstract protected function make(string $class, array $args = []): mixed;
+}

src/Testing/Faker/Faker.php

@@ -0,0 +1,113 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Constructo\Testing\Faker;
+
+use Constructo\Contract\Formatter;
+use Constructo\Contract\Testing\Faker as Contract;
+use Constructo\Support\Reflective\Engine;
+use Constructo\Support\Reflective\Factory\Target;
+use Constructo\Support\Reflective\Notation;
+use Constructo\Support\Set;
+use Constructo\Testing\Faker\Resolver\FromCollection;
+use Constructo\Testing\Faker\Resolver\FromDefaultValue;
+use Constructo\Testing\Faker\Resolver\FromDependency;
+use Constructo\Testing\Faker\Resolver\FromEnum;
+use Constructo\Testing\Faker\Resolver\FromPreset;
+use Constructo\Testing\Faker\Resolver\FromTypeAttributes;
+use Constructo\Testing\Faker\Resolver\FromTypeBuiltin;
+use Constructo\Testing\Faker\Resolver\FromTypeDate;
+use Faker\Factory;
+use Faker\Generator;
+use ReflectionException;
+use ReflectionParameter;
+
+use function Constructo\Cast\stringify;
+use function getenv;
+
+
+class Faker extends Engine implements Contract
+{
+    protected readonly Generator $generator;
+
+    /**
+     * @param array<callable|Formatter> $formatters
+     * @SuppressWarnings(StaticAccess)
+     */
+    public function __construct(
+        Notation $case = Notation::SNAKE,
+        array $formatters = [],
+        ?string $locale = null,
+    ) {
+        parent::__construct($case, $formatters);
+
+        $this->generator = Factory::create($this->locale($locale));
+    }
+
+    public function __call(string $name, array $arguments): mixed
+    {
+        return $this->generate($name, $arguments);
+    }
+
+    /**
+     * @template U of object
+     * @param class-string<U> $class
+     * @throws ReflectionException
+     */
+    public function fake(string $class, array $presets = []): Set
+    {
+        $target = Target::createFrom($class);
+        $parameters = $target->getReflectionParameters();
+        if (empty($parameters)) {
+            return Set::createFrom([]);
+        }
+
+        return $this->resolveParameters($parameters, new Set($presets));
+    }
+
+    public function generate(string $name, array $arguments = []): mixed
+    {
+        return $this->generator->__call($name, $arguments);
+    }
+
+    public function generator(): Generator
+    {
+        return $this->generator;
+    }
+
+    /**
+     * @param array<ReflectionParameter> $parameters
+     */
+    private function resolveParameters(array $parameters, Set $presets): Set
+    {
+        $values = [];
+        foreach ($parameters as $parameter) {
+            $field = $this->casedField($parameter);
+            $generated = (new FromDependency($this->notation))
+                ->then(new FromTypeDate($this->notation))
+                ->then(new FromCollection($this->notation))
+                ->then(new FromTypeBuiltin($this->notation))
+                ->then(new FromTypeAttributes($this->notation))
+                ->then(new FromEnum($this->notation))
+                ->then(new FromDefaultValue($this->notation))
+                ->then(new FromPreset($this->notation))
+                ->resolve($parameter, $presets);
+
+            if ($generated === null) {
+                continue;
+            }
+            $values[$field] = $generated->content;
+        }
+        return Set::createFrom($values);
+    }
+
+    private function locale(?string $locale): string
+    {
+        $fallback = static function (string $default = 'en_US'): string {
+            $locale = stringify(getenv('FAKER_LOCALE'), $default);
+            return empty($locale) ? $default : $locale;
+        };
+        return $locale ?? $fallback();
+    }
+}

src/Testing/Faker/Resolver.php

@@ -0,0 +1,51 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Constructo\Testing\Faker;
+
+use Constructo\Support\Set;
+use Constructo\Support\Value;
+use ReflectionNamedType;
+use ReflectionParameter;
+use ReflectionType;
+use ReflectionUnionType;
+
+use function count;
+
+abstract class Resolver extends Faker
+{
+    protected ?Resolver $previous = null;
+
+    final public function then(Resolver $resolver): Resolver
+    {
+        $resolver->previous($this);
+        return $resolver;
+    }
+
+    public function resolve(ReflectionParameter $parameter, Set $presets): ?Value
+    {
+        if (isset($this->previous)) {
+            return $this->previous->resolve($parameter, $presets);
+        }
+        return null;
+    }
+
+    final protected function previous(Resolver $previous): void
+    {
+        $this->previous = $previous;
+    }
+
+    protected function detectReflectionType(?ReflectionType $type): ?string
+    {
+        if ($type instanceof ReflectionNamedType) {
+            return $type->getName();
+        }
+        if ($type instanceof ReflectionUnionType) {
+            $reflectionNamedTypes = $type->getTypes();
+            $index = $this->generator->numberBetween(0, count($reflectionNamedTypes) - 1);
+            return $this->detectReflectionType($reflectionNamedTypes[$index]);
+        }
+        return null;
+    }
+}

src/Testing/Faker/Resolver/FromCollection.php

@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Constructo\Testing\Faker\Resolver;
+
+use Constructo\Support\Set;
+use Constructo\Support\Value;
+use Constructo\Type\Collection;
+use ReflectionClass;
+use ReflectionException;
+use ReflectionParameter;
+use Constructo\Testing\Faker\Resolver;
+
+final class FromCollection extends Resolver
+{
+    use MakeExtension;
+    use ManagedExtension;
+
+    /**
+     * @throws ReflectionException
+     */
+    public function resolve(ReflectionParameter $parameter, Set $presets): ?Value
+    {
+        $collectionName = $this->detectCollectionName($parameter);
+        if ($collectionName) {
+            return $this->resolveCollection($collectionName);
+        }
+        return parent::resolve($parameter, $presets);
+    }
+
+    /**
+     * @param class-string<Collection> $collectionName
+     * @throws ReflectionException
+     */
+    private function resolveCollection(string $collectionName): Value
+    {
+        $reflection = new ReflectionClass($collectionName);
+        $type = $this->detectCollectionType($reflection);
+
+        return new Value($type === null ? [] : $this->resolveCollectionFake($type));
+    }
+
+    /**
+     * @param class-string<object> $type
+     * @throws ReflectionException
+     */
+    private function resolveCollectionFake(string $type): array
+    {
+        $total = $this->generator->numberBetween(1, 5);
+        return array_map(fn () => $this->fake($type)->toArray(), range(1, $total));
+    }
+}

src/Testing/Faker/Resolver/FromDefaultValue.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Constructo\Testing\Faker\Resolver;
+
+use Constructo\Support\Set;
+use Constructo\Support\Value;
+use ReflectionException;
+use ReflectionParameter;
+use Constructo\Testing\Faker\Resolver;
+
+final class FromDefaultValue extends Resolver
+{
+    /**
+     * @throws ReflectionException
+     */
+    public function resolve(ReflectionParameter $parameter, Set $presets): ?Value
+    {
+        if ($parameter->isOptional() || $parameter->isDefaultValueAvailable()) {
+            return new Value($parameter->getDefaultValue());
+        }
+        if ($parameter->allowsNull()) {
+            return new Value(null);
+        }
+        return parent::resolve($parameter, $presets);
+    }
+}