ProxyQueryTest::testGetFixedQueryBuilder() - Code Metrics - Inspection of "Merge 3.x into master" - sonata-project/SonataDoctrineORMAdminBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 7e3209...8a0315 )

unknown

created 2017-09-29 00:00 UTC

ProxyQueryTest::testGetFixedQueryBuilder() B

↳ Parent: ProxyQueryTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	81
Code Lines	64

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	81
rs	8.8076
c	0
b	0
f	0
cc	1
eloc	64
nc	1
nop	6

How to fix Long Method

<?php

/*
 * This file is part of the Sonata Project package.
 *
 * (c) Thomas Rabaix <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Sonata\DoctrineORMAdminBundle\Tests\Datagrid;

use Doctrine\DBAL\Types\Type;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\Query\Expr\From;
use Doctrine\ORM\Query\Expr\OrderBy;
use Doctrine\ORM\Tools\SchemaTool;
use Sonata\DoctrineORMAdminBundle\Datagrid\ProxyQuery;
use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\DoctrineType\UuidType;
use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Util\NonIntegerIdentifierTestClass;
use Sonata\DoctrineORMAdminBundle\Tests\Helpers\PHPUnit_Framework_TestCase;
use Symfony\Bridge\Doctrine\Test\DoctrineTestHelper;
use Symfony\Bridge\Doctrine\Tests\Fixtures\DoubleNameEntity;

class ProxyQueryTest extends PHPUnit_Framework_TestCase
{
    const DOUBLE_NAME_CLASS = 'Symfony\Bridge\Doctrine\Tests\Fixtures\DoubleNameEntity';

    /**
     * @var EntityManager
     */
    private $em;

    public static function setUpBeforeClass()
    {
        if (!Type::hasType('uuid')) {
            Type::addType('uuid', 'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\DoctrineType\UuidType');
        }
    }

    protected function setUp()
    {
        $this->em = DoctrineTestHelper::createTestEntityManager();

        $schemaTool = new SchemaTool($this->em);
        $classes = array(
            $this->em->getClassMetadata(self::DOUBLE_NAME_CLASS),
        );

        try {
            $schemaTool->dropSchema($classes);
        } catch (\Exception $e) {

        }

        try {
            $schemaTool->createSchema($classes);
        } catch (\Exception $e) {

        }
    }

    protected function tearDown()
    {
        $this->em = null;
    }

    public function dataGetFixedQueryBuilder()
    {
        return array(
            array('aaa', 'bbb', 'id', 'id_idx', 33, Type::INTEGER),
            array('aaa', 'bbb', 'associatedId', 'associatedId_idx', 33, null),
            array('aaa', 'bbb', 'id.value', 'id_value_idx', 33, Type::INTEGER),
            array('aaa', 'bbb', 'id.uuid', 'id_uuid_idx', new NonIntegerIdentifierTestClass('80fb6f91-bba1-4d35-b3d4-e06b24494e85'), UuidType::NAME),
        );
    }

    /**
     * @dataProvider dataGetFixedQueryBuilder
     *
     * @param $class
     * @param $alias
     * @param $id
     */
    public function testGetFixedQueryBuilder($class, $alias, $id, $expectedId, $value, $identifierType)
    {
        $meta = $this->createMock('Doctrine\ORM\Mapping\ClassMetadataInfo');
        $meta->expects($this->any())
            ->method('getIdentifierFieldNames')
            ->willReturn(array($id));
        $meta->expects($this->any())
            ->method('getTypeOfField')
            ->willReturn($identifierType);

        $mf = $this->createMock('Doctrine\ORM\Mapping\ClassMetadataFactory');
        $mf->expects($this->any())
            ->method('getMetadataFor')
            ->with($this->equalTo($class))
            ->willReturn($meta);

        $platform = $this->createMock('Doctrine\DBAL\Platforms\PostgreSqlPlatform');

        $conn = $this->createMock('Doctrine\DBAL\Connection');
        $conn->expects($this->any())
            ->method('getDatabasePlatform')
            ->willReturn($platform);

        $em = $this->createMock('Doctrine\ORM\EntityManager');
        $em->expects($this->any())
            ->method('getMetadataFactory')
            ->willReturn($mf);
        $em->expects($this->any())
            ->method('getConnection')
            ->willReturn($conn);

        // NEXT MAJOR: Replace this when dropping PHP < 5.6
        // $q = $this->createMock('PDOStatement');
        $q = $this->getMockBuilder('stdClass')
            ->setMethods(array('execute'))
            ->getMock();
        $q->expects($this->any())
            ->method('execute')
            ->willReturn(array(array($id => $value)));

        $qb = $this->getMockBuilder('Doctrine\ORM\QueryBuilder')
            ->setConstructorArgs(array($em))
            ->getMock();
        $qb->expects($this->any())
            ->method('getEntityManager')
            ->willReturn($em);
        $qb->expects($this->any())
            ->method('getQuery')
            ->willReturn($q);
        $qb->expects($this->once())
            ->method('setParameter')
            ->with($this->equalTo($expectedId), $this->equalTo(array($value)));
        $qb->expects($this->any())
            ->method('getDQLPart')
            ->will($this->returnCallBack(function ($part) use ($class, $alias) {
                $parts = array(
                    'from' => array(new From($class, $alias)),
                    'orderBy' => array(new OrderBy('whatever', 'DESC')),
                );

                return $parts[$part];
            }));
        $qb->expects($this->once())
            ->method('addOrderBy')
            ->with("$alias.$id", null);
        $qb->expects($this->once())
            ->method('getRootEntities')
            ->willReturn(array($class));
        $qb->expects($this->exactly(2))
            ->method('getRootAliases')
            ->willReturn(array($alias));

        $pq = $this->getMockBuilder('Sonata\DoctrineORMAdminBundle\Datagrid\ProxyQuery')
            ->setConstructorArgs(array($qb))
            ->setMethods(array('a'))
            ->getMock();

        /* Work */

        $pq->execute();
    }

    public function testAddOrderedColumns()
    {
        $qb = $this->em->createQueryBuilder()
                       ->select('o.id')
                       ->distinct()
                       ->from(self::DOUBLE_NAME_CLASS, 'o')
                       ->orderBy('o.name', 'ASC')
                       ->addOrderBy('o.name2', 'DESC');

        $pq = $this->getMockBuilder('Sonata\DoctrineORMAdminBundle\Datagrid\ProxyQuery')
                   ->disableOriginalConstructor()
                   ->getMock();

        $reflection = new \ReflectionClass(get_class($pq));
        $method = $reflection->getMethod('addOrderedColumns');
        $method->setAccessible(true);
        $method->invoke($pq, $qb);

        $dqlPart = $qb->getDqlPart('select');
        $this->assertCount(3, $dqlPart);
        $this->assertEquals('o.id', $dqlPart[0]);
        $this->assertEquals('o.name', $dqlPart[1]);
        $this->assertEquals('o.name2', $dqlPart[2]);
    }

    public function testSetHint()
    {
        $entity1 = new DoubleNameEntity(1, 'Foo', null);
        $entity2 = new DoubleNameEntity(2, 'Bar', null);

        $this->em->persist($entity1);
        $this->em->persist($entity2);
        $this->em->flush();

        $qb = $this->em->createQueryBuilder()
                       ->select('o.id')
                       ->from(self::DOUBLE_NAME_CLASS, 'o');

        $pq = new ProxyQuery($qb);
        $pq->setHint(
            \Doctrine\ORM\Query::HINT_CUSTOM_OUTPUT_WALKER,
            'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Query\FooWalker'
        );
        $pq->setHint('hint', 'value');

        $result = $pq->execute();

        $this->assertEquals(2, $result[0]['id']);
    }
}


1			<?php
2
3			/*
4			* This file is part of the Sonata Project package.
5			*
6			* (c) Thomas Rabaix <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Sonata\DoctrineORMAdminBundle\Tests\Datagrid;
13
14			use Doctrine\DBAL\Types\Type;
15			use Doctrine\ORM\EntityManager;
16			use Doctrine\ORM\Query\Expr\From;
17			use Doctrine\ORM\Query\Expr\OrderBy;
18			use Doctrine\ORM\Tools\SchemaTool;
19			use Sonata\DoctrineORMAdminBundle\Datagrid\ProxyQuery;
20			use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\DoctrineType\UuidType;
21			use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Util\NonIntegerIdentifierTestClass;
22			use Sonata\DoctrineORMAdminBundle\Tests\Helpers\PHPUnit_Framework_TestCase;
23			use Symfony\Bridge\Doctrine\Test\DoctrineTestHelper;
24			use Symfony\Bridge\Doctrine\Tests\Fixtures\DoubleNameEntity;
25
26			class ProxyQueryTest extends PHPUnit_Framework_TestCase
27			{
28			const DOUBLE_NAME_CLASS = 'Symfony\Bridge\Doctrine\Tests\Fixtures\DoubleNameEntity';
29
30			/**
31			* @var EntityManager
32			*/
33			private $em;
34
35			public static function setUpBeforeClass()
36			{
37			if (!Type::hasType('uuid')) {
38			Type::addType('uuid', 'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\DoctrineType\UuidType');
39			}
40			}
41
42			protected function setUp()
43			{
44			$this->em = DoctrineTestHelper::createTestEntityManager();
45
46			$schemaTool = new SchemaTool($this->em);
47			$classes = array(
48			$this->em->getClassMetadata(self::DOUBLE_NAME_CLASS),
49			);
50
51			try {
52			$schemaTool->dropSchema($classes);
53			} catch (\Exception $e) {
			0 ignored issues – show Coding Style Comprehensibility introduced 2017-09-23 23:24 UTC by Report Bug Copy Issue Report Consider adding a comment why this CATCH block is empty. Loading history...
54			}
55
56			try {
57			$schemaTool->createSchema($classes);
58			} catch (\Exception $e) {
			0 ignored issues – show Coding Style Comprehensibility introduced 2017-09-23 23:24 UTC by Report Bug Copy Issue Report Consider adding a comment why this CATCH block is empty. Loading history...
59			}
60			}
61
62			protected function tearDown()
63			{
64			$this->em = null;
65			}
66
67			public function dataGetFixedQueryBuilder()
68			{
69			return array(
70			array('aaa', 'bbb', 'id', 'id_idx', 33, Type::INTEGER),
71			array('aaa', 'bbb', 'associatedId', 'associatedId_idx', 33, null),
72			array('aaa', 'bbb', 'id.value', 'id_value_idx', 33, Type::INTEGER),
73			array('aaa', 'bbb', 'id.uuid', 'id_uuid_idx', new NonIntegerIdentifierTestClass('80fb6f91-bba1-4d35-b3d4-e06b24494e85'), UuidType::NAME),
74			);
75			}
76
77			/**
78			* @dataProvider dataGetFixedQueryBuilder
79			*
80			* @param $class
81			* @param $alias
82			* @param $id
83			*/
84			public function testGetFixedQueryBuilder($class, $alias, $id, $expectedId, $value, $identifierType)
85			{
86			$meta = $this->createMock('Doctrine\ORM\Mapping\ClassMetadataInfo');
87			$meta->expects($this->any())
88			->method('getIdentifierFieldNames')
89			->willReturn(array($id));
90			$meta->expects($this->any())
91			->method('getTypeOfField')
92			->willReturn($identifierType);
93
94			$mf = $this->createMock('Doctrine\ORM\Mapping\ClassMetadataFactory');
95			$mf->expects($this->any())
96			->method('getMetadataFor')
97			->with($this->equalTo($class))
98			->willReturn($meta);
99
100			$platform = $this->createMock('Doctrine\DBAL\Platforms\PostgreSqlPlatform');
101
102			$conn = $this->createMock('Doctrine\DBAL\Connection');
103			$conn->expects($this->any())
104			->method('getDatabasePlatform')
105			->willReturn($platform);
106
107			$em = $this->createMock('Doctrine\ORM\EntityManager');
108			$em->expects($this->any())
109			->method('getMetadataFactory')
110			->willReturn($mf);
111			$em->expects($this->any())
112			->method('getConnection')
113			->willReturn($conn);
114
115			// NEXT MAJOR: Replace this when dropping PHP < 5.6
116			// $q = $this->createMock('PDOStatement');
117			$q = $this->getMockBuilder('stdClass')
118			->setMethods(array('execute'))
119			->getMock();
120			$q->expects($this->any())
121			->method('execute')
122			->willReturn(array(array($id => $value)));
123
124			$qb = $this->getMockBuilder('Doctrine\ORM\QueryBuilder')
125			->setConstructorArgs(array($em))
126			->getMock();
127			$qb->expects($this->any())
128			->method('getEntityManager')
129			->willReturn($em);
130			$qb->expects($this->any())
131			->method('getQuery')
132			->willReturn($q);
133			$qb->expects($this->once())
134			->method('setParameter')
135			->with($this->equalTo($expectedId), $this->equalTo(array($value)));
136			$qb->expects($this->any())
137			->method('getDQLPart')
138			->will($this->returnCallBack(function ($part) use ($class, $alias) {
139			$parts = array(
140			'from' => array(new From($class, $alias)),
141			'orderBy' => array(new OrderBy('whatever', 'DESC')),
142			);
143
144			return $parts[$part];
145			}));
146			$qb->expects($this->once())
147			->method('addOrderBy')
148			->with("$alias.$id", null);
149			$qb->expects($this->once())
150			->method('getRootEntities')
151			->willReturn(array($class));
152			$qb->expects($this->exactly(2))
153			->method('getRootAliases')
154			->willReturn(array($alias));
155
156			$pq = $this->getMockBuilder('Sonata\DoctrineORMAdminBundle\Datagrid\ProxyQuery')
157			->setConstructorArgs(array($qb))
158			->setMethods(array('a'))
159			->getMock();
160
161			/* Work */
162
163			$pq->execute();
164			}
165
166			public function testAddOrderedColumns()
167			{
168			$qb = $this->em->createQueryBuilder()
169			->select('o.id')
170			->distinct()
171			->from(self::DOUBLE_NAME_CLASS, 'o')
172			->orderBy('o.name', 'ASC')
173			->addOrderBy('o.name2', 'DESC');
174
175			$pq = $this->getMockBuilder('Sonata\DoctrineORMAdminBundle\Datagrid\ProxyQuery')
176			->disableOriginalConstructor()
177			->getMock();
178
179			$reflection = new \ReflectionClass(get_class($pq));
180			$method = $reflection->getMethod('addOrderedColumns');
181			$method->setAccessible(true);
182			$method->invoke($pq, $qb);
183
184			$dqlPart = $qb->getDqlPart('select');
185			$this->assertCount(3, $dqlPart);
186			$this->assertEquals('o.id', $dqlPart[0]);
187			$this->assertEquals('o.name', $dqlPart[1]);
188			$this->assertEquals('o.name2', $dqlPart[2]);
189			}
190
191			public function testSetHint()
192			{
193			$entity1 = new DoubleNameEntity(1, 'Foo', null);
194			$entity2 = new DoubleNameEntity(2, 'Bar', null);
195
196			$this->em->persist($entity1);
197			$this->em->persist($entity2);
198			$this->em->flush();
199
200			$qb = $this->em->createQueryBuilder()
201			->select('o.id')
202			->from(self::DOUBLE_NAME_CLASS, 'o');
203
204			$pq = new ProxyQuery($qb);
205			$pq->setHint(
206			\Doctrine\ORM\Query::HINT_CUSTOM_OUTPUT_WALKER,
207			'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Query\FooWalker'
208			);
209			$pq->setHint('hint', 'value');
210
211			$result = $pq->execute();
212
213			$this->assertEquals(2, $result[0]['id']);
214			}
215			}
216

sonata-project / SonataDoctrineORMAdminBundle

Push — master ( 7e3209...8a0315 )

ProxyQueryTest::testGetFixedQueryBuilder() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like