add tests

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">

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)
     {

tests/Unit/Metadata/Subscriber/AttributeSubscriberMetadataFactoryTest.php

@@ -10,6 +10,8 @@
 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\AttributeSubscriberMetadataFactory;
 use Patchlevel\EventSourcing\Metadata\Subscriber\ClassIsNotASubscriber;
 use Patchlevel\EventSourcing\Metadata\Subscriber\DuplicateSetupMethod;
@@ -163,6 +165,42 @@ 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 testDuplicateSetupAttributeException(): void
     {
         $this->expectException(DuplicateSetupMethod::class);

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,
+            ),
+        );
+    }
+}

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,
+            ),
+        );
+    }
+}

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,
+            ),
+        );
+    }
+}

tests/Unit/Subscription/Subscriber/ArgumentResolver/RecordedOnArgumentResolverTest.php

@@ -0,0 +1,59 @@
+<?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\RecordedOnArgumentResolver;
+use PHPUnit\Framework\TestCase;
+use stdClass;
+
+/** @covers \Patchlevel\EventSourcing\Subscription\Subscriber\ArgumentResolver\RecordedOnArgumentResolver */
+final class RecordedOnArgumentResolverTest extends TestCase
+{
+    public function testSupport(): void
+    {
+        $resolver = new RecordedOnArgumentResolver();
+
+        self::assertTrue(
+            $resolver->support(
+                new ArgumentMetadata('foo', DateTimeImmutable::class),
+                'qux',
+            ),
+        );
+
+        self::assertFalse(
+            $resolver->support(
+                new ArgumentMetadata('foo', 'bar'),
+                'qux',
+            ),
+        );
+    }
+
+    public function testResolve(): void
+    {
+        $date = new DateTimeImmutable();
+
+        $resolver = new RecordedOnArgumentResolver();
+        $message = (new Message(new stdClass()))->withHeader(
+            new AggregateHeader(
+                'foo',
+                'bar',
+                1,
+                $date,
+            ),
+        );
+
+        self::assertSame(
+            $date,
+            $resolver->resolve(
+                new ArgumentMetadata('foo', DateTimeImmutable::class),
+                $message,
+            ),
+        );
+    }
+}

tests/Unit/Subscription/Subscriber/MetadataSubscriberAccessorRepositoryTest.php

@@ -5,6 +5,8 @@
 namespace Patchlevel\EventSourcing\Tests\Unit\Subscription\Subscriber;
 
 use Patchlevel\EventSourcing\Attribute\Subscriber;
+use Patchlevel\EventSourcing\Message\Message;
+use Patchlevel\EventSourcing\Metadata\Subscriber\ArgumentMetadata;
 use Patchlevel\EventSourcing\Metadata\Subscriber\AttributeSubscriberMetadataFactory;
 use Patchlevel\EventSourcing\Subscription\RunMode;
 use Patchlevel\EventSourcing\Subscription\Subscriber\ArgumentResolver;
@@ -32,15 +34,29 @@ class {
         };
         $metadataFactory = new AttributeSubscriberMetadataFactory();
 
+        $customResolver = new class implements ArgumentResolver\ArgumentResolver {
+            public function resolve(ArgumentMetadata $argument, Message $message): mixed
+            {
+                return null;
+            }
+
+            public function support(ArgumentMetadata $argument, string $eventClass): bool
+            {
+                return false;
+            }
+        };
+
         $repository = new MetadataSubscriberAccessorRepository(
             [$subscriber],
             $metadataFactory,
+            [$customResolver],
         );
 
         $accessor = new MetadataSubscriberAccessor(
             $subscriber,
             $metadataFactory->metadata($subscriber::class),
             [
+                $customResolver,
                 new ArgumentResolver\MessageArgumentResolver(),
                 new ArgumentResolver\EventArgumentResolver(),
                 new ArgumentResolver\AggregateIdArgumentResolver(),