ParameterResolverTest::testResolveSerializerGroupsDefault() - Code Metrics - Inspection of "[ResourceBundle] Move Serializer/Validation groups..." - php-lug/lug - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#45)

by Eric
created 2016-06-01 14:16 UTC
testResolveSerializerGroupsDefault() A

↳ Parent: ParameterResolverTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	18
Code Lines	13
Duplication

Lines	15
Ratio	83.33 %
Importance

Changes	3
Bugs	0	Features	1
Metric	Value
c	3
b	0
f	1
dl	15
loc	18
rs	9.4285
cc	1
eloc	13
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
            ->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
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('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
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('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
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_criteria'), $this->identicalTo([$identifier = 'id']))
            ->will($this->returnValue([$identifier]));

        $request
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('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
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_criteria'), $this->identicalTo(['id']))
            ->will($this->returnValue([$identifier = 'code']));

        $request
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('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
            ->expects($this->at(0))
            ->method('get')
            ->with($this->identicalTo('_lug_criteria'), $this->identicalTo(['id']))
            ->will($this->returnValue([]));

        $request->attributes
            ->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
            ->expects($this->at(0))
            ->method('get')
            ->with($this->identicalTo('_lug_criteria'), $this->identicalTo([$identifier = 'id']))
            ->will($this->returnValue([$identifier]));

        $request->attributes
            ->expects($this->at(1))
            ->method('get')
            ->with($this->identicalTo('_route'), $this->isNull())
            ->will($this->returnValue('route'));

        $request
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('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
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_page_parameter'), $this->identicalTo($pageParameter = 'page'))
            ->will($this->returnValue($pageParameter));

        $request
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('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
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_page_parameter'), $this->identicalTo('page'))
            ->will($this->returnValue($pageParameter = 'p'));

        $request
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('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
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_page_parameter'), $this->identicalTo($pageParameter = 'page'))
            ->will($this->returnValue($pageParameter));

        $request
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('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
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('getForm')
            ->will($this->returnValue($form = 'form'));

        $this->assertSame($form, $this->parameterResolver->resolveForm($resource));
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }

    public function testResolveFormDefault()
    {
        $resource = $this->createResourceMock();
        $resource
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('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
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_form'), $this->identicalTo($form))
            ->will($this->returnValue($form));

        $this->assertSame($form, $this->parameterResolver->resolveForm($resource));
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }

    public function testResolveFormExplicit()
    {
        $resource = $this->createResourceMock();
        $resource
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('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
            ->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));
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }

    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
            ->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)
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        );
    }

    /**
     * @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
            ->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
            ->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
            ->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
            ->expects($this->at(0))
            ->method('get')
            ->with($this->identicalTo('_lug_location_route'), $this->isNull())
            ->will($this->returnValue(null));

        $request->attributes
            ->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
            ->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
            ->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
            ->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
            ->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
            ->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
            ->expects($this->at(0))
            ->method('get')
            ->with($this->identicalTo('_lug_redirect_route'), $this->isNull())
            ->will($this->returnValue(null));

        $request->attributes
            ->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
            ->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
            ->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
            ->expects($this->once())
            ->method('get')
            ->with($this->identicalTo('_lug_redirect_route_parameters'), $this->identicalTo([]))
            ->will($this->returnValue([$parameter = 'id']));

        $request->query = $this->createParameterBagMock();
        $request->query
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('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
            ->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
            ->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
            ->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
            ->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
            ->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
            ->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
            ->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
            ->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
            ->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
            ->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
            ->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
            ->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 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
            ->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
            ->expects($this->at(0))
            ->method('get')
            ->with($this->identicalTo('_lug_template'), $this->isNull())
            ->will($this->returnValue(null));

        $request->attributes
            ->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
            ->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
            ->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
            ->expects($this->at(0))
            ->method('get')
            ->with($this->identicalTo('_lug_grid'), $this->isNull())
            ->will($this->returnValue(null));

        $request->attributes
            ->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
            ->expects($this->at(0))
            ->method('get')
            ->with($this->identicalTo('_lug_grid'), $this->isNull())
            ->will($this->returnValue(null));

        $request->attributes
            ->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
            ->expects($this->at(0))
            ->method('get')
            ->with($this->identicalTo('_lug_grid'), $this->isNull())
            ->will($this->returnValue(['grid']));

        $request->attributes
            ->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
            ->expects($this->at(0))
            ->method('get')
            ->with($this->identicalTo('_lug_grid'), $this->isNull())
            ->will($this->returnValue(['grid']));

        $request->attributes
            ->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
            ->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
            ->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
            ->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
            ->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->getMock(RequestStack::class);

    }

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

    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|Request
     */
    private function createRequestMock()
    {
        $request = $this->getMock(Request::class);

        $request->attributes = $this->createParameterBagMock();

        return $request;
    }

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

    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|ResourceInterface
     */
    private function createResourceMock()
    {
        return $this->getMock(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

Pull Request — master (#45)

testResolveSerializerGroupsDefault() 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

Duplication Side-by-Side

Filter issues like
