Add demo app tests (#3)

Author: yoanm

.gitignore

@@ -2,3 +2,6 @@ vendor
 build
 #A library must not provide a composer.lock file
 composer.lock
+
+# Demo app excluded dirs
+features/demo_app/var/

behat.yml

@@ -2,4 +2,5 @@ default:
   suites:
     default:
       contexts:
-        - Tests\Functional\BehatContext\FeatureContext: ~
+        - Tests\Functional\BehatContext\SymfonyExtensionContext: ~
+        - Tests\Functional\BehatContext\DemoAppContext: ~

composer.json

@@ -23,7 +23,8 @@
     "autoload-dev": {
         "psr-4": {
             "Tests\\": "tests",
-            "Tests\\Functional\\BehatContext\\": "features/bootstrap"
+            "Tests\\Functional\\BehatContext\\": "features/bootstrap",
+            "DemoApp\\": "features/demo_app/src"
         }
     },
     "require": {
@@ -37,6 +38,9 @@
         "behat/behat": "~3.0",
         "squizlabs/php_codesniffer": "3.*",
         "phpunit/phpunit": "^6.0 || ^7.0",
-        "matthiasnoback/symfony-dependency-injection-test": "^2.0 || ^3.0"
+        "matthiasnoback/symfony-dependency-injection-test": "^2.0 || ^3.0",
+        "symfony/framework-bundle": "^3.4",
+        "symfony/http-kernel": "^3.4",
+        "symfony/routing": "^3.4"
     }
 }

features/bootstrap/DemoAppContext.php

@@ -0,0 +1,70 @@
+<?php
+namespace Tests\Functional\BehatContext;
+
+use Behat\Behat\Context\Context;
+use Behat\Gherkin\Node\PyStringNode;
+use DemoApp\BaseKernel;
+use DemoApp\DefaultKernel;
+use DemoApp\KernelWithCustomResolver;
+use PHPUnit\Framework\Assert;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+
+/**
+ * Defines application features from the specific context.
+ */
+class DemoAppContext implements Context
+{
+    /** @var Response|null */
+    private $lastResponse;
+    /** @var bool */
+    private $useCustomResolver = false;
+
+    /**
+     * @Given I use my DemoApp custom method resolver
+     */
+    public function givenIUseMyDemoAppCustomMethodResolve()
+    {
+        $this->useCustomResolver = true;
+    }
+
+    /**
+     * @When I send following :httpMethod input on :uri demoApp kernel endpoint:
+     */
+    public function whenISendFollowingPayloadToDemoApp($httpMethod, $uri, PyStringNode $payload)
+    {
+        $this->lastResponse = null;
+
+        $kernel = $this->getDemoAppKernel();
+        $kernel->boot();
+        $this->lastResponse = $kernel->handle(
+            Request::create($uri, $httpMethod, [], [], [], [], $payload->getRaw())
+        );
+    }
+
+    /**
+     * @Then I should have a :httpCode response from demoApp with following content:
+     */
+    public function thenIShouldHaveAResponseFromDemoAppWithFollowingContent($httpCode, PyStringNode $payload)
+    {
+        Assert::assertInstanceOf(Response::class, $this->lastResponse);
+        // Decode payload to get ride of indentation, spacing, etc
+        Assert::assertEquals(
+            json_decode($payload->getRaw(), true),
+            json_decode($this->lastResponse->getContent(), true)
+        );
+        Assert::assertSame((int) $httpCode, $this->lastResponse->getStatusCode());
+    }
+
+    /**
+     * @return BaseKernel
+     */
+    protected function getDemoAppKernel()
+    {
+        if (true === $this->useCustomResolver) {
+            return new KernelWithCustomResolver('prod', true);
+        }
+
+        return new DefaultKernel('prod', true);
+    }
+}

features/bootstrap/FeatureContext.php renamed to features/bootstrap/SymfonyExtensionContext.php

@@ -4,22 +4,23 @@
 use Behat\Behat\Context\Context;
 use Behat\Gherkin\Node\PyStringNode;
 use Behat\Gherkin\Node\TableNode;
+use DemoApp\Method\MethodB;
+use DemoApp\Resolver\JsonRpcMethodResolver;
 use PHPUnit\Framework\Assert;
 use Prophecy\Argument;
 use Prophecy\Prophet;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\DependencyInjection\Definition;
 use Symfony\Component\HttpFoundation\Request;
-use Tests\Functional\BehatContext\App\CustomMethodResolver;
-use Tests\Functional\BehatContext\App\JsonRpcMethod;
+use Yoanm\JsonRpcServer\Domain\Model\JsonRpcMethodInterface;
 use Yoanm\JsonRpcServer\Infra\Endpoint\JsonRpcEndpoint;
 use Yoanm\SymfonyJsonRpcHttpServer\Infra\Endpoint\JsonRpcHttpEndpoint;
 use Yoanm\SymfonyJsonRpcHttpServer\Infra\Symfony\DependencyInjection\JsonRpcHttpServerExtension;
 
 /**
  * Defines application features from the specific context.
  */
-class FeatureContext implements Context
+class SymfonyExtensionContext implements Context
 {
     const CUSTOM_METHOD_RESOLVER_SERVICE_ID = 'custom-method-resolver-service';
 
@@ -41,14 +42,15 @@ class FeatureContext implements Context
     public function __construct()
     {
         $this->prophet = new Prophet();
+        $this->extension = new JsonRpcHttpServerExtension();
     }
 
     /**
      * @Given I process the symfony extension
      */
     public function givenIProcessTheSymfonyExtension()
     {
-        (new JsonRpcHttpServerExtension())->load([], $this->getContainerBuilder());
+        $this->extension->load([], $this->getContainerBuilder());
     }
 
     /**
@@ -116,6 +118,7 @@ public function givenITagMyJsonRpcMethodServiceWithTagAndFollowingAttributes(
      */
     public function whenILoadEndpointFromService($serviceId)
     {
+        $this->extension->process($this->getContainerBuilder());
         $this->getContainerBuilder()->compile();
         $this->endpoint = $this->getContainerBuilder()->get($serviceId);
     }
@@ -152,7 +155,7 @@ private function assertEndpointRespondToCalls(JsonRpcHttpEndpoint $endpoint, arr
                     [
                         'jsonrpc' => '2.0',
                         'id' => $requestId,
-                        'result' => 'OK'
+                        'result' => 'MethodB'
                     ]
                 ),
                 $endpoint->index($request)->getContent()
@@ -161,19 +164,19 @@ private function assertEndpointRespondToCalls(JsonRpcHttpEndpoint $endpoint, arr
     }
 
     /**
-     * @return JsonRpcMethod
+     * @return JsonRpcMethodInterface
      */
     private function createJsonRpcMethod()
     {
-        return new JsonRpcMethod();
+        return new MethodB();
     }
 
     /**
      * @return Definition
      */
     private function createJsonRpcMethodDefinition()
     {
-        return (new Definition(JsonRpcMethod::class))->setPrivate(false);
+        return (new Definition(MethodB::class))->setPrivate(false);
     }
 
     /**
@@ -196,8 +199,8 @@ private function injectJsonRpcMethodToDefaultResolverService($methodName, $metho
     }
 
     /**
-     * @param string                   $methodName
-     * @param JsonRpcMethod|Definition $method
+     * @param string                            $methodName
+     * @param JsonRpcMethodInterface|Definition $method
      */
     private function injectJsonRpcMethodToCustomResolverService($methodName, $method)
     {
@@ -221,7 +224,7 @@ private function getContainerBuilder()
         if (!$this->containerBuilder) {
             $this->containerBuilder = new ContainerBuilder();
             // Add definition of custom resolver (without tags)
-            $customResolverDefinition = (new Definition(CustomMethodResolver::class))->setPrivate(false);
+            $customResolverDefinition = (new Definition(JsonRpcMethodResolver::class))->setPublic(true);
             $this->containerBuilder->setDefinition(self::CUSTOM_METHOD_RESOLVER_SERVICE_ID, $customResolverDefinition);
         }
         return $this->containerBuilder;

features/demo-app.feature

@@ -0,0 +1,75 @@
+Feature: demo symfony application
+
+  Scenario: Default method resolver with JSON-RPC method tags
+    # Ensure the two methods with tag have been loaded
+    When I send following "POST" input on "/my-json-rpc-endpoint" demoApp kernel endpoint:
+    """
+    {"jsonrpc": "2.0", "method": "methodA", "id": 1}
+    """
+    Then I should have a "200" response from demoApp with following content:
+    """
+    {"jsonrpc":"2.0", "result":"MethodA", "id":1}
+    """
+    When I send following "POST" input on "/my-json-rpc-endpoint" demoApp kernel endpoint:
+    """
+    {"jsonrpc": "2.0", "method": "MethodB", "id": 2}
+    """
+    Then I should have a "200" response from demoApp with following content:
+    """
+    {"jsonrpc":"2.0", "result":"MethodB", "id":2}
+    """
+
+  Scenario: Default method resolver with JSON-RPC methods container injection
+    # Ensure the two injected methods have been loaded
+    When I send following "POST" input on "/my-json-rpc-endpoint" demoApp kernel endpoint:
+    """
+    {"jsonrpc": "2.0", "method": "getDummy", "id": 3}
+    """
+    Then I should have a "200" response from demoApp with following content:
+    """
+    {"jsonrpc":"2.0", "result":"MethodC", "id":3}
+    """
+    When I send following "POST" input on "/my-json-rpc-endpoint" demoApp kernel endpoint:
+    """
+    {"jsonrpc": "2.0", "method": "getAnotherDummy", "id": 4}
+    """
+    Then I should have a "200" response from demoApp with following content:
+    """
+    {"jsonrpc":"2.0", "result":"MethodD", "id":4}
+    """
+
+  Scenario: custom method resolver
+    Given I use my DemoApp custom method resolver
+    # Ensure all methods have been loaded
+    When I send following "POST" input on "/my-json-rpc-endpoint" demoApp kernel endpoint:
+    """
+    {"jsonrpc": "2.0", "method": "custom_methodA", "id": 1}
+    """
+    Then I should have a "200" response from demoApp with following content:
+    """
+    {"jsonrpc":"2.0", "result":"MethodA", "id":1}
+    """
+    When I send following "POST" input on "/my-json-rpc-endpoint" demoApp kernel endpoint:
+    """
+    {"jsonrpc": "2.0", "method": "custom_methodB", "id": 2}
+    """
+    Then I should have a "200" response from demoApp with following content:
+    """
+    {"jsonrpc":"2.0", "result":"MethodB", "id":2}
+    """
+    When I send following "POST" input on "/my-json-rpc-endpoint" demoApp kernel endpoint:
+    """
+    {"jsonrpc": "2.0", "method": "custom_methodC", "id": 3}
+    """
+    Then I should have a "200" response from demoApp with following content:
+    """
+    {"jsonrpc":"2.0", "result":"MethodC", "id":3}
+    """
+    When I send following "POST" input on "/my-json-rpc-endpoint" demoApp kernel endpoint:
+    """
+    {"jsonrpc": "2.0", "method": "custom_methodD", "id": 4}
+    """
+    Then I should have a "200" response from demoApp with following content:
+    """
+    {"jsonrpc":"2.0", "result":"MethodD", "id":4}
+    """

features/demo_app/config/bundles.php

@@ -0,0 +1,4 @@
+<?php
+return [
+    Symfony\Bundle\FrameworkBundle\FrameworkBundle::class => ['all' => true],
+];

features/demo_app/config/config.yaml

@@ -0,0 +1,4 @@
+framework:
+    secret: '%env(APP_SECRET)%'
+
+yoanm_jsonrpc_http_server: ~

features/demo_app/config/custom_method_resolver.yaml

@@ -0,0 +1,25 @@
+# Configure your resolver and add the required tag
+services:
+  jsonrpc.custom_method_resolver:
+    class: Tests\Common\Infra\Symfony\DependencyInjection\CustomMethodResolverClass
+    tags: ['yoanm.jsonrpc_http_server.method_resolver']
+
+    # Inject your JSON-RPC methods (They cannot be automatically injected as resolver implementation is on your own)
+    calls:
+      - method: 'addMethod'
+        arguments:
+            - '@jsonrpc.method.a'
+            - 'custom_methodA'
+      - method: 'addMethod'
+        arguments:
+            - '@jsonrpc.method.b'
+            - 'custom_methodB'
+      - method: 'addMethod'
+        arguments:
+            - '@jsonrpc.method.c'
+            - 'custom_methodC'
+      - method: 'addMethod'
+        arguments:
+            - '@jsonrpc.method.d'
+            - 'custom_methodD'
+

features/demo_app/config/routes.yaml

@@ -0,0 +1,5 @@
+# Configure the HTTP JSON-RPC endpoint on any path
+# And configure the controller
+homepage:
+    path: /my-json-rpc-endpoint
+    defaults: { _controller: 'yoanm.jsonrpc_http_server.endpoint:index' }