XmlMappingDriverTest::testIdentifierWithAssociationKey() - Code Metrics - Inspection of "Embeddable attribute override support" - doctrine/orm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#6151)

by Andy

created 2016-11-27 02:14 UTC

testIdentifierWithAssociationKey() A

↳ Parent: XmlMappingDriverTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	17
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	17
c	0
b	0
f	0
rs	9.4285
cc	1
eloc	11
nc	1
nop	0

<?php

namespace Doctrine\Tests\ORM\Mapping;

use Doctrine\Common\Persistence\Mapping\RuntimeReflectionService;
use Doctrine\ORM\Mapping\ClassMetadata;
use Doctrine\ORM\Mapping\ClassMetadataFactory;
use Doctrine\ORM\Mapping\Driver\XmlDriver;

class XmlMappingDriverTest extends AbstractMappingDriverTest
{
    protected function _loadDriver()
    {
        return new XmlDriver(__DIR__ . DIRECTORY_SEPARATOR . 'xml');
    }

    public function testClassTableInheritanceDiscriminatorMap()
    {
        $className = 'Doctrine\Tests\ORM\Mapping\CTI';
        $mappingDriver = $this->_loadDriver();

        $class = new ClassMetadata($className);
        $class->initializeReflection(new RuntimeReflectionService());
        $mappingDriver->loadMetadataForClass($className, $class);

        $expectedMap = array(
            'foo' => 'Doctrine\Tests\ORM\Mapping\CTIFoo',
            'bar' => 'Doctrine\Tests\ORM\Mapping\CTIBar',
            'baz' => 'Doctrine\Tests\ORM\Mapping\CTIBaz',
        );

        $this->assertEquals(3, count($class->discriminatorMap));
        $this->assertEquals($expectedMap, $class->discriminatorMap);
    }

    /**
     * @expectedException \Doctrine\ORM\Cache\CacheException
     * @expectedExceptionMessage Entity association field "Doctrine\Tests\ORM\Mapping\XMLSLC#foo" not configured as part of the second-level cache.
     */
    public function testFailingSecondLevelCacheAssociation()
    {
        $className = 'Doctrine\Tests\ORM\Mapping\XMLSLC';
        $mappingDriver = $this->_loadDriver();

        $class = new ClassMetadata($className);
        $mappingDriver->loadMetadataForClass($className, $class);
    }

    public function testIdentifierWithAssociationKey()
    {
        $driver  = $this->_loadDriver();
        $em      = $this->_getTestEntityManager();
        $factory = new ClassMetadataFactory();

        $em->getConfiguration()->setMetadataDriverImpl($driver);
        $factory->setEntityManager($em);

        $class = $factory->getMetadataFor('Doctrine\Tests\Models\DDC117\DDC117Translation');

        $this->assertEquals(array('language', 'article'), $class->identifier);
        $this->assertArrayHasKey('article', $class->associationMappings);

        $this->assertArrayHasKey('id', $class->associationMappings['article']);
        $this->assertTrue($class->associationMappings['article']['id']);
    }

    public function testEmbeddableMapping()
    {
        $class = $this->createClassMetadata('Doctrine\Tests\Models\ValueObjects\Name');

        $this->assertEquals(true, $class->isEmbeddedClass);
    }

    /**
     * @group DDC-3293
     * @group DDC-3477
     * @group 1238
     */
    public function testEmbeddedMappingsWithUseColumnPrefix()
    {
        $factory = new ClassMetadataFactory();
        $em      = $this->_getTestEntityManager();

        $em->getConfiguration()->setMetadataDriverImpl($this->_loadDriver());
        $factory->setEntityManager($em);

        $this->assertEquals(
            '__prefix__',
            $factory
                ->getMetadataFor('Doctrine\Tests\Models\DDC3293\DDC3293UserPrefixed')
                ->embeddedClasses['address']['columnPrefix']
        );
    }

    /**
     * @group DDC-3293
     * @group DDC-3477
     * @group 1238
     */
    public function testEmbeddedMappingsWithFalseUseColumnPrefix()
    {
        $factory = new ClassMetadataFactory();
        $em      = $this->_getTestEntityManager();

        $em->getConfiguration()->setMetadataDriverImpl($this->_loadDriver());
        $factory->setEntityManager($em);

        $this->assertFalse(
            $factory
                ->getMetadataFor('Doctrine\Tests\Models\DDC3293\DDC3293User')
                ->embeddedClasses['address']['columnPrefix']
        );
    }

    public function testEmbeddedMapping()
    {
        $class = $this->createClassMetadata('Doctrine\Tests\Models\ValueObjects\Person');

        $this->assertEquals(
            array(
                'name' => array(
                    'class' => 'Doctrine\Tests\Models\ValueObjects\Name',
                    'columnPrefix' => 'nm_',
                    'declaredField' => null,
                    'originalField' => null,
                    'attributeOverrides' => null,
                )
            ),
            $class->embeddedClasses
        );
    }

    /**
     * @group DDC-1468
     *
     * @expectedException \Doctrine\Common\Persistence\Mapping\MappingException
     * @expectedExceptionMessage Invalid mapping file 'Doctrine.Tests.Models.Generic.SerializationModel.dcm.xml' for class 'Doctrine\Tests\Models\Generic\SerializationModel'.
     */
    public function testInvalidMappingFileException()
    {
        $this->createClassMetadata('Doctrine\Tests\Models\Generic\SerializationModel');
    }

    /**
     * @param string $xmlMappingFile
     * @dataProvider dataValidSchema
     * @group DDC-2429
     */
    public function testValidateXmlSchema($xmlMappingFile)
    {
        $xsdSchemaFile  = __DIR__ . '/../../../../../doctrine-mapping.xsd';
        $dom            = new \DOMDocument('UTF-8');

        $dom->load($xmlMappingFile);

        $this->assertTrue($dom->schemaValidate($xsdSchemaFile));
    }

    static public function dataValidSchema()
    {
        $list    = glob(__DIR__ . '/xml/*.xml');
        $invalid = array(
            'Doctrine.Tests.Models.DDC889.DDC889Class.dcm'
        );

        $list = array_filter($list, function($item) use ($invalid){
            return ! in_array(pathinfo($item, PATHINFO_FILENAME), $invalid);
        });

        return array_map(function($item){
            return array($item);
        }, $list);
    }

    /**
     * @group DDC-889
     * @expectedException \Doctrine\Common\Persistence\Mapping\MappingException
     * @expectedExceptionMessage Invalid mapping file 'Doctrine.Tests.Models.DDC889.DDC889Class.dcm.xml' for class 'Doctrine\Tests\Models\DDC889\DDC889Class'.
     */
    public function testinvalidEntityOrMappedSuperClassShouldMentionParentClasses()
    {
        $this->createClassMetadata('Doctrine\Tests\Models\DDC889\DDC889Class');
    }

    public function testEmbeddableAttributeOverride()
    {
        $metadata = $this->createClassMetadata('Doctrine\Tests\Models\Overrides\EntityWithEmbeddableOverriddenAttribute');

        $this->assertArrayHasKey('valueObject', $metadata->embeddedClasses);
        $this->assertArrayHasKey('attributeOverrides', $metadata->embeddedClasses['valueObject']);
        $this->assertNotNull($metadata->embeddedClasses['valueObject']['attributeOverrides']);
        $this->assertArrayHasKey('value', $metadata->embeddedClasses['valueObject']['attributeOverrides']);
        $this->assertEquals($metadata->embeddedClasses['valueObject']['attributeOverrides']['value']['columnName'], 'value_override');
    }

    public function testEmbeddableAttributeRemoval()
    {
        $metadata = $this->createClassMetadata('Doctrine\Tests\Models\Overrides\EntityWithEmbeddableRemovedAttribute');

        $this->assertArrayHasKey('valueObject', $metadata->embeddedClasses);
        $this->assertArrayHasKey('attributeOverrides', $metadata->embeddedClasses['valueObject']);
        $this->assertNotNull($metadata->embeddedClasses['valueObject']['attributeOverrides']);
        $this->assertArrayHasKey('value', $metadata->embeddedClasses['valueObject']['attributeOverrides']);
        $this->assertNull($metadata->embeddedClasses['valueObject']['attributeOverrides']['value']);
    }

    public function testEmbeddableAttributeOverrides()
    {
        $metadata = $this->createClassMetadata('Doctrine\Tests\Models\Overrides\EntityWithEmbeddableOverriddenAndRemovedAttributes');

        $this->assertArrayHasKey('valueObject', $metadata->embeddedClasses);
        $this->assertArrayHasKey('attributeOverrides', $metadata->embeddedClasses['valueObject']);
        $this->assertNotNull($metadata->embeddedClasses['valueObject']['attributeOverrides']);
        $this->assertArrayHasKey('value', $metadata->embeddedClasses['valueObject']['attributeOverrides']);
        $this->assertTrue(is_array($metadata->embeddedClasses['valueObject']['attributeOverrides']['value']));
        $this->assertEquals($metadata->embeddedClasses['valueObject']['attributeOverrides']['value']['columnName'], 'value_override');
        $this->assertArrayHasKey('count', $metadata->embeddedClasses['valueObject']['attributeOverrides']);
        $this->assertNull($metadata->embeddedClasses['valueObject']['attributeOverrides']['count']);
    }

    public function testNestedEmbeddableAttributeOverrides()
    {
        $metadata = $this->createClassMetadata('Doctrine\Tests\Models\Overrides\EntityWithNestedEmbeddableOverriddenAndRemovedAttributes');

        $this->assertArrayHasKey('nestedValueObject', $metadata->embeddedClasses);
        $this->assertArrayHasKey('attributeOverrides', $metadata->embeddedClasses['nestedValueObject']);
        $this->assertNotNull($metadata->embeddedClasses['nestedValueObject']['attributeOverrides']);
        $this->assertArrayHasKey('nested.value', $metadata->embeddedClasses['nestedValueObject']['attributeOverrides']);
        $this->assertTrue(is_array($metadata->embeddedClasses['nestedValueObject']['attributeOverrides']['nested.value']));
        $this->assertEquals($metadata->embeddedClasses['nestedValueObject']['attributeOverrides']['nested.value']['columnName'], 'value_override');
        $this->assertArrayHasKey('nested.count', $metadata->embeddedClasses['nestedValueObject']['attributeOverrides']);
        $this->assertNull($metadata->embeddedClasses['nestedValueObject']['attributeOverrides']['nested.count']);
    }
}

class CTI
{
    public $id;
}

class CTIFoo extends CTI {}
class CTIBar extends CTI {}
class CTIBaz extends CTI {}

class XMLSLC
{
    public $foo;
}
class XMLSLCFoo
{
    public $id;
}


1			<?php
2
3			namespace Doctrine\Tests\ORM\Mapping;
4
5			use Doctrine\Common\Persistence\Mapping\RuntimeReflectionService;
6			use Doctrine\ORM\Mapping\ClassMetadata;
7			use Doctrine\ORM\Mapping\ClassMetadataFactory;
8			use Doctrine\ORM\Mapping\Driver\XmlDriver;
9
10			class XmlMappingDriverTest extends AbstractMappingDriverTest
11			{
12			protected function _loadDriver()
13			{
14			return new XmlDriver(__DIR__ . DIRECTORY_SEPARATOR . 'xml');
15			}
16
17			public function testClassTableInheritanceDiscriminatorMap()
18			{
19			$className = 'Doctrine\Tests\ORM\Mapping\CTI';
20			$mappingDriver = $this->_loadDriver();
21
22			$class = new ClassMetadata($className);
23			$class->initializeReflection(new RuntimeReflectionService());
24			$mappingDriver->loadMetadataForClass($className, $class);
25
26			$expectedMap = array(
27			'foo' => 'Doctrine\Tests\ORM\Mapping\CTIFoo',
28			'bar' => 'Doctrine\Tests\ORM\Mapping\CTIBar',
29			'baz' => 'Doctrine\Tests\ORM\Mapping\CTIBaz',
30			);
31
32			$this->assertEquals(3, count($class->discriminatorMap));
33			$this->assertEquals($expectedMap, $class->discriminatorMap);
34			}
35
36			/**
37			* @expectedException \Doctrine\ORM\Cache\CacheException
38			* @expectedExceptionMessage Entity association field "Doctrine\Tests\ORM\Mapping\XMLSLC#foo" not configured as part of the second-level cache.
39			*/
40			public function testFailingSecondLevelCacheAssociation()
41			{
42			$className = 'Doctrine\Tests\ORM\Mapping\XMLSLC';
43			$mappingDriver = $this->_loadDriver();
44
45			$class = new ClassMetadata($className);
46			$mappingDriver->loadMetadataForClass($className, $class);
47			}
48
49			public function testIdentifierWithAssociationKey()
50			{
51			$driver = $this->_loadDriver();
52			$em = $this->_getTestEntityManager();
53			$factory = new ClassMetadataFactory();
54
55			$em->getConfiguration()->setMetadataDriverImpl($driver);
56			$factory->setEntityManager($em);
57
58			$class = $factory->getMetadataFor('Doctrine\Tests\Models\DDC117\DDC117Translation');
59
60			$this->assertEquals(array('language', 'article'), $class->identifier);
61			$this->assertArrayHasKey('article', $class->associationMappings);
62
63			$this->assertArrayHasKey('id', $class->associationMappings['article']);
64			$this->assertTrue($class->associationMappings['article']['id']);
65			}
66
67			public function testEmbeddableMapping()
68			{
69			$class = $this->createClassMetadata('Doctrine\Tests\Models\ValueObjects\Name');
70
71			$this->assertEquals(true, $class->isEmbeddedClass);
72			}
73
74			/**
75			* @group DDC-3293
76			* @group DDC-3477
77			* @group 1238
78			*/
79			public function testEmbeddedMappingsWithUseColumnPrefix()
80			{
81			$factory = new ClassMetadataFactory();
82			$em = $this->_getTestEntityManager();
83
84			$em->getConfiguration()->setMetadataDriverImpl($this->_loadDriver());
85			$factory->setEntityManager($em);
86
87			$this->assertEquals(
88			'__prefix__',
89			$factory
90			->getMetadataFor('Doctrine\Tests\Models\DDC3293\DDC3293UserPrefixed')
91			->embeddedClasses['address']['columnPrefix']
92			);
93			}
94
95			/**
96			* @group DDC-3293
97			* @group DDC-3477
98			* @group 1238
99			*/
100			public function testEmbeddedMappingsWithFalseUseColumnPrefix()
101			{
102			$factory = new ClassMetadataFactory();
103			$em = $this->_getTestEntityManager();
104
105			$em->getConfiguration()->setMetadataDriverImpl($this->_loadDriver());
106			$factory->setEntityManager($em);
107
108			$this->assertFalse(
109			$factory
110			->getMetadataFor('Doctrine\Tests\Models\DDC3293\DDC3293User')
111			->embeddedClasses['address']['columnPrefix']
112			);
113			}
114
115			public function testEmbeddedMapping()
116			{
117			$class = $this->createClassMetadata('Doctrine\Tests\Models\ValueObjects\Person');
118
119			$this->assertEquals(
120			array(
121			'name' => array(
122			'class' => 'Doctrine\Tests\Models\ValueObjects\Name',
123			'columnPrefix' => 'nm_',
124			'declaredField' => null,
125			'originalField' => null,
126			'attributeOverrides' => null,
127			)
128			),
129			$class->embeddedClasses
130			);
131			}
132
133			/**
134			* @group DDC-1468
135			*
136			* @expectedException \Doctrine\Common\Persistence\Mapping\MappingException
137			* @expectedExceptionMessage Invalid mapping file 'Doctrine.Tests.Models.Generic.SerializationModel.dcm.xml' for class 'Doctrine\Tests\Models\Generic\SerializationModel'.
138			*/
139			public function testInvalidMappingFileException()
140			{
141			$this->createClassMetadata('Doctrine\Tests\Models\Generic\SerializationModel');
142			}
143
144			/**
145			* @param string $xmlMappingFile
146			* @dataProvider dataValidSchema
147			* @group DDC-2429
148			*/
149			public function testValidateXmlSchema($xmlMappingFile)
150			{
151			$xsdSchemaFile = __DIR__ . '/../../../../../doctrine-mapping.xsd';
152			$dom = new \DOMDocument('UTF-8');
153
154			$dom->load($xmlMappingFile);
155
156			$this->assertTrue($dom->schemaValidate($xsdSchemaFile));
157			}
158
159			static public function dataValidSchema()
160			{
161			$list = glob(__DIR__ . '/xml/*.xml');
162			$invalid = array(
163			'Doctrine.Tests.Models.DDC889.DDC889Class.dcm'
164			);
165
166			$list = array_filter($list, function($item) use ($invalid){
167			return ! in_array(pathinfo($item, PATHINFO_FILENAME), $invalid);
168			});
169
170			return array_map(function($item){
171			return array($item);
172			}, $list);
173			}
174
175			/**
176			* @group DDC-889
177			* @expectedException \Doctrine\Common\Persistence\Mapping\MappingException
178			* @expectedExceptionMessage Invalid mapping file 'Doctrine.Tests.Models.DDC889.DDC889Class.dcm.xml' for class 'Doctrine\Tests\Models\DDC889\DDC889Class'.
179			*/
180			public function testinvalidEntityOrMappedSuperClassShouldMentionParentClasses()
181			{
182			$this->createClassMetadata('Doctrine\Tests\Models\DDC889\DDC889Class');
183			}
184
185			public function testEmbeddableAttributeOverride()
186			{
187			$metadata = $this->createClassMetadata('Doctrine\Tests\Models\Overrides\EntityWithEmbeddableOverriddenAttribute');
188
189			$this->assertArrayHasKey('valueObject', $metadata->embeddedClasses);
190			$this->assertArrayHasKey('attributeOverrides', $metadata->embeddedClasses['valueObject']);
191			$this->assertNotNull($metadata->embeddedClasses['valueObject']['attributeOverrides']);
192			$this->assertArrayHasKey('value', $metadata->embeddedClasses['valueObject']['attributeOverrides']);
193			$this->assertEquals($metadata->embeddedClasses['valueObject']['attributeOverrides']['value']['columnName'], 'value_override');
194			}
195
196			public function testEmbeddableAttributeRemoval()
197			{
198			$metadata = $this->createClassMetadata('Doctrine\Tests\Models\Overrides\EntityWithEmbeddableRemovedAttribute');
199
200			$this->assertArrayHasKey('valueObject', $metadata->embeddedClasses);
201			$this->assertArrayHasKey('attributeOverrides', $metadata->embeddedClasses['valueObject']);
202			$this->assertNotNull($metadata->embeddedClasses['valueObject']['attributeOverrides']);
203			$this->assertArrayHasKey('value', $metadata->embeddedClasses['valueObject']['attributeOverrides']);
204			$this->assertNull($metadata->embeddedClasses['valueObject']['attributeOverrides']['value']);
205			}
206
207			public function testEmbeddableAttributeOverrides()
208			{
209			$metadata = $this->createClassMetadata('Doctrine\Tests\Models\Overrides\EntityWithEmbeddableOverriddenAndRemovedAttributes');
210
211			$this->assertArrayHasKey('valueObject', $metadata->embeddedClasses);
212			$this->assertArrayHasKey('attributeOverrides', $metadata->embeddedClasses['valueObject']);
213			$this->assertNotNull($metadata->embeddedClasses['valueObject']['attributeOverrides']);
214			$this->assertArrayHasKey('value', $metadata->embeddedClasses['valueObject']['attributeOverrides']);
215			$this->assertTrue(is_array($metadata->embeddedClasses['valueObject']['attributeOverrides']['value']));
216			$this->assertEquals($metadata->embeddedClasses['valueObject']['attributeOverrides']['value']['columnName'], 'value_override');
217			$this->assertArrayHasKey('count', $metadata->embeddedClasses['valueObject']['attributeOverrides']);
218			$this->assertNull($metadata->embeddedClasses['valueObject']['attributeOverrides']['count']);
219			}
220
221			public function testNestedEmbeddableAttributeOverrides()
222			{
223			$metadata = $this->createClassMetadata('Doctrine\Tests\Models\Overrides\EntityWithNestedEmbeddableOverriddenAndRemovedAttributes');
224
225			$this->assertArrayHasKey('nestedValueObject', $metadata->embeddedClasses);
226			$this->assertArrayHasKey('attributeOverrides', $metadata->embeddedClasses['nestedValueObject']);
227			$this->assertNotNull($metadata->embeddedClasses['nestedValueObject']['attributeOverrides']);
228			$this->assertArrayHasKey('nested.value', $metadata->embeddedClasses['nestedValueObject']['attributeOverrides']);
229			$this->assertTrue(is_array($metadata->embeddedClasses['nestedValueObject']['attributeOverrides']['nested.value']));
230			$this->assertEquals($metadata->embeddedClasses['nestedValueObject']['attributeOverrides']['nested.value']['columnName'], 'value_override');
231			$this->assertArrayHasKey('nested.count', $metadata->embeddedClasses['nestedValueObject']['attributeOverrides']);
232			$this->assertNull($metadata->embeddedClasses['nestedValueObject']['attributeOverrides']['nested.count']);
233			}
234			}
235
236			class CTI
237			{
238			public $id;
239			}
240
241			class CTIFoo extends CTI {}
242			class CTIBar extends CTI {}
243			class CTIBaz extends CTI {}
244
245			class XMLSLC
246			{
247			public $foo;
248			}
249			class XMLSLCFoo
250			{
251			public $id;
252			}
253

doctrine / orm

Pull Request — master (#6151)

testIdentifierWithAssociationKey() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like