test: test bundle in framework

Author: ph-fritsche

test/Fixtures/MyException.php

@@ -0,0 +1,8 @@
+<?php
+namespace Pitch\AdrBundle\Fixtures;
+
+use Exception;
+
+class MyException extends Exception
+{
+}

test/Fixtures/MyResponseHandler.php

@@ -0,0 +1,20 @@
+<?php
+namespace Pitch\AdrBundle\Fixtures;
+
+use Pitch\AdrBundle\Responder\ResponseHandlerInterface;
+use Pitch\AdrBundle\Responder\ResponsePayloadEvent;
+
+class MyResponseHandler implements ResponseHandlerInterface
+{
+    public function getSupportedPayloadTypes(): array
+    {
+        return [
+            MyResponseHandler::class,
+        ];
+    }
+
+    public function handleResponsePayload(ResponsePayloadEvent $payloadEvent)
+    {
+        $payloadEvent->payload = 'foo';
+    }
+}

test/Fixtures/MyResponsePayload.php

@@ -0,0 +1,6 @@
+<?php
+namespace Pitch\AdrBundle\Fixtures;
+
+class MyResponsePayload
+{
+}

test/PitchAdrBundleTest.php

@@ -1,29 +1,145 @@
 <?php
 namespace Pitch\AdrBundle;
 
+use Pitch\AdrBundle\Action\ActionProxy;
+use Pitch\AdrBundle\Fixtures\MyException;
+use Pitch\AdrBundle\Fixtures\MyResponseHandler;
+use Pitch\AdrBundle\PitchAdrBundle;
+use Pitch\Annotation\PitchAnnotationBundle;
+use RuntimeException;
+use Symfony\Bundle\FrameworkBundle\FrameworkBundle;
+use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
+use Symfony\Component\Config\Loader\LoaderInterface;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
-use Pitch\AdrBundle\DependencyInjection\Compiler\ResponseHandlerPass;
-use Pitch\AdrBundle\DependencyInjection\PitchAdrExtension;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\EventDispatcher\EventDispatcher;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpKernel\Event\ControllerArgumentsEvent;
+use Symfony\Component\HttpKernel\Event\ControllerEvent;
+use Symfony\Component\HttpKernel\Event\ViewEvent;
+use Symfony\Component\HttpKernel\HttpKernelInterface;
+use Symfony\Component\HttpKernel\Kernel;
+use Symfony\Component\HttpKernel\KernelEvents;
 
-class PitchAdrBundleTest extends \PHPUnit\Framework\TestCase
+class PitchAdrBundleTest extends KernelTestCase
 {
-    public function testAddCompilerPass()
+    protected EventDispatcher $dispatcher;
+
+    protected static function getKernelClass()
+    {
+        return get_class(new class('', true) extends Kernel
+        {
+            public function getProjectDir()
+            {
+                return $this->dir ??= sys_get_temp_dir() . '/PitchForm-' . uniqid() . '/';
+            }
+
+            public function registerBundles(): iterable
+            {
+                return [
+                    new FrameworkBundle(),
+                    new PitchAnnotationBundle(),
+                    new PitchAdrBundle(),
+                ];
+            }
+
+            public function registerContainerConfiguration(LoaderInterface $loader)
+            {
+                $loader->load(function (ContainerBuilder $containerBuilder) {
+                    $containerBuilder->setParameter('kernel.secret', 'secret');
+                });
+
+                $loader->load(function (ContainerBuilder $containerBuilder) {
+                    $containerBuilder->setDefinition(
+                        'myHandler',
+                        new Definition(MyResponseHandler::class),
+                    );
+                });
+            }
+        });
+    }
+
+    protected function boot(): void
+    {
+        self::bootKernel();
+
+        $this->dispatcher = self::$kernel->getContainer()->get('event_dispatcher');
+    }
+
+    protected function dispatchControllerArgumentsEvent(
+        callable $controller
+    ): ControllerArgumentsEvent {
+        $request = new Request();
+        $controllerEvent = new ControllerEvent(self::$kernel, $controller, $request, null);
+
+        $this->dispatcher->dispatch($controllerEvent, KernelEvents::CONTROLLER);
+
+        $event = new ControllerArgumentsEvent(self::$kernel, $controllerEvent->getController(), [], $request, null);
+
+        $this->dispatcher->dispatch($event, KernelEvents::CONTROLLER_ARGUMENTS);
+
+        return $event;
+    }
+
+    public function testGracefulExceptions()
     {
-        $container = $this->createMock(ContainerBuilder::class);
+        $this->boot();
+        $controller = new class {
+            /**
+             * @\Pitch\AdrBundle\Configuration\Graceful(MyException::class)
+             */
+            public function throwMyExceptionGraceful()
+            {
+                throw new MyException();
+            }
+
+            public function throwRuntimeException()
+            {
+                // this is graceful per default global graceful
+                throw new RuntimeException();
+            }
+
+            public function throwMyException()
+            {
+                throw new MyException();
+            }
+        };
+
+        $event = $this->dispatchControllerArgumentsEvent([$controller, 'throwMyExceptionGraceful']);
+
+        $this->assertInstanceOf(ActionProxy::class, $event->getController());
+        $this->assertInstanceOf(MyException::class, $event->getController()());
+
+        $event = $this->dispatchControllerArgumentsEvent([$controller, 'throwRuntimeException']);
+
+        $this->assertInstanceOf(ActionProxy::class, $event->getController());
+        $this->assertInstanceOf(RuntimeException::class, $event->getController()());
 
-        $container->expects($this->once())->method('addCompilerPass')
-            ->with($this->isInstanceOf(ResponseHandlerPass::class));
+        $event = $event = $this->dispatchControllerArgumentsEvent([$controller, 'throwMyException']);
 
-        $bundle = new PitchAdrBundle();
+        $this->assertInstanceOf(ActionProxy::class, $event->getController());
 
-        /** @var ContainerBuilder $container */
-        $bundle->build($container);
+        $this->expectException(MyException::class);
+        $event->getController()();
     }
 
-    public function testGetContainerExtension()
+    protected function dispatchViewEvent($payload, Request $request = null)
     {
-        $bundle = new PitchAdrBundle();
+        $request ??= new Request();
+
+        $event = new ViewEvent(self::$kernel, $request, HttpKernelInterface::MASTER_REQUEST, $payload);
+
+        $this->dispatcher->dispatch($event, KernelEvents::VIEW);
+
+        return $event;
+    }
+
+    public function testResponder()
+    {
+        $this->boot();
+
+        $event = $this->dispatchViewEvent('foo');
 
-        $this->assertInstanceOf(PitchAdrExtension::class, $bundle->getContainerExtension());
+        $this->assertEquals(['value' => 'foo'], $event->getControllerResult());
     }
 }