add tests

patchlevel · Mar 26, 2024 · 89214f4 · 89214f4
1 parent 00d280c
commit 89214f4
Show file tree

Hide file tree

Showing 11 changed files with 471 additions and 15 deletions.
diff --git a/baseline.xml b/baseline.xml
@@ -121,7 +121,7 @@
     <MixedMethodCall>
       <code><![CDATA[$method]]></code>
       <code><![CDATA[$method]]></code>
-      <code><![CDATA[$method]]></code>
+      <code><![CDATA[$methodName]]></code>
     </MixedMethodCall>
   </file>
   <file src="tests/Benchmark/BasicImplementation/Profile.php">
@@ -278,6 +278,14 @@
       <code><![CDATA[$id]]></code>
     </PropertyNotSetInConstructor>
   </file>
+  <file src="tests/Unit/Metadata/Subscriber/AttributeSubscriberMetadataFactoryTest.php">
+    <MissingParamType>
+      <code><![CDATA[$message]]></code>
+    </MissingParamType>
+    <ReservedWord>
+      <code><![CDATA[ProfileVisited&ProfileCreated $event]]></code>
+    </ReservedWord>
+  </file>
   <file src="tests/Unit/Subscription/Engine/DefaultSubscriptionEngineTest.php">
     <PossiblyUndefinedArrayOffset>
       <code><![CDATA[$update1]]></code>

diff --git a/src/Metadata/Subscriber/ArgumentTypeNotSupported.php b/src/Metadata/Subscriber/ArgumentTypeNotSupported.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Patchlevel\EventSourcing\Metadata\Subscriber;
+
+use Patchlevel\EventSourcing\Metadata\MetadataException;
+
+use function sprintf;
+
+final class ArgumentTypeNotSupported extends MetadataException
+{
+    public static function missingType(string $class, string $method, string $argumentName): self
+    {
+        return new self(
+            sprintf(
+                'Argument type for method "%s" in class "%s" is not supported. Argument "%s" must have a type.',
+                $method,
+                $class,
+                $argumentName,
+            ),
+        );
+    }
+
+    public static function onlyNamedTypeSupported(string $class, string $method, string $argumentName): self
+    {
+        return new self(
+            sprintf(
+                'Argument type for method "%s" in class "%s" is not supported. Argument "%s" must not have a union or intersection type.',
+                $method,
+                $class,
+                $argumentName,
+            ),
+        );
+    }
+}
diff --git a/src/Metadata/Subscriber/AttributeSubscriberMetadataFactory.php b/src/Metadata/Subscriber/AttributeSubscriberMetadataFactory.php
@@ -12,7 +12,6 @@
 use ReflectionClass;
 use ReflectionMethod;
 use ReflectionNamedType;
-use RuntimeException;
 
 use function array_key_exists;
 
@@ -102,8 +101,20 @@ private function subscribeMethod(ReflectionMethod $method): SubscribeMethodMetad
         foreach ($method->getParameters() as $parameter) {
             $type = $parameter->getType();
 
+            if ($type === null) {
+                throw ArgumentTypeNotSupported::missingType(
+                    $method->getDeclaringClass()->getName(),
+                    $method->getName(),
+                    $parameter->getName(),
+                );
+            }
+
             if (!$type instanceof ReflectionNamedType) {
-                throw new RuntimeException('parameter type is required');
+                throw ArgumentTypeNotSupported::onlyNamedTypeSupported(
+                    $method->getDeclaringClass()->getName(),
+                    $method->getName(),
+                    $parameter->getName(),
+                );
             }
 
             $arguments[] = new ArgumentMetadata(

diff --git a/src/Subscription/Subscriber/NoSuitableResolver.php b/src/Subscription/Subscriber/NoSuitableResolver.php
@@ -8,7 +8,7 @@
 
 use function sprintf;
 
-class NoSuitableResolver extends RuntimeException
+final class NoSuitableResolver extends RuntimeException
 {
     public function __construct(string $class, string $methodName, string $argumentName)
     {

diff --git a/tests/Unit/Metadata/Subscriber/AttributeSubscriberMetadataFactoryTest.php b/tests/Unit/Metadata/Subscriber/AttributeSubscriberMetadataFactoryTest.php
@@ -10,6 +10,9 @@
 use Patchlevel\EventSourcing\Attribute\Subscribe;
 use Patchlevel\EventSourcing\Attribute\Subscriber;
 use Patchlevel\EventSourcing\Attribute\Teardown;
+use Patchlevel\EventSourcing\Message\Message;
+use Patchlevel\EventSourcing\Metadata\Subscriber\ArgumentMetadata;
+use Patchlevel\EventSourcing\Metadata\Subscriber\ArgumentTypeNotSupported;
 use Patchlevel\EventSourcing\Metadata\Subscriber\AttributeSubscriberMetadataFactory;
 use Patchlevel\EventSourcing\Metadata\Subscriber\ClassIsNotASubscriber;
 use Patchlevel\EventSourcing\Metadata\Subscriber\DuplicateSetupMethod;
@@ -163,6 +166,92 @@ public function handle(): void
         );
     }
 
+    public function testSubscribeAttributes(): void
+    {
+        $subscriber = new #[Subscriber('foo', RunMode::FromBeginning)]
+        class {
+            #[Subscribe(ProfileVisited::class)]
+            public function profileVisited(Message $message): void
+            {
+            }
+
+            #[Subscribe(ProfileCreated::class)]
+            public function profileCreated(ProfileCreated $profileCreated, string $aggregateId): void
+            {
+            }
+        };
+
+        $metadataFactory = new AttributeSubscriberMetadataFactory();
+        $metadata = $metadataFactory->metadata($subscriber::class);
+
+        self::assertEquals(
+            [
+                ProfileVisited::class => [
+                    new SubscribeMethodMetadata('profileVisited', [
+                        new ArgumentMetadata('message', Message::class),
+                    ]),
+                ],
+                ProfileCreated::class => [
+                    new SubscribeMethodMetadata('profileCreated', [
+                        new ArgumentMetadata('profileCreated', ProfileCreated::class),
+                        new ArgumentMetadata('aggregateId', 'string'),
+                    ]),
+                ],
+            ],
+            $metadata->subscribeMethods,
+        );
+    }
+
+    public function testMissingArgumentType(): void
+    {
+        $this->expectException(ArgumentTypeNotSupported::class);
+
+        $subscriber = new #[Subscriber('foo', RunMode::FromBeginning)]
+        class {
+            // phpcs:disable
+            #[Subscribe(ProfileVisited::class)]
+            public function profileVisited($message): void
+            {
+            }
+            // phpcs:enable
+        };
+
+        $metadataFactory = new AttributeSubscriberMetadataFactory();
+        $metadataFactory->metadata($subscriber::class);
+    }
+
+    public function testUnionTypeNotSupported(): void
+    {
+        $this->expectException(ArgumentTypeNotSupported::class);
+
+        $subscriber = new #[Subscriber('foo', RunMode::FromBeginning)]
+        class {
+            #[Subscribe(ProfileVisited::class)]
+            public function profileVisited(ProfileVisited|ProfileCreated $event): void
+            {
+            }
+        };
+
+        $metadataFactory = new AttributeSubscriberMetadataFactory();
+        $metadataFactory->metadata($subscriber::class);
+    }
+
+    public function testIntersectionTypeNotSupported(): void
+    {
+        $this->expectException(ArgumentTypeNotSupported::class);
+
+        $subscriber = new #[Subscriber('foo', RunMode::FromBeginning)]
+        class {
+            #[Subscribe(ProfileVisited::class)]
+            public function profileVisited(ProfileVisited&ProfileCreated $event): void
+            {
+            }
+        };
+
+        $metadataFactory = new AttributeSubscriberMetadataFactory();
+        $metadataFactory->metadata($subscriber::class);
+    }
+
     public function testDuplicateSetupAttributeException(): void
     {
         $this->expectException(DuplicateSetupMethod::class);

diff --git a/tests/Unit/Subscription/Subscriber/ArgumentResolver/AggregateIdArgumentResolverTest.php b/tests/Unit/Subscription/Subscriber/ArgumentResolver/AggregateIdArgumentResolverTest.php
@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Patchlevel\EventSourcing\Tests\Unit\Subscription\Subscriber\ArgumentResolver;
+
+use DateTimeImmutable;
+use Patchlevel\EventSourcing\Aggregate\AggregateHeader;
+use Patchlevel\EventSourcing\Message\Message;
+use Patchlevel\EventSourcing\Metadata\Subscriber\ArgumentMetadata;
+use Patchlevel\EventSourcing\Subscription\Subscriber\ArgumentResolver\AggregateIdArgumentResolver;
+use Patchlevel\EventSourcing\Tests\Unit\Fixture\ProfileCreated;
+use Patchlevel\EventSourcing\Tests\Unit\Fixture\ProfileId;
+use Patchlevel\EventSourcing\Tests\Unit\Fixture\ProfileVisited;
+use PHPUnit\Framework\TestCase;
+
+/** @covers \Patchlevel\EventSourcing\Subscription\Subscriber\ArgumentResolver\AggregateIdArgumentResolver */
+final class AggregateIdArgumentResolverTest extends TestCase
+{
+    public function testSupport(): void
+    {
+        $resolver = new AggregateIdArgumentResolver();
+
+        self::assertTrue(
+            $resolver->support(
+                new ArgumentMetadata('aggregateId', 'string'),
+                ProfileCreated::class,
+            ),
+        );
+
+        self::assertTrue(
+            $resolver->support(
+                new ArgumentMetadata('aggregateRootId', 'string'),
+                ProfileCreated::class,
+            ),
+        );
+
+        self::assertFalse(
+            $resolver->support(
+                new ArgumentMetadata('foo', 'string'),
+                ProfileCreated::class,
+            ),
+        );
+    }
+
+    public function testResolve(): void
+    {
+        $event = new ProfileVisited(ProfileId::fromString('1'));
+
+        $resolver = new AggregateIdArgumentResolver();
+        $message = (new Message($event))->withHeader(
+            new AggregateHeader('foo', 'bar', 1, new DateTimeImmutable()),
+        );
+
+        self::assertSame(
+            'bar',
+            $resolver->resolve(
+                new ArgumentMetadata('foo', 'string'),
+                $message,
+            ),
+        );
+    }
+}
diff --git a/tests/Unit/Subscription/Subscriber/ArgumentResolver/EventArgumentResolverTest.php b/tests/Unit/Subscription/Subscriber/ArgumentResolver/EventArgumentResolverTest.php
@@ -0,0 +1,52 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Patchlevel\EventSourcing\Tests\Unit\Subscription\Subscriber\ArgumentResolver;
+
+use Patchlevel\EventSourcing\Message\Message;
+use Patchlevel\EventSourcing\Metadata\Subscriber\ArgumentMetadata;
+use Patchlevel\EventSourcing\Subscription\Subscriber\ArgumentResolver\EventArgumentResolver;
+use Patchlevel\EventSourcing\Tests\Unit\Fixture\ProfileCreated;
+use Patchlevel\EventSourcing\Tests\Unit\Fixture\ProfileId;
+use Patchlevel\EventSourcing\Tests\Unit\Fixture\ProfileVisited;
+use PHPUnit\Framework\TestCase;
+
+/** @covers \Patchlevel\EventSourcing\Subscription\Subscriber\ArgumentResolver\EventArgumentResolver */
+final class EventArgumentResolverTest extends TestCase
+{
+    public function testSupport(): void
+    {
+        $resolver = new EventArgumentResolver();
+
+        self::assertTrue(
+            $resolver->support(
+                new ArgumentMetadata('foo', ProfileCreated::class),
+                ProfileCreated::class,
+            ),
+        );
+
+        self::assertFalse(
+            $resolver->support(
+                new ArgumentMetadata('foo', ProfileVisited::class),
+                ProfileCreated::class,
+            ),
+        );
+    }
+
+    public function testResolve(): void
+    {
+        $event = new ProfileVisited(ProfileId::fromString('1'));
+
+        $resolver = new EventArgumentResolver();
+        $message = new Message($event);
+
+        self::assertSame(
+            $event,
+            $resolver->resolve(
+                new ArgumentMetadata('foo', ProfileVisited::class),
+                $message,
+            ),
+        );
+    }
+}
diff --git a/tests/Unit/Subscription/Subscriber/ArgumentResolver/MessageArgumentResolverTest.php b/tests/Unit/Subscription/Subscriber/ArgumentResolver/MessageArgumentResolverTest.php
@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Patchlevel\EventSourcing\Tests\Unit\Subscription\Subscriber\ArgumentResolver;
+
+use Patchlevel\EventSourcing\Message\Message;
+use Patchlevel\EventSourcing\Metadata\Subscriber\ArgumentMetadata;
+use Patchlevel\EventSourcing\Subscription\Subscriber\ArgumentResolver\MessageArgumentResolver;
+use PHPUnit\Framework\TestCase;
+use stdClass;
+
+/** @covers \Patchlevel\EventSourcing\Subscription\Subscriber\ArgumentResolver\MessageArgumentResolver */
+final class MessageArgumentResolverTest extends TestCase
+{
+    public function testSupport(): void
+    {
+        $resolver = new MessageArgumentResolver();
+
+        self::assertTrue(
+            $resolver->support(
+                new ArgumentMetadata('foo', Message::class),
+                'qux',
+            ),
+        );
+
+        self::assertFalse(
+            $resolver->support(
+                new ArgumentMetadata('foo', 'bar'),
+                'qux',
+            ),
+        );
+    }
+
+    public function testResolve(): void
+    {
+        $resolver = new MessageArgumentResolver();
+        $message = new Message(new stdClass());
+
+        self::assertSame(
+            $message,
+            $resolver->resolve(
+                new ArgumentMetadata('foo', Message::class),
+                $message,
+            ),
+        );
+    }
+}