FOS\HttpCacheBundle\Tests\Unit\EventListener\InvalidationListenerTest

Complexity

Total Complexity

10

Size/Duplication

Total Lines	164
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	16

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	4	1
A	testNoRoutesInvalidatedWhenResponseIsUnsuccessful()	0	18	1
B	testOnKernelTerminate()	0	46	1
A	testOnKernelException()	0	16	1
A	testInvalidatePath()	0	18	1
A	testInvalidateRoute()	0	18	1
A	testOnConsoleTerminate()	0	15	1
A	getEvent()	0	8	2
A	getListener()	0	7	1

<?php

/*
 * This file is part of the FOSHttpCacheBundle 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\HttpCacheBundle\Tests\Unit\EventListener;

use FOS\HttpCacheBundle\Configuration\InvalidatePath;
use FOS\HttpCacheBundle\Configuration\InvalidateRoute;
use FOS\HttpCacheBundle\EventListener\InvalidationListener;
use FOS\HttpCacheBundle\Http\RuleMatcher;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\RequestMatcher;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Event\PostResponseEvent;
use Symfony\Component\Routing\Route;
use Symfony\Component\Routing\RouteCollection;

class InvalidationListenerTest extends \PHPUnit_Framework_TestCase
{
    protected $cacheManager;
    protected $invalidators;

    public function setUp()
    {
        $this->cacheManager = \Mockery::mock('\FOS\HttpCacheBundle\CacheManager');
    }

    public function testNoRoutesInvalidatedWhenResponseIsUnsuccessful()
    {
        $this->cacheManager

The method shouldReceive() does not seem to exist on object<Mockery\Expectation>.

            ->shouldReceive('invalidateRoute')->never()
            ->shouldReceive('flush')->once();

        $this->invalidators = \Mockery::mock('\FOS\HttpCacheBundle\Invalidator\InvalidatorCollection')
            ->shouldReceive('hasInvalidatorRoute')
            ->with('my_route')
            ->andReturn(false)
            ->getMock();

        $request = new Request();
        $request->attributes->set('_route', 'my_route');

        $event = $this->getEvent($request, new Response('', 500));
        $this->getListener()->onKernelTerminate($event);
    }

    public function testOnKernelTerminate()
    {
        $cacheManager = \Mockery::mock('\FOS\HttpCacheBundle\CacheManager');
        $cacheManager->shouldReceive('invalidatePath')->with('/retrieve/something/123')

The method shouldReceive() does not seem to exist on object<Mockery\Expectation>.

            ->shouldReceive('invalidatePath')->with('/retrieve/something/123/bla')
            ->shouldReceive('flush')->once()
            ->getMock();

        $routes = new RouteCollection();
        $routes->add('route_invalidator', new Route('/edit/something/{id}/{special}'));
        $routes->add('route_invalidated', new Route('/retrieve/something/{id}'));
        $routes->add('route_invalidated_special', new Route('/retrieve/something/{id}/{special}'));

        $requestParams = array('id' => 123, 'special' => 'bla');
        $router = \Mockery::mock('\Symfony\Component\Routing\Router')
            ->shouldDeferMissing()
            ->shouldReceive('generate')
            ->with('route_invalidated', $requestParams)
            ->andReturn('/retrieve/something/123?special=bla')

            ->shouldReceive('generate')
            ->with('route_invalidated_special', $requestParams)
            ->andReturn('/retrieve/something/123/bla')
            ->getMock();

        $ruleMatcher = new RuleMatcher(new RequestMatcher(
            null,
            null,
            null,
            null,
            array('_route' => 'route_invalidator')
        ), array());

        $listener = new InvalidationListener($cacheManager, $router);
        $listener->addRule($ruleMatcher, array(
            'route_invalidated' => array('ignore_extra_params' => true),
            'route_invalidated_special' => array('ignore_extra_params' => true),
        ));

        $request = new Request();
        $request->attributes->set('_route', 'route_invalidator');
        $request->attributes->set('_route_params', $requestParams);

        $event = $this->getEvent($request);
        $listener->onKernelTerminate($event);
    }

    public function testOnKernelException()
    {
        $cacheManager = \Mockery::mock('\FOS\HttpCacheBundle\CacheManager');
        $cacheManager
            ->shouldReceive('flush')->once()
        ;

        $router = \Mockery::mock('\Symfony\Component\Routing\Generator\UrlGeneratorInterface');

        $listener = new InvalidationListener($cacheManager, $router);

        $request = new Request();

        $event = $this->getEvent($request);
        $listener->onKernelException($event);

The call to InvalidationListener::onKernelException() has too many arguments starting with $event.

    }

    public function testInvalidatePath()
    {
        $request = new Request();
        $request->attributes->set('_invalidate_path', array(
            new InvalidatePath(array('value' => '/some/path')),
            new InvalidatePath(array('value' => array('/other/path', 'http://absolute.com/path'))),
        ));

        $event = $this->getEvent($request);

        $this->cacheManager

The method shouldReceive() does not seem to exist on object<Mockery\Expectation>.

            ->shouldReceive('invalidatePath')->with('/some/path')->once()
            ->shouldReceive('invalidatePath')->with('/other/path')->once()
            ->shouldReceive('invalidatePath')->with('http://absolute.com/path')->once()
            ->shouldReceive('flush')->once();

        $this->getListener()->onKernelTerminate($event);
    }

    public function testInvalidateRoute()
    {
        $request = new Request();
        $request->attributes->set('request_id', 123);
        $request->attributes->set('_invalidate_route', array(
            new InvalidateRoute(array('name' => 'some_route')),
            new InvalidateRoute(array('name' => 'other_route', 'params' => array('id' => array('expression' => 'request_id')))),
        ));

        $event = $this->getEvent($request);

        $this->cacheManager

The method shouldReceive() does not seem to exist on object<Mockery\Expectation>.

            ->shouldReceive('invalidateRoute')->with('some_route', array())->once()
            ->shouldReceive('invalidateRoute')->with('other_route', array('id' => 123))->once()
            ->shouldReceive('flush')->once();

        $this->getListener()->onKernelTerminate($event);
    }

    public function testOnConsoleTerminate()
    {
        $this->cacheManager->shouldReceive('flush')->once()->andReturn(2);

        $output = \Mockery::mock('\Symfony\Component\Console\Output\OutputInterface')

The method shouldReceive() does not seem to exist on object<Mockery\Expectation>.

            ->shouldReceive('getVerbosity')->once()->andReturn(OutputInterface::VERBOSITY_VERBOSE)
            ->shouldReceive('writeln')->with('Sent 2 invalidation request(s)')->once()
            ->getMock();

        $event = \Mockery::mock('\Symfony\Component\Console\Event\ConsoleEvent')
            ->shouldReceive('getOutput')->andReturn($output)
            ->getMock();

        $this->getListener()->onConsoleTerminate($event);
    }

    protected function getEvent(Request $request, Response $response = null)
    {
        return new PostResponseEvent(
            \Mockery::mock('\Symfony\Component\HttpKernel\HttpKernelInterface'),
            $request,
            null !== $response ? $response : new Response()
        );
    }

    protected function getListener()
    {
        return new InvalidationListener(
            $this->cacheManager,
            \Mockery::mock('\Symfony\Component\Routing\Generator\UrlGeneratorInterface')
        );
    }
}