Service locator for method resolver (#37)

Author: yoanm

features/demo_app/default_config/services.yaml

@@ -18,16 +18,8 @@ services:
     tags:
     - { name: 'json_rpc_http_server.jsonrpc_method', method: 'bundledGetAnotherDummy' }
 
-  ## Resolver mock
-  resolver:
-    class: DemoApp\Resolver\JsonRpcMethodResolver
-    tags: ['json_rpc_http_server.method_aware']
-
   ## Mapping aware service
   mapping_aware_service:
     public: true # In order to allow Behat context to load it later
     class: DemoApp\Collector\MappingCollector
     tags: ['json_rpc_http_server.method_aware']
-
-  # Alias resolver mock to bundle resolver
-  json_rpc_http_server.alias.method_resolver: '@resolver'

features/demo_app/src/Resolver/JsonRpcMethodResolver.php

@@ -55,6 +55,7 @@ public function load(array $configs, ContainerBuilder $container)
         );
         $loader->load('sdk.services.app.yaml');
         $loader->load('sdk.services.infra.yaml');
+        $loader->load('services.private.yaml');
         $loader->load('services.public.yaml');
     }
 
@@ -159,11 +160,18 @@ private function binJsonRpcMethods(ContainerBuilder $container) : void
         $jsonRpcMethodDefinitionList = (new JsonRpcMethodDefinitionHelper())
             ->findAndValidateJsonRpcMethodDefinition($container);
 
+        $methodMappingList = [];
         foreach ($jsonRpcMethodDefinitionList as $jsonRpcMethodServiceId => $methodNameList) {
             foreach ($methodNameList as $methodName) {
+                $methodMappingList[$methodName] = new Reference($jsonRpcMethodServiceId);
                 $this->bindJsonRpcMethod($methodName, $jsonRpcMethodServiceId, $mappingAwareServiceDefinitionList);
             }
         }
+
+        // Service locator for method resolver
+        // => first argument is an array of wanted service with keys as alias for internal use
+        $container->getDefinition('json_rpc_http_server.service_locator.method_resolver')
+            ->setArgument(0, $methodMappingList);
     }
 
     /**

src/DependencyInjection/JsonRpcHttpServerExtension.php

@@ -0,0 +1,31 @@
+<?php
+namespace Yoanm\SymfonyJsonRpcHttpServer\Resolver;
+
+use Psr\Container\ContainerInterface;
+use Yoanm\JsonRpcServer\Domain\JsonRpcMethodInterface;
+use Yoanm\JsonRpcServer\Domain\JsonRpcMethodResolverInterface;
+
+/**
+ * Class MethodResolver
+ */
+class MethodResolver implements JsonRpcMethodResolverInterface
+{
+    /** @var ContainerInterface */
+    private $locator;
+
+    public function __construct(ContainerInterface $locator)
+    {
+        $this->locator = $locator;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function resolve(string $methodName) : ?JsonRpcMethodInterface
+    {
+        return $this->locator->has($methodName)
+            ? $this->locator->get($methodName)
+            : null
+        ;
+    }
+}

src/Resolver/MethodResolver.php

@@ -0,0 +1,13 @@
+services:
+  _defaults:
+      public: false
+
+  json_rpc_http_server.service_locator.method_resolver:
+    class: Symfony\Component\DependencyInjection\ServiceLocator
+    tags: ['container.service_locator']
+    arguments:
+      - [] # <-- Will be defined during container compilation
+
+  # Alias method resolver (used in sdk.services.app.yml)
+  json_rpc_http_server.alias.method_resolver: '@json_rpc_http_server.method_resolver'
+

src/Resources/config/services.private.yaml

@@ -12,3 +12,7 @@ services:
     arguments:
       - '@event_dispatcher'
 
+  json_rpc_http_server.method_resolver:
+    class: Yoanm\SymfonyJsonRpcHttpServer\Resolver\MethodResolver
+    arguments:
+      - '@json_rpc_http_server.service_locator.method_resolver'

src/Resources/config/services.public.yaml

@@ -1,6 +1,7 @@
 <?php
 namespace Tests\Functional\DependencyInjection;
 
+use Symfony\Component\DependencyInjection\ServiceLocator;
 use Tests\Common\DependencyInjection\AbstractTestClass;
 use Yoanm\JsonRpcServer\App\Creator\ResponseCreator;
 use Yoanm\JsonRpcServer\App\Handler\ExceptionHandler;
@@ -14,6 +15,7 @@
 use Yoanm\SymfonyJsonRpcHttpServer\DependencyInjection\JsonRpcHttpServerExtension;
 use Yoanm\SymfonyJsonRpcHttpServer\Dispatcher\SymfonyJsonRpcServerDispatcher;
 use Yoanm\SymfonyJsonRpcHttpServer\Endpoint\JsonRpcHttpEndpoint;
+use Yoanm\SymfonyJsonRpcHttpServer\Resolver\MethodResolver;
 
 /**
  * /!\ This test class does not cover JsonRpcHttpServerExtension, it covers yaml configuration files
@@ -132,4 +134,23 @@ public function provideBundlePublicServiceIdAndClass()
             ],
         ];
     }
+
+    /**
+     * @return array
+     */
+    public function provideBundlePrivateServiceIdAndClass()
+    {
+        return [
+            'Bundle - Private - JSON-RPC method resolver ServiceLocator' => [
+                'serviceId' => 'json_rpc_http_server.service_locator.method_resolver',
+                'serviceClassName' => ServiceLocator::class,
+                'public' => true,
+            ],
+            'Bundle - Private - MethodResolver alias' => [
+                'serviceId' => 'json_rpc_http_server.alias.method_resolver',
+                'serviceClassName' => MethodResolver::class,
+                'public' => true,
+            ],
+        ];
+    }
 }

tests/Functional/DependencyInjection/ConfigFilesTest.php

@@ -0,0 +1,65 @@
+<?php
+namespace Tests\Functional\Endpoint;
+
+use PHPUnit\Framework\TestCase;
+use Prophecy\Prophecy\ObjectProphecy;
+use Psr\Container\ContainerInterface;
+use Yoanm\JsonRpcServer\Domain\JsonRpcMethodInterface;
+use Yoanm\SymfonyJsonRpcHttpServer\Resolver\MethodResolver;
+
+/**
+ * @covers Yoanm\SymfonyJsonRpcHttpServer\Resolver\MethodResolver
+ */
+class MethodResolverTest extends TestCase
+{
+    /** @var MethodResolver */
+    private $resolver;
+
+    /** @var ContainerInterface|ObjectProphecy */
+    private $locator;
+
+    protected function setUp()
+    {
+        $this->locator = $this->prophesize(ContainerInterface::class);
+
+        $this->resolver = new MethodResolver(
+            $this->locator->reveal()
+        );
+    }
+
+    public function testShouldReturnJsonRpcMethodIfRegistered()
+    {
+        $methodName = 'method_name';
+
+        $method = $this->prophesize(JsonRpcMethodInterface::class);
+
+        $this->locator->has($methodName)
+            ->willReturn(true)
+            ->shouldBeCalled()
+        ;
+
+        $this->locator->get($methodName)
+            ->willReturn($method->reveal())
+            ->shouldBeCalled()
+        ;
+
+        $this->assertSame(
+            $method->reveal(),
+            $this->resolver->resolve($methodName)
+        );
+    }
+
+    public function testShouldReturnNullIfNoMethodRegisteredForGivenName()
+    {
+        $methodName = 'method_name';
+
+        $this->locator->has($methodName)
+            ->willReturn(false)
+            ->shouldBeCalled()
+        ;
+
+        $this->assertNull(
+            $this->resolver->resolve($methodName)
+        );
+    }
+}