Dispatcher validates the data types of the given parameters according to the message signature.

Author: ThomasNunninger

src/Magic/Dispatcher.php

@@ -15,6 +15,7 @@
 use ScaleUpStack\Metadata\FeatureAnalyzers\VirtualMethods;
 use ScaleUpStack\Metadata\Metadata\ClassMetadata;
 use ScaleUpStack\Metadata\Factory;
+use ScaleUpStack\Metadata\Metadata\DataTypeMetadata;
 use ScaleUpStack\Metadata\Metadata\VirtualMethodMetadata;
 
 final class Dispatcher
@@ -96,7 +97,12 @@ private function doInvocation(
                 throw new \Error("Calling a non-static method when not in object context.");
             }
 
-            $this->assertGivenParametersMatchMethodSignature($methodName, $arguments, $classMetadata);
+            $this->assertGivenParametersMatchMethodSignature(
+                $objectOrClassName,
+                $methodName,
+                $arguments,
+                $classMetadata
+            );
 
             $return = $callHandler->execute($objectOrClassName, $methodName, $arguments, $classMetadata);
 
@@ -158,16 +164,22 @@ private function determineCallHandler(
         return null;
     }
 
+    /**
+     * @param object|string $objectContext
+     */
     private function assertGivenParametersMatchMethodSignature(
+        $objectContext,
         string $methodName,
-        array $parameters,
+        array $givenParameters,
         ClassMetadata $classMetadata
     )
     {
+        /** @var VirtualMethodMetadata $methodMetadata */
         $methodMetadata = $classMetadata->features[VirtualMethods::class][$methodName];
-        $expectedParameterCount = count($methodMetadata->parameters);
 
-        $givenParametersCount = count($parameters);
+        // validate parameter count according to method signature
+        $expectedParameterCount = count($methodMetadata->parameters);
+        $givenParametersCount = count($givenParameters);
 
         if ($expectedParameterCount !== $givenParametersCount) {
             throw new \ArgumentCountError(
@@ -176,11 +188,31 @@ private function assertGivenParametersMatchMethodSignature(
                     $expectedParameterCount > $givenParametersCount ? 'few' : 'many',
                     $classMetadata->name,
                     $methodName,
-                    count($parameters),
+                    count($givenParameters),
                     $expectedParameterCount
                 )
             );
         }
+
+        // validate parameters' data types according to method signature
+        $key = 0;
+        /** @var DataTypeMetadata $signatureParameter */
+        foreach ($methodMetadata->parameters as $signatureParameterName => $signatureParameter) {
+            $parameterValue = $givenParameters[$key];
+            if (! $signatureParameter->validateVariable($parameterValue, $objectContext)) {
+                throw new \TypeError(
+                    sprintf(
+                        'Argument %s (%s) passed to %s() must be of the type %s, %s given',
+                        $key + 1,
+                        $signatureParameterName,
+                        $methodName,
+                        $signatureParameter->declaration(),
+                        gettype($parameterValue)
+                    )
+                );
+            }
+            $key++;
+        }
     }
 
     /**

tests/PhpUnit/Magic/DispatcherTest.php

@@ -80,6 +80,7 @@ public function it_invokes_a_virtual_static_method_on_some_object_via_some_call_
             'myFactoryMethod',
             [
                 17,
+                'some string'
             ],
             $supportedCallHandlers
         );
@@ -158,6 +159,41 @@ public function it_throws_an_exception_when_the_number_of_parameters_is_invalid(
         );
     }
 
+    /**
+     * @test
+     * @covers ::assertGivenParametersMatchMethodSignature()
+     */
+    public function it_throws_an_exception_on_invalid_parameter_types()
+    {
+        // given an object, and a list of supported call handlers
+        $object = new ClassForDispatcherTesting();
+        $supportedCallHandlers = [
+            [
+                NamedConstructor::class,
+                [
+                    'methodName' => 'myFactoryMethod',
+                ]
+            ]
+        ];
+
+        // when invoking an allowed method, but with wrong arguments
+        // then an exception is thrown
+        $this->expectException(\TypeError::class);
+        $this->expectExceptionMessage(
+            'Argument 2 (otherProperty) passed to myFactoryMethod() must be of the type string, integer given'
+        );
+
+        $result = Dispatcher::invoke(
+            $object,
+            'myFactoryMethod',
+            [
+                17,
+                42, // must be string
+            ],
+            $supportedCallHandlers
+        );
+    }
+
     /**
      * @test
      * @covers ::doInvocation()

tests/Resources/Magic/ClassForDispatcherTesting.php

@@ -13,10 +13,12 @@
 namespace ScaleUpStack\EasyObject\Tests\Resources\Magic;
 
 /**
- * @method static self myFactoryMethod(int $someProperty)
+ * @method static self myFactoryMethod(int $someProperty, string $otherProperty)
  * @method int getSomeProperty()
  */
 final class ClassForDispatcherTesting
 {
     private $someProperty = 42;
+
+    private $otherProperty;
 }