Merge remote-tracking branch 'MyIgel/routing'

composer.json

@@ -22,6 +22,7 @@
         "illuminate/container": "5.5.*",
         "illuminate/database": "5.5.*",
         "illuminate/support": "^5.5",
+        "nikic/fast-route": "^1.3",
         "psr/container": "^1.0",
         "psr/http-server-middleware": "^1.0",
         "psr/log": "^1.0",

config/app.php

@@ -8,20 +8,22 @@ return [
         \Engelsystem\Logger\LoggerServiceProvider::class,
         \Engelsystem\Exceptions\ExceptionsServiceProvider::class,
         \Engelsystem\Config\ConfigServiceProvider::class,
-        \Engelsystem\Routing\RoutingServiceProvider::class,
+        \Engelsystem\Http\UrlGeneratorServiceProvider::class,
         \Engelsystem\Renderer\RendererServiceProvider::class,
         \Engelsystem\Database\DatabaseServiceProvider::class,
         \Engelsystem\Http\RequestServiceProvider::class,
         \Engelsystem\Http\SessionServiceProvider::class,
         \Engelsystem\Http\ResponseServiceProvider::class,
         \Engelsystem\Http\Psr7ServiceProvider::class,
+        \Engelsystem\Middleware\RouteDispatcherServiceProvider::class,
+        \Engelsystem\Middleware\RequestHandlerServiceProvider::class,
     ],
 
     // Application middleware
     'middleware' => [
         \Engelsystem\Middleware\SendResponseHandler::class,
         \Engelsystem\Middleware\ExceptionHandler::class,
-        \Engelsystem\Middleware\LegacyMiddleware::class,
+        \Engelsystem\Middleware\RouteDispatcher::class,
-        \Engelsystem\Middleware\NotFoundResponse::class,
+        \Engelsystem\Middleware\RequestHandler::class,
     ],
 ];

config/routes.php

@@ -0,0 +1,14 @@
+<?php
+
+use FastRoute\RouteCollector;
+use Psr\Http\Message\ServerRequestInterface;
+
+/** @var RouteCollector $route */
+
+/** Demo route endpoint, TODO: Remove */
+$route->addRoute('GET', '/hello/{name}', function ($request) {
+    /** @var ServerRequestInterface $request */
+    $name = $request->getAttribute('name');
+
+    return response(sprintf('Hello %s!', htmlspecialchars($name)));
+});

src/Http/LegacyUrlGenerator.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace Engelsystem\Routing;
+namespace Engelsystem\Http;
 
 /**
  * Provides urls when webserver rewriting is disabled.
@@ -14,7 +14,7 @@ class LegacyUrlGenerator extends UrlGenerator
      * @param array  $parameters
      * @return string urls in the form <app url>/index.php?p=<path>&<parameters>
      */
-    public function linkTo($path, $parameters = [])
+    public function to($path, $parameters = [])
     {
         $page = ltrim($path, '/');
         if (!empty($page)) {
@@ -22,7 +22,7 @@ class LegacyUrlGenerator extends UrlGenerator
             $parameters = array_merge(['p' => $page], $parameters);
         }
 
-        $uri = parent::linkTo('index.php', $parameters);
+        $uri = parent::to('index.php', $parameters);
         $uri = preg_replace('~(/index\.php)+~', '/index.php', $uri);
         $uri = preg_replace('~(/index\.php)$~', '/', $uri);
 

src/Http/UrlGenerator.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace Engelsystem\Routing;
+namespace Engelsystem\Http;
 
 /**
  * Provides urls when rewriting on the webserver is enabled. (default)
@@ -14,7 +14,7 @@ class UrlGenerator implements UrlGeneratorInterface
      * @param array  $parameters
      * @return string url in the form [app url]/[path]?[parameters]
      */
-    public function linkTo($path, $parameters = [])
+    public function to($path, $parameters = [])
     {
         $path = '/' . ltrim($path, '/');
         $request = app('request');

src/Http/UrlGeneratorInterface.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace Engelsystem\Routing;
+namespace Engelsystem\Http;
 
 /**
  * To switch between different URL schemes.
@@ -12,5 +12,5 @@ interface UrlGeneratorInterface
      * @param array  $parameters
      * @return string
      */
-    public function linkTo($path, $parameters = []);
+    public function to($path, $parameters = []);
 }

src/Http/UrlGeneratorServiceProvider.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace Engelsystem\Http;
+
+use Engelsystem\Container\ServiceProvider;
+
+class UrlGeneratorServiceProvider extends ServiceProvider
+{
+    public function register()
+    {
+        $urlGenerator = $this->app->make(UrlGenerator::class);
+        $this->app->instance('http.urlGenerator', $urlGenerator);
+    }
+}

src/Middleware/CallableHandler.php

@@ -0,0 +1,77 @@
+<?php
+
+namespace Engelsystem\Middleware;
+
+use Engelsystem\Container\Container;
+use Engelsystem\Http\Response;
+use InvalidArgumentException;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\MiddlewareInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+
+class CallableHandler implements MiddlewareInterface, RequestHandlerInterface
+{
+    /** @var callable */
+    protected $callable;
+
+    /** @var Container */
+    protected $container;
+
+    /**
+     * @param callable  $callable The callable that should be wrapped
+     * @param Container $container
+     */
+    public function __construct(callable $callable, Container $container = null)
+    {
+        $this->callable = $callable;
+        $this->container = $container;
+    }
+
+    /**
+     * Process an incoming server request and return a response, optionally delegating
+     * response creation to a handler.
+     *
+     * @param ServerRequestInterface  $request
+     * @param RequestHandlerInterface $handler
+     * @return ResponseInterface
+     */
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
+    {
+        return $this->execute([$request, $handler]);
+    }
+
+    /**
+     * Handle the request and return a response.
+     *
+     * @param ServerRequestInterface $request
+     * @return ResponseInterface
+     */
+    public function handle(ServerRequestInterface $request): ResponseInterface
+    {
+        return $this->execute([$request]);
+    }
+
+    /**
+     * Execute the callable and return a response
+     *
+     * @param array $arguments
+     * @return ResponseInterface
+     */
+    protected function execute(array $arguments = []): ResponseInterface
+    {
+        $return = call_user_func_array($this->callable, $arguments);
+
+        if ($return instanceof ResponseInterface) {
+            return $return;
+        }
+
+        if (!$this->container instanceof Container) {
+            throw new InvalidArgumentException('Unable to resolve response');
+        }
+
+        /** @var Response $response */
+        $response = $this->container->get('response');
+        return $response->withContent($return);
+    }
+}

src/Middleware/Dispatcher.php

@@ -12,6 +12,8 @@ use Psr\Http\Server\RequestHandlerInterface;
 
 class Dispatcher implements MiddlewareInterface, RequestHandlerInterface
 {
+    use ResolvesMiddlewareTrait;
+
     /** @var MiddlewareInterface[]|string[] */
     protected $stack;
 
@@ -70,10 +72,7 @@ class Dispatcher implements MiddlewareInterface, RequestHandlerInterface
             throw new LogicException('Middleware queue is empty');
         }
 
-        if (is_string($middleware)) {
+        $middleware = $this->resolveMiddleware($middleware);
-            $middleware = $this->resolveMiddleware($middleware);
-        }
-
         if (!$middleware instanceof MiddlewareInterface) {
             throw new InvalidArgumentException('Middleware is no instance of ' . MiddlewareInterface::class);
         }
@@ -81,25 +80,6 @@ class Dispatcher implements MiddlewareInterface, RequestHandlerInterface
         return $middleware->process($request, $this);
     }
 
-    /**
-     * Resolve the middleware with the container
-     *
-     * @param string $middleware
-     * @return MiddlewareInterface
-     */
-    protected function resolveMiddleware($middleware)
-    {
-        if (!$this->container instanceof Application) {
-            throw new InvalidArgumentException('Unable to resolve middleware ' . $middleware);
-        }
-
-        if ($this->container->has($middleware)) {
-            return $this->container->get($middleware);
-        }
-
-        return $this->container->make($middleware);
-    }
-
     /**
      * @param Application $container
      */

src/Middleware/LegacyMiddleware.php

@@ -83,7 +83,9 @@ class LegacyMiddleware implements MiddlewareInterface
         }
 
         if (empty($title) and empty($content)) {
-            return $handler->handle($request);
+            $page = '404';
+            $title = _('Page not found');
+            $content = _('This page could not be found or you don\'t have permission to view it. You probably have to sign in or register in order to gain access!');
         }
 
         return $this->renderPage($page, $title, $content);
@@ -270,10 +272,17 @@ class LegacyMiddleware implements MiddlewareInterface
         $parameters = [
             'key' => (isset($user) ? $user['api_key'] : ''),
         ];
+
         if ($page == 'user_meetings') {
             $parameters['meetings'] = 1;
         }
 
+        $status = 200;
+        if ($page == '404') {
+            $status = 404;
+            $content = info($content, true);
+        }
+
         return response(view(__DIR__ . '/../../templates/layout.html', [
             'theme'          => isset($user) ? $user['color'] : config('theme'),
             'title'          => $title,
@@ -291,6 +300,6 @@ class LegacyMiddleware implements MiddlewareInterface
             'contact_email'  => config('contact_email'),
             'locale'         => locale(),
             'event_info'     => EventConfig_info($event_config) . ' <br />'
-        ]));
+        ]), $status);
     }
 }

src/Middleware/NotFoundResponse.php

@@ -1,56 +0,0 @@
-<?php
-
-namespace Engelsystem\Middleware;
-
-use Engelsystem\Http\Response;
-use Psr\Http\Message\ResponseInterface;
-use Psr\Http\Message\ServerRequestInterface;
-use Psr\Http\Server\MiddlewareInterface;
-use Psr\Http\Server\RequestHandlerInterface;
-
-class NotFoundResponse implements MiddlewareInterface
-{
-    /**
-     * Returns a 404: Page not found response
-     *
-     * Should be the last middleware
-     *
-     * @param ServerRequestInterface  $request
-     * @param RequestHandlerInterface $handler
-     * @return ResponseInterface
-     */
-    public function process(
-        ServerRequestInterface $request,
-        RequestHandlerInterface $handler
-    ): ResponseInterface {
-        $info = _('This page could not be found or you don\'t have permission to view it. You probably have to sign in or register in order to gain access!');
-
-        return $this->renderPage($info);
-    }
-
-    /**
-     * @param string $content
-     * @return Response
-     * @codeCoverageIgnore
-     */
-    protected function renderPage($content)
-    {
-        global $user;
-        $event_config = EventConfig();
-
-        return response(view(__DIR__ . '/../../templates/layout.html', [
-            'theme'          => isset($user) ? $user['color'] : config('theme'),
-            'title'          => _('Page not found'),
-            'atom_link'      => '',
-            'start_page_url' => page_link_to('/'),
-            'credits_url'    => page_link_to('credits'),
-            'menu'           => make_menu(),
-            'content'        => msg() . info($content),
-            'header_toolbar' => header_toolbar(),
-            'faq_url'        => config('faq_url'),
-            'contact_email'  => config('contact_email'),
-            'locale'         => locale(),
-            'event_info'     => EventConfig_info($event_config) . ' <br />'
-        ]), 404);
-    }
-}

src/Middleware/RequestHandler.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace Engelsystem\Middleware;
+
+use Engelsystem\Application;
+use InvalidArgumentException;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\MiddlewareInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+
+class RequestHandler implements MiddlewareInterface
+{
+    use ResolvesMiddlewareTrait;
+
+    /** @var Application */
+    protected $container;
+
+    /**
+     * @param Application $container
+     */
+    public function __construct(Application $container)
+    {
+        $this->container = $container;
+    }
+
+    /**
+     * Process an incoming server request and return a response, optionally delegating
+     * response creation to a handler.
+     *
+     * @param ServerRequestInterface  $request
+     * @param RequestHandlerInterface $handler
+     * @return ResponseInterface
+     */
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
+    {
+        $requestHandler = $request->getAttribute('route-request-handler');
+        $requestHandler = $this->resolveMiddleware($requestHandler);
+
+        if ($requestHandler instanceof MiddlewareInterface) {
+            return $requestHandler->process($request, $handler);
+        }
+
+        if ($requestHandler instanceof RequestHandlerInterface) {
+            return $requestHandler->handle($request);
+        }
+
+        throw new InvalidArgumentException('Unable to process request handler of type ' . gettype($requestHandler));
+    }
+}

src/Middleware/RequestHandlerServiceProvider.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Engelsystem\Middleware;
+
+use Engelsystem\Container\ServiceProvider;
+
+class RequestHandlerServiceProvider extends ServiceProvider
+{
+    public function register()
+    {
+        /** @var RequestHandler $requestHandler */
+        $requestHandler = $this->app->make(RequestHandler::class);
+
+        $this->app->instance('request.handler', $requestHandler);
+        $this->app->bind(RequestHandler::class, 'request.handler');
+    }
+}

src/Middleware/ResolvesMiddlewareTrait.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace Engelsystem\Middleware;
+
+use Engelsystem\Application;
+use InvalidArgumentException;
+use Psr\Http\Server\MiddlewareInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+
+trait ResolvesMiddlewareTrait
+{
+    /**
+     * Resolve the middleware with the container
+     *
+     * @param string|callable|MiddlewareInterface|RequestHandlerInterface $middleware
+     * @return MiddlewareInterface|RequestHandlerInterface
+     */
+    protected function resolveMiddleware($middleware)
+    {
+        if ($this->isMiddleware($middleware)) {
+            return $middleware;
+        }
+
+        if (!property_exists($this, 'container') || !$this->container instanceof Application) {
+            throw new InvalidArgumentException('Unable to resolve middleware');
+        }
+
+        /** @var Application $container */
+        $container = $this->container;
+
+        if (is_string($middleware)) {
+            $middleware = $container->make($middleware);
+        }
+
+        if (is_callable($middleware)) {
+            $middleware = $container->make(CallableHandler::class, ['callable' => $middleware]);
+        }
+
+        if ($this->isMiddleware($middleware)) {
+            return $middleware;
+        }
+
+        throw new InvalidArgumentException('Unable to resolve middleware');
+    }
+
+    /**
+     * Checks if the given object is a middleware or middleware or request handler
+     *
+     * @param mixed $middleware
+     * @return bool
+     */
+    protected function isMiddleware($middleware)
+    {
+        return ($middleware instanceof MiddlewareInterface || $middleware instanceof RequestHandlerInterface);
+    }
+}

src/Middleware/RouteDispatcher.php

@@ -0,0 +1,75 @@
+<?php
+
+namespace Engelsystem\Middleware;
+
+use FastRoute\Dispatcher as FastRouteDispatcher;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\MiddlewareInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+
+class RouteDispatcher implements MiddlewareInterface
+{
+    /** @var FastRouteDispatcher */
+    protected $dispatcher;
+
+    /** @var ResponseInterface */
+    protected $response;
+
+    /** @var MiddlewareInterface|null */
+    protected $notFound;
+
+    /**
+     * @param FastRouteDispatcher      $dispatcher
+     * @param ResponseInterface        $response Default response
+     * @param MiddlewareInterface|null $notFound Handles any requests if the route can't be found
+     */
+    public function __construct(
+        FastRouteDispatcher $dispatcher,
+        ResponseInterface $response,
+        MiddlewareInterface $notFound = null
+    ) {
+        $this->dispatcher = $dispatcher;
+        $this->response = $response;
+        $this->notFound = $notFound;
+    }
+
+    /**
+     * Process an incoming server request and return a response, optionally delegating
+     * response creation to a handler.
+     *
+     * @param ServerRequestInterface  $request
+     * @param RequestHandlerInterface $handler
+     * @return ResponseInterface
+     */
+    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
+    {
+        $route = $this->dispatcher->dispatch($request->getMethod(), urldecode($request->getUri()->getPath()));
+
+        $status = $route[0];
+        if ($status == FastRouteDispatcher::NOT_FOUND) {
+            if ($this->notFound instanceof MiddlewareInterface) {
+                return $this->notFound->process($request, $handler);
+            }
+
+            return $this->response->withStatus(404);
+        }
+
+        if ($status == FastRouteDispatcher::METHOD_NOT_ALLOWED) {
+            $methods = $route[1];
+            return $this->response
+                ->withStatus(405)
+                ->withHeader('Allow', implode(', ', $methods));
+        }
+
+        $routeHandler = $route[1];
+        $request = $request->withAttribute('route-request-handler', $routeHandler);
+
+        $vars = $route[2];
+        foreach ($vars as $name => $value) {
+            $request = $request->withAttribute($name, $value);
+        }
+
+        return $handler->handle($request);
+    }
+}

src/Middleware/RouteDispatcherServiceProvider.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace Engelsystem\Middleware;
+
+use Engelsystem\Container\ServiceProvider;
+use FastRoute\Dispatcher as FastRouteDispatcher;
+use FastRoute\RouteCollector;
+use Psr\Http\Server\MiddlewareInterface;
+
+class RouteDispatcherServiceProvider extends ServiceProvider
+{
+    public function register()
+    {
+        $this->app->alias(RouteDispatcher::class, 'route.dispatcher');
+
+        $this->app
+            ->when(RouteDispatcher::class)
+            ->needs(FastRouteDispatcher::class)
+            ->give(function () {
+                return $this->generateRouting();
+            });
+
+        $this->app
+            ->when(RouteDispatcher::class)
+            ->needs(MiddlewareInterface::class)
+            ->give(LegacyMiddleware::class);
+    }
+
+    /**
+     * Includes the routes.php file
+     *
+     * @return FastRouteDispatcher
+     * @codeCoverageIgnore
+     */
+    function generateRouting()
+    {
+        return \FastRoute\simpleDispatcher(function (RouteCollector $route) {
+            require config_path('routes.php');
+        });
+    }
+}

src/Routing/RoutingServiceProvider.php

@@ -1,24 +0,0 @@
-<?php
-namespace Engelsystem\Routing;
-
-use Engelsystem\Container\ServiceProvider;
-
-/**
- * Registers the url generator depending on config.
- */
-class RoutingServiceProvider extends ServiceProvider
-{
-
-    public function register()
-    {
-        $config = $this->app->get('config');
-        $class = UrlGenerator::class;
-        if (! $config->get('rewrite_urls', true)) {
-            $class = LegacyUrlGenerator::class;
-        }
-
-        $urlGenerator = $this->app->make($class);
-        $this->app->instance('routing.urlGenerator', $urlGenerator);
-        $this->app->bind(UrlGeneratorInterface::class, 'routing.urlGenerator');
-    }
-}

src/helpers.php

@@ -6,7 +6,7 @@ use Engelsystem\Config\Config;
 use Engelsystem\Http\Request;
 use Engelsystem\Http\Response;
 use Engelsystem\Renderer\Renderer;
-use Engelsystem\Routing\UrlGeneratorInterface;
+use Engelsystem\Http\UrlGenerator;
 use Symfony\Component\HttpFoundation\Session\SessionInterface;
 
 /**
@@ -125,13 +125,13 @@ function session($key = null, $default = null)
  */
 function url($path = null, $parameters = [])
 {
-    $urlGenerator = app('routing.urlGenerator');
+    $urlGenerator = app('http.urlGenerator');
 
     if (is_null($path)) {
         return $urlGenerator;
     }
 
-    return $urlGenerator->linkTo($path, $parameters);
+    return $urlGenerator->to($path, $parameters);
 }
 
 /**

tests/Unit/HelpersTest.php

@@ -8,7 +8,8 @@ use Engelsystem\Container\Container;
 use Engelsystem\Http\Request;
 use Engelsystem\Http\Response;
 use Engelsystem\Renderer\Renderer;
-use Engelsystem\Routing\UrlGeneratorInterface;
+use Engelsystem\Http\UrlGenerator;
+use Engelsystem\Http\UrlGeneratorInterface;
 use PHPUnit\Framework\TestCase;
 use PHPUnit_Framework_MockObject_MockObject as MockObject;
 use Symfony\Component\HttpFoundation\Session\Session;
@@ -201,11 +202,11 @@ class HelpersTest extends TestCase
     {
         $urlGeneratorMock = $this->getMockForAbstractClass(UrlGeneratorInterface::class);
 
-        $this->getAppMock('routing.urlGenerator', $urlGeneratorMock);
+        $this->getAppMock('http.urlGenerator', $urlGeneratorMock);
         $this->assertEquals($urlGeneratorMock, url());
 
         $urlGeneratorMock->expects($this->once())
-            ->method('linkTo')
+            ->method('to')
             ->with('foo/bar', ['param' => 'value'])
             ->willReturn('http://lorem.ipsum/foo/bar?param=value');
 

tests/Unit/Http/LegacyUrlGeneratorTest.php

@@ -1,12 +1,12 @@
 <?php
 
-namespace Engelsystem\Test\Unit\Routing;
+namespace Engelsystem\Test\Unit\Http;
 
 use Engelsystem\Application;
 use Engelsystem\Container\Container;
 use Engelsystem\Http\Request;
-use Engelsystem\Routing\LegacyUrlGenerator;
+use Engelsystem\Http\LegacyUrlGenerator;
-use Engelsystem\Routing\UrlGeneratorInterface;
+use Engelsystem\Http\UrlGeneratorInterface;
 use PHPUnit\Framework\TestCase;
 
 class LegacyUrlGeneratorTest extends TestCase
@@ -23,14 +23,14 @@ class LegacyUrlGeneratorTest extends TestCase
 
     /**
      * @dataProvider provideLinksTo
-     * @covers       \Engelsystem\Routing\LegacyUrlGenerator::linkTo
+     * @covers       \Engelsystem\Http\LegacyUrlGenerator::to
      *
      * @param string   $urlToPath
      * @param string   $willReturn
      * @param string[] $arguments
      * @param string   $expectedUrl
      */
-    public function testLinkTo($urlToPath, $willReturn, $arguments, $expectedUrl)
+    public function testTo($urlToPath, $willReturn, $arguments, $expectedUrl)
     {
         $app = new Container();
         Application::setInstance($app);
@@ -48,7 +48,7 @@ class LegacyUrlGeneratorTest extends TestCase
         $urlGenerator = new LegacyUrlGenerator();
         $this->assertInstanceOf(UrlGeneratorInterface::class, $urlGenerator);
 
-        $url = $urlGenerator->linkTo($urlToPath, $arguments);
+        $url = $urlGenerator->to($urlToPath, $arguments);
         $this->assertEquals($expectedUrl, $url);
     }
 }

tests/Unit/Http/UrlGeneratorServiceProviderTest.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace Engelsystem\Test\Unit\Http;
+
+use Engelsystem\Http\UrlGenerator;
+use Engelsystem\Http\UrlGeneratorServiceProvider;
+use Engelsystem\Test\Unit\ServiceProviderTest;
+use PHPUnit_Framework_MockObject_MockObject;
+
+class UrlGeneratorServiceProviderTest extends ServiceProviderTest
+{
+    /**
+     * @covers \Engelsystem\Http\UrlGeneratorServiceProvider::register()
+     */
+    public function testRegister()
+    {
+        /** @var PHPUnit_Framework_MockObject_MockObject|UrlGenerator $urlGenerator */
+        $urlGenerator = $this->getMockBuilder(UrlGenerator::class)
+            ->getMock();
+
+        $app = $this->getApp();
+
+        $this->setExpects($app, 'make', [UrlGenerator::class], $urlGenerator);
+        $this->setExpects($app, 'instance', ['http.urlGenerator', $urlGenerator]);
+
+        $serviceProvider = new UrlGeneratorServiceProvider($app);
+        $serviceProvider->register();
+    }
+}

tests/Unit/Http/UrlGeneratorTest.php

@@ -1,12 +1,11 @@
 <?php
 
-namespace Engelsystem\Test\Unit\Routing;
+namespace Engelsystem\Test\Unit\Http;
 
 use Engelsystem\Application;
 use Engelsystem\Container\Container;
 use Engelsystem\Http\Request;
-use Engelsystem\Routing\UrlGenerator;
+use Engelsystem\Http\UrlGenerator;
-use Engelsystem\Routing\UrlGeneratorInterface;
 use PHPUnit\Framework\TestCase;
 
 class UrlGeneratorTest extends TestCase
@@ -14,7 +13,6 @@ class UrlGeneratorTest extends TestCase
     public function provideLinksTo()
     {
         return [
-            ['/', '/', 'http://foo.bar/', [], 'http://foo.bar/'],
             ['/foo/path', '/foo/path', 'http://foo.bar/foo/path', [], 'http://foo.bar/foo/path'],
             ['foo', '/foo', 'https://foo.bar/foo', [], 'https://foo.bar/foo'],
             ['foo', '/foo', 'http://f.b/foo', ['test' => 'abc', 'bla' => 'foo'], 'http://f.b/foo?test=abc&bla=foo'],
@@ -23,7 +21,7 @@ class UrlGeneratorTest extends TestCase
 
     /**
      * @dataProvider provideLinksTo
-     * @covers       \Engelsystem\Routing\UrlGenerator::linkTo
+     * @covers       \Engelsystem\Http\UrlGenerator::to
      *
      * @param string   $path
      * @param string   $willReturn
@@ -31,9 +29,10 @@ class UrlGeneratorTest extends TestCase
      * @param string[] $arguments
      * @param string   $expectedUrl
      */
-    public function testLinkTo($urlToPath, $path, $willReturn, $arguments, $expectedUrl)
+    public function testTo($urlToPath, $path, $willReturn, $arguments, $expectedUrl)
     {
         $app = new Container();
+        $urlGenerator = new UrlGenerator();
         Application::setInstance($app);
 
         $request = $this->getMockBuilder(Request::class)
@@ -46,10 +45,7 @@ class UrlGeneratorTest extends TestCase
 
         $app->instance('request', $request);
 
-        $urlGenerator = new UrlGenerator();
+        $url = $urlGenerator->to($urlToPath, $arguments);
-        $this->assertInstanceOf(UrlGeneratorInterface::class, $urlGenerator);
-
-        $url = $urlGenerator->linkTo($urlToPath, $arguments);
         $this->assertEquals($expectedUrl, $url);
     }
 }

tests/Unit/Middleware/CallableHandlerTest.php

@@ -0,0 +1,141 @@
+<?php
+
+namespace Engelsystem\Test\Unit\Middleware;
+
+use Engelsystem\Container\Container;
+use Engelsystem\Http\Response;
+use Engelsystem\Middleware\CallableHandler;
+use Engelsystem\Test\Unit\Middleware\Stub\HasStaticMethod;
+use PHPUnit\Framework\MockObject\MockObject;
+use PHPUnit\Framework\TestCase;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+use ReflectionClass as Reflection;
+use stdClass;
+
+class CallableHandlerTest extends TestCase
+{
+    public function provideCallable()
+    {
+        return [
+            [function () { }],
+            [[$this, 'provideCallable']],
+            [[HasStaticMethod::class, 'foo']],
+        ];
+    }
+
+    /**
+     * @dataProvider provideCallable
+     * @covers       \Engelsystem\Middleware\CallableHandler::__construct
+     * @param callable $callable
+     */
+    public function testInit($callable)
+    {
+        $handler = new CallableHandler($callable);
+
+        $reflection = new Reflection(get_class($handler));
+        $property = $reflection->getProperty('callable');
+        $property->setAccessible(true);
+
+        $this->assertEquals($callable, $property->getValue($handler));
+    }
+
+    /**
+     * @covers \Engelsystem\Middleware\CallableHandler::process
+     */
+    public function testProcess()
+    {
+        /** @var ServerRequestInterface|MockObject $request */
+        /** @var ResponseInterface|MockObject $response */
+        /** @var callable|MockObject $callable */
+        /** @var RequestHandlerInterface|MockObject $handler */
+        list($request, $response, $callable, $handler) = $this->getMocks();
+
+        $callable->expects($this->once())
+            ->method('__invoke')
+            ->with($request, $handler)
+            ->willReturn($response);
+
+        $middleware = new CallableHandler($callable);
+        $middleware->process($request, $handler);
+    }
+
+    /**
+     * @covers \Engelsystem\Middleware\CallableHandler::handle
+     */
+    public function testHandler()
+    {
+        /** @var ServerRequestInterface|MockObject $request */
+        /** @var ResponseInterface|MockObject $response */
+        /** @var callable|MockObject $callable */
+        list($request, $response, $callable) = $this->getMocks();
+
+        $callable->expects($this->once())
+            ->method('__invoke')
+            ->with($request)
+            ->willReturn($response);
+
+        $middleware = new CallableHandler($callable);
+        $middleware->handle($request);
+    }
+
+    /**
+     * @covers \Engelsystem\Middleware\CallableHandler::execute
+     */
+    public function testExecute()
+    {
+        /** @var ServerRequestInterface|MockObject $request */
+        /** @var Response|MockObject $response */
+        /** @var callable|MockObject $callable */
+        list($request, $response, $callable) = $this->getMocks();
+        /** @var Container|MockObject $container */
+        $container = $this->createMock(Container::class);
+
+        $callable->expects($this->exactly(3))
+            ->method('__invoke')
+            ->with($request)
+            ->willReturnOnConsecutiveCalls($response, 'Lorem ipsum?', 'I\'m not an exception!');
+
+        $container->expects($this->once())
+            ->method('get')
+            ->with('response')
+            ->willReturn($response);
+
+        $response->expects($this->once())
+            ->method('withContent')
+            ->with('Lorem ipsum?')
+            ->willReturn($response);
+
+        $middleware = new CallableHandler($callable, $container);
+        $return = $middleware->handle($request);
+        $this->assertInstanceOf(ResponseInterface::class, $return);
+        $this->assertEquals($response, $return);
+
+        $return = $middleware->handle($request);
+        $this->assertInstanceOf(ResponseInterface::class, $return);
+        $this->assertEquals($response, $return);
+
+        $middleware = new CallableHandler($callable);
+        $this->expectException(\InvalidArgumentException::class);
+        $middleware->handle($request);
+    }
+
+    /**
+     * @return array
+     */
+    protected function getMocks(): array
+    {
+        /** @var ServerRequestInterface|MockObject $request */
+        $request = $this->getMockForAbstractClass(ServerRequestInterface::class);
+        /** @var RequestHandlerInterface|MockObject $handler */
+        $handler = $this->getMockForAbstractClass(RequestHandlerInterface::class);
+        /** @var Response|MockObject $response */
+        $response = $this->createMock(Response::class);
+        /** @var callable|MockObject $callable */
+        $callable = $this->getMockBuilder(stdClass::class)
+            ->setMethods(['__invoke'])
+            ->getMock();
+        return array($request, $response, $callable, $handler);
+    }
+}

tests/Unit/Middleware/DispatcherTest.php

@@ -5,7 +5,6 @@ namespace Engelsystem\Test\Unit\Middleware;
 use Engelsystem\Application;
 use Engelsystem\Middleware\Dispatcher;
 use Engelsystem\Test\Unit\Middleware\Stub\NotARealMiddleware;
-use Engelsystem\Test\Unit\Middleware\Stub\ReturnResponseMiddleware;
 use InvalidArgumentException;
 use LogicException;
 use PHPUnit\Framework\TestCase;
@@ -158,14 +157,14 @@ class DispatcherTest extends TestCase
 
         /** @var Dispatcher|MockObject $dispatcher */
         $dispatcher = $this->getMockBuilder(Dispatcher::class)
-            ->setConstructorArgs([[MiddlewareInterface::class]])
+            ->setConstructorArgs([[MiddlewareInterface::class, MiddlewareInterface::class]])
             ->setMethods(['resolveMiddleware'])
             ->getMock();
 
-        $dispatcher->expects($this->once())
+        $dispatcher->expects($this->exactly(2))
             ->method('resolveMiddleware')
             ->with(MiddlewareInterface::class)
-            ->willReturn($middleware);
+            ->willReturnOnConsecutiveCalls($middleware, null);
 
         $middleware->expects($this->once())
             ->method('process')
@@ -174,57 +173,26 @@ class DispatcherTest extends TestCase
 
         $return = $dispatcher->handle($request);
         $this->assertEquals($response, $return);
+
+        $this->expectException(InvalidArgumentException::class);
+        $dispatcher->handle($request);
     }
 
     /**
-     * @covers \Engelsystem\Middleware\Dispatcher::resolveMiddleware
      * @covers \Engelsystem\Middleware\Dispatcher::setContainer
      */
-    public function testResolveMiddleware()
+    public function testSetContainer()
     {
         /** @var Application|MockObject $container */
         $container = $this->createMock(Application::class);
-        /** @var ServerRequestInterface|MockObject $request */
-        $request = $this->createMock(ServerRequestInterface::class);
-        /** @var ResponseInterface|MockObject $response */
-        $response = $this->createMock(ResponseInterface::class);
 
-        $returnResponseMiddleware = new ReturnResponseMiddleware($response);
+        $middleware = new Dispatcher();
+        $middleware->setContainer($container);
 
-        $container->expects($this->exactly(2))
+        $reflection = new Reflection(get_class($middleware));
-            ->method('has')
+        $property = $reflection->getProperty('container');
-            ->withConsecutive([ReturnResponseMiddleware::class], ['middleware'])
+        $property->setAccessible(true);
-            ->willReturnOnConsecutiveCalls(false, true);
 
-        $container->expects($this->once())
+        $this->assertEquals($container, $property->getValue($middleware));
-            ->method('make')
-            ->with(ReturnResponseMiddleware::class)
-            ->willReturn($returnResponseMiddleware);
-
-        $container->expects($this->once())
-            ->method('get')
-            ->with('middleware')
-            ->willReturn($returnResponseMiddleware);
-
-        $dispatcher = new Dispatcher([ReturnResponseMiddleware::class]);
-        $dispatcher->setContainer($container);
-        $dispatcher->handle($request);
-
-        $dispatcher = new Dispatcher(['middleware'], $container);
-        $dispatcher->handle($request);
-    }
-
-    /**
-     * @covers \Engelsystem\Middleware\Dispatcher::resolveMiddleware
-     */
-    public function testResolveMiddlewareNoContainer()
-    {
-        /** @var ServerRequestInterface|MockObject $request */
-        $request = $this->createMock(ServerRequestInterface::class);
-
-        $this->expectException(InvalidArgumentException::class);
-
-        $dispatcher = new Dispatcher([ReturnResponseMiddleware::class]);
-        $dispatcher->handle($request);
     }
 }

tests/Unit/Middleware/LegacyMiddlewareTest.php

@@ -46,10 +46,11 @@ class LegacyMiddlewareTest extends TestCase
                 ['title2', 'content2']
             );
 
-        $middleware->expects($this->exactly(2))
+        $middleware->expects($this->exactly(3))
             ->method('renderPage')
             ->withConsecutive(
                 ['user_worklog', 'title', 'content'],
+                ['404', 'Page not found'],
                 ['login', 'title2', 'content2']
             )
             ->willReturn($response);
@@ -73,11 +74,6 @@ class LegacyMiddlewareTest extends TestCase
                 '/'
             );
 
-        $handler->expects($this->once())
-            ->method('handle')
-            ->with($request)
-            ->willReturn($response);
-
         $middleware->process($request, $handler);
         $middleware->process($request, $handler);
         $middleware->process($request, $handler);

tests/Unit/Middleware/NotFoundResponseTest.php

@@ -1,39 +0,0 @@
-<?php
-
-namespace Engelsystem\Test\Unit\Middleware;
-
-use Engelsystem\Middleware\NotFoundResponse;
-use PHPUnit\Framework\TestCase;
-use PHPUnit_Framework_MockObject_MockObject as MockObject;
-use Psr\Http\Message\ResponseInterface;
-use Psr\Http\Message\ServerRequestInterface;
-use Psr\Http\Server\RequestHandlerInterface;
-
-class NotFoundResponseTest extends TestCase
-{
-    /**
-     * @covers \Engelsystem\Middleware\NotFoundResponse::process
-     */
-    public function testRegister()
-    {
-        /** @var NotFoundResponse|MockObject $middleware */
-        $middleware = $this->getMockBuilder(NotFoundResponse::class)
-            ->setMethods(['renderPage'])
-            ->getMock();
-        /** @var ResponseInterface|MockObject $response */
-        $response = $this->getMockForAbstractClass(ResponseInterface::class);
-        /** @var RequestHandlerInterface|MockObject $handler */
-        $handler = $this->getMockForAbstractClass(RequestHandlerInterface::class);
-        /** @var ServerRequestInterface|MockObject $request */
-        $request = $this->getMockForAbstractClass(ServerRequestInterface::class);
-
-        $middleware->expects($this->once())
-            ->method('renderPage')
-            ->willReturn($response);
-
-        $handler->expects($this->never())
-            ->method('handle');
-
-        $middleware->process($request, $handler);
-    }
-}

tests/Unit/Middleware/RequestHandlerServiceProviderTest.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace Engelsystem\Test\Unit\Middleware;
+
+use Engelsystem\Middleware\RequestHandler;
+use Engelsystem\Middleware\RequestHandlerServiceProvider;
+use Engelsystem\Test\Unit\ServiceProviderTest;
+use PHPUnit\Framework\MockObject\MockObject;
+
+class RequestHandlerServiceProviderTest extends ServiceProviderTest
+{
+    /**
+     * @covers \Engelsystem\Middleware\RequestHandlerServiceProvider::register()
+     */
+    public function testRegister()
+    {
+        /** @var RequestHandler|MockObject $requestHandler */
+        $requestHandler = $this->createMock(RequestHandler::class);
+
+        $app = $this->getApp(['make', 'instance', 'bind']);
+
+        $app->expects($this->once())
+            ->method('make')
+            ->with(RequestHandler::class)
+            ->willReturn($requestHandler);
+        $app->expects($this->once())
+            ->method('instance')
+            ->with('request.handler', $requestHandler);
+        $app->expects($this->once())
+            ->method('bind')
+            ->with(RequestHandler::class, 'request.handler');
+
+        $serviceProvider = new RequestHandlerServiceProvider($app);
+        $serviceProvider->register();
+    }
+}

tests/Unit/Middleware/RequestHandlerTest.php

@@ -0,0 +1,89 @@
+<?php
+
+namespace Engelsystem\Test\Unit\Middleware;
+
+use Engelsystem\Application;
+use Engelsystem\Middleware\RequestHandler;
+use InvalidArgumentException;
+use PHPUnit\Framework\MockObject\MockObject;
+use PHPUnit\Framework\TestCase;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\MiddlewareInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+use ReflectionClass as Reflection;
+
+class RequestHandlerTest extends TestCase
+{
+    /**
+     * @covers \Engelsystem\Middleware\RequestHandler::__construct
+     */
+    public function testInit()
+    {
+        /** @var Application|MockObject $container */
+        $container = $this->createMock(Application::class);
+
+        $handler = new RequestHandler($container);
+
+        $reflection = new Reflection(get_class($handler));
+        $property = $reflection->getProperty('container');
+        $property->setAccessible(true);
+
+        $this->assertEquals($container, $property->getValue($handler));
+    }
+
+    /**
+     * @covers \Engelsystem\Middleware\RequestHandler::process
+     */
+    public function testProcess()
+    {
+        /** @var Application|MockObject $container */
+        $container = $this->createMock(Application::class);
+        /** @var ServerRequestInterface|MockObject $request */
+        $request = $this->getMockForAbstractClass(ServerRequestInterface::class);
+        /** @var RequestHandlerInterface|MockObject $handler */
+        $handler = $this->getMockForAbstractClass(RequestHandlerInterface::class);
+        /** @var ResponseInterface|MockObject $response */
+        $response = $this->getMockForAbstractClass(ResponseInterface::class);
+
+        $middlewareInterface = $this->getMockForAbstractClass(MiddlewareInterface::class);
+        $requestHandlerInterface = $this->getMockForAbstractClass(RequestHandlerInterface::class);
+
+        $request->expects($this->exactly(3))
+            ->method('getAttribute')
+            ->with('route-request-handler')
+            ->willReturn('FooBarClass');
+
+        /** @var RequestHandler|MockObject $middleware */
+        $middleware = $this->getMockBuilder(RequestHandler::class)
+            ->setConstructorArgs([$container])
+            ->setMethods(['resolveMiddleware'])
+            ->getMock();
+        $middleware->expects($this->exactly(3))
+            ->method('resolveMiddleware')
+            ->with('FooBarClass')
+            ->willReturnOnConsecutiveCalls(
+                $middlewareInterface,
+                $requestHandlerInterface,
+                null
+            );
+
+        $middlewareInterface->expects($this->once())
+            ->method('process')
+            ->with($request, $handler)
+            ->willReturn($response);
+        $requestHandlerInterface->expects($this->once())
+            ->method('handle')
+            ->with($request)
+            ->willReturn($response);
+
+        $return = $middleware->process($request, $handler);
+        $this->assertEquals($return, $response);
+
+        $middleware->process($request, $handler);
+        $this->assertEquals($return, $response);
+
+        $this->expectException(InvalidArgumentException::class);
+        $middleware->process($request, $handler);
+    }
+}

tests/Unit/Middleware/ResolvesMiddlewareTraitTest.php

@@ -0,0 +1,67 @@
+<?php
+
+namespace Engelsystem\Test\Unit\Middleware;
+
+use Engelsystem\Application;
+use Engelsystem\Middleware\CallableHandler;
+use Engelsystem\Test\Unit\Middleware\Stub\HasStaticMethod;
+use Engelsystem\Test\Unit\Middleware\Stub\ResolvesMiddlewareTraitImplementation;
+use InvalidArgumentException;
+use PHPUnit\Framework\MockObject\MockObject;
+use PHPUnit\Framework\TestCase;
+use Psr\Http\Server\MiddlewareInterface;
+
+class ResolvesMiddlewareTraitTest extends TestCase
+{
+    /**
+     * @covers \Engelsystem\Middleware\ResolvesMiddlewareTrait::resolveMiddleware
+     * @covers \Engelsystem\Middleware\ResolvesMiddlewareTrait::isMiddleware
+     */
+    public function testResolveMiddleware()
+    {
+        /** @var Application|MockObject $container */
+        $container = $this->createMock(Application::class);
+        $middlewareInterface = $this->getMockForAbstractClass(MiddlewareInterface::class);
+        $callable = [HasStaticMethod::class, 'foo'];
+
+        $container->expects($this->exactly(3))
+            ->method('make')
+            ->withConsecutive(
+                ['FooBarClass'],
+                [CallableHandler::class, ['callable' => $callable]],
+                ['UnresolvableClass']
+            )
+            ->willReturnOnConsecutiveCalls(
+                $middlewareInterface,
+                $middlewareInterface,
+                null
+            );
+
+        $middleware = new ResolvesMiddlewareTraitImplementation($container);
+
+        $return = $middleware->callResolveMiddleware('FooBarClass');
+        $this->assertEquals($middlewareInterface, $return);
+
+        $return = $middleware->callResolveMiddleware($callable);
+        $this->assertEquals($middlewareInterface, $return);
+
+        $this->expectException(InvalidArgumentException::class);
+        $middleware->callResolveMiddleware('UnresolvableClass');
+    }
+
+    /**
+     * @covers \Engelsystem\Middleware\ResolvesMiddlewareTrait::resolveMiddleware
+     */
+    public function testResolveMiddlewareNoContainer()
+    {
+        $middlewareInterface = $this->getMockForAbstractClass(MiddlewareInterface::class);
+
+        $middleware = new ResolvesMiddlewareTraitImplementation();
+        $return = $middleware->callResolveMiddleware($middlewareInterface);
+
+        $this->assertEquals($middlewareInterface, $return);
+
+        $this->expectException(InvalidArgumentException::class);
+        $middleware->callResolveMiddleware('FooBarClass');
+    }
+}

tests/Unit/Middleware/RouteDispatcherServiceProviderTest.php

@@ -0,0 +1,65 @@
+<?php
+
+namespace Engelsystem\Test\Unit\Middleware;
+
+use Engelsystem\Middleware\LegacyMiddleware;
+use Engelsystem\Middleware\RouteDispatcher;
+use Engelsystem\Middleware\RouteDispatcherServiceProvider;
+use Engelsystem\Test\Unit\ServiceProviderTest;
+use FastRoute\Dispatcher as FastRouteDispatcher;
+use Illuminate\Contracts\Container\ContextualBindingBuilder;
+use PHPUnit\Framework\MockObject\MockObject;
+use Psr\Http\Server\MiddlewareInterface;
+
+class RouteDispatcherServiceProviderTest extends ServiceProviderTest
+{
+    /**
+     * @covers \Engelsystem\Middleware\RouteDispatcherServiceProvider::register()
+     */
+    public function testRegister()
+    {
+        $bindingBuilder = $this->createMock(ContextualBindingBuilder::class);
+        $routeDispatcher = $this->getMockForAbstractClass(FastRouteDispatcher::class);
+
+        $app = $this->getApp(['alias', 'when']);
+
+        $app->expects($this->once())
+            ->method('alias')
+            ->with(RouteDispatcher::class, 'route.dispatcher');
+
+        $app->expects($this->exactly(2))
+            ->method('when')
+            ->with(RouteDispatcher::class)
+            ->willReturn($bindingBuilder);
+
+        $bindingBuilder->expects($this->exactly(2))
+            ->method('needs')
+            ->withConsecutive(
+                [FastRouteDispatcher::class],
+                [MiddlewareInterface::class]
+            )
+            ->willReturn($bindingBuilder);
+
+        $bindingBuilder->expects($this->exactly(2))
+            ->method('give')
+            ->with($this->callback(function ($subject) {
+                if (is_callable($subject)) {
+                    $subject();
+                }
+
+                return is_callable($subject) || $subject == LegacyMiddleware::class;
+            }));
+
+        /** @var RouteDispatcherServiceProvider|MockObject $serviceProvider */
+        $serviceProvider = $this->getMockBuilder(RouteDispatcherServiceProvider::class)
+            ->setConstructorArgs([$app])
+            ->setMethods(['generateRouting'])
+            ->getMock();
+
+        $serviceProvider->expects($this->once())
+            ->method('generateRouting')
+            ->willReturn($routeDispatcher);
+
+        $serviceProvider->register();
+    }
+}

tests/Unit/Middleware/RouteDispatcherTest.php

@@ -0,0 +1,148 @@
+<?php
+
+namespace Engelsystem\Test\Unit\Middleware;
+
+use Engelsystem\Middleware\RouteDispatcher;
+use FastRoute\Dispatcher as FastRouteDispatcher;
+use PHPUnit\Framework\MockObject\MockObject;
+use PHPUnit\Framework\TestCase;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Message\UriInterface;
+use Psr\Http\Server\MiddlewareInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+
+class RouteDispatcherTest extends TestCase
+{
+    /**
+     * @covers \Engelsystem\Middleware\RouteDispatcher::process
+     * @covers \Engelsystem\Middleware\RouteDispatcher::__construct
+     */
+    public function testProcess()
+    {
+        /** @var FastRouteDispatcher|MockObject $dispatcher */
+        /** @var ResponseInterface|MockObject $response */
+        /** @var ServerRequestInterface|MockObject $request */
+        /** @var RequestHandlerInterface|MockObject $handler */
+        list($dispatcher, $response, $request, $handler) = $this->getMocks();
+
+        $dispatcher->expects($this->once())
+            ->method('dispatch')
+            ->with('HEAD', '/foo!bar')
+            ->willReturn([FastRouteDispatcher::FOUND, $handler, ['foo' => 'bar', 'lorem' => 'ipsum']]);
+
+        $request->expects($this->exactly(3))
+            ->method('withAttribute')
+            ->withConsecutive(
+                ['route-request-handler', $handler],
+                ['foo', 'bar'],
+                ['lorem', 'ipsum']
+            )
+            ->willReturn($request);
+
+        $handler->expects($this->once())
+            ->method('handle')
+            ->with($request)
+            ->willReturn($response);
+
+        $middleware = new RouteDispatcher($dispatcher, $response);
+        $return = $middleware->process($request, $handler);
+        $this->assertEquals($response, $return);
+    }
+
+    /**
+     * @covers \Engelsystem\Middleware\RouteDispatcher::process
+     */
+    public function testProcessNotFound()
+    {
+        /** @var FastRouteDispatcher|MockObject $dispatcher */
+        /** @var ResponseInterface|MockObject $response */
+        /** @var ServerRequestInterface|MockObject $request */
+        /** @var RequestHandlerInterface|MockObject $handler */
+        list($dispatcher, $response, $request, $handler) = $this->getMocks();
+        /** @var MiddlewareInterface|MockObject $notFound */
+        $notFound = $this->createMock(MiddlewareInterface::class);
+
+        $dispatcher->expects($this->exactly(2))
+            ->method('dispatch')
+            ->with('HEAD', '/foo!bar')
+            ->willReturn([FastRouteDispatcher::NOT_FOUND]);
+
+        $response->expects($this->once())
+            ->method('withStatus')
+            ->with(404)
+            ->willReturn($response);
+
+        $notFound->expects($this->once())
+            ->method('process')
+            ->with($request, $handler)
+            ->willReturn($response);
+
+        $middleware = new RouteDispatcher($dispatcher, $response, $notFound);
+        $return = $middleware->process($request, $handler);
+        $this->assertEquals($response, $return);
+
+        $middleware = new RouteDispatcher($dispatcher, $response);
+        $return = $middleware->process($request, $handler);
+        $this->assertEquals($response, $return);
+    }
+
+    /**
+     * @covers \Engelsystem\Middleware\RouteDispatcher::process
+     */
+    public function testProcessNotAllowed()
+    {
+        /** @var FastRouteDispatcher|MockObject $dispatcher */
+        /** @var ResponseInterface|MockObject $response */
+        /** @var ServerRequestInterface|MockObject $request */
+        /** @var RequestHandlerInterface|MockObject $handler */
+        list($dispatcher, $response, $request, $handler) = $this->getMocks();
+
+        $dispatcher->expects($this->once())
+            ->method('dispatch')
+            ->with('HEAD', '/foo!bar')
+            ->willReturn([FastRouteDispatcher::METHOD_NOT_ALLOWED, ['POST', 'TEST']]);
+
+        $response->expects($this->once())
+            ->method('withStatus')
+            ->with(405)
+            ->willReturn($response);
+        $response->expects($this->once())
+            ->method('withHeader')
+            ->with('Allow', 'POST, TEST')
+            ->willReturn($response);
+
+        $middleware = new RouteDispatcher($dispatcher, $response);
+        $return = $middleware->process($request, $handler);
+        $this->assertEquals($response, $return);
+    }
+
+    /**
+     * @return array
+     */
+    protected function getMocks(): array
+    {
+        /** @var FastRouteDispatcher|MockObject $dispatcher */
+        $dispatcher = $this->getMockForAbstractClass(FastRouteDispatcher::class);
+        /** @var ResponseInterface|MockObject $response */
+        $response = $this->getMockForAbstractClass(ResponseInterface::class);
+        /** @var ServerRequestInterface|MockObject $request */
+        $request = $this->getMockForAbstractClass(ServerRequestInterface::class);
+        /** @var RequestHandlerInterface|MockObject $handler */
+        $handler = $this->getMockForAbstractClass(RequestHandlerInterface::class);
+        /** @var UriInterface|MockObject $uriInterface */
+        $uriInterface = $this->getMockForAbstractClass(UriInterface::class);
+
+        $request->expects($this->atLeastOnce())
+            ->method('getMethod')
+            ->willReturn('HEAD');
+        $request->expects($this->atLeastOnce())
+            ->method('getUri')
+            ->willReturn($uriInterface);
+        $uriInterface->expects($this->atLeastOnce())
+            ->method('getPath')
+            ->willReturn('/foo%21bar');
+
+        return array($dispatcher, $response, $request, $handler);
+    }
+}

tests/Unit/Middleware/Stub/HasStaticMethod.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace Engelsystem\Test\Unit\Middleware\Stub;
+
+class HasStaticMethod
+{
+    public static function foo() { }
+}

tests/Unit/Middleware/Stub/ResolvesMiddlewareTraitImplementation.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Engelsystem\Test\Unit\Middleware\Stub;
+
+use Engelsystem\Application;
+use Engelsystem\Middleware\ResolvesMiddlewareTrait;
+use InvalidArgumentException;
+use Psr\Http\Server\MiddlewareInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+
+class ResolvesMiddlewareTraitImplementation
+{
+    use ResolvesMiddlewareTrait;
+
+    /** @var Application */
+    protected $container;
+
+    /**
+     * @param Application $container
+     */
+    public function __construct(Application $container = null)
+    {
+        $this->container = $container;
+    }
+
+    /**
+     * @param string|callable|MiddlewareInterface|RequestHandlerInterface $middleware
+     * @return MiddlewareInterface|RequestHandlerInterface
+     * @throws InvalidArgumentException
+     */
+    public function callResolveMiddleware($middleware)
+    {
+        return $this->resolveMiddleware($middleware);
+    }
+}

tests/Unit/Routing/RoutingServiceProviderTest.php

@@ -1,64 +0,0 @@
-<?php
-
-namespace Engelsystem\Test\Unit\Routing;
-
-use Engelsystem\Config\Config;
-use Engelsystem\Routing\LegacyUrlGenerator;
-use Engelsystem\Routing\RoutingServiceProvider;
-use Engelsystem\Routing\UrlGenerator;
-use Engelsystem\Routing\UrlGeneratorInterface;
-use Engelsystem\Test\Unit\ServiceProviderTest;
-use PHPUnit_Framework_MockObject_MockObject as MockObject;
-
-class RoutingServiceProviderTest extends ServiceProviderTest
-{
-    /**
-     * @covers \Engelsystem\Routing\RoutingServiceProvider::register()
-     */
-    public function testRegister()
-    {
-        $app = $this->getApp(['make', 'instance', 'bind', 'get']);
-        /** @var MockObject|Config $config */
-        $config = $this->getMockBuilder(Config::class)->getMock();
-        /** @var MockObject|UrlGeneratorInterface $urlGenerator */
-        $urlGenerator = $this->getMockForAbstractClass(UrlGeneratorInterface::class);
-        /** @var MockObject|UrlGeneratorInterface $legacyUrlGenerator */
-        $legacyUrlGenerator = $this->getMockForAbstractClass(UrlGeneratorInterface::class);
-
-        $config->expects($this->atLeastOnce())
-            ->method('get')
-            ->with('rewrite_urls')
-            ->willReturnOnConsecutiveCalls(
-                true,
-                false
-            );
-
-        $this->setExpects($app, 'get', ['config'], $config, $this->atLeastOnce());
-
-        $app->expects($this->atLeastOnce())
-            ->method('make')
-            ->withConsecutive(
-                [UrlGenerator::class],
-                [LegacyUrlGenerator::class]
-            )
-            ->willReturnOnConsecutiveCalls(
-                $urlGenerator,
-                $legacyUrlGenerator
-            );
-        $app->expects($this->atLeastOnce())
-            ->method('instance')
-            ->withConsecutive(
-                ['routing.urlGenerator', $urlGenerator],
-                ['routing.urlGenerator', $legacyUrlGenerator]
-            );
-        $this->setExpects(
-            $app, 'bind',
-            [UrlGeneratorInterface::class, 'routing.urlGenerator'], null,
-            $this->atLeastOnce()
-        );
-
-        $serviceProvider = new RoutingServiceProvider($app);
-        $serviceProvider->register();
-        $serviceProvider->register();
-    }
-}