ModelManagerTest::testLock() - Code Metrics - Inspection of "use createMock instead of deprecated getMock" - sonata-project/SonataDoctrineORMAdminBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — 3.x (#677)

unknown

created 2017-04-03 13:04 UTC

ModelManagerTest::testLock() B

↳ Parent: ModelManagerTest

Complexity

Conditions	2
Paths	2

Size

Total Lines	34
Code Lines	23

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	34
rs	8.8571
cc	2
eloc	23
nc	2
nop	2

<?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 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->createMock('Symfony\Bridge\Doctrine\RegistryInterface');

        $manager = new ModelManager($registry);

        $datagrid1 = $this->createMock('Sonata\AdminBundle\Datagrid\Datagrid');
        $datagrid2 = $this->createMock('Sonata\AdminBundle\Datagrid\Datagrid');

        $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->createMock('Doctrine\ORM\EntityManager');

        /** @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->createMock('Doctrine\ORM\Mapping\ClassMetadataInfo');
        $meta->expects($this->any())
            ->method('getIdentifierValues')
            ->willReturn(array($entity->getId()));
        $meta->expects($this->any())
            ->method('getTypeOfField')
            ->willReturn(UuidType::NAME);

        $mf = $this->createMock('Doctrine\ORM\Mapping\ClassMetadataFactory');
        $mf->expects($this->any())
            ->method('getMetadataFor')
            ->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);

        $registry = $this->createMock('Symfony\Bridge\Doctrine\RegistryInterface');
        $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->createMock('Doctrine\ORM\Mapping\ClassMetadataInfo');
        $meta->expects($this->any())
            ->method('getIdentifierValues')
            ->willReturn(array($entity->getAssociatedEntity()->getPlainField()));
        $meta->expects($this->any())
            ->method('getTypeOfField')
            ->willReturn(null);

        $mf = $this->createMock('Doctrine\ORM\Mapping\ClassMetadataFactory');
        $mf->expects($this->any())
            ->method('getMetadataFor')
            ->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);

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

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

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

    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 Sonata\DoctrineORMAdminBundle\Admin\FieldDescription;
19			use Sonata\DoctrineORMAdminBundle\Model\ModelManager;
20			use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\DoctrineType\UuidType;
21			use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\AssociatedEntity;
22			use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\ContainerEntity;
23			use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\Embeddable\EmbeddedEntity;
24			use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\UuidEntity;
25			use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\VersionedEntity;
26			use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Util\NonIntegerIdentifierTestClass;
27
28			class ModelManagerTest extends \PHPUnit_Framework_TestCase
29			{
30			public static function setUpBeforeClass()
31			{
32			if (!Type::hasType('uuid')) {
33			Type::addType('uuid', 'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\DoctrineType\UuidType');
34			}
35			}
36
37			public function testSortParameters()
38			{
39			$registry = $this->createMock('Symfony\Bridge\Doctrine\RegistryInterface');
40
41			$manager = new ModelManager($registry);
42
43			$datagrid1 = $this->createMock('Sonata\AdminBundle\Datagrid\Datagrid');
44			$datagrid2 = $this->createMock('Sonata\AdminBundle\Datagrid\Datagrid');
45
46			$field1 = new FieldDescription();
47			$field1->setName('field1');
48
49			$field2 = new FieldDescription();
50			$field2->setName('field2');
51
52			$field3 = new FieldDescription();
53			$field3->setName('field3');
54			$field3->setOption('sortable', 'field3sortBy');
55
56			$datagrid1
57			->expects($this->any())
58			->method('getValues')
59			->will($this->returnValue(array(
60			'_sort_by' => $field1,
61			'_sort_order' => 'ASC',
62			)));
63
64			$datagrid2
65			->expects($this->any())
66			->method('getValues')
67			->will($this->returnValue(array(
68			'_sort_by' => $field3,
69			'_sort_order' => 'ASC',
70			)));
71
72			$parameters = $manager->getSortParameters($field1, $datagrid1);
73
74			$this->assertEquals('DESC', $parameters['filter']['_sort_order']);
75			$this->assertEquals('field1', $parameters['filter']['_sort_by']);
76
77			$parameters = $manager->getSortParameters($field2, $datagrid1);
78
79			$this->assertEquals('ASC', $parameters['filter']['_sort_order']);
80			$this->assertEquals('field2', $parameters['filter']['_sort_by']);
81
82			$parameters = $manager->getSortParameters($field3, $datagrid1);
83
84			$this->assertEquals('ASC', $parameters['filter']['_sort_order']);
85			$this->assertEquals('field3sortBy', $parameters['filter']['_sort_by']);
86
87			$parameters = $manager->getSortParameters($field3, $datagrid2);
88
89			$this->assertEquals('DESC', $parameters['filter']['_sort_order']);
90			$this->assertEquals('field3sortBy', $parameters['filter']['_sort_by']);
91			}
92
93			public function getVersionDataProvider()
94			{
95			return array(
96			array(true),
97			array(false),
98			);
99			}
100
101			/**
102			* @dataProvider getVersionDataProvider
103			*/
104			public function testGetVersion($isVersioned)
105			{
106			$object = new VersionedEntity();
107
108			$modelManager = $this->getMockBuilder('Sonata\DoctrineORMAdminBundle\Model\ModelManager')
109			->disableOriginalConstructor()
110			->setMethods(array('getMetadata'))
111			->getMock();
112
113			$metadata = $this->getMetadata(get_class($object), $isVersioned);
114
115			$modelManager->expects($this->any())
116			->method('getMetadata')
117			->will($this->returnValue($metadata));
118
119			if ($isVersioned) {
120			$object->version = 123;
121
122			$this->assertNotNull($modelManager->getLockVersion($object));
123			} else {
124			$this->assertNull($modelManager->getLockVersion($object));
125			}
126			}
127
128			public function lockDataProvider()
129			{
130			return array(
131			array(true, false),
132			array(true, true),
133			array(false, false),
134			);
135			}
136
137			/**
138			* @dataProvider lockDataProvider
139			*/
140			public function testLock($isVersioned, $expectsException)
141			{
142			$object = new VersionedEntity();
143
144			$em = $this->getMockBuilder('Doctrine\ORM\EntityManager')
145			->disableOriginalConstructor()
146			->setMethods(array('lock'))
147			->getMock();
148
149			$modelManager = $this->getMockBuilder('Sonata\DoctrineORMAdminBundle\Model\ModelManager')
150			->disableOriginalConstructor()
151			->setMethods(array('getMetadata', 'getEntityManager'))
152			->getMock();
153
154			$modelManager->expects($this->any())
155			->method('getEntityManager')
156			->will($this->returnValue($em));
157
158			$metadata = $this->getMetadata(get_class($object), $isVersioned);
159
160			$modelManager->expects($this->any())
161			->method('getMetadata')
162			->will($this->returnValue($metadata));
163
164			if ($expectsException) {
165			$em->expects($this->once())
166			->method('lock')
167			->will($this->throwException(OptimisticLockException::lockFailed($object)));
168
169			$this->setExpectedException('Sonata\AdminBundle\Exception\LockException');
170			}
171
172			$modelManager->lock($object, 123);
173			}
174
175			public function testGetParentMetadataForProperty()
176			{
177			if (version_compare(Version::VERSION, '2.5') < 0) {
178			$this->markTestSkipped('Test for embeddables needs to run on Doctrine >= 2.5');
179
180			return;
181			}
182
183			$containerEntityClass = 'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\ContainerEntity';
184			$associatedEntityClass = 'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\AssociatedEntity';
185			$embeddedEntityClass = 'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\Embeddable\EmbeddedEntity';
186			$modelManagerClass = 'Sonata\DoctrineORMAdminBundle\Model\ModelManager';
187
188			$object = new ContainerEntity(new AssociatedEntity(), new EmbeddedEntity());
			0 ignored issues – show Unused Code introduced 2015-11-23 21:03 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...
189
190			$em = $this->createMock('Doctrine\ORM\EntityManager');
191
192			/** @var \PHPUnit_Framework_MockObject_MockObject\|ModelManager $modelManager */
193			$modelManager = $this->getMockBuilder($modelManagerClass)
194			->disableOriginalConstructor()
195			->setMethods(array('getMetadata', 'getEntityManager'))
196			->getMock();
197
198			$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...
199			->method('getEntityManager')
200			->will($this->returnValue($em));
201
202			$containerEntityMetadata = $this->getMetadataForContainerEntity();
203			$associatedEntityMetadata = $this->getMetadataForAssociatedEntity();
204			$embeddedEntityMetadata = $this->getMetadataForEmbeddedEntity();
205
206			$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...
207			->will(
208			$this->returnValueMap(
209			array(
210			array($containerEntityClass, $containerEntityMetadata),
211			array($embeddedEntityClass, $embeddedEntityMetadata),
212			array($associatedEntityClass, $associatedEntityMetadata),
213			)
214			)
215			);
216
217			/** @var ClassMetadata $metadata */
218			list($metadata, $lastPropertyName) = $modelManager
219			->getParentMetadataForProperty($containerEntityClass, 'plainField');
220			$this->assertEquals($metadata->fieldMappings[$lastPropertyName]['type'], 'integer');
221
222			list($metadata, $lastPropertyName) = $modelManager
223			->getParentMetadataForProperty($containerEntityClass, 'associatedEntity.plainField');
224			$this->assertEquals($metadata->fieldMappings[$lastPropertyName]['type'], 'string');
225
226			list($metadata, $lastPropertyName) = $modelManager
227			->getParentMetadataForProperty($containerEntityClass, 'embeddedEntity.plainField');
228			$this->assertEquals($metadata->fieldMappings[$lastPropertyName]['type'], 'boolean');
229			}
230
231			public function getMetadataForEmbeddedEntity()
232			{
233			$metadata = new ClassMetadata('Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\Embeddable\EmbeddedEntity');
234
235			$metadata->fieldMappings = array(
236			'plainField' => array(
237			'fieldName' => 'plainField',
238			'columnName' => 'plainField',
239			'type' => 'boolean',
240			),
241			);
242
243			return $metadata;
244			}
245
246			public function getMetadataForAssociatedEntity()
247			{
248			$metadata = new ClassMetadata('Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\AssociatedEntity');
249
250			$metadata->fieldMappings = array(
251			'plainField' => array(
252			'fieldName' => 'plainField',
253			'columnName' => 'plainField',
254			'type' => 'string',
255			),
256			);
257
258			return $metadata;
259			}
260
261			public function getMetadataForContainerEntity()
262			{
263			$containerEntityClass = 'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\ContainerEntity';
264			$associatedEntityClass = 'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\AssociatedEntity';
265			$embeddedEntityClass = 'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\Embeddable\EmbeddedEntity';
266
267			$metadata = new ClassMetadata($containerEntityClass);
268
269			$metadata->fieldMappings = array(
270			'plainField' => array(
271			'fieldName' => 'plainField',
272			'columnName' => 'plainField',
273			'type' => 'integer',
274			),
275			);
276
277			$metadata->associationMappings['associatedEntity'] = array(
278			'fieldName' => 'associatedEntity',
279			'targetEntity' => $associatedEntityClass,
280			'sourceEntity' => $containerEntityClass,
281			);
282
283			$metadata->embeddedClasses['embeddedEntity'] = array(
284			'class' => $embeddedEntityClass,
285			'columnPrefix' => 'embeddedEntity',
286			);
287
288			$metadata->inlineEmbeddable('embeddedEntity', $this->getMetadataForEmbeddedEntity());
289
290			return $metadata;
291			}
292
293			public function testNonIntegerIdentifierType()
294			{
295			$uuid = new NonIntegerIdentifierTestClass('efbcfc4b-8c43-4d42-aa4c-d707e55151ac');
296			$entity = new UuidEntity($uuid);
297
298			$meta = $this->createMock('Doctrine\ORM\Mapping\ClassMetadataInfo');
299			$meta->expects($this->any())
300			->method('getIdentifierValues')
301			->willReturn(array($entity->getId()));
302			$meta->expects($this->any())
303			->method('getTypeOfField')
304			->willReturn(UuidType::NAME);
305
306			$mf = $this->createMock('Doctrine\ORM\Mapping\ClassMetadataFactory');
307			$mf->expects($this->any())
308			->method('getMetadataFor')
309			->willReturn($meta);
310
311			$platform = $this->createMock('Doctrine\DBAL\Platforms\PostgreSqlPlatform');
312
313			$conn = $this->createMock('Doctrine\DBAL\Connection');
314			$conn->expects($this->any())
315			->method('getDatabasePlatform')
316			->willReturn($platform);
317
318			$em = $this->createMock('Doctrine\ORM\EntityManager');
319			$em->expects($this->any())
320			->method('getMetadataFactory')
321			->willReturn($mf);
322			$em->expects($this->any())
323			->method('getConnection')
324			->willReturn($conn);
325
326			$registry = $this->createMock('Symfony\Bridge\Doctrine\RegistryInterface');
327			$registry->expects($this->any())
328			->method('getManagerForClass')
329			->willReturn($em);
330
331			$manager = new ModelManager($registry);
332			$result = $manager->getIdentifierValues($entity);
333
334			$this->assertEquals($entity->getId()->toString(), $result[0]);
335			}
336
337			public function testAssociationIdentifierType()
338			{
339			$entity = new ContainerEntity(new AssociatedEntity(42), new EmbeddedEntity());
340
341			$meta = $this->createMock('Doctrine\ORM\Mapping\ClassMetadataInfo');
342			$meta->expects($this->any())
343			->method('getIdentifierValues')
344			->willReturn(array($entity->getAssociatedEntity()->getPlainField()));
345			$meta->expects($this->any())
346			->method('getTypeOfField')
347			->willReturn(null);
348
349			$mf = $this->createMock('Doctrine\ORM\Mapping\ClassMetadataFactory');
350			$mf->expects($this->any())
351			->method('getMetadataFor')
352			->willReturn($meta);
353
354			$platform = $this->createMock('Doctrine\DBAL\Platforms\PostgreSqlPlatform');
355
356			$conn = $this->createMock('Doctrine\DBAL\Connection');
357			$conn->expects($this->any())
358			->method('getDatabasePlatform')
359			->willReturn($platform);
360
361			$em = $this->createMock('Doctrine\ORM\EntityManager');
362			$em->expects($this->any())
363			->method('getMetadataFactory')
364			->willReturn($mf);
365			$em->expects($this->any())
366			->method('getConnection')
367			->willReturn($conn);
368
369			$registry = $this->createMock('Symfony\Bridge\Doctrine\RegistryInterface');
370			$registry->expects($this->any())
371			->method('getManagerForClass')
372			->willReturn($em);
373
374			$manager = new ModelManager($registry);
375			$result = $manager->getIdentifierValues($entity);
376
377			$this->assertSame(42, $result[0]);
378			}
379
380			private function getMetadata($class, $isVersioned)
381			{
382			$metadata = new ClassMetadata($class);
383
384			$metadata->isVersioned = $isVersioned;
385
386			if ($isVersioned) {
387			$versionField = 'version';
388			$metadata->versionField = $versionField;
389			$metadata->reflFields[$versionField] = new \ReflectionProperty($class, $versionField);
390			}
391
392			return $metadata;
393			}
394			}
395

sonata-project / SonataDoctrineORMAdminBundle

Pull Request — 3.x (#677)

ModelManagerTest::testLock() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like