Adding tests for lazy attribute

Author: Fa-BRAIK

src/Attributes/Class/Lazy.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace Nuxtifyts\PhpDto\Attributes\Class;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_CLASS)]
+class Lazy
+{
+}

src/Concerns/BaseData.php

@@ -31,14 +31,20 @@ final public static function create(mixed ...$args): static
                 throw DataCreationException::invalidParamsPassed(static::class);
             }
 
-            $data = DeserializePipeline::createFromArray()
-                ->sendThenReturn(new DeserializePipelinePassable(
-                    classContext: $context,
-                    data: $value
-                ))
-                ->data;
-
-            return $context->constructFromArray($data);
+            $dataCreationClosure = static function () use ($context, $value): static {
+                $data = DeserializePipeline::createFromArray()
+                    ->sendThenReturn(new DeserializePipelinePassable(
+                        classContext: $context,
+                        data: $value
+                    ))
+                    ->data;
+
+                return $context->constructFromArray($data);
+            };
+
+            return $context->isLazy
+                ? $context->newLazyProxy($dataCreationClosure)
+                : $dataCreationClosure();
         } catch (Throwable $e) {
             throw DataCreationException::unableToCreateInstance(static::class, $e);
         }
@@ -59,16 +65,22 @@ final public static function from(mixed $value): static
                 throw DeserializeException::invalidValue();
             }
 
-            $data = DeserializePipeline::hydrateFromArray()
-                ->sendThenReturn(new DeserializePipelinePassable(
-                    classContext: $context,
-                    data: $value
-                ))
-                ->data;
-
-            return $context->hasComputedProperties
-                ? $context->constructFromArray($data)
-                : static::instanceWithoutConstructorFrom($context, $data);
+            $dataCreationClosure = static function () use ($context, $value): static {
+                $data = DeserializePipeline::hydrateFromArray()
+                    ->sendThenReturn(new DeserializePipelinePassable(
+                        classContext: $context,
+                        data: $value
+                    ))
+                    ->data;
+
+                return $context->hasComputedProperties
+                    ? $context->constructFromArray($data)
+                    : static::instanceWithoutConstructorFrom($context, $data);
+            };
+
+            return $context->isLazy
+                ? $context->newLazyProxy($dataCreationClosure)
+                : $dataCreationClosure();
         } catch (Throwable $e) {
             throw DeserializeException::generic($e);
         }

src/Concerns/CloneableData.php

@@ -32,9 +32,13 @@ public function with(mixed ...$args): static
                 throw DataCreationException::invalidParamsPassed(static::class);
             }
 
-            return $context->hasComputedProperties
+            $cloneDataClosure = fn (): static => $context->hasComputedProperties
                 ? $this->cloneInstanceWithConstructorCall($context, $value)
                 : $this->cloneInstanceWithoutConstructorCall($context, $value);
+
+            return $context->isLazy
+                ? $context->newLazyProxy($cloneDataClosure)
+                : $cloneDataClosure();
         } catch (Throwable $t) {
             throw DataCreationException::unableToCloneInstanceWithNewData(static::class, $t);
         }

src/Contexts/ClassContext.php

@@ -3,6 +3,7 @@
 namespace Nuxtifyts\PhpDto\Contexts;
 
 use Exception;
+use Nuxtifyts\PhpDto\Attributes\Class\Lazy;
 use Nuxtifyts\PhpDto\Attributes\Class\MapName;
 use Nuxtifyts\PhpDto\Attributes\Class\WithNormalizer;
 use Nuxtifyts\PhpDto\Contexts\ClassContext\NameMapperConfig;
@@ -41,6 +42,8 @@ class ClassContext
 
     private(set) ?NameMapperConfig $nameMapperConfig = null;
 
+    private(set) bool $isLazy = false;
+
     /**
      * @param ReflectionClass<T> $reflection
      *
@@ -135,6 +138,8 @@ private function syncClassAttributes(): void
                 to: $instance->to
             );
         }
+
+        $this->isLazy = !empty($this->reflection->getAttributes(Lazy::class));
     }
 
     /**
@@ -204,19 +209,25 @@ public function newLazyProxy(callable $lazyProxyCallable): mixed
      */
     public function emptyValue(): mixed
     {
-        /** @var array<string, mixed> $args */
-        $args = [];
+        $emptyValueCreationClosure = function () {
+            /** @var array<string, mixed> $args */
+            $args = [];
 
-        foreach ($this->constructorParams as $paramName) {
-            $propertyContext = $this->properties[$paramName] ?? null;
+            foreach ($this->constructorParams as $paramName) {
+                $propertyContext = $this->properties[$paramName] ?? null;
 
-            if (!$propertyContext) {
-                throw DataCreationException::invalidProperty();
+                if (!$propertyContext) {
+                    throw DataCreationException::invalidProperty();
+                }
+
+                $args[$paramName] = $propertyContext->emptyValue();
             }
 
-            $args[$paramName] = $propertyContext->emptyValue();
-        }
+            return $this->newInstanceWithConstructorCall(...$args);
+        };
 
-        return $this->newInstanceWithConstructorCall(...$args);
+        return $this->isLazy
+            ? $this->newLazyProxy($emptyValueCreationClosure)
+            : $emptyValueCreationClosure();
     }
 }

tests/Dummies/LazyDummyData.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Nuxtifyts\PhpDto\Tests\Dummies;
+
+use Nuxtifyts\PhpDto\Attributes\Class\Lazy;
+use Nuxtifyts\PhpDto\Data;
+
+#[Lazy]
+final readonly class LazyDummyData extends Data
+{
+    public function __construct(
+        public string $propertyA,
+        public string $propertyB,
+    ) {
+    }
+}

tests/Unit/Attributes/LazyTest.php

@@ -0,0 +1,66 @@
+<?php
+
+namespace Nuxtifyts\PhpDto\Tests\Unit\Attributes;
+
+use Nuxtifyts\PhpDto\Attributes\Class\Lazy;
+use Nuxtifyts\PhpDto\Contexts\ClassContext;
+use Nuxtifyts\PhpDto\Data;
+use Nuxtifyts\PhpDto\Tests\Dummies\LazyDummyData;
+use Nuxtifyts\PhpDto\Tests\Unit\UnitCase;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\Attributes\UsesClass;
+use Throwable;
+
+#[CoversClass(Lazy::class)]
+#[CoversClass(Data::class)]
+#[CoversClass(ClassContext::class)]
+#[UsesClass(LazyDummyData::class)]
+final class LazyTest extends UnitCase
+{
+    /**
+     * @throws Throwable
+     */
+    #[Test]
+    public function will_be_able_to_detect_lazy_data_and_create_it_using_attribute(): void
+    {
+        $context = ClassContext::getInstance(LazyDummyData::class);
+
+        self::assertTrue($context->isLazy);
+
+        $lazyDummyData = LazyDummyData::create(propertyA: 'a', propertyB: 'b');
+
+        self::assertEquals('a', $lazyDummyData->propertyA);
+        self::assertEquals('b', $lazyDummyData->propertyB);
+
+        $lazyDummyData = LazyDummyData::from(['propertyA' => 'a', 'propertyB' => 'b']);
+        self::assertEquals('a', $lazyDummyData->propertyA);
+        self::assertEquals('b', $lazyDummyData->propertyB);
+    }
+
+    /**
+     * @throws Throwable
+     */
+    #[Test]
+    public function will_be_able_to_create_empty_instance_of_lazy_data(): void
+    {
+        $lazyDummyData = LazyDummyData::empty();
+
+        self::assertInstanceOf(LazyDummyData::class, $lazyDummyData);
+        self::assertEquals('', $lazyDummyData->propertyA);
+        self::assertEquals('', $lazyDummyData->propertyB);
+    }
+
+    /**
+     * @throws Throwable
+     */
+    #[Test]
+    public function will_be_able_to_clone_instance_of_lazy_data(): void
+    {
+        $lazyDummyData = LazyDummyData::create(propertyA: 'a', propertyB: 'b');
+        $clonedLazyDummyData = $lazyDummyData->with(propertyA: 'c', propertyB: 'd');
+
+        self::assertEquals('c', $clonedLazyDummyData->propertyA);
+        self::assertEquals('d', $clonedLazyDummyData->propertyB);
+    }
+}