ModelManagerTest::testSortableInDataSourceIterator() - Code Metrics - Inspection of "Fixed exception on missing field order by" - sonata-project/SonataDoctrineORMAdminBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — 3.x (#696)

unknown

created 2017-06-26 14:53 UTC

testSortableInDataSourceIterator() B

↳ Parent: ModelManagerTest

Complexity

Conditions	2
Paths	1

Size

Total Lines	46
Code Lines	35

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
dl	0
loc	46
rs	8.9411
c	1
b	0
f	0
cc	2
eloc	35
nc	1
nop	3

<?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\Model;

use Doctrine\DBAL\Types\Type;
use Doctrine\ORM\Mapping\ClassMetadata;
use Doctrine\ORM\OptimisticLockException;
use Doctrine\ORM\Version;
use Doctrine\ORM\Query;
use Sonata\DoctrineORMAdminBundle\Admin\FieldDescription;
use Sonata\DoctrineORMAdminBundle\Model\ModelManager;
use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\DoctrineType\UuidType;
use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\AssociatedEntity;
use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\ContainerEntity;
use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\Embeddable\EmbeddedEntity;
use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\UuidEntity;
use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\VersionedEntity;
use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Util\NonIntegerIdentifierTestClass;

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

    public function testSortParameters()
    {
        $registry = $this->getMock('Symfony\Bridge\Doctrine\RegistryInterface');

        $manager = new ModelManager($registry);

        $datagrid1 = $this->getMockBuilder('\Sonata\AdminBundle\Datagrid\Datagrid')->disableOriginalConstructor()->getMock();
        $datagrid2 = $this->getMockBuilder('\Sonata\AdminBundle\Datagrid\Datagrid')->disableOriginalConstructor()->getMock();

        $field1 = new FieldDescription();
        $field1->setName('field1');

        $field2 = new FieldDescription();
        $field2->setName('field2');

        $field3 = new FieldDescription();
        $field3->setName('field3');
        $field3->setOption('sortable', 'field3sortBy');

        $datagrid1
            ->expects($this->any())
            ->method('getValues')
            ->will($this->returnValue(array(
                '_sort_by' => $field1,
                '_sort_order' => 'ASC',
            )));

        $datagrid2
            ->expects($this->any())
            ->method('getValues')
            ->will($this->returnValue(array(
                '_sort_by' => $field3,
                '_sort_order' => 'ASC',
            )));

        $parameters = $manager->getSortParameters($field1, $datagrid1);

        $this->assertEquals('DESC', $parameters['filter']['_sort_order']);
        $this->assertEquals('field1', $parameters['filter']['_sort_by']);

        $parameters = $manager->getSortParameters($field2, $datagrid1);

        $this->assertEquals('ASC', $parameters['filter']['_sort_order']);
        $this->assertEquals('field2', $parameters['filter']['_sort_by']);

        $parameters = $manager->getSortParameters($field3, $datagrid1);

        $this->assertEquals('ASC', $parameters['filter']['_sort_order']);
        $this->assertEquals('field3sortBy', $parameters['filter']['_sort_by']);

        $parameters = $manager->getSortParameters($field3, $datagrid2);

        $this->assertEquals('DESC', $parameters['filter']['_sort_order']);
        $this->assertEquals('field3sortBy', $parameters['filter']['_sort_by']);
    }

    public function getVersionDataProvider()
    {
        return array(
            array(true),
            array(false),
        );
    }

    /**
     * @dataProvider getVersionDataProvider
     */
    public function testGetVersion($isVersioned)
    {
        $object = new VersionedEntity();

        $modelManager = $this->getMockBuilder('Sonata\DoctrineORMAdminBundle\Model\ModelManager')
            ->disableOriginalConstructor()
            ->setMethods(array('getMetadata'))
            ->getMock();

        $metadata = $this->getMetadata(get_class($object), $isVersioned);

        $modelManager->expects($this->any())
            ->method('getMetadata')
            ->will($this->returnValue($metadata));

        if ($isVersioned) {
            $object->version = 123;

            $this->assertNotNull($modelManager->getLockVersion($object));
        } else {
            $this->assertNull($modelManager->getLockVersion($object));
        }
    }

    public function lockDataProvider()
    {
        return array(
            array(true,  false),
            array(true,  true),
            array(false, false),
        );
    }

    /**
     * @dataProvider lockDataProvider
     */
    public function testLock($isVersioned, $expectsException)
    {
        $object = new VersionedEntity();

        $em = $this->getMockBuilder('Doctrine\ORM\EntityManager')
            ->disableOriginalConstructor()
            ->setMethods(array('lock'))
            ->getMock();

        $modelManager = $this->getMockBuilder('Sonata\DoctrineORMAdminBundle\Model\ModelManager')
            ->disableOriginalConstructor()
            ->setMethods(array('getMetadata', 'getEntityManager'))
            ->getMock();

        $modelManager->expects($this->any())
            ->method('getEntityManager')
            ->will($this->returnValue($em));

        $metadata = $this->getMetadata(get_class($object), $isVersioned);

        $modelManager->expects($this->any())
            ->method('getMetadata')
            ->will($this->returnValue($metadata));

        if ($expectsException) {
            $em->expects($this->once())
                ->method('lock')
                ->will($this->throwException(OptimisticLockException::lockFailed($object)));

            $this->setExpectedException('Sonata\AdminBundle\Exception\LockException');
        }

        $modelManager->lock($object, 123);
    }

    public function testGetParentMetadataForProperty()
    {
        if (version_compare(Version::VERSION, '2.5') < 0) {
            $this->markTestSkipped('Test for embeddables needs to run on Doctrine >= 2.5');

            return;
        }

        $containerEntityClass = 'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\ContainerEntity';
        $associatedEntityClass = 'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\AssociatedEntity';
        $embeddedEntityClass = 'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\Embeddable\EmbeddedEntity';
        $modelManagerClass = 'Sonata\DoctrineORMAdminBundle\Model\ModelManager';

        $object = new ContainerEntity(new AssociatedEntity(), new EmbeddedEntity());
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

        $em = $this->getMockBuilder('Doctrine\ORM\EntityManager')
            ->disableOriginalConstructor()
            ->getMock();

        /** @var \PHPUnit_Framework_MockObject_MockObject|ModelManager $modelManager */
        $modelManager = $this->getMockBuilder($modelManagerClass)
            ->disableOriginalConstructor()
            ->setMethods(array('getMetadata', 'getEntityManager'))
            ->getMock();

        $modelManager->expects($this->any())

            ->method('getEntityManager')
            ->will($this->returnValue($em));

        $containerEntityMetadata = $this->getMetadataForContainerEntity();
        $associatedEntityMetadata = $this->getMetadataForAssociatedEntity();
        $embeddedEntityMetadata = $this->getMetadataForEmbeddedEntity();

        $modelManager->expects($this->any())->method('getMetadata')

            ->will(
                $this->returnValueMap(
                    array(
                        array($containerEntityClass, $containerEntityMetadata),
                        array($embeddedEntityClass, $embeddedEntityMetadata),
                        array($associatedEntityClass, $associatedEntityMetadata),
                    )
                )
            );

        /** @var ClassMetadata $metadata */
        list($metadata, $lastPropertyName) = $modelManager
            ->getParentMetadataForProperty($containerEntityClass, 'plainField');
        $this->assertEquals($metadata->fieldMappings[$lastPropertyName]['type'], 'integer');

        list($metadata, $lastPropertyName) = $modelManager
            ->getParentMetadataForProperty($containerEntityClass, 'associatedEntity.plainField');
        $this->assertEquals($metadata->fieldMappings[$lastPropertyName]['type'], 'string');

        list($metadata, $lastPropertyName) = $modelManager
            ->getParentMetadataForProperty($containerEntityClass, 'embeddedEntity.plainField');
        $this->assertEquals($metadata->fieldMappings[$lastPropertyName]['type'], 'boolean');
    }

    public function getMetadataForEmbeddedEntity()
    {
        $metadata = new ClassMetadata('Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\Embeddable\EmbeddedEntity');

        $metadata->fieldMappings = array(
            'plainField' => array(
                'fieldName' => 'plainField',
                'columnName' => 'plainField',
                'type' => 'boolean',
            ),
        );

        return $metadata;
    }

    public function getMetadataForAssociatedEntity()
    {
        $metadata = new ClassMetadata('Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\AssociatedEntity');

        $metadata->fieldMappings = array(
            'plainField' => array(
                'fieldName' => 'plainField',
                'columnName' => 'plainField',
                'type' => 'string',
            ),
        );

        return $metadata;
    }

    public function getMetadataForContainerEntity()
    {
        $containerEntityClass = 'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\ContainerEntity';
        $associatedEntityClass = 'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\AssociatedEntity';
        $embeddedEntityClass = 'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\Embeddable\EmbeddedEntity';

        $metadata = new ClassMetadata($containerEntityClass);

        $metadata->fieldMappings = array(
            'plainField' => array(
                'fieldName' => 'plainField',
                'columnName' => 'plainField',
                'type' => 'integer',
            ),
        );

        $metadata->associationMappings['associatedEntity'] = array(
            'fieldName' => 'associatedEntity',
            'targetEntity' => $associatedEntityClass,
            'sourceEntity' => $containerEntityClass,
        );

        $metadata->embeddedClasses['embeddedEntity'] = array(
            'class' => $embeddedEntityClass,
            'columnPrefix' => 'embeddedEntity',
        );

        $metadata->inlineEmbeddable('embeddedEntity', $this->getMetadataForEmbeddedEntity());

        return $metadata;
    }

    public function testNonIntegerIdentifierType()
    {
        $uuid = new NonIntegerIdentifierTestClass('efbcfc4b-8c43-4d42-aa4c-d707e55151ac');
        $entity = new UuidEntity($uuid);

        $meta = $this->getMockBuilder('Doctrine\ORM\Mapping\ClassMetadataInfo')
            ->disableOriginalConstructor()
            ->getMock();
        $meta->expects($this->any())
            ->method('getIdentifierValues')
            ->willReturn(array($entity->getId()));
        $meta->expects($this->any())
            ->method('getTypeOfField')
            ->willReturn(UuidType::NAME);

        $mf = $this->getMockBuilder('Doctrine\ORM\Mapping\ClassMetadataFactory')
            ->disableOriginalConstructor()
            ->getMock();
        $mf->expects($this->any())
            ->method('getMetadataFor')
            ->willReturn($meta);

        $platform = $this->getMockBuilder('Doctrine\DBAL\Platforms\PostgreSqlPlatform')
            ->disableOriginalConstructor()
            ->getMock();

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

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

        $registry = $this->getMockBuilder('Symfony\Bridge\Doctrine\RegistryInterface')
            ->disableOriginalConstructor()
            ->getMock();
        $registry->expects($this->any())
            ->method('getManagerForClass')
            ->willReturn($em);

        $manager = new ModelManager($registry);
        $result = $manager->getIdentifierValues($entity);

        $this->assertEquals($entity->getId()->toString(), $result[0]);
    }

    public function testAssociationIdentifierType()
    {
        $entity = new ContainerEntity(new AssociatedEntity(42), new EmbeddedEntity());

        $meta = $this->getMockBuilder('Doctrine\ORM\Mapping\ClassMetadataInfo')
            ->disableOriginalConstructor()
            ->getMock();
        $meta->expects($this->any())
            ->method('getIdentifierValues')
            ->willReturn(array($entity->getAssociatedEntity()->getPlainField()));
        $meta->expects($this->any())
            ->method('getTypeOfField')
            ->willReturn(null);

        $mf = $this->getMockBuilder('Doctrine\ORM\Mapping\ClassMetadataFactory')
            ->disableOriginalConstructor()
            ->getMock();
        $mf->expects($this->any())
            ->method('getMetadataFor')
            ->willReturn($meta);

        $platform = $this->getMockBuilder('Doctrine\DBAL\Platforms\PostgreSqlPlatform')
            ->disableOriginalConstructor()
            ->getMock();

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

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

        $registry = $this->getMockBuilder('Symfony\Bridge\Doctrine\RegistryInterface')
            ->disableOriginalConstructor()
            ->getMock();
        $registry->expects($this->any())
            ->method('getManagerForClass')
            ->willReturn($em);

        $manager = new ModelManager($registry);
        $result = $manager->getIdentifierValues($entity);

        $this->assertSame(42, $result[0]);
    }

    public function getSortableInDataSourceIteratorDataProvider()
    {
        return [
            [
                $sortBy = null,
                $sortOrder = null,
                $isAddOrderBy = false,
            ],
            [
                $sortBy = '',
                $sortOrder = 'ASC',
                $isAddOrderBy = false,
            ],
            [
                $sortBy = 'field',
                $sortOrder = 'ASC',
                $isAddOrderBy = true,
            ],
        ];
    }

    /**
     * @dataProvider getSortableInDataSourceIteratorDataProvider
     *
     * @param string|null $sortBy
     * @param string|null $sortOrder
     * @param bool $isAddOrderBy
     */
    public function testSortableInDataSourceIterator($sortBy, $sortOrder, $isAddOrderBy)
    {
        $datagrid = $this->getMockForAbstractClass('Sonata\AdminBundle\Datagrid\DatagridInterface');
        $configuration = $this->getMock('Doctrine\ORM\Configuration');
        $configuration->expects($this->any())
            ->method('getDefaultQueryHints')
            ->willReturn([]);

        $em = $this->getMockForAbstractClass('Doctrine\ORM\EntityManagerInterface');
        $em->expects($this->any())
            ->method('getConfiguration')
            ->willReturn($configuration);

        $queryBuilder = $this->getMockBuilder('Doctrine\ORM\QueryBuilder')
            ->setConstructorArgs([$em])
            ->getMock();
        $query = new Query($em);

        $proxyQuery = $this->getMockBuilder('Sonata\DoctrineORMAdminBundle\Datagrid\ProxyQuery')
            ->setConstructorArgs([$queryBuilder])
            ->setMethods(['getSortBy', 'getSortOrder'])
            ->getMock();

        $proxyQuery->expects($this->any())
            ->method('getSortOrder')
            ->willReturn($sortOrder);

        $proxyQuery->expects($this->any())
            ->method('getSortBy')
            ->willReturn($sortBy);

        $queryBuilder->expects($isAddOrderBy ? $this->atLeastOnce() : $this->never())
            ->method('addOrderBy');

        $queryBuilder->expects($this->any())
            ->method('getQuery')
            ->willReturn($query);

        $datagrid->expects($this->any())
            ->method('getQuery')
            ->willReturn($proxyQuery);

        $registry = $this->getMock('Symfony\Bridge\Doctrine\RegistryInterface');
        $manager = new ModelManager($registry);
        $manager->getDataSourceIterator($datagrid, []);
    }

    private function getMetadata($class, $isVersioned)
    {
        $metadata = new ClassMetadata($class);

        $metadata->isVersioned = $isVersioned;

        if ($isVersioned) {
            $versionField = 'version';
            $metadata->versionField = $versionField;
            $metadata->reflFields[$versionField] = new \ReflectionProperty($class, $versionField);
        }

        return $metadata;
    }
}


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\Model;
13
14			use Doctrine\DBAL\Types\Type;
15			use Doctrine\ORM\Mapping\ClassMetadata;
16			use Doctrine\ORM\OptimisticLockException;
17			use Doctrine\ORM\Version;
18			use Doctrine\ORM\Query;
19			use Sonata\DoctrineORMAdminBundle\Admin\FieldDescription;
20			use Sonata\DoctrineORMAdminBundle\Model\ModelManager;
21			use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\DoctrineType\UuidType;
22			use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\AssociatedEntity;
23			use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\ContainerEntity;
24			use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\Embeddable\EmbeddedEntity;
25			use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\UuidEntity;
26			use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\VersionedEntity;
27			use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Util\NonIntegerIdentifierTestClass;
28
29			class ModelManagerTest extends \PHPUnit_Framework_TestCase
30			{
31			public static function setUpBeforeClass()
32			{
33			if (!Type::hasType('uuid')) {
34			Type::addType('uuid', 'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\DoctrineType\UuidType');
35			}
36			}
37
38			public function testSortParameters()
39			{
40			$registry = $this->getMock('Symfony\Bridge\Doctrine\RegistryInterface');
41
42			$manager = new ModelManager($registry);
43
44			$datagrid1 = $this->getMockBuilder('\Sonata\AdminBundle\Datagrid\Datagrid')->disableOriginalConstructor()->getMock();
45			$datagrid2 = $this->getMockBuilder('\Sonata\AdminBundle\Datagrid\Datagrid')->disableOriginalConstructor()->getMock();
46
47			$field1 = new FieldDescription();
48			$field1->setName('field1');
49
50			$field2 = new FieldDescription();
51			$field2->setName('field2');
52
53			$field3 = new FieldDescription();
54			$field3->setName('field3');
55			$field3->setOption('sortable', 'field3sortBy');
56
57			$datagrid1
58			->expects($this->any())
59			->method('getValues')
60			->will($this->returnValue(array(
61			'_sort_by' => $field1,
62			'_sort_order' => 'ASC',
63			)));
64
65			$datagrid2
66			->expects($this->any())
67			->method('getValues')
68			->will($this->returnValue(array(
69			'_sort_by' => $field3,
70			'_sort_order' => 'ASC',
71			)));
72
73			$parameters = $manager->getSortParameters($field1, $datagrid1);
74
75			$this->assertEquals('DESC', $parameters['filter']['_sort_order']);
76			$this->assertEquals('field1', $parameters['filter']['_sort_by']);
77
78			$parameters = $manager->getSortParameters($field2, $datagrid1);
79
80			$this->assertEquals('ASC', $parameters['filter']['_sort_order']);
81			$this->assertEquals('field2', $parameters['filter']['_sort_by']);
82
83			$parameters = $manager->getSortParameters($field3, $datagrid1);
84
85			$this->assertEquals('ASC', $parameters['filter']['_sort_order']);
86			$this->assertEquals('field3sortBy', $parameters['filter']['_sort_by']);
87
88			$parameters = $manager->getSortParameters($field3, $datagrid2);
89
90			$this->assertEquals('DESC', $parameters['filter']['_sort_order']);
91			$this->assertEquals('field3sortBy', $parameters['filter']['_sort_by']);
92			}
93
94			public function getVersionDataProvider()
95			{
96			return array(
97			array(true),
98			array(false),
99			);
100			}
101
102			/**
103			* @dataProvider getVersionDataProvider
104			*/
105			public function testGetVersion($isVersioned)
106			{
107			$object = new VersionedEntity();
108
109			$modelManager = $this->getMockBuilder('Sonata\DoctrineORMAdminBundle\Model\ModelManager')
110			->disableOriginalConstructor()
111			->setMethods(array('getMetadata'))
112			->getMock();
113
114			$metadata = $this->getMetadata(get_class($object), $isVersioned);
115
116			$modelManager->expects($this->any())
117			->method('getMetadata')
118			->will($this->returnValue($metadata));
119
120			if ($isVersioned) {
121			$object->version = 123;
122
123			$this->assertNotNull($modelManager->getLockVersion($object));
124			} else {
125			$this->assertNull($modelManager->getLockVersion($object));
126			}
127			}
128
129			public function lockDataProvider()
130			{
131			return array(
132			array(true, false),
133			array(true, true),
134			array(false, false),
135			);
136			}
137
138			/**
139			* @dataProvider lockDataProvider
140			*/
141			public function testLock($isVersioned, $expectsException)
142			{
143			$object = new VersionedEntity();
144
145			$em = $this->getMockBuilder('Doctrine\ORM\EntityManager')
146			->disableOriginalConstructor()
147			->setMethods(array('lock'))
148			->getMock();
149
150			$modelManager = $this->getMockBuilder('Sonata\DoctrineORMAdminBundle\Model\ModelManager')
151			->disableOriginalConstructor()
152			->setMethods(array('getMetadata', 'getEntityManager'))
153			->getMock();
154
155			$modelManager->expects($this->any())
156			->method('getEntityManager')
157			->will($this->returnValue($em));
158
159			$metadata = $this->getMetadata(get_class($object), $isVersioned);
160
161			$modelManager->expects($this->any())
162			->method('getMetadata')
163			->will($this->returnValue($metadata));
164
165			if ($expectsException) {
166			$em->expects($this->once())
167			->method('lock')
168			->will($this->throwException(OptimisticLockException::lockFailed($object)));
169
170			$this->setExpectedException('Sonata\AdminBundle\Exception\LockException');
171			}
172
173			$modelManager->lock($object, 123);
174			}
175
176			public function testGetParentMetadataForProperty()
177			{
178			if (version_compare(Version::VERSION, '2.5') < 0) {
179			$this->markTestSkipped('Test for embeddables needs to run on Doctrine >= 2.5');
180
181			return;
182			}
183
184			$containerEntityClass = 'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\ContainerEntity';
185			$associatedEntityClass = 'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\AssociatedEntity';
186			$embeddedEntityClass = 'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\Embeddable\EmbeddedEntity';
187			$modelManagerClass = 'Sonata\DoctrineORMAdminBundle\Model\ModelManager';
188
189			$object = new ContainerEntity(new AssociatedEntity(), new EmbeddedEntity());
			0 ignored issues – show Unused Code introduced 2017-04-20 00:09 UTC by Report Bug Copy Issue Report `$object` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
190
191			$em = $this->getMockBuilder('Doctrine\ORM\EntityManager')
192			->disableOriginalConstructor()
193			->getMock();
194
195			/** @var \PHPUnit_Framework_MockObject_MockObject\|ModelManager $modelManager */
196			$modelManager = $this->getMockBuilder($modelManagerClass)
197			->disableOriginalConstructor()
198			->setMethods(array('getMetadata', 'getEntityManager'))
199			->getMock();
200
201			$modelManager->expects($this->any())
			0 ignored issues – show Bug introduced 2015-11-23 21:03 UTC by Report Bug Copy Issue Report The method `expects()` does not seem to exist on `object<Sonata\DoctrineOR...dle\Model\ModelManager>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
202			->method('getEntityManager')
203			->will($this->returnValue($em));
204
205			$containerEntityMetadata = $this->getMetadataForContainerEntity();
206			$associatedEntityMetadata = $this->getMetadataForAssociatedEntity();
207			$embeddedEntityMetadata = $this->getMetadataForEmbeddedEntity();
208
209			$modelManager->expects($this->any())->method('getMetadata')
			0 ignored issues – show Bug introduced 2015-11-23 21:03 UTC by Report Bug Copy Issue Report The method `expects()` does not seem to exist on `object<Sonata\DoctrineOR...dle\Model\ModelManager>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
210			->will(
211			$this->returnValueMap(
212			array(
213			array($containerEntityClass, $containerEntityMetadata),
214			array($embeddedEntityClass, $embeddedEntityMetadata),
215			array($associatedEntityClass, $associatedEntityMetadata),
216			)
217			)
218			);
219
220			/** @var ClassMetadata $metadata */
221			list($metadata, $lastPropertyName) = $modelManager
222			->getParentMetadataForProperty($containerEntityClass, 'plainField');
223			$this->assertEquals($metadata->fieldMappings[$lastPropertyName]['type'], 'integer');
224
225			list($metadata, $lastPropertyName) = $modelManager
226			->getParentMetadataForProperty($containerEntityClass, 'associatedEntity.plainField');
227			$this->assertEquals($metadata->fieldMappings[$lastPropertyName]['type'], 'string');
228
229			list($metadata, $lastPropertyName) = $modelManager
230			->getParentMetadataForProperty($containerEntityClass, 'embeddedEntity.plainField');
231			$this->assertEquals($metadata->fieldMappings[$lastPropertyName]['type'], 'boolean');
232			}
233
234			public function getMetadataForEmbeddedEntity()
235			{
236			$metadata = new ClassMetadata('Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\Embeddable\EmbeddedEntity');
237
238			$metadata->fieldMappings = array(
239			'plainField' => array(
240			'fieldName' => 'plainField',
241			'columnName' => 'plainField',
242			'type' => 'boolean',
243			),
244			);
245
246			return $metadata;
247			}
248
249			public function getMetadataForAssociatedEntity()
250			{
251			$metadata = new ClassMetadata('Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\AssociatedEntity');
252
253			$metadata->fieldMappings = array(
254			'plainField' => array(
255			'fieldName' => 'plainField',
256			'columnName' => 'plainField',
257			'type' => 'string',
258			),
259			);
260
261			return $metadata;
262			}
263
264			public function getMetadataForContainerEntity()
265			{
266			$containerEntityClass = 'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\ContainerEntity';
267			$associatedEntityClass = 'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\AssociatedEntity';
268			$embeddedEntityClass = 'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\Embeddable\EmbeddedEntity';
269
270			$metadata = new ClassMetadata($containerEntityClass);
271
272			$metadata->fieldMappings = array(
273			'plainField' => array(
274			'fieldName' => 'plainField',
275			'columnName' => 'plainField',
276			'type' => 'integer',
277			),
278			);
279
280			$metadata->associationMappings['associatedEntity'] = array(
281			'fieldName' => 'associatedEntity',
282			'targetEntity' => $associatedEntityClass,
283			'sourceEntity' => $containerEntityClass,
284			);
285
286			$metadata->embeddedClasses['embeddedEntity'] = array(
287			'class' => $embeddedEntityClass,
288			'columnPrefix' => 'embeddedEntity',
289			);
290
291			$metadata->inlineEmbeddable('embeddedEntity', $this->getMetadataForEmbeddedEntity());
292
293			return $metadata;
294			}
295
296			public function testNonIntegerIdentifierType()
297			{
298			$uuid = new NonIntegerIdentifierTestClass('efbcfc4b-8c43-4d42-aa4c-d707e55151ac');
299			$entity = new UuidEntity($uuid);
300
301			$meta = $this->getMockBuilder('Doctrine\ORM\Mapping\ClassMetadataInfo')
302			->disableOriginalConstructor()
303			->getMock();
304			$meta->expects($this->any())
305			->method('getIdentifierValues')
306			->willReturn(array($entity->getId()));
307			$meta->expects($this->any())
308			->method('getTypeOfField')
309			->willReturn(UuidType::NAME);
310
311			$mf = $this->getMockBuilder('Doctrine\ORM\Mapping\ClassMetadataFactory')
312			->disableOriginalConstructor()
313			->getMock();
314			$mf->expects($this->any())
315			->method('getMetadataFor')
316			->willReturn($meta);
317
318			$platform = $this->getMockBuilder('Doctrine\DBAL\Platforms\PostgreSqlPlatform')
319			->disableOriginalConstructor()
320			->getMock();
321
322			$conn = $this->getMockBuilder('Doctrine\DBAL\Connection')
323			->disableOriginalConstructor()
324			->getMock();
325			$conn->expects($this->any())
326			->method('getDatabasePlatform')
327			->willReturn($platform);
328
329			$em = $this->getMockBuilder('Doctrine\ORM\EntityManager')
330			->disableOriginalConstructor()
331			->getMock();
332			$em->expects($this->any())
333			->method('getMetadataFactory')
334			->willReturn($mf);
335			$em->expects($this->any())
336			->method('getConnection')
337			->willReturn($conn);
338
339			$registry = $this->getMockBuilder('Symfony\Bridge\Doctrine\RegistryInterface')
340			->disableOriginalConstructor()
341			->getMock();
342			$registry->expects($this->any())
343			->method('getManagerForClass')
344			->willReturn($em);
345
346			$manager = new ModelManager($registry);
347			$result = $manager->getIdentifierValues($entity);
348
349			$this->assertEquals($entity->getId()->toString(), $result[0]);
350			}
351
352			public function testAssociationIdentifierType()
353			{
354			$entity = new ContainerEntity(new AssociatedEntity(42), new EmbeddedEntity());
355
356			$meta = $this->getMockBuilder('Doctrine\ORM\Mapping\ClassMetadataInfo')
357			->disableOriginalConstructor()
358			->getMock();
359			$meta->expects($this->any())
360			->method('getIdentifierValues')
361			->willReturn(array($entity->getAssociatedEntity()->getPlainField()));
362			$meta->expects($this->any())
363			->method('getTypeOfField')
364			->willReturn(null);
365
366			$mf = $this->getMockBuilder('Doctrine\ORM\Mapping\ClassMetadataFactory')
367			->disableOriginalConstructor()
368			->getMock();
369			$mf->expects($this->any())
370			->method('getMetadataFor')
371			->willReturn($meta);
372
373			$platform = $this->getMockBuilder('Doctrine\DBAL\Platforms\PostgreSqlPlatform')
374			->disableOriginalConstructor()
375			->getMock();
376
377			$conn = $this->getMockBuilder('Doctrine\DBAL\Connection')
378			->disableOriginalConstructor()
379			->getMock();
380			$conn->expects($this->any())
381			->method('getDatabasePlatform')
382			->willReturn($platform);
383
384			$em = $this->getMockBuilder('Doctrine\ORM\EntityManager')
385			->disableOriginalConstructor()
386			->getMock();
387			$em->expects($this->any())
388			->method('getMetadataFactory')
389			->willReturn($mf);
390			$em->expects($this->any())
391			->method('getConnection')
392			->willReturn($conn);
393
394			$registry = $this->getMockBuilder('Symfony\Bridge\Doctrine\RegistryInterface')
395			->disableOriginalConstructor()
396			->getMock();
397			$registry->expects($this->any())
398			->method('getManagerForClass')
399			->willReturn($em);
400
401			$manager = new ModelManager($registry);
402			$result = $manager->getIdentifierValues($entity);
403
404			$this->assertSame(42, $result[0]);
405			}
406
407			public function getSortableInDataSourceIteratorDataProvider()
408			{
409			return [
410			[
411			$sortBy = null,
412			$sortOrder = null,
413			$isAddOrderBy = false,
414			],
415			[
416			$sortBy = '',
417			$sortOrder = 'ASC',
418			$isAddOrderBy = false,
419			],
420			[
421			$sortBy = 'field',
422			$sortOrder = 'ASC',
423			$isAddOrderBy = true,
424			],
425			];
426			}
427
428			/**
429			* @dataProvider getSortableInDataSourceIteratorDataProvider
430			*
431			* @param string\|null $sortBy
432			* @param string\|null $sortOrder
433			* @param bool $isAddOrderBy
434			*/
435			public function testSortableInDataSourceIterator($sortBy, $sortOrder, $isAddOrderBy)
436			{
437			$datagrid = $this->getMockForAbstractClass('Sonata\AdminBundle\Datagrid\DatagridInterface');
438			$configuration = $this->getMock('Doctrine\ORM\Configuration');
439			$configuration->expects($this->any())
440			->method('getDefaultQueryHints')
441			->willReturn([]);
442
443			$em = $this->getMockForAbstractClass('Doctrine\ORM\EntityManagerInterface');
444			$em->expects($this->any())
445			->method('getConfiguration')
446			->willReturn($configuration);
447
448			$queryBuilder = $this->getMockBuilder('Doctrine\ORM\QueryBuilder')
449			->setConstructorArgs([$em])
450			->getMock();
451			$query = new Query($em);
452
453			$proxyQuery = $this->getMockBuilder('Sonata\DoctrineORMAdminBundle\Datagrid\ProxyQuery')
454			->setConstructorArgs([$queryBuilder])
455			->setMethods(['getSortBy', 'getSortOrder'])
456			->getMock();
457
458			$proxyQuery->expects($this->any())
459			->method('getSortOrder')
460			->willReturn($sortOrder);
461
462			$proxyQuery->expects($this->any())
463			->method('getSortBy')
464			->willReturn($sortBy);
465
466			$queryBuilder->expects($isAddOrderBy ? $this->atLeastOnce() : $this->never())
467			->method('addOrderBy');
468
469			$queryBuilder->expects($this->any())
470			->method('getQuery')
471			->willReturn($query);
472
473			$datagrid->expects($this->any())
474			->method('getQuery')
475			->willReturn($proxyQuery);
476
477			$registry = $this->getMock('Symfony\Bridge\Doctrine\RegistryInterface');
478			$manager = new ModelManager($registry);
479			$manager->getDataSourceIterator($datagrid, []);
480			}
481
482			private function getMetadata($class, $isVersioned)
483			{
484			$metadata = new ClassMetadata($class);
485
486			$metadata->isVersioned = $isVersioned;
487
488			if ($isVersioned) {
489			$versionField = 'version';
490			$metadata->versionField = $versionField;
491			$metadata->reflFields[$versionField] = new \ReflectionProperty($class, $versionField);
492			}
493
494			return $metadata;
495			}
496			}
497

sonata-project / SonataDoctrineORMAdminBundle

Pull Request — 3.x (#696)

testSortableInDataSourceIterator() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like