route lookup fix

src/AppFactory.php

@@ -25,8 +25,6 @@
 
 /**
  * Custom routing aware AppFactory.
- *
- * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
  */
 class AppFactory extends SlimAppFactory
 {

src/Route/Route.php

@@ -26,8 +26,6 @@
 
 /**
  * Metadata aware route.
- *
- * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
  */
 class Route extends SlimRoute
 {

src/RouteCollector.php

@@ -91,6 +91,18 @@ public function getRoutes(): array
         return $this->routes;
     }
 
+    /**
+     * {@inheritdoc}
+     */
+    public function lookupRoute(string $identifier): RouteInterface
+    {
+        if ($this->routesRegistered === false) {
+            $this->registerRoutes();
+        }
+
+        return parent::lookupRoute($identifier);
+    }
+
     /**
      * Register routes.
      *

tests/Routing/AppFactoryTest.php

@@ -0,0 +1,33 @@
+<?php
+
+/*
+ * slim-routing (https://github.com/juliangut/slim-routing).
+ * Slim framework routing.
+ *
+ * @license BSD-3-Clause
+ * @link https://github.com/juliangut/slim-routing
+ * @author Julián Gutiérrez <[email protected]>
+ */
+
+declare(strict_types=1);
+
+namespace Jgut\Slim\Routing\Tests;
+
+use Jgut\Slim\Routing\AppFactory;
+use Jgut\Slim\Routing\Configuration;
+use Jgut\Slim\Routing\RouteCollector;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Custom routing aware AppFactory tests.
+ */
+class AppFactoryTest extends TestCase
+{
+    public function testCreation(): void
+    {
+        AppFactory::setRouteCollectorConfiguration(new Configuration());
+        $app = AppFactory::create();
+
+        static::assertInstanceOf(RouteCollector::class, $app->getRouteCollector());
+    }
+}

tests/Routing/RouteCollectorTest.php

@@ -21,6 +21,7 @@
 use PHPUnit\Framework\TestCase;
 use Psr\Http\Message\ResponseFactoryInterface;
 use Slim\Interfaces\CallableResolverInterface;
+use Slim\Interfaces\RouteInterface;
 
 /**
  * Route loader collector tests.
@@ -97,4 +98,55 @@ public function testRoutes(): void
 
         static::assertCount(2, $router->getRoutes());
     }
+
+    public function testRouteLookup(): void
+    {
+        $responseFactory = $this->getMockBuilder(ResponseFactoryInterface::class)
+            ->getMock();
+        /* @var ResponseFactoryInterface $responseFactory */
+        $callableResolver = $this->getMockBuilder(CallableResolverInterface::class)
+            ->getMock();
+        /** @var CallableResolverInterface $callableResolver */
+        $configuration = $this->getMockBuilder(Configuration::class)
+            ->setMethods(['getSources', 'getRouteResolver'])
+            ->getMock();
+        $configuration->expects(static::once())
+            ->method('getSources')
+            ->will($this->returnValue([__DIR__ . '/Files/Annotation/Valid']));
+
+        $routesMetadata = [
+            (new RouteMetadata())
+                ->setMethods(['GET'])
+                ->setPattern('one/{id}')
+                ->setPlaceholders(['id' => 'numeric'])
+                ->setInvokable(['one', 'action'])
+                ->setXmlHttpRequest(true),
+            (new RouteMetadata())
+                ->setMethods(['POST'])
+                ->setPattern('two')
+                ->setName('two')
+                ->setMiddleware(['twoMiddleware'])
+                ->setInvokable(['two', 'action']),
+        ];
+
+        $resolver = $this->getMockBuilder(RouteResolver::class)
+            ->setConstructorArgs([$configuration])
+            ->setMethods(['sort'])
+            ->getMock();
+        $resolver->expects(static::once())
+            ->method('sort')
+            ->will($this->returnValue($routesMetadata));
+        /* @var RouteResolver $resolver */
+
+        $configuration->expects(static::any())
+            ->method('getRouteResolver')
+            ->will($this->returnValue($resolver));
+        /* @var Configuration $configuration */
+
+        $router = new RouteCollector($configuration, $responseFactory, $callableResolver);
+
+        $resolvedRoute = $router->lookupRoute('route1');
+        static::assertInstanceOf(RouteInterface::class, $resolvedRoute);
+        static::assertEquals('two', $resolvedRoute->getName());
+    }
 }