ModelManagerTest::getMetadata() - Code Metrics - Inspection of "Avoid 'No entity manager defined for class' in has..." - sonata-project/SonataDoctrineORMAdminBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#524)

by Warnar

created 2016-02-16 11:08 UTC

ModelManagerTest::getMetadata() A

↳ Parent: ModelManagerTest

Complexity

Conditions	2
Paths	2

Size

Total Lines	14
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	1

Metric	Value
c	2
b	0
f	1
dl	0
loc	14
rs	9.4285
cc	2
eloc	8
nc	2
nop	2

<?php

/*
 * This file is part of the Sonata 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\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\Entity\AssociatedEntity;
use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\ContainerEntity;
use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\Embeddable\EmbeddedEntity;
use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\VersionedEntity;

class ModelManagerTest extends \PHPUnit_Framework_TestCase
{
    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);
    }

    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;
    }

    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 testHasMetadata()
    {
        $metaDataFactory = $this->getMock('Doctrine\Common\Persistence\Mapping\ClassMetadataFactory');
        $metaDataFactory
            ->expects($this->any())
            ->method('hasMetadataFor')
            ->willReturnMap([
                ['myEntity', true],
                ['mySecondEntity', true],
                ['objectWithNoMetadata', false]
            ])
        ;

        $entityManager = $this->getMockBuilder('Doctrine\ORM\EntityManager')
            ->disableOriginalConstructor()
            ->getMock();
        $entityManager
            ->expects($this->any())
            ->method('getMetadataFactory')
            ->willReturn($metaDataFactory);

        $registry = $this->getMock('Symfony\Bridge\Doctrine\RegistryInterface');
        $registry->expects($this->any())
            ->method('getManagerForClass')
            ->willReturnMap([
                ['stdClass', null],
                ['myEntity', $entityManager],
                ['mySecondEntity', $entityManager],
                ['objectWithNoMetadata', $entityManager]
            ])
        ;

        $manager = new ModelManager($registry);

        $this->assertFalse($manager->hasMetadata('stdClass'));
        $this->assertTrue($manager->hasMetadata('myEntity'));
        $this->assertTrue($manager->hasMetadata('mySecondEntity'));
        $this->assertFalse($manager->hasMetadata('objectWithNoMetadata'));
    }

    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;
    }
}


1			<?php
2
3			/*
4			* This file is part of the Sonata 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\ORM\Mapping\ClassMetadata;
15			use Doctrine\ORM\OptimisticLockException;
16			use Doctrine\ORM\Version;
17			use Sonata\DoctrineORMAdminBundle\Admin\FieldDescription;
18			use Sonata\DoctrineORMAdminBundle\Model\ModelManager;
19			use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\AssociatedEntity;
20			use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\ContainerEntity;
21			use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\Embeddable\EmbeddedEntity;
22			use Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\VersionedEntity;
23
24			class ModelManagerTest extends \PHPUnit_Framework_TestCase
25			{
26			public function testSortParameters()
27			{
28			$registry = $this->getMock('Symfony\Bridge\Doctrine\RegistryInterface');
29
30			$manager = new ModelManager($registry);
31
32			$datagrid1 = $this->getMockBuilder('\Sonata\AdminBundle\Datagrid\Datagrid')->disableOriginalConstructor()->getMock();
33			$datagrid2 = $this->getMockBuilder('\Sonata\AdminBundle\Datagrid\Datagrid')->disableOriginalConstructor()->getMock();
34
35			$field1 = new FieldDescription();
36			$field1->setName('field1');
37
38			$field2 = new FieldDescription();
39			$field2->setName('field2');
40
41			$field3 = new FieldDescription();
42			$field3->setName('field3');
43			$field3->setOption('sortable', 'field3sortBy');
44
45			$datagrid1
46			->expects($this->any())
47			->method('getValues')
48			->will($this->returnValue(array(
49			'_sort_by' => $field1,
50			'_sort_order' => 'ASC',
51			)));
52
53			$datagrid2
54			->expects($this->any())
55			->method('getValues')
56			->will($this->returnValue(array(
57			'_sort_by' => $field3,
58			'_sort_order' => 'ASC',
59			)));
60
61			$parameters = $manager->getSortParameters($field1, $datagrid1);
62
63			$this->assertEquals('DESC', $parameters['filter']['_sort_order']);
64			$this->assertEquals('field1', $parameters['filter']['_sort_by']);
65
66			$parameters = $manager->getSortParameters($field2, $datagrid1);
67
68			$this->assertEquals('ASC', $parameters['filter']['_sort_order']);
69			$this->assertEquals('field2', $parameters['filter']['_sort_by']);
70
71			$parameters = $manager->getSortParameters($field3, $datagrid1);
72
73			$this->assertEquals('ASC', $parameters['filter']['_sort_order']);
74			$this->assertEquals('field3sortBy', $parameters['filter']['_sort_by']);
75
76			$parameters = $manager->getSortParameters($field3, $datagrid2);
77
78			$this->assertEquals('DESC', $parameters['filter']['_sort_order']);
79			$this->assertEquals('field3sortBy', $parameters['filter']['_sort_by']);
80			}
81
82			public function getVersionDataProvider()
83			{
84			return array(
85			array(true),
86			array(false),
87			);
88			}
89
90			/**
91			* @dataProvider getVersionDataProvider
92			*/
93			public function testGetVersion($isVersioned)
94			{
95			$object = new VersionedEntity();
96
97			$modelManager = $this->getMockBuilder('Sonata\DoctrineORMAdminBundle\Model\ModelManager')
98			->disableOriginalConstructor()
99			->setMethods(array('getMetadata'))
100			->getMock();
101
102			$metadata = $this->getMetadata(get_class($object), $isVersioned);
103
104			$modelManager->expects($this->any())
105			->method('getMetadata')
106			->will($this->returnValue($metadata));
107
108			if ($isVersioned) {
109			$object->version = 123;
110
111			$this->assertNotNull($modelManager->getLockVersion($object));
112			} else {
113			$this->assertNull($modelManager->getLockVersion($object));
114			}
115			}
116
117			public function lockDataProvider()
118			{
119			return array(
120			array(true, false),
121			array(true, true),
122			array(false, false),
123			);
124			}
125
126			/**
127			* @dataProvider lockDataProvider
128			*/
129			public function testLock($isVersioned, $expectsException)
130			{
131			$object = new VersionedEntity();
132
133			$em = $this->getMockBuilder('Doctrine\ORM\EntityManager')
134			->disableOriginalConstructor()
135			->setMethods(array('lock'))
136			->getMock();
137
138			$modelManager = $this->getMockBuilder('Sonata\DoctrineORMAdminBundle\Model\ModelManager')
139			->disableOriginalConstructor()
140			->setMethods(array('getMetadata', 'getEntityManager'))
141			->getMock();
142
143			$modelManager->expects($this->any())
144			->method('getEntityManager')
145			->will($this->returnValue($em));
146
147			$metadata = $this->getMetadata(get_class($object), $isVersioned);
148
149			$modelManager->expects($this->any())
150			->method('getMetadata')
151			->will($this->returnValue($metadata));
152
153			if ($expectsException) {
154			$em->expects($this->once())
155			->method('lock')
156			->will($this->throwException(OptimisticLockException::lockFailed($object)));
157
158			$this->setExpectedException('Sonata\AdminBundle\Exception\LockException');
159			}
160
161			$modelManager->lock($object, 123);
162			}
163
164			private function getMetadata($class, $isVersioned)
165			{
166			$metadata = new ClassMetadata($class);
167
168			$metadata->isVersioned = $isVersioned;
169
170			if ($isVersioned) {
171			$versionField = 'version';
172			$metadata->versionField = $versionField;
173			$metadata->reflFields[$versionField] = new \ReflectionProperty($class, $versionField);
174			}
175
176			return $metadata;
177			}
178
179			public function testGetParentMetadataForProperty()
180			{
181			if (version_compare(Version::VERSION, '2.5') < 0) {
182			$this->markTestSkipped('Test for embeddables needs to run on Doctrine >= 2.5');
183
184			return;
185			}
186
187			$containerEntityClass = 'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\ContainerEntity';
188			$associatedEntityClass = 'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\AssociatedEntity';
189			$embeddedEntityClass = 'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\Embeddable\EmbeddedEntity';
190			$modelManagerClass = 'Sonata\DoctrineORMAdminBundle\Model\ModelManager';
191
192			$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...
193
194			$em = $this->getMockBuilder('Doctrine\ORM\EntityManager')
195			->disableOriginalConstructor()
196			->getMock();
197
198			/** @var \PHPUnit_Framework_MockObject_MockObject\|ModelManager $modelManager */
199			$modelManager = $this->getMockBuilder($modelManagerClass)
200			->disableOriginalConstructor()
201			->setMethods(array('getMetadata', 'getEntityManager'))
202			->getMock();
203
204			$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...
205			->method('getEntityManager')
206			->will($this->returnValue($em));
207
208			$containerEntityMetadata = $this->getMetadataForContainerEntity();
209			$associatedEntityMetadata = $this->getMetadataForAssociatedEntity();
210			$embeddedEntityMetadata = $this->getMetadataForEmbeddedEntity();
211
212			$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...
213			->will(
214			$this->returnValueMap(
215			array(
216			array($containerEntityClass, $containerEntityMetadata),
217			array($embeddedEntityClass, $embeddedEntityMetadata),
218			array($associatedEntityClass, $associatedEntityMetadata),
219			)
220			)
221			);
222
223			/** @var ClassMetadata $metadata */
224			list($metadata, $lastPropertyName) = $modelManager
225			->getParentMetadataForProperty($containerEntityClass, 'plainField');
226			$this->assertEquals($metadata->fieldMappings[$lastPropertyName]['type'], 'integer');
227
228			list($metadata, $lastPropertyName) = $modelManager
229			->getParentMetadataForProperty($containerEntityClass, 'associatedEntity.plainField');
230			$this->assertEquals($metadata->fieldMappings[$lastPropertyName]['type'], 'string');
231
232			list($metadata, $lastPropertyName) = $modelManager
233			->getParentMetadataForProperty($containerEntityClass, 'embeddedEntity.plainField');
234			$this->assertEquals($metadata->fieldMappings[$lastPropertyName]['type'], 'boolean');
235			}
236
237			public function testHasMetadata()
238			{
239			$metaDataFactory = $this->getMock('Doctrine\Common\Persistence\Mapping\ClassMetadataFactory');
240			$metaDataFactory
241			->expects($this->any())
242			->method('hasMetadataFor')
243			->willReturnMap([
244			['myEntity', true],
245			['mySecondEntity', true],
246			['objectWithNoMetadata', false]
247			])
248			;
249
250			$entityManager = $this->getMockBuilder('Doctrine\ORM\EntityManager')
251			->disableOriginalConstructor()
252			->getMock();
253			$entityManager
254			->expects($this->any())
255			->method('getMetadataFactory')
256			->willReturn($metaDataFactory);
257
258			$registry = $this->getMock('Symfony\Bridge\Doctrine\RegistryInterface');
259			$registry->expects($this->any())
260			->method('getManagerForClass')
261			->willReturnMap([
262			['stdClass', null],
263			['myEntity', $entityManager],
264			['mySecondEntity', $entityManager],
265			['objectWithNoMetadata', $entityManager]
266			])
267			;
268
269			$manager = new ModelManager($registry);
270
271			$this->assertFalse($manager->hasMetadata('stdClass'));
272			$this->assertTrue($manager->hasMetadata('myEntity'));
273			$this->assertTrue($manager->hasMetadata('mySecondEntity'));
274			$this->assertFalse($manager->hasMetadata('objectWithNoMetadata'));
275			}
276
277			public function getMetadataForEmbeddedEntity()
278			{
279			$metadata = new ClassMetadata('Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\Embeddable\EmbeddedEntity');
280
281			$metadata->fieldMappings = array(
282			'plainField' => array(
283			'fieldName' => 'plainField',
284			'columnName' => 'plainField',
285			'type' => 'boolean',
286			),
287			);
288
289			return $metadata;
290			}
291
292			public function getMetadataForAssociatedEntity()
293			{
294			$metadata = new ClassMetadata('Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\AssociatedEntity');
295
296			$metadata->fieldMappings = array(
297			'plainField' => array(
298			'fieldName' => 'plainField',
299			'columnName' => 'plainField',
300			'type' => 'string',
301			),
302			);
303
304			return $metadata;
305			}
306
307			public function getMetadataForContainerEntity()
308			{
309			$containerEntityClass = 'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\ContainerEntity';
310			$associatedEntityClass = 'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\AssociatedEntity';
311			$embeddedEntityClass = 'Sonata\DoctrineORMAdminBundle\Tests\Fixtures\Entity\Embeddable\EmbeddedEntity';
312
313			$metadata = new ClassMetadata($containerEntityClass);
314
315			$metadata->fieldMappings = array(
316			'plainField' => array(
317			'fieldName' => 'plainField',
318			'columnName' => 'plainField',
319			'type' => 'integer',
320			),
321			);
322
323			$metadata->associationMappings['associatedEntity'] = array(
324			'fieldName' => 'associatedEntity',
325			'targetEntity' => $associatedEntityClass,
326			'sourceEntity' => $containerEntityClass,
327			);
328
329			$metadata->embeddedClasses['embeddedEntity'] = array(
330			'class' => $embeddedEntityClass,
331			'columnPrefix' => 'embeddedEntity',
332			);
333
334			$metadata->inlineEmbeddable('embeddedEntity', $this->getMetadataForEmbeddedEntity());
335
336			return $metadata;
337			}
338			}
339

sonata-project / SonataDoctrineORMAdminBundle

Pull Request — master (#524)

ModelManagerTest::getMetadata() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like