cleanup event dispatching and add debug subscriber

Author: dbu

src/SymfonyCache/DebugSubscriber.php

@@ -0,0 +1,64 @@
+<?php
+
+/*
+ * This file is part of the FOSHttpCache package.
+ *
+ * (c) FriendsOfSymfony <http://friendsofsymfony.github.com/>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace FOS\HttpCache\SymfonyCache;
+
+use Symfony\Component\EventDispatcher\EventSubscriberInterface;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\RequestMatcher;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpKernel\HttpKernelInterface;
+use Symfony\Component\OptionsResolver\OptionsResolver;
+
+/**
+ * Debug handler for the symfony built-in HttpCache.
+ *
+ * Add debug information to the response for use in cache tests.
+ *
+ * @author David Buchmann <[email protected]>
+ *
+ * {@inheritdoc}
+ */
+class DebugSubscriber implements EventSubscriberInterface
+{
+    /**
+     * {@inheritdoc}
+     */
+    public static function getSubscribedEvents()
+    {
+        return [
+            Events::POST_HANDLE => 'handleDebug',
+        ];
+    }
+
+    /**
+     * Extract the cache HIT/MISS information from the X-Symfony-Cache header.
+     *
+     * For this header to be present, the HttpCache must be created with the
+     * debug option set to true.
+     *
+     * @param CacheEvent $event
+     */
+    public function handleDebug(CacheEvent $event)
+    {
+        $response = $event->getResponse();
+        if ($response->headers->has('X-Symfony-Cache')) {
+            if (false !== strpos($response->headers->get('X-Symfony-Cache'), 'miss')) {
+                $state = 'MISS';
+            } elseif (false !== strpos($response->headers->get('X-Symfony-Cache'), 'fresh')) {
+                $state = 'HIT';
+            } else {
+                $state = 'UNDETERMINED';
+            }
+            $response->headers->set('X-Cache', $state);
+        }
+    }
+}

src/SymfonyCache/EventDispatchingHttpCache.php

@@ -19,12 +19,21 @@
 use Symfony\Component\HttpKernel\HttpKernelInterface;
 
 /**
- * Trait for enhanced Symfony reverse proxy based on the symfony component.
+ * Trait for enhanced Symfony reverse proxy based on the symfony kernel component.
  *
- * <b>When using FOSHttpCacheBundle, look at FOS\HttpCacheBundle\HttpCache instead.</b>
+ * Your kernel needs to implement CacheInvalidatorInterface and redeclare the
+ * fetch method as public. (The later is needed because the trait declaring it
+ * public does not satisfy the interface for whatever reason. See also
+ * http://stackoverflow.com/questions/31877844/php-trait-exposing-a-method-and-interfaces )
  *
- * This kernel supports event subscribers that can act on the events defined in
- * FOS\HttpCache\SymfonyCache\Events and may alter the request flow.
+ * CacheInvalidator kernels support event subscribers that can act on the
+ * events defined in FOS\HttpCache\SymfonyCache\Events and may alter the
+ * request flow.
+ *
+ * If your kernel overwrites any of the methods defined in this trait, make
+ * sure to also call the trait method. You might get into issues with the order
+ * of events, in which case you will need to copy event triggering into your
+ * kernel.
  *
  * @author Jérôme Vieilledent <[email protected]> (courtesy of eZ Systems AS)
  *
@@ -68,17 +77,13 @@ public function addSubscriber(EventSubscriberInterface $subscriber)
      */
     public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
     {
-        if ($this->getEventDispatcher()->hasListeners(Events::PRE_HANDLE)) {
-            $event = new CacheEvent($this, $request);
-            $this->getEventDispatcher()->dispatch(Events::PRE_HANDLE, $event);
-            if ($event->getResponse()) {
-                return $this->dispatchPostHandle($request, $event->getResponse());
-            }
+        if ($response = $this->dispatch(Events::PRE_HANDLE, $request)) {
+            return $this->dispatch(Events::POST_HANDLE, $request, $response);
         }
 
         $response = parent::handle($request, $type, $catch);
 
-        return $this->dispatchPostHandle($request, $response);
+        return $this->dispatch(Events::POST_HANDLE, $request, $response);
     }
 
     /**
@@ -88,57 +93,40 @@ public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQ
      */
     protected function store(Request $request, Response $response)
     {
-        if ($this->getEventDispatcher()->hasListeners(Events::PRE_STORE)) {
-            $event = new CacheEvent($this, $request, $response);
-            $this->getEventDispatcher()->dispatch(Events::PRE_STORE, $event);
-            $response = $event->getResponse();
-        }
+        $response = $this->dispatch(Events::PRE_STORE, $request, $response);
 
         parent::store($request, $response);
     }
 
     /**
-     * Dispatch the POST_HANDLE event if needed.
+     * Dispatch an event if needed.
      *
-     * @param Request  $request
-     * @param Response $response
+     * @param string        $name     Name of the event to trigger. One of the constants in FOS\HttpCache\SymfonyCache\Events
+     * @param Request       $request
+     * @param Response|null $response If already available
      *
-     * @return Response The response to return which might be altered by a POST_HANDLE listener.
+     * @return Response The response to return, which might be provided/altered by a listener.
      */
-    private function dispatchPostHandle(Request $request, Response $response)
+    protected function dispatch($name, Request $request, Response $response = null)
     {
-        if ($this->getEventDispatcher()->hasListeners(Events::POST_HANDLE)) {
+        if ($this->getEventDispatcher()->hasListeners($name)) {
             $event = new CacheEvent($this, $request, $response);
-            $this->getEventDispatcher()->dispatch(Events::POST_HANDLE, $event);
+            $this->getEventDispatcher()->dispatch($name, $event);
             $response = $event->getResponse();
         }
 
         return $response;
     }
 
-    /**
-     * Made public to allow event subscribers to do refresh operations.
-     *
-     * {@inheritDoc}
-     */
-    public function fetch(Request $request, $catch = false)
-    {
-        return parent::fetch($request, $catch);
-    }
-
     /**
      * {@inheritDoc}
      *
      * Adding the Events::PRE_INVALIDATE event.
      */
     protected function invalidate(Request $request, $catch = false)
     {
-        if ($this->getEventDispatcher()->hasListeners(Events::PRE_INVALIDATE)) {
-            $event = new CacheEvent($this, $request);
-            $this->getEventDispatcher()->dispatch(Events::PRE_INVALIDATE, $event);
-            if ($event->getResponse()) {
-                return $event->getResponse();
-            }
+        if ($response = $this->dispatch(Events::PRE_INVALIDATE, $request)) {
+            return $response;
         }
 
         return parent::invalidate($request, $catch);

src/Test/PHPUnit/AbstractCacheConstraint.php

@@ -11,6 +11,8 @@
 
 namespace FOS\HttpCache\Test\PHPUnit;
 
+use GuzzleHttp\Psr7\Response;
+
 /**
  * Abstract cache constraint
  */
@@ -41,17 +43,25 @@ abstract public function getValue();
 
     /**
      * {@inheritdoc}
+     *
+     * @param Response $other The guzzle response object
      */
     protected function matches($other)
     {
+        if (!$other instanceof Response) {
+            throw new \RuntimeException('Expected a GuzzleHttp\Psr7\Response but got %s', get_class($other));
+        }
         if (!$other->hasHeader($this->header)) {
-            throw new \RuntimeException(
-                sprintf(
-                    'Response has no "%s" header. Configure your caching proxy '
-                    . 'to set the header with cache hit/miss status.',
-                    $this->header
-                )
+            $message = sprintf(
+                'Response has no "%s" header. Configure your caching proxy '
+                . 'to set the header with cache hit/miss status.',
+                $this->header
             );
+            if (200 !== $other->getStatusCode()) {
+                $message .= sprintf("\nStatus code of response is %s.", $other->getStatusCode());
+            }
+
+            throw new \RuntimeException($message);
         }
 
         return $this->getValue() === (string) $other->getHeaderLine($this->header);

tests/Functional/Fixtures/Symfony/AppCache.php

@@ -10,26 +10,7 @@
 
 class AppCache extends HttpCache implements CacheInvalidationInterface
 {
-    // http://stackoverflow.com/questions/31877844/php-trait-exposing-a-method-and-interfaces
-    use EventDispatchingHttpCache {fetch as public eventTriggeringFetch;}
-
-    public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true)
-    {
-        $response = parent::handle($request, $type, $catch);
-
-        if ($response->headers->has('X-Symfony-Cache')) {
-            if (false !== strpos($response->headers->get('X-Symfony-Cache'), 'miss')) {
-                $state = 'MISS';
-            } elseif (false !== strpos($response->headers->get('X-Symfony-Cache'), 'fresh')) {
-                $state = 'HIT';
-            } else {
-                $state = 'UNDETERMINED';
-            }
-            $response->headers->set('X-Cache', $state);
-        }
-
-        return $response;
-    }
+    use EventDispatchingHttpCache;
 
     /**
      * Made public to allow event subscribers to do refresh operations.
@@ -38,6 +19,6 @@ public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQ
      */
     public function fetch(Request $request, $catch = false)
     {
-        return $this->eventTriggeringFetch($request, $catch);
+        return parent::fetch($request, $catch);
     }
 }

tests/Functional/Fixtures/web/symfony.php

@@ -18,6 +18,7 @@
 $kernel->addSubscriber(new PurgeSubscriber(['purge_method' => 'NOTIFY']));
 $kernel->addSubscriber(new RefreshSubscriber());
 $kernel->addSubscriber(new UserContextSubscriber());
+$kernel->addSubscriber(new \FOS\HttpCache\SymfonyCache\DebugSubscriber());
 $request = Request::createFromGlobals();
 $response = $kernel->handle($request);
 $response->send();

tests/Unit/SymfonyCache/EventDispatchingHttpCacheTest.php

@@ -146,11 +146,16 @@ public function testAbortInvalidate()
 
 class AppCache extends HttpCache implements CacheInvalidationInterface
 {
-    // http://stackoverflow.com/questions/31877844/php-trait-exposing-a-method-and-interfaces
-    use EventDispatchingHttpCache {fetch as public eventTriggeringFetch;}
+    use EventDispatchingHttpCache;
+
+    /**
+     * Made public to allow event subscribers to do refresh operations.
+     *
+     * {@inheritDoc}
+     */
     public function fetch(Request $request, $catch = false)
     {
-        return $this->eventTriggeringFetch($request, $catch);
+        parent::fetch($request, $catch);
     }
 }