Merge pull request #14 from jasny/middleware-path

Specify a path when adding middleware

3 files changed, 176 insertions, 14 deletions

diff --git a/src/Router.php b/src/Router.php
index 5cc2108..7a4f5c8 100644
--- a/src/Router.php
+++ b/src/Router.php
@@ -94,22 +94,62 @@ class Router
     }
 
     /**
-     * Add middleware call to router
+     * Add middleware call to router.
      *
-     * @param callback $middleware
+     * @param string   $path        Middleware is only applied for this path (including subdirectories), may be omitted
+     * @param callable $middleware
      * @return Router $this
      */
-    public function add($middleware)
+    public function add($path, $middleware = null)
     {
+        if (!isset($middleware)) {
+            $middleware = $path;
+            $path = null;
+        }
+
+        if (!empty($path) && !ctype_digit($path) && $path[0] !== '/') {
+            trigger_error("Middleware path '$path' doesn't start with a '/'", E_USER_NOTICE);
+        }
+        
         if (!is_callable($middleware)) {
             throw new \InvalidArgumentException("Middleware should be callable");
         }
 
+        if (!empty($path)) {
+            $middleware = $this->wrapMiddleware($path, $middleware);
+        }
+        
         $this->middlewares[] = $middleware;
-
+        
         return $this;
     }
     
+    /**
+     * Wrap middleware, so it's only applied to a specified path
+     * 
+     * @param string   $path
+     * @param callable $middleware
+     * @return callable
+     */
+    protected function wrapMiddleware($path, $middleware)
+    {
+        return function(
+            ServerRequestInterface $request,
+            ResponseInterface $response,
+            $next
+        ) use ($middleware, $path) {
+            $uriPath = $request->getUri()->getPath();
+
+            if ($uriPath === $path || strpos($uriPath, rtrim($path, '/') . '/') === 0) {
+                $ret = $middleware($request, $response, $next);
+            } else {
+                $ret = $next($request, $response);
+            }
+            
+            return $ret;
+        };
+    }
+    
     
     /**
      * Run the action for the request
@@ -137,7 +177,7 @@ class Router
             return $this->run($request, $response, $next);
         }
         
-        $stack = array_merge([[$this, 'run']], $this->middlewares);
+        $stack = array_reverse(array_merge($this->middlewares, [[$this, 'run']]));
 
         // Turn the stack into a call chain
         foreach ($stack as $handle) {
diff --git a/tests/Router/Runner/ControllerTest.php b/tests/Router/Runner/ControllerTest.php
index cd3e653..c1b1801 100644
--- a/tests/Router/Runner/ControllerTest.php
+++ b/tests/Router/Runner/ControllerTest.php
@@ -10,7 +10,7 @@ use Psr\Http\Message\ResponseInterface;
 use Jasny\Router\TestHelpers;
 
 /**
- * @covers Jasny\Router\Runner\Controller;
+ * @covers Jasny\Router\Runner\Controller
  */
 class ControllerTest extends \PHPUnit_Framework_TestCase
 {
diff --git a/tests/RouterTest.php b/tests/RouterTest.php
index c036c71..3e5accf 100644
--- a/tests/RouterTest.php
+++ b/tests/RouterTest.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace Jasny\Router;
+namespace Jasny;
 
 use Jasny\Router;
 use Jasny\Router\Route;
@@ -9,6 +9,8 @@ use Jasny\Router\RunnerFactory;
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\StreamInterface;
+use Psr\Http\Message\UriInterface;
+use PHPUnit_Framework_MockObject_Matcher_InvokedCount as InvokedCount;
 
 use Jasny\Router\TestHelpers;
 
@@ -170,6 +172,50 @@ class RouterTest extends \PHPUnit_Framework_TestCase
         $this->assertSame([$middlewareOne, $middlewareTwo], $router->getMiddlewares());
     }
 
+    public function middlewareWithPathProvider()
+    {
+        return [
+            ['/', $this->never(), $this->once(), 'zoo'],
+            ['/foo', $this->once(), $this->never(), 'foo'],
+            ['/foo/bar', $this->once(), $this->never(), 'foo'],
+            ['/zoo', $this->never(), $this->once(), 'zoo']
+        ];
+    }
+    
+    /**
+     * Test adding middleware action specifying a path
+     * @dataProvider middlewareWithPathProvider
+     * 
+     * @param string       $path
+     * @param InvokedCount $invokeMiddleware
+     * @param InvokedCount $invokeNext
+     * @param string       $expect
+     */
+    public function testAddMiddlewareWithPath($path, $invokeMiddleware, $invokeNext, $expect)
+    {
+        $uri = $this->createMock(UriInterface::class);
+        $uri->method('getPath')->willReturn($path);
+        
+        $request = $this->createMock(ServerRequestInterface::class);
+        $request->method('getUri')->willReturn($uri);
+        
+        $response = $this->createMock(ResponseInterface::class);
+        
+        $middleware = $this->createCallbackMock($invokeMiddleware, [$request, $response], 'foo');
+        $next = $this->createCallbackMock($invokeNext, [$request, $response], 'zoo');
+        
+        $router = new Router($this->createMock(Routes::class));
+        $router->add('/foo', $middleware);
+        
+        list($fn) = $router->getMiddlewares() + [null];
+        
+        $this->assertNotSame($middleware, $fn);
+        
+        $result = $fn($request, $response, $next);
+        
+        $this->assertEquals($expect, $result);
+    }
+    
     /**
      * @expectedException \InvalidArgumentException
      */
@@ -178,18 +224,46 @@ class RouterTest extends \PHPUnit_Framework_TestCase
         $router = new Router($this->createMock(Routes::class));
         $router->add('foo bar zoo');
     }
+    
+    /**
+     * @expectedException PHPUnit_Framework_Error
+     * @expectedException Middleware path 'foobar' doesn't start with a '/'
+     */
+    public function testAddNoticeWeirdPath()
+    {
+        $middleware = $this->createCallbackMock($this->never());
+        
+        $router = new Router($this->createMock(Routes::class));
+        $router->add('foobar', $middleware);
+    }
+    
+    public function testAddNoticeWeirdPathSkip()
+    {
+        $middleware = $this->createCallbackMock($this->never());
+        
+        $router = new Router($this->createMock(Routes::class));
+        @$router->add('foobar', $middleware);
+        
+        $this->assertCount(1, $router->getMiddlewares());
+    }
 
     /**
-     * Test executing router with middlewares chain (test only execution order)
+     * Test executing router with middlewares chain
      */
-    public function testRunMiddlewares()
+    public function testRunWithMiddlewares()
     {
         $route = $this->createMock(Route::class);
 
+        $uri = $this->createMock(UriInterface::class);
+        $uri->method('getPath')->willReturn('/');
+        
         $request = $this->createMock(ServerRequestInterface::class);
-        $request->expects($this->once())->method('withAttribute')->with('route')->willReturn($request);
+        $request->method('getUri')->willReturn($uri);
+        
         $requestOne = $this->createMock(ServerRequestInterface::class);
+        $requestOne->expects($this->never())->method('withAttribute');
         $requestTwo = $this->createMock(ServerRequestInterface::class);
+        $requestTwo->expects($this->once())->method('withAttribute')->with('route')->willReturn($requestTwo);
         
         $response = $this->createMock(ResponseInterface::class);
         $responseOne = $this->createMock(ResponseInterface::class);
@@ -197,15 +271,15 @@ class RouterTest extends \PHPUnit_Framework_TestCase
         $finalResponse = $this->createMock(ResponseInterface::class);
 
         $middlewareOne = $this->getMockBuilder(\stdClass::class)->setMethods(['__invoke'])->getMock();
-        $middlewareOne->expects($this->once())->method('__invoke')->id('one')
-            ->with($request, $response, $this->isInstanceOf(Closure::class))
+        $middlewareOne->expects($this->once())->method('__invoke')
+            ->with($request, $response, $this->isInstanceOf(\Closure::class))
             ->will($this->returnCallback(function($a, $b, $next) use ($requestOne, $responseOne) {
                 return $next($requestOne, $responseOne);
             }));
 
         $middlewareTwo = $this->getMockBuilder(\stdClass::class)->setMethods(['__invoke'])->getMock();
-        $middlewareTwo->expects($this->once())->method('__invoke')->id('two')->after('one')
-            ->with($request, $response, $this->isInstanceOf(Closure::class))
+        $middlewareTwo->expects($this->once())->method('__invoke')
+            ->with($request, $response, $this->isInstanceOf(\Closure::class))
             ->will($this->returnCallback(function($a, $b, $next) use ($requestTwo, $responseTwo) {
                 return $next($requestTwo, $responseTwo);
             }));
@@ -221,6 +295,54 @@ class RouterTest extends \PHPUnit_Framework_TestCase
         
         $router->add($middlewareOne);
         $router->add($middlewareTwo);
+
+        $result = $router($request, $response);
+        
+        $this->assertSame($finalResponse, $result);
+    }
+
+    /**
+     * Test executing router with middlewares chain where each middleware is only applied for specific paths
+     */
+    public function testRunWithMiddlewaresByPath()
+    {
+        $route = $this->createMock(Route::class);
+
+        $uri = $this->createMock(UriInterface::class);
+        $uri->method('getPath')->willReturn('/foo/bar');
+        
+        $request = $this->createMock(ServerRequestInterface::class);
+        $request->method('getUri')->willReturn($uri);
+        
+        $requestOne = $this->createMock(ServerRequestInterface::class);
+        $requestOne->expects($this->once())->method('withAttribute')->with('route')->willReturn($requestOne);
+        $requestOne->method('getUri')->willReturn($uri);
+        
+        $response = $this->createMock(ResponseInterface::class);
+        $responseOne = $this->createMock(ResponseInterface::class);
+        $finalResponse = $this->createMock(ResponseInterface::class);
+        
+        $middlewareOne = $this->getMockBuilder(\stdClass::class)->setMethods(['__invoke'])->getMock();
+        $middlewareOne->expects($this->once())->method('__invoke')
+            ->with($request, $response, $this->isInstanceOf(\Closure::class))
+            ->will($this->returnCallback(function($a, $b, $next) use ($requestOne, $responseOne) {
+                return $next($requestOne, $responseOne);
+            }));
+        
+        $middlewareTwo = $this->getMockBuilder(\stdClass::class)->setMethods(['__invoke'])->getMock();
+        $middlewareTwo->expects($this->never())->method('__invoke');
+        
+        $runner = $this->createCallbackMock($this->once(), [$requestOne, $responseOne], $finalResponse);
+        $factory = $this->createCallbackMock($this->once(), [$route], $runner);
+
+        $routes = $this->createMock(Routes::class);
+        $routes->expects($this->once())->method('getRoute')->with($request)->willReturn($route);
+
+        $router = new Router($routes);
+        $router->setFactory($factory);
+        
+        $router->add('/foo', $middlewareOne);
+        $router->add('/zoo', $middlewareTwo);
         
         $result = $router($request, $response);