Fix AggregateTypeResolver to respect interface, improve test coverage (#308)

* Fix AggregateTypeResolver to respect interface, improve test coverage

* Shift around where exception expectation is declared

Author: ben-challis

src/MapAggregateTypeResolver.php

@@ -34,9 +34,6 @@ public function __construct(array $map)
 
     public function resolve(object $aggregate): AggregateType
     {
-        $aggregateType = $this->map[$aggregate::class] ?? null;
-        \assert($aggregateType instanceof AggregateType);
-
-        return $aggregateType;
+        return $this->map[$aggregate::class] ?? throw CannotResolveAggregateType::of($aggregate, 'Class is not mapped');
     }
 }

tests/helper/.gitkeep

@@ -49,7 +49,9 @@ public function it_throws_when_constructing_from_integer_less_than_one(int $less
      */
     public function it_can_provide_the_next_aggregate_version_that_follows_it(): void
     {
-        $this->assertSame(2, AggregateVersion::fromInteger(1)->next()->toInteger());
+        $v1 = AggregateVersion::fromInteger(1);
+        $this->assertSame(2, $v1->next()->toInteger());
+        $this->assertSame(1, $v1->toInteger());
     }
 
     /**

tests/unit/.gitkeep

@@ -6,6 +6,7 @@
 
 use Lendable\Aggregate\AggregateId;
 use Lendable\Aggregate\AggregateIdExtractor;
+use Lendable\Aggregate\CannotExtractAggregateId;
 use Lendable\Aggregate\ClosureAggregateIdExtractor;
 use Lendable\Aggregate\Testing\AggregateIdExtractorSpec;
 use Tests\Fixture\Lendable\Aggregate\Blog\Domain\Email;
@@ -36,4 +37,46 @@ protected function createAggregateWithExpectedAggregateId(): object
             Email::fromString('foo@example.com')
         );
     }
+
+    /**
+     * @test
+     */
+    public function it_rethrows_any_interface_compliant_exception_from_the_closure(): void
+    {
+        $aggregate = new class () {
+        };
+        $exception = CannotExtractAggregateId::from($aggregate);
+
+        $extractor = new ClosureAggregateIdExtractor(static function (object $aggregate) use ($exception): AggregateId {
+            throw $exception;
+        });
+
+        $this->expectExceptionObject($exception);
+
+        $extractor->extract($aggregate);
+    }
+
+    /**
+     * @test
+     */
+    public function it_wraps_and_throws_for_any_non_interface_compliant_exception_from_the_closure(): void
+    {
+        $aggregate = new class () {
+        };
+        $exception = new \Exception();
+
+        $extractor = new ClosureAggregateIdExtractor(static function (object $aggregate) use ($exception): AggregateId {
+            throw $exception;
+        });
+        $wasAnExceptionThrown = false;
+
+        try {
+            $extractor->extract($aggregate);
+        } catch (CannotExtractAggregateId $thrown) {
+            $wasAnExceptionThrown = true;
+            $this->assertSame($exception, $thrown->getPrevious());
+        }
+
+        $this->assertTrue($wasAnExceptionThrown);
+    }
 }

tests/unit/AggregateVersionTest.php

@@ -5,6 +5,7 @@
 namespace Tests\Unit\Lendable\Aggregate;
 
 use Lendable\Aggregate\AggregateType;
+use Lendable\Aggregate\CannotResolveAggregateType;
 use Lendable\Aggregate\MapAggregateTypeResolver;
 use PHPUnit\Framework\TestCase;
 
@@ -22,4 +23,46 @@ public function it_can_resolve_an_aggregate_type_for_a_mapped_aggregate_root():
 
         $this->assertSame('foo', $fixture->resolve(new \stdClass())->toString());
     }
+
+    /**
+     * @test
+     */
+    public function it_throws_if_a_mapped_class_does_not_exist(): void
+    {
+        $this->expectException(\InvalidArgumentException::class);
+        $this->expectExceptionMessage('All map keys must be class names that exist, FooBarBaz does not exist.');
+
+        // @phpstan-ignore-next-line intentional undefined class.
+        new MapAggregateTypeResolver([\FooBarBaz::class => AggregateType::fromString('FooBarBaz')]);
+    }
+
+    /**
+     * @test
+     */
+    public function it_throws_if_a_mapped_value_is_not_an_aggregate_type(): void
+    {
+        $badValue = new class () {
+        };
+
+        $this->expectException(\InvalidArgumentException::class);
+        $this->expectExceptionMessage(\sprintf('All map values must be instances of %s, %s is not', AggregateType::class, $badValue::class));
+
+        // @phpstan-ignore-next-line intentionally non-compliant value passed.
+        new MapAggregateTypeResolver([\stdClass::class => $badValue]);
+    }
+
+    /**
+     * @test
+     */
+    public function it_throws_if_cannot_resolve_an_aggregate_as_not_mapped(): void
+    {
+        $this->expectException(CannotResolveAggregateType::class);
+
+        $fixture = new MapAggregateTypeResolver([\stdClass::class => AggregateType::fromString('foo')]);
+        $fixture->resolve(
+            // @phpstan-ignore-next-line intentional bad method call violating static analysis for runtime check.
+            new class () {
+            }
+        );
+    }
 }