add tests

Author: DavidBadura

src/MetadataHydrator.php

@@ -64,9 +64,7 @@ public function hydrate(string $class, array $data): object
         }
 
         if ($this->eventDispatcher) {
-            $event = new PreHydrate($data, $metadata);
-            $this->eventDispatcher->dispatch($event);
-            $data = $event->data;
+            $data = $this->eventDispatcher->dispatch(new PreHydrate($data, $metadata))->data;
         }
 
         $object = $metadata->newInstance();
@@ -193,9 +191,7 @@ public function extract(object $object): array
             }
 
             if ($this->eventDispatcher) {
-                $event = new PostExtract($data, $metadata);
-                $this->eventDispatcher->dispatch($event);
-                $data = $event->data;
+                return $this->eventDispatcher->dispatch(new PostExtract($data, $metadata))->data;
             }
 
             return $data;

tests/Unit/Cryptography/CryptographySubscriberTest.php

@@ -0,0 +1,76 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Patchlevel\Hydrator\Tests\Unit\Cryptography;
+
+use Patchlevel\Hydrator\Cryptography\CryptographySubscriber;
+use Patchlevel\Hydrator\Cryptography\PayloadCryptographer;
+use Patchlevel\Hydrator\Event\PostExtract;
+use Patchlevel\Hydrator\Event\PreHydrate;
+use Patchlevel\Hydrator\Metadata\ClassMetadata;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+use Prophecy\PhpUnit\ProphecyTrait;
+use ReflectionClass;
+use stdClass;
+
+#[CoversClass(CryptographySubscriber::class)]
+final class CryptographySubscriberTest extends TestCase
+{
+    use ProphecyTrait;
+
+    public function testSubscriptions(): void
+    {
+        self::assertEquals([
+            PreHydrate::class => 'preHydrate',
+            PostExtract::class => 'postExtract',
+        ], CryptographySubscriber::getSubscribedEvents());
+    }
+
+    public function testPreHydrate(): void
+    {
+        $metadata = new ClassMetadata(
+            new ReflectionClass(stdClass::class),
+        );
+
+        $event = new PreHydrate(
+            ['foo' => 'bar'],
+            $metadata,
+        );
+
+        $cryptographer = $this->prophesize(PayloadCryptographer::class);
+        $cryptographer->decrypt(
+            $metadata,
+            ['foo' => 'bar'],
+        )->willReturn(['foo' => 'baz'])->shouldBeCalledOnce();
+
+        $subscriber = new CryptographySubscriber($cryptographer->reveal());
+        $subscriber->preHydrate($event);
+
+        self::assertEquals(['foo' => 'baz'], $event->data);
+    }
+
+    public function testPostExtract(): void
+    {
+        $metadata = new ClassMetadata(
+            new ReflectionClass(stdClass::class),
+        );
+
+        $event = new PostExtract(
+            ['foo' => 'bar'],
+            $metadata,
+        );
+
+        $cryptographer = $this->prophesize(PayloadCryptographer::class);
+        $cryptographer->encrypt(
+            $metadata,
+            ['foo' => 'bar'],
+        )->willReturn(['foo' => 'baz'])->shouldBeCalledOnce();
+
+        $subscriber = new CryptographySubscriber($cryptographer->reveal());
+        $subscriber->postExtract($event);
+
+        self::assertEquals(['foo' => 'baz'], $event->data);
+    }
+}

tests/Unit/MetadataHydratorTest.php

@@ -11,6 +11,8 @@
 use Patchlevel\Hydrator\ClassNotSupported;
 use Patchlevel\Hydrator\Cryptography\PayloadCryptographer;
 use Patchlevel\Hydrator\DenormalizationFailure;
+use Patchlevel\Hydrator\Event\PostExtract;
+use Patchlevel\Hydrator\Event\PreHydrate;
 use Patchlevel\Hydrator\Metadata\AttributeMetadataFactory;
 use Patchlevel\Hydrator\MetadataHydrator;
 use Patchlevel\Hydrator\NormalizationFailure;
@@ -37,6 +39,7 @@
 use Patchlevel\Hydrator\TypeMismatch;
 use PHPUnit\Framework\TestCase;
 use Prophecy\PhpUnit\ProphecyTrait;
+use Symfony\Component\EventDispatcher\EventDispatcherInterface;
 
 final class MetadataHydratorTest extends TestCase
 {
@@ -298,6 +301,76 @@ public function testEncrypt(): void
         self::assertSame($encryptedPayload, $return);
     }
 
+    public function testPreHydrate(): void
+    {
+        $object = new ProfileCreated(
+            ProfileId::fromString('1'),
+            Email::fromString('info@patchlevel.de'),
+        );
+
+        $payload = ['profileId' => '1', 'email' => 'info@patchlevel.de'];
+        $encryptedPayload = ['profileId' => '1', 'email' => 'encrypted'];
+
+        $metadataFactory = new AttributeMetadataFactory();
+
+        $event = new PreHydrate(
+            $encryptedPayload,
+            $metadataFactory->metadata(ProfileCreated::class),
+        );
+
+        $eventReturn = new PreHydrate(
+            $payload,
+            $metadataFactory->metadata(ProfileCreated::class),
+        );
+
+        $eventDispatcher = $this->prophesize(EventDispatcherInterface::class);
+        $eventDispatcher
+            ->dispatch($event)
+            ->willReturn($eventReturn)
+            ->shouldBeCalledOnce();
+
+        $hydrator = new MetadataHydrator($metadataFactory, eventDispatcher: $eventDispatcher->reveal());
+
+        $return = $hydrator->hydrate(ProfileCreated::class, $encryptedPayload);
+
+        self::assertEquals($object, $return);
+    }
+
+    public function testPostExtract(): void
+    {
+        $object = new ProfileCreated(
+            ProfileId::fromString('1'),
+            Email::fromString('info@patchlevel.de'),
+        );
+
+        $payload = ['profileId' => '1', 'email' => 'info@patchlevel.de'];
+        $encryptedPayload = ['profileId' => '1', 'email' => 'encrypted'];
+
+        $metadataFactory = new AttributeMetadataFactory();
+
+        $event = new PostExtract(
+            $payload,
+            $metadataFactory->metadata(ProfileCreated::class),
+        );
+
+        $eventReturn = new PostExtract(
+            $encryptedPayload,
+            $metadataFactory->metadata(ProfileCreated::class),
+        );
+
+        $eventDispatcher = $this->prophesize(EventDispatcherInterface::class);
+        $eventDispatcher
+            ->dispatch($event)
+            ->willReturn($eventReturn)
+            ->shouldBeCalledOnce();
+
+        $hydrator = new MetadataHydrator($metadataFactory, eventDispatcher: $eventDispatcher->reveal());
+
+        $return = $hydrator->extract($object);
+
+        self::assertSame($encryptedPayload, $return);
+    }
+
     public function testHydrateWithNormalizerInBaseClass(): void
     {
         $expected = new NormalizerInBaseClassDefinedDto(