Rename MiddlewareNotCallableException to InvalidMiddlewareException

Also, adds a `fromNull()` method, allowing it to be used in cases where
a `null` value is provided for middleware. This means that `null`
middleware is handled exactly the same way as any other invalid
middleware type, which required changes to several test expectations.

Author: weierophinney

src/Exception/MiddlewareNotCallableException.php renamed to src/Exception/InvalidMiddlewareException.php

@@ -9,7 +9,7 @@
 
 namespace Zend\Mvc\Exception;
 
-final class MiddlewareNotCallableException extends RuntimeException
+final class InvalidMiddlewareException extends RuntimeException
 {
     /**
      * @var string
@@ -28,6 +28,12 @@ public static function fromMiddlewareName($middlewareName)
         return $instance;
     }
 
+    public static function fromNull()
+    {
+        $instance = new self('Middleware name cannot be null');
+        return $instance;
+    }
+
     /**
      * @return string
      */

src/MiddlewareListener.php

@@ -16,7 +16,7 @@
 use Psr\Http\Message\ServerRequestInterface as PsrServerRequestInterface;
 use Zend\EventManager\AbstractListenerAggregate;
 use Zend\EventManager\EventManagerInterface;
-use Zend\Mvc\Exception\MiddlewareNotCallableException;
+use Zend\Mvc\Exception\InvalidMiddlewareException;
 use Zend\Mvc\Exception\ReachedFinalHandlerException;
 use Zend\Psr7Bridge\Psr7ServerRequest as Psr7Request;
 use Zend\Psr7Bridge\Psr7Response;
@@ -63,12 +63,13 @@ public function onDispatch(MvcEvent $event)
                 $psr7ResponsePrototype,
                 is_array($middleware) ? $middleware : [$middleware]
             );
-        } catch (MiddlewareNotCallableException $middlewareNotCallableException) {
-            $return = $this->marshalMiddlewareNotCallable(
+        } catch (InvalidMiddlewareException $invalidMiddlewareException) {
+            $return = $this->marshalInvalidMiddleware(
                 $application::ERROR_MIDDLEWARE_CANNOT_DISPATCH,
-                $middlewareNotCallableException->toMiddlewareName(),
+                $invalidMiddlewareException->toMiddlewareName(),
                 $event,
-                $application
+                $application,
+                $invalidMiddlewareException
             );
             $event->setResult($return);
             return $return;
@@ -122,8 +123,7 @@ function (PsrServerRequestInterface $request, PsrResponseInterface $response) {
      * @param ResponseInterface $responsePrototype
      * @param array $middlewaresToBePiped
      * @return MiddlewarePipe
-     * @throws \InvalidArgumentException
-     * @throws \Zend\Mvc\Exception\MiddlewareNotCallableException
+     * @throws InvalidMiddlewareException
      */
     private function createPipeFromSpec(
         ContainerInterface $serviceLocator,
@@ -134,7 +134,7 @@ private function createPipeFromSpec(
         $pipe->setResponsePrototype($responsePrototype);
         foreach ($middlewaresToBePiped as $middlewareToBePiped) {
             if (null === $middlewareToBePiped) {
-                throw new \InvalidArgumentException('Middleware name cannot be null');
+                throw InvalidMiddlewareException::fromNull();
             }
 
             $middlewareName = is_string($middlewareToBePiped) ? $middlewareToBePiped : get_class($middlewareToBePiped);
@@ -143,7 +143,7 @@ private function createPipeFromSpec(
                 $middlewareToBePiped = $serviceLocator->get($middlewareToBePiped);
             }
             if (! $middlewareToBePiped instanceof MiddlewareInterface && ! is_callable($middlewareToBePiped)) {
-                throw MiddlewareNotCallableException::fromMiddlewareName($middlewareName);
+                throw InvalidMiddlewareException::fromMiddlewareName($middlewareName);
             }
 
             $pipe->pipe($middlewareToBePiped);
@@ -161,7 +161,7 @@ private function createPipeFromSpec(
      * @param  \Exception $exception
      * @return mixed
      */
-    protected function marshalMiddlewareNotCallable(
+    protected function marshalInvalidMiddleware(
         $type,
         $middlewareName,
         MvcEvent $event,

test/Exception/MiddlewareNotCallableExceptionTest.php renamed to test/Exception/InvalidMiddlewareExceptionTest.php

@@ -10,23 +10,32 @@
 namespace ZendTest\Mvc;
 
 use PHPUnit\Framework\TestCase;
-use Zend\Mvc\Exception\MiddlewareNotCallableException;
+use Zend\Mvc\Exception\InvalidMiddlewareException;
 
-final class MiddlewareNotCallableExceptionTest extends TestCase
+final class InvalidMiddlewareExceptionTest extends TestCase
 {
     public function testFromMiddlewareName()
     {
         $middlewareName = uniqid('middlewareName', true);
-        $exception = MiddlewareNotCallableException::fromMiddlewareName($middlewareName);
+        $exception = InvalidMiddlewareException::fromMiddlewareName($middlewareName);
 
-        $this->assertInstanceOf(MiddlewareNotCallableException::class, $exception);
+        $this->assertInstanceOf(InvalidMiddlewareException::class, $exception);
         $this->assertSame('Cannot dispatch middleware ' . $middlewareName, $exception->getMessage());
         $this->assertSame($middlewareName, $exception->toMiddlewareName());
     }
 
     public function testToMiddlewareNameWhenNotSet()
     {
-        $exception = new MiddlewareNotCallableException();
+        $exception = new InvalidMiddlewareException();
+        $this->assertSame('', $exception->toMiddlewareName());
+    }
+
+    public function testFromNull()
+    {
+        $exception = InvalidMiddlewareException::fromNull();
+
+        $this->assertInstanceOf(InvalidMiddlewareException::class, $exception);
+        $this->assertSame('Middleware name cannot be null', $exception->getMessage());
         $this->assertSame('', $exception->toMiddlewareName());
     }
 }

test/MiddlewareListenerTest.php

@@ -20,6 +20,7 @@
 use Zend\Http\Request;
 use Zend\Http\Response;
 use Zend\Mvc\Application;
+use Zend\Mvc\Exception\InvalidMiddlewareException;
 use Zend\Mvc\Exception\ReachedFinalHandlerException;
 use Zend\Mvc\MiddlewareListener;
 use Zend\Mvc\MvcEvent;
@@ -305,7 +306,7 @@ public function testMiddlewareWithNothingPipedReachesFinalHandlerException()
         $this->assertEquals('FAILED', $return);
     }
 
-    public function testNullMiddlewareThrowsInvalidArgument()
+    public function testNullMiddlewareThrowsInvalidMiddlewareException()
     {
         $response   = new Response();
         $routeMatch = $this->prophesize(RouteMatch::class);
@@ -329,14 +330,14 @@ public function testNullMiddlewareThrowsInvalidArgument()
         $event->setRouteMatch($routeMatch->reveal());
 
         $event->getApplication()->getEventManager()->attach(MvcEvent::EVENT_DISPATCH_ERROR, function ($e) {
-            $this->assertEquals(Application::ERROR_EXCEPTION, $e->getError());
-            $this->assertInstanceOf(ReachedFinalHandlerException::class, $e->getParam('exception'));
+            $this->assertEquals(Application::ERROR_MIDDLEWARE_CANNOT_DISPATCH, $e->getError());
+            $this->assertInstanceOf(InvalidMiddlewareException::class, $e->getParam('exception'));
             return 'FAILED';
         });
 
         $listener = new MiddlewareListener();
 
-        $this->expectException(\InvalidArgumentException::class);
-        $listener->onDispatch($event);
+        $return = $listener->onDispatch($event);
+        $this->assertEquals('FAILED', $return);
     }
 }