ProxyQueryTest::testGetFixedQueryBuilder() - Code Metrics - sonata-project/SonataDoctrineORMAdminBundle - Measure and Improve Code Quality continuously with Scrutinizer

ProxyQueryTest::testGetFixedQueryBuilder() B
last analyzed 2020-08-28 02:03 UTC

↳ Parent: ProxyQueryTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	87
rs	8.2836
c	0
b	0
f	0
cc	1
nc	1
nop	7

How to fix Long Method

<?php

declare(strict_types=1);

/*
 * 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\Connection;
use Doctrine\DBAL\Platforms\PostgreSqlPlatform;
use Doctrine\DBAL\Types\Type;
use Doctrine\ORM\AbstractQuery;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\Mapping\ClassMetadata;
use Doctrine\ORM\Mapping\ClassMetadataFactory;
use Doctrine\ORM\Query;
use Doctrine\ORM\Query\Expr\From;
use Doctrine\ORM\Query\Expr\OrderBy;
use Doctrine\ORM\QueryBuilder;
use Doctrine\ORM\Tools\SchemaTool;
use PHPUnit\Framework\TestCase;
use Sonata\DoctrineORMAdminBundle\Datagrid\ProxyQuery;
use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\DoctrineType\UuidType;
use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\DoubleNameEntity;
use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Query\FooWalker;
use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Util\NonIntegerIdentifierTestClass;
use Symfony\Bridge\Doctrine\Test\DoctrineTestHelper;

class ProxyQueryTest extends TestCase
{
    /**
     * @var EntityManager
     */
    private $em;

    public static function setUpBeforeClass(): void
    {
        if (!Type::hasType('uuid')) {
            Type::addType('uuid', UuidType::class);
        }
    }

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

        $schemaTool = new SchemaTool($this->em);
        $classes = [
            $this->em->getClassMetadata(DoubleNameEntity::class),
        ];

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

        }

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

        }
    }

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

    public function dataGetFixedQueryBuilder()
    {
        return [
            ['aaa', 'bbb', 'id', 'id_idx', 33, Type::INTEGER, true],

            ['aaa', 'bbb', 'associatedId', 'associatedId_idx', 33, null, true],
            ['aaa', 'bbb', 'id.value', 'id_value_idx', 33, Type::INTEGER, false],

            ['aaa', 'bbb', 'id.uuid', 'id_uuid_idx', new NonIntegerIdentifierTestClass('80fb6f91-bba1-4d35-b3d4-e06b24494e85'), UuidType::NAME, false],
        ];
    }

    /**
     * @dataProvider dataGetFixedQueryBuilder
     */
    public function testGetFixedQueryBuilder($class, $alias, $id, $expectedId, $value, $identifierType, $distinct): void
    {
        $meta = $this->createMock(ClassMetadata::class);
        $meta->expects($this->any())
            ->method('getIdentifierFieldNames')
            ->willReturn([$id]);
        $meta->expects($this->any())
            ->method('getTypeOfField')
            ->willReturn($identifierType);

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

        $platform = $this->createMock(PostgreSqlPlatform::class);

        $conn = $this->createMock(Connection::class);
        $conn->expects($this->any())
            ->method('getDatabasePlatform')
            ->willReturn($platform);

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

        $q = $this->getMockBuilder(AbstractQuery::class)
            ->disableOriginalConstructor()
            ->setMethods(['setHint', 'execute'])
            ->getMockForAbstractClass();
        $q->expects($this->once())
           ->method('setHint')
           ->willReturn($q);
        $q->expects($this->any())
            ->method('execute')
            ->willReturn([[$id => $value]]);

        $qb = $this->getMockBuilder(QueryBuilder::class)
            ->setConstructorArgs([$em])
            ->getMock();
        $qb->expects($this->once())
            ->method('distinct')
            ->with($this->equalTo($distinct));
        $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([$value]));
        $qb->expects($this->any())
            ->method('getDQLPart')
            ->willReturnCallback(static function ($part) use ($class, $alias) {
                $parts = [
                    'from' => [new From($class, $alias)],
                    'orderBy' => [new OrderBy('whatever', 'DESC')],
                ];

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

        $pq = $this->getMockBuilder(ProxyQuery::class)
            ->setConstructorArgs([$qb])
            ->setMethods(['a'])
            ->getMock();

        $pq->setDistinct($distinct);

        /* Work */
        $pq->execute();
    }

    public function testSetHint(): void
    {
        $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(DoubleNameEntity::class, 'o');

        $pq = new ProxyQuery($qb);
        $pq->setHint(
            Query::HINT_CUSTOM_OUTPUT_WALKER,
            FooWalker::class
        );
        $pq->setHint('hint', 'value');

        $result = $pq->execute();

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

    public function testSortOrderValidatesItsInput(): void
    {
        $query = new ProxyQuery($this->em->createQueryBuilder());
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionMessage(
            '"ASC,injection" is not a valid sort order, valid values are "ASC, DESC"'
        );
        $query->setSortOrder('ASC,injection');
    }

    public function validSortOrders()
    {
        return [
            ['ASC'],
            ['DESC'],
            ['asc'],
            ['desc'],
            ['AsC'],
            ['deSc'],
        ];
    }

    /**
     * @dataProvider validSortOrders
     */
    public function testItAllowsSortOrdersWithStrangeCase($validValue): void
    {
        $query = new ProxyQuery($this->em->createQueryBuilder());
        $query->setSortOrder($validValue);
        $this->assertSame($validValue, $query->getSortOrder());
    }

    public function testExecuteWithOrderBy(): void
    {
        $entity1 = new DoubleNameEntity(1, 'Foo', 'Bar');
        $entity2 = new DoubleNameEntity(2, 'Bar', 'Bar');
        $entity3 = new DoubleNameEntity(3, 'Bar', 'Foo');

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

        $query = new ProxyQuery(
            $this->em->createQueryBuilder()->select('o.id')->from(DoubleNameEntity::class, 'o')
        );
        $query->setSortBy([], ['fieldName' => 'name2'])->setSortOrder('ASC');

        $this->assertSame(
            [
                ['id' => 1],
                ['id' => 2],
                ['id' => 3],
            ],
            $query->execute()
        );

        $query2 = new ProxyQuery(
            $this->em->createQueryBuilder()->select('o.id')->from(DoubleNameEntity::class, 'o')->addOrderBy('o.name')
        );
        $query2->setSortBy([], ['fieldName' => 'name2'])->setSortOrder('ASC');

        $this->assertSame(
            [
                ['id' => 2],
                ['id' => 1],
                ['id' => 3],
            ],
            $query2->execute()
        );
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* This file is part of the Sonata Project package.
7			*
8			* (c) Thomas Rabaix <[email protected]>
9			*
10			* For the full copyright and license information, please view the LICENSE
11			* file that was distributed with this source code.
12			*/
13
14			namespace Sonata\DoctrineORMAdminBundle\Tests\Datagrid;
15
16			use Doctrine\DBAL\Connection;
17			use Doctrine\DBAL\Platforms\PostgreSqlPlatform;
18			use Doctrine\DBAL\Types\Type;
19			use Doctrine\ORM\AbstractQuery;
20			use Doctrine\ORM\EntityManager;
21			use Doctrine\ORM\Mapping\ClassMetadata;
22			use Doctrine\ORM\Mapping\ClassMetadataFactory;
23			use Doctrine\ORM\Query;
24			use Doctrine\ORM\Query\Expr\From;
25			use Doctrine\ORM\Query\Expr\OrderBy;
26			use Doctrine\ORM\QueryBuilder;
27			use Doctrine\ORM\Tools\SchemaTool;
28			use PHPUnit\Framework\TestCase;
29			use Sonata\DoctrineORMAdminBundle\Datagrid\ProxyQuery;
30			use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\DoctrineType\UuidType;
31			use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\DoubleNameEntity;
32			use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Query\FooWalker;
33			use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Util\NonIntegerIdentifierTestClass;
34			use Symfony\Bridge\Doctrine\Test\DoctrineTestHelper;
35
36			class ProxyQueryTest extends TestCase
37			{
38			/**
39			* @var EntityManager
40			*/
41			private $em;
42
43			public static function setUpBeforeClass(): void
44			{
45			if (!Type::hasType('uuid')) {
46			Type::addType('uuid', UuidType::class);
47			}
48			}
49
50			protected function setUp(): void
51			{
52			$this->em = DoctrineTestHelper::createTestEntityManager();
53
54			$schemaTool = new SchemaTool($this->em);
55			$classes = [
56			$this->em->getClassMetadata(DoubleNameEntity::class),
57			];
58
59			try {
60			$schemaTool->dropSchema($classes);
61			} 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...
62			}
63
64			try {
65			$schemaTool->createSchema($classes);
66			} 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...
67			}
68			}
69
70			protected function tearDown(): void
71			{
72			$this->em = null;
73			}
74
75			public function dataGetFixedQueryBuilder()
76			{
77			return [
78			['aaa', 'bbb', 'id', 'id_idx', 33, Type::INTEGER, true],
			0 ignored issues – show Deprecated Code introduced 2020-01-22 01:16 UTC by Report Bug Copy Issue Report The constant `Doctrine\DBAL\Types\Type::INTEGER` has been deprecated with message: Use {@see Types::INTEGER} instead. This class constant has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the constant will be removed from the class and what other constant to use instead. Loading history...
79			['aaa', 'bbb', 'associatedId', 'associatedId_idx', 33, null, true],
80			['aaa', 'bbb', 'id.value', 'id_value_idx', 33, Type::INTEGER, false],
			0 ignored issues – show Deprecated Code introduced 2020-01-22 01:16 UTC by Report Bug Copy Issue Report The constant `Doctrine\DBAL\Types\Type::INTEGER` has been deprecated with message: Use {@see Types::INTEGER} instead. This class constant has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the constant will be removed from the class and what other constant to use instead. Loading history...
81			['aaa', 'bbb', 'id.uuid', 'id_uuid_idx', new NonIntegerIdentifierTestClass('80fb6f91-bba1-4d35-b3d4-e06b24494e85'), UuidType::NAME, false],
82			];
83			}
84
85			/**
86			* @dataProvider dataGetFixedQueryBuilder
87			*/
88			public function testGetFixedQueryBuilder($class, $alias, $id, $expectedId, $value, $identifierType, $distinct): void
89			{
90			$meta = $this->createMock(ClassMetadata::class);
91			$meta->expects($this->any())
92			->method('getIdentifierFieldNames')
93			->willReturn([$id]);
94			$meta->expects($this->any())
95			->method('getTypeOfField')
96			->willReturn($identifierType);
97
98			$mf = $this->createMock(ClassMetadataFactory::class);
99			$mf->expects($this->any())
100			->method('getMetadataFor')
101			->with($this->equalTo($class))
102			->willReturn($meta);
103
104			$platform = $this->createMock(PostgreSqlPlatform::class);
105
106			$conn = $this->createMock(Connection::class);
107			$conn->expects($this->any())
108			->method('getDatabasePlatform')
109			->willReturn($platform);
110
111			$em = $this->createMock(EntityManager::class);
112			$em->expects($this->any())
113			->method('getMetadataFactory')
114			->willReturn($mf);
115			$em->expects($this->any())
116			->method('getConnection')
117			->willReturn($conn);
118
119			$q = $this->getMockBuilder(AbstractQuery::class)
120			->disableOriginalConstructor()
121			->setMethods(['setHint', 'execute'])
122			->getMockForAbstractClass();
123			$q->expects($this->once())
124			->method('setHint')
125			->willReturn($q);
126			$q->expects($this->any())
127			->method('execute')
128			->willReturn([[$id => $value]]);
129
130			$qb = $this->getMockBuilder(QueryBuilder::class)
131			->setConstructorArgs([$em])
132			->getMock();
133			$qb->expects($this->once())
134			->method('distinct')
135			->with($this->equalTo($distinct));
136			$qb->expects($this->any())
137			->method('getEntityManager')
138			->willReturn($em);
139			$qb->expects($this->any())
140			->method('getQuery')
141			->willReturn($q);
142			$qb->expects($this->once())
143			->method('setParameter')
144			->with($this->equalTo($expectedId), $this->equalTo([$value]));
145			$qb->expects($this->any())
146			->method('getDQLPart')
147			->willReturnCallback(static function ($part) use ($class, $alias) {
148			$parts = [
149			'from' => [new From($class, $alias)],
150			'orderBy' => [new OrderBy('whatever', 'DESC')],
151			];
152
153			return $parts[$part];
154			});
155			$qb->expects($this->once())
156			->method('addOrderBy')
157			->with("$alias.$id", null);
158			$qb->expects($this->once())
159			->method('getRootEntities')
160			->willReturn([$class]);
161			$qb->expects($this->exactly(2))
162			->method('getRootAliases')
163			->willReturn([$alias]);
164
165			$pq = $this->getMockBuilder(ProxyQuery::class)
166			->setConstructorArgs([$qb])
167			->setMethods(['a'])
168			->getMock();
169
170			$pq->setDistinct($distinct);
171
172			/* Work */
173			$pq->execute();
174			}
175
176			public function testSetHint(): void
177			{
178			$entity1 = new DoubleNameEntity(1, 'Foo', null);
179			$entity2 = new DoubleNameEntity(2, 'Bar', null);
180
181			$this->em->persist($entity1);
182			$this->em->persist($entity2);
183			$this->em->flush();
184
185			$qb = $this->em->createQueryBuilder()
186			->select('o.id')
187			->from(DoubleNameEntity::class, 'o');
188
189			$pq = new ProxyQuery($qb);
190			$pq->setHint(
191			Query::HINT_CUSTOM_OUTPUT_WALKER,
192			FooWalker::class
193			);
194			$pq->setHint('hint', 'value');
195
196			$result = $pq->execute();
197
198			$this->assertSame(2, $result[0]['id']);
199			}
200
201			public function testSortOrderValidatesItsInput(): void
202			{
203			$query = new ProxyQuery($this->em->createQueryBuilder());
204			$this->expectException(\InvalidArgumentException::class);
205			$this->expectExceptionMessage(
206			'"ASC,injection" is not a valid sort order, valid values are "ASC, DESC"'
207			);
208			$query->setSortOrder('ASC,injection');
209			}
210
211			public function validSortOrders()
212			{
213			return [
214			['ASC'],
215			['DESC'],
216			['asc'],
217			['desc'],
218			['AsC'],
219			['deSc'],
220			];
221			}
222
223			/**
224			* @dataProvider validSortOrders
225			*/
226			public function testItAllowsSortOrdersWithStrangeCase($validValue): void
227			{
228			$query = new ProxyQuery($this->em->createQueryBuilder());
229			$query->setSortOrder($validValue);
230			$this->assertSame($validValue, $query->getSortOrder());
231			}
232
233			public function testExecuteWithOrderBy(): void
234			{
235			$entity1 = new DoubleNameEntity(1, 'Foo', 'Bar');
236			$entity2 = new DoubleNameEntity(2, 'Bar', 'Bar');
237			$entity3 = new DoubleNameEntity(3, 'Bar', 'Foo');
238
239			$this->em->persist($entity1);
240			$this->em->persist($entity2);
241			$this->em->persist($entity3);
242			$this->em->flush();
243
244			$query = new ProxyQuery(
245			$this->em->createQueryBuilder()->select('o.id')->from(DoubleNameEntity::class, 'o')
246			);
247			$query->setSortBy([], ['fieldName' => 'name2'])->setSortOrder('ASC');
248
249			$this->assertSame(
250			[
251			['id' => 1],
252			['id' => 2],
253			['id' => 3],
254			],
255			$query->execute()
256			);
257
258			$query2 = new ProxyQuery(
259			$this->em->createQueryBuilder()->select('o.id')->from(DoubleNameEntity::class, 'o')->addOrderBy('o.name')
260			);
261			$query2->setSortBy([], ['fieldName' => 'name2'])->setSortOrder('ASC');
262
263			$this->assertSame(
264			[
265			['id' => 2],
266			['id' => 1],
267			['id' => 3],
268			],
269			$query2->execute()
270			);
271			}
272			}
273

sonata-project / SonataDoctrineORMAdminBundle

ProxyQueryTest::testGetFixedQueryBuilder() B last analyzed 2020-08-28 02:03 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

ProxyQueryTest::testGetFixedQueryBuilder() B
last analyzed 2020-08-28 02:03 UTC