ParameterResolverTest::testResolveLocationRoute() - Code Metrics - Inspection of "Merge pull request #57 from php-lug/response-statu..." - php-lug/lug - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 346488...5472e0 )

by Eric
created 2016-06-29 18:05 UTC
ParameterResolverTest::testResolveLocationRoute() A

↳ Parent: ParameterResolverTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	15
Code Lines	11
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
c	1
b	0
f	0
dl	0
loc	15
rs	9.4285
cc	1
eloc	11
nc	1
nop	0
<?php

/*
 * This file is part of the Lug package.
 *
 * (c) Eric GELOEN <[email protected]>
 *
 * For the full copyright and license information, please read the LICENSE
 * file that was distributed with this source code.
 */

namespace Lug\Bundle\ResourceBundle\Tests\Routing;

use Lug\Bundle\ResourceBundle\Routing\ParameterResolver;
use Lug\Component\Resource\Model\ResourceInterface;
use Symfony\Component\HttpFoundation\ParameterBag;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\RequestStack;
use Symfony\Component\PropertyAccess\PropertyAccessorInterface;

/**
 * @author GeLo <[email protected]>
 */
class ParameterResolverTest extends \PHPUnit_Framework_TestCase
{
    /**
     * @var ParameterResolver
     */
    private $parameterResolver;

    /**
     * @var \PHPUnit_Framework_MockObject_MockObject|RequestStack
     */
    private $requestStack;

    /**
     * @var \PHPUnit_Framework_MockObject_MockObject|PropertyAccessorInterface
     */
    private $propertyAccessor;

    /**
     * {@inheritdoc}
     */
    protected function setUp()
    {
        $this->requestStack = $this->createRequestStackMock();
        $this->propertyAccessor = $this->createPropertyAccessorMock();

        $this->parameterResolver = new ParameterResolver($this->requestStack, $this->propertyAccessor);
    }

    public function testResolveApiWithoutRequest()
    {
        $this->assertFalse($this->parameterResolver->resolveApi());
    }

    public function testResolveApiWihApiRequest()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_api'), $this->identicalTo(false))
            ->will($this->returnValue(true));

        $this->assertTrue($this->parameterResolver->resolveApi());
    }

    public function testResolveApiWithHtmlRequest()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request
            ->expects($this->once())
            ->method('getRequestFormat')
            ->will($this->returnValue('html'));

        $this->assertFalse($this->parameterResolver->resolveApi());
    }

    public function testResolveApiWithCustomRequest()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request
            ->expects($this->once())
            ->method('getRequestFormat')
            ->will($this->returnValue('json'));

        $this->assertTrue($this->parameterResolver->resolveApi());
    }

    public function testResolveCriteriaWithoutRequest()
    {
        $this->assertEmpty($this->parameterResolver->resolveCriteria());
    }

    public function testResolveCriteriaWithDefault()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_criteria'), $this->identicalTo([$identifier = 'id']))
            ->will($this->returnValue([$identifier]));

        $request
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo($identifier), $this->isNull())
            ->will($this->returnValue($value = 'value'));

        $this->assertSame([$identifier => $value], $this->parameterResolver->resolveCriteria());
    }

    public function testResolveCriteriaWithExplicit()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_criteria'), $this->identicalTo(['id']))
            ->will($this->returnValue([$identifier = 'code']));

        $request
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo($identifier), $this->isNull())
            ->will($this->returnValue($value = 'value'));

        $this->assertSame([$identifier => $value], $this->parameterResolver->resolveCriteria());
    }

    /**
     * @expectedException \Lug\Bundle\ResourceBundle\Exception\RequestNotFoundException
     * @expectedExceptionMessage The request could not be found.
     */
    public function testResolveCriteriaMandatoryWithoutRequest()
    {
        $this->parameterResolver->resolveCriteria(true);
    }

    /**
     * @expectedException \Lug\Bundle\ResourceBundle\Exception\RuntimeException
     * @expectedExceptionMessage The criteria could not be found for the route "route".
     */
    public function testResolveCriteriaMandatoryWithoutCriteria()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->at(0))
            ->method('get')
            ->with($this->identicalTo('_lug_criteria'), $this->identicalTo(['id']))
            ->will($this->returnValue([]));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->at(1))
            ->method('get')
            ->with($this->identicalTo('_route'), $this->isNull())
            ->will($this->returnValue('route'));

        $this->parameterResolver->resolveCriteria(true);
    }

    /**
     * @expectedException \Lug\Bundle\ResourceBundle\Exception\RuntimeException
     * @expectedExceptionMessage The criteria "id" could not be found for the route "route".
     */
    public function testResolveCriteriaMandatoryWithoutRequestCriteria()
    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->at(0))
            ->method('get')
            ->with($this->identicalTo('_lug_criteria'), $this->identicalTo([$identifier = 'id']))
            ->will($this->returnValue([$identifier]));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->at(1))
            ->method('get')
            ->with($this->identicalTo('_route'), $this->isNull())
            ->will($this->returnValue('route'));

        $request
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo($identifier), $this->isNull())
            ->will($this->returnValue(null));

        $this->parameterResolver->resolveCriteria(true);
    }

    public function testResolveCurrentPageWithoutRequest()
    {
        $this->assertSame(1, $this->parameterResolver->resolveCurrentPage());
    }

    public function testResolveCurrentPageDefault()
    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_page_parameter'), $this->identicalTo($pageParameter = 'page'))
            ->will($this->returnValue($pageParameter));

        $request
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo($pageParameter), $this->identicalTo($page = 1))
            ->will($this->returnValue($page));

        $this->assertSame($page, $this->parameterResolver->resolveCurrentPage());
    }

    public function testResolveCurrentPageExplicitParameter()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_page_parameter'), $this->identicalTo('page'))
            ->will($this->returnValue($pageParameter = 'p'));

        $request
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo($pageParameter), $this->identicalTo($page = 1))
            ->will($this->returnValue($page));

        $this->assertSame($page, $this->parameterResolver->resolveCurrentPage());
    }

    public function testResolveCurrentPageExplicitPage()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_page_parameter'), $this->identicalTo($pageParameter = 'page'))
            ->will($this->returnValue($pageParameter));

        $request
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo($pageParameter), $this->identicalTo(1))
            ->will($this->returnValue($page = 2));

        $this->assertSame($page, $this->parameterResolver->resolveCurrentPage());
    }

    public function testResolveFormWithoutRequest()
    {
        $resource = $this->createResourceMock();
        $resource
            ->expects($this->once())
            ->method('getForm')
            ->will($this->returnValue($form = 'form'));

        $this->assertSame($form, $this->parameterResolver->resolveForm($resource));
    }

    public function testResolveFormDefault()
    {
        $resource = $this->createResourceMock();
        $resource
            ->expects($this->once())
            ->method('getForm')
            ->will($this->returnValue($form = 'form'));

        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_form'), $this->identicalTo($form))
            ->will($this->returnValue($form));

        $this->assertSame($form, $this->parameterResolver->resolveForm($resource));
    }

    public function testResolveFormExplicit()
    {
        $resource = $this->createResourceMock();
        $resource
            ->expects($this->once())
            ->method('getForm')
            ->will($this->returnValue($form = 'form'));

        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_form'), $this->identicalTo($form))
            ->will($this->returnValue($explicitForm = 'explicit_form'));

        $this->assertSame($explicitForm, $this->parameterResolver->resolveForm($resource));
    }

    public function testResolveGrid()
    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_grid'), $this->identicalTo([]))
            ->will($this->returnValue($grid = ['foo' => 'bar']));

        $this->assertSame(
            array_merge(['resource' => $resource = $this->createResourceMock()], $grid),
            $this->parameterResolver->resolveGrid($resource)
        );
    }

    /**
     * @expectedException \Lug\Bundle\ResourceBundle\Exception\RequestNotFoundException
     * @expectedExceptionMessage The request could not be found.
     */
    public function testResolveGridWithoutRequest()
    {
        $this->parameterResolver->resolveGrid($this->createResourceMock());
    }

    public function testResolveHateoasWithoutRequest()
    {
        $this->assertFalse($this->parameterResolver->resolveHateoas());
    }

    public function testResolveHateoasDefault()
    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_hateoas'), $this->identicalTo($hateaos = false))
            ->will($this->returnValue($hateaos));

        $this->assertFalse($this->parameterResolver->resolveHateoas());
    }

    public function testResolveHateoasExplicit()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_hateoas'), $this->identicalTo(false))
            ->will($this->returnValue(true));

        $this->assertTrue($this->parameterResolver->resolveHateoas());
    }

    public function testResolveLocationRoute()
    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_location_route'), $this->isNull())
            ->will($this->returnValue($route = 'route'));

        $this->assertSame($route, $this->parameterResolver->resolveLocationRoute());
    }

    /**
     * @expectedException \Lug\Bundle\ResourceBundle\Exception\RequestNotFoundException
     * @expectedExceptionMessage The request could not be found.
     */
    public function testResolveLocationRouteWithoutRequest()
    {
        $this->parameterResolver->resolveLocationRoute();
    }

    /**
     * @expectedException \Lug\Bundle\ResourceBundle\Exception\RuntimeException
     * @expectedExceptionMessage The location route could not be found for the route "route".
     */
    public function testResolveLocationRouteMissing()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->at(0))
            ->method('get')
            ->with($this->identicalTo('_lug_location_route'), $this->isNull())
            ->will($this->returnValue(null));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->at(1))
            ->method('get')
            ->with($this->identicalTo('_route'), $this->isNull())
            ->will($this->returnValue('route'));

        $this->parameterResolver->resolveLocationRoute();
    }

    public function testResolveLocationRouteParametersWithoutRequest()
    {
        $this->assertEmpty($this->parameterResolver->resolveLocationRouteParameters(new \stdClass()));
    }

    public function testResolveLocationRouteParametersDefault()
    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_location_route_parameters'), $this->identicalTo($parameters = []))
            ->will($this->returnValue($parameters));

        $this->assertEmpty($this->parameterResolver->resolveLocationRouteParameters(new \stdClass()));
    }

    public function testResolveLocationRouteParametersExplicit()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_location_route_parameters'), $this->identicalTo([]))
            ->will($this->returnValue([$parameter = 'id']));

        $object = new \stdClass();
        $object->{$parameter} = $value = 1;

        $this->propertyAccessor
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getValue')
            ->with($this->identicalTo($object), $this->identicalTo($parameter))
            ->will($this->returnValue($value));

        $this->assertSame([$parameter => $value], $this->parameterResolver->resolveLocationRouteParameters($object));
    }

    public function testResolveMaxPerPageWithoutRequest()
    {
        $this->assertSame(10, $this->parameterResolver->resolveMaxPerPage());
    }

    public function testResolveMaxPerPageDefault()
    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_max_per_page'), $this->identicalTo($maxPerPage = 10))
            ->will($this->returnValue($maxPerPage));

        $this->assertSame($maxPerPage, $this->parameterResolver->resolveMaxPerPage());
    }

    public function testResolveMaxPerPageExplicit()
    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_max_per_page'), $this->identicalTo(10))
            ->will($this->returnValue($maxPerPage = 5));

        $this->assertSame($maxPerPage, $this->parameterResolver->resolveMaxPerPage());
    }

    public function testResolveRedirectRoute()
    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_redirect_route'), $this->isNull())
            ->will($this->returnValue($route = 'route'));

        $this->assertSame($route, $this->parameterResolver->resolveRedirectRoute());
    }

    /**
     * @expectedException \Lug\Bundle\ResourceBundle\Exception\RequestNotFoundException
     * @expectedExceptionMessage The request could not be found.
     */
    public function testResolveRedirectRouteWithoutRequest()
    {
        $this->parameterResolver->resolveRedirectRoute();
    }

    /**
     * @expectedException \Lug\Bundle\ResourceBundle\Exception\RuntimeException
     * @expectedExceptionMessage The redirect route could not be found for the route "route".
     */
    public function testResolveRedirectRouteMissing()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->at(0))
            ->method('get')
            ->with($this->identicalTo('_lug_redirect_route'), $this->isNull())
            ->will($this->returnValue(null));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->at(1))
            ->method('get')
            ->with($this->identicalTo('_route'), $this->isNull())
            ->will($this->returnValue('route'));

        $this->parameterResolver->resolveRedirectRoute();
    }

    public function testResolveRedirectRouteParametersWithoutRequest()
    {
        $this->assertEmpty($this->parameterResolver->resolveRedirectRouteParameters(new \stdClass()));
    }

    public function testResolveRedirectRouteParametersDefault()
    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_redirect_route_parameters'), $this->identicalTo($parameters = []))
            ->will($this->returnValue($parameters));

        $this->assertEmpty($this->parameterResolver->resolveRedirectRouteParameters(new \stdClass()));
    }

    public function testResolveRedirectRouteParametersExplicit()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_redirect_route_parameters'), $this->identicalTo([]))
            ->will($this->returnValue([$parameter = 'id']));

        $object = new \stdClass();
        $object->{$parameter} = $value = 1;

        $this->propertyAccessor
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getValue')
            ->with($this->identicalTo($object), $this->identicalTo($parameter))
            ->will($this->returnValue($value));

        $this->assertSame([$parameter => $value], $this->parameterResolver->resolveRedirectRouteParameters($object));
    }

    public function testResolveRedirectRouteParametersForwardParameters()
    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_redirect_route_parameters'), $this->identicalTo([]))
            ->will($this->returnValue([$parameter = 'id']));

        $request->query = $this->createParameterBagMock();
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        $request->query
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('all')
            ->will($this->returnValue($query = ['foo' => 'bar']));

        $object = new \stdClass();
        $object->{$parameter} = $value = 1;

        $this->propertyAccessor
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getValue')
            ->with($this->identicalTo($object), $this->identicalTo($parameter))
            ->will($this->returnValue($value));

        $this->assertSame(
            array_merge($query, [$parameter => $value]),
            $this->parameterResolver->resolveRedirectRouteParameters($object, true)
        );
    }

    public function testResolveRedirectRouteParametersWithoutObject()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_redirect_route_parameters'), $this->identicalTo([]))
            ->will($this->returnValue([]));

        $this->assertEmpty($this->parameterResolver->resolveRedirectRouteParameters());
    }

    /**
     * @expectedException \Lug\Bundle\ResourceBundle\Exception\RuntimeException
     * @expectedExceptionMessage The route parameters could not be found for the route "redirect_route_parameters".
     */
    public function testResolveRedirectRouteParametersWithObjectMissing()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_redirect_route_parameters'), $this->identicalTo([]))
            ->will($this->returnValue(['id']));

        $this->assertEmpty($this->parameterResolver->resolveRedirectRouteParameters());
    }

    public function testResolveRedirectRouteParametersForwardWithoutRequest()
    {
        $this->assertFalse($this->parameterResolver->resolveRedirectRouteParametersForward());
    }

    public function testResolveRedirectRouteParametersForwardDefault()
    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_redirect_route_parameters_forward'), $this->identicalTo($forward = false))
            ->will($this->returnValue($forward));

        $this->assertFalse($this->parameterResolver->resolveRedirectRouteParametersForward());
    }

    public function testResolveRedirectRouteParametersForwardExplicit()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_redirect_route_parameters_forward'), $this->identicalTo(false))
            ->will($this->returnValue(true));

        $this->assertTrue($this->parameterResolver->resolveRedirectRouteParametersForward());
    }

    public function testResolveRepositoryMethodWithoutRequest()
    {
        $this->assertSame('findForTest', $this->parameterResolver->resolveRepositoryMethod('test'));
    }

    public function testResolveRepositoryMethodDefault()
    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_repository_method'), $this->identicalTo($repositoryMethod = 'findForTest'))
            ->will($this->returnValue($repositoryMethod));

        $this->assertSame($repositoryMethod, $this->parameterResolver->resolveRepositoryMethod('test'));
    }

    public function testResolveRepositoryMethodExplicit()
    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_repository_method'), $this->identicalTo('findForTest'))
            ->will($this->returnValue($repositoryMethod = 'findForAction'));

        $this->assertSame($repositoryMethod, $this->parameterResolver->resolveRepositoryMethod('test'));
    }

    public function testResolveSerializerGroupsWithoutRequest()
    {
        $this->assertEmpty($this->parameterResolver->resolveSerializerGroups());
    }

    public function testResolveSerializerGroupsDefault()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with(
                $this->identicalTo('_lug_serializer_groups'),
                $this->identicalTo($groups = [])
            )
            ->will($this->returnValue($groups));

        $this->assertEmpty($this->parameterResolver->resolveSerializerGroups());
    }

    public function testResolveSerializerGroupsExplicit()
    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with(
                $this->identicalTo('_lug_serializer_groups'),
                $this->identicalTo([])
            )
            ->will($this->returnValue($groups = ['group']));

        $this->assertSame($groups, $this->parameterResolver->resolveSerializerGroups());
    }

    public function testResolveSerializerNullWithoutRequest()
    {
        $this->assertTrue($this->parameterResolver->resolveSerializerNull());
    }

    public function testResolveSerializerNullDefault()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_serializer_null'), $this->identicalTo($null = true))
            ->will($this->returnValue($null));

        $this->assertTrue($this->parameterResolver->resolveSerializerNull());
    }

    public function testResolveSerializerNullExplicit()
    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_serializer_null'), $this->identicalTo(true))
            ->will($this->returnValue(false));

        $this->assertFalse($this->parameterResolver->resolveSerializerNull());
    }

    public function testResolveSortingWithoutRequest()
    {
        $this->assertEmpty($this->parameterResolver->resolveSorting());
    }

    public function testResolveSortingDefault()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_sorting'), $this->identicalTo($sorting = []))
            ->will($this->returnValue($sorting));

        $this->assertEmpty($this->parameterResolver->resolveSorting());
    }

    public function testResolveSortingExplicit()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_sorting'), $this->identicalTo([]))
            ->will($this->returnValue($sorting = ['foo' => 'ASC']));

        $this->assertSame($sorting, $this->parameterResolver->resolveSorting());
    }

    public function testResolveStatusCodeWithoutRequest()
    {
        $this->assertSame($statusCode = 200, $this->parameterResolver->resolveStatusCode($statusCode));
    }

    public function testResolveStatusCodeDefault()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_status_code'), $this->identicalTo($statusCode = 200))
            ->will($this->returnValue($statusCode));

        $this->assertSame($statusCode, $this->parameterResolver->resolveStatusCode($statusCode));
    }

    public function testResolveStatusCodeExplicit()
    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_status_code'), $this->identicalTo($defaultStatusCode = 200))
            ->will($this->returnValue($statusCode = 201));

        $this->assertSame($statusCode, $this->parameterResolver->resolveStatusCode($defaultStatusCode));
    }

    public function testResolveTemplate()
    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_template'), $this->isNull())
            ->will($this->returnValue($template = 'template'));

        $this->assertSame($template, $this->parameterResolver->resolveTemplate());
    }

    /**
     * @expectedException \Lug\Bundle\ResourceBundle\Exception\RequestNotFoundException
     * @expectedExceptionMessage The request could not be found.
     */
    public function testResolveTemplateWithoutRequest()
    {
        $this->parameterResolver->resolveTemplate();
    }

    /**
     * @expectedException \Lug\Bundle\ResourceBundle\Exception\RuntimeException
     * @expectedExceptionMessage The template could not be found for the route "route".
     */
    public function testResolveTemplateMissing()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->at(0))
            ->method('get')
            ->with($this->identicalTo('_lug_template'), $this->isNull())
            ->will($this->returnValue(null));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->at(1))
            ->method('get')
            ->with($this->identicalTo('_route'), $this->isNull())
            ->will($this->returnValue('route'));

        $this->parameterResolver->resolveTemplate();
    }

    public function testResolveThemesWithoutRequest()
    {
        $this->assertEmpty($this->parameterResolver->resolveThemes());
    }

    public function testResolveThemesDefault()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_themes'), $this->identicalTo($themes = []))
            ->will($this->returnValue($themes));

        $this->assertEmpty($this->parameterResolver->resolveThemes());
    }

    public function testResolveThemesExplicit()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_themes'), $this->identicalTo([]))
            ->will($this->returnValue($themes = ['theme']));

        $this->assertSame($themes, $this->parameterResolver->resolveThemes());
    }

    public function testResolveTranslationDomainWithoutRequest()
    {
        $this->assertSame('forms', $this->parameterResolver->resolveTranslationDomain());
    }

    public function testResolveTranslationDomainDefault()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->at(0))
            ->method('get')
            ->with($this->identicalTo('_lug_grid'), $this->isNull())
            ->will($this->returnValue(null));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->at(1))
            ->method('get')
            ->with($this->identicalTo('_lug_translation_domain'), $this->identicalTo($translationDomain = 'forms'))
            ->will($this->returnValue($translationDomain));

        $this->assertSame($translationDomain, $this->parameterResolver->resolveTranslationDomain());
    }

    public function testResolveTranslationDomainExplicit()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->at(0))
            ->method('get')
            ->with($this->identicalTo('_lug_grid'), $this->isNull())
            ->will($this->returnValue(null));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->at(1))
            ->method('get')
            ->with($this->identicalTo('_lug_translation_domain'), $this->identicalTo('forms'))
            ->will($this->returnValue($translationDomain = 'translation_domain'));

        $this->assertSame($translationDomain, $this->parameterResolver->resolveTranslationDomain());
    }

    public function testResolveTranslationDomainWithGrid()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->at(0))
            ->method('get')
            ->with($this->identicalTo('_lug_grid'), $this->isNull())
            ->will($this->returnValue(['grid']));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->at(1))
            ->method('get')
            ->with($this->identicalTo('_lug_translation_domain'), $this->identicalTo($translationDomain = 'grids'))
            ->will($this->returnValue($translationDomain));

        $this->assertSame($translationDomain, $this->parameterResolver->resolveTranslationDomain());
    }

    public function testResolveTranslationDomainExplicitWithGrid()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->at(0))
            ->method('get')
            ->with($this->identicalTo('_lug_grid'), $this->isNull())
            ->will($this->returnValue(['grid']));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->at(1))
            ->method('get')
            ->with($this->identicalTo('_lug_translation_domain'), $this->identicalTo('grids'))
            ->will($this->returnValue($translationDomain = 'translation_domain'));

        $this->assertSame($translationDomain, $this->parameterResolver->resolveTranslationDomain());
    }

    public function testResolveValidationGroupsWithoutRequest()
    {
        $this->assertEmpty($this->parameterResolver->resolveValidationGroups());
    }

    public function testResolveValidationGroupsDefault()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_validation_groups'), $this->identicalTo($groups = []))
            ->will($this->returnValue($groups));

        $this->assertEmpty($this->parameterResolver->resolveValidationGroups());
    }

    public function testResolveValidationGroupsExplicit()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_validation_groups'), $this->identicalTo([]))
            ->will($this->returnValue($groups = ['group']));

        $this->assertSame($groups, $this->parameterResolver->resolveValidationGroups());
    }

    public function testResolveVoterWithoutRequest()
    {
        $this->assertFalse($this->parameterResolver->resolveVoter());
    }

    public function testResolveVoterDefault()
    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_voter'), $this->identicalTo(false))
            ->will($this->returnValue(false));

        $this->assertFalse($this->parameterResolver->resolveVoter());
    }

    public function testResolveVoterExplicit()

    {
        $this->requestStack
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getMasterRequest')
            ->will($this->returnValue($request = $this->createRequestMock()));

        $request->attributes
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_voter'), $this->identicalTo(false))
            ->will($this->returnValue(true));

        $this->assertTrue($this->parameterResolver->resolveVoter());
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|RequestStack
     */
    private function createRequestStackMock()
    {
        return $this->createMock(RequestStack::class);
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|PropertyAccessorInterface
     */
    private function createPropertyAccessorMock()
    {
        return $this->createMock(PropertyAccessorInterface::class);
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|Request
     */
    private function createRequestMock()
    {
        $request = $this->createMock(Request::class);
        $request->attributes = $this->createParameterBagMock();
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}

        return $request;
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|ParameterBag
     */
    private function createParameterBagMock()
    {
        return $this->createMock(ParameterBag::class);
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|ResourceInterface
     */
    private function createResourceMock()
    {
        return $this->createMock(ResourceInterface::class);
    }
}

1			<?php
2
3			/*
4			* This file is part of the Lug package.
5			*
6			* (c) Eric GELOEN <[email protected]>
7			*
8			* For the full copyright and license information, please read the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Lug\Bundle\ResourceBundle\Tests\Routing;
13
14			use Lug\Bundle\ResourceBundle\Routing\ParameterResolver;
15			use Lug\Component\Resource\Model\ResourceInterface;
16			use Symfony\Component\HttpFoundation\ParameterBag;
17			use Symfony\Component\HttpFoundation\Request;
18			use Symfony\Component\HttpFoundation\RequestStack;
19			use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
20
21			/**
22			* @author GeLo <[email protected]>
23			*/
24			class ParameterResolverTest extends \PHPUnit_Framework_TestCase
25			{
26			/**
27			* @var ParameterResolver
28			*/
29			private $parameterResolver;
30
31			/**
32			* @var \PHPUnit_Framework_MockObject_MockObject\|RequestStack
33			*/
34			private $requestStack;
35
36			/**
37			* @var \PHPUnit_Framework_MockObject_MockObject\|PropertyAccessorInterface
38			*/
39			private $propertyAccessor;
40
php-lug / lug

Push — master ( 346488...5472e0 )

ParameterResolverTest::testResolveLocationRoute() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes
