XmlMappingDriverTest::_loadDriver() - Code Metrics - Inspection of "[XML] Fix default value of many-to-many order-by t..." - doctrine/orm - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — 2.6 (#7317)

by Alex

created 2018-07-19 09:41 UTC

XmlMappingDriverTest::_loadDriver() A

↳ Parent: XmlMappingDriverTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
rs	10
c	0
b	0
f	0

<?php

namespace Doctrine\Tests\ORM\Mapping;

use Doctrine\Common\Collections\Criteria;
use Doctrine\Common\Persistence\Mapping\RuntimeReflectionService;
use Doctrine\ORM\Mapping\ClassMetadata;
use Doctrine\ORM\Mapping\ClassMetadataFactory;
use Doctrine\ORM\Mapping\Driver\XmlDriver;
use Doctrine\Tests\Models\DDC117\DDC117Translation;
use Doctrine\Tests\Models\DDC3293\DDC3293User;
use Doctrine\Tests\Models\DDC3293\DDC3293UserPrefixed;
use Doctrine\Tests\Models\DDC889\DDC889Class;
use Doctrine\Tests\Models\Generic\SerializationModel;
use Doctrine\Tests\Models\GH7141\GH7141Article;
use Doctrine\Tests\Models\GH7316\GH7316Article;
use Doctrine\Tests\Models\ValueObjects\Name;
use Doctrine\Tests\Models\ValueObjects\Person;

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

    public function testClassTableInheritanceDiscriminatorMap()
    {
        $mappingDriver = $this->_loadDriver();

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

        $expectedMap = [
            'foo' => CTIFoo::class,
            'bar' => CTIBar::class,
            'baz' => CTIBaz::class,
        ];

        $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()
    {
        $mappingDriver = $this->_loadDriver();

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

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

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

        $class = $factory->getMetadataFor(DDC117Translation::class);

        $this->assertEquals(['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(Name::class);

        $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(DDC3293UserPrefixed::class)
                ->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(DDC3293User::class)
                ->embeddedClasses['address']['columnPrefix']

        );
    }

    public function testEmbeddedMapping()
    {
        $class = $this->createClassMetadata(Person::class);

        $this->assertEquals(
            [
                'name' => [
                    'class' => Name::class,
                    'columnPrefix' => 'nm_',
                    'declaredField' => null,
                    'originalField' => 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(SerializationModel::class);
    }

    /**
     * @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 = [
            '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 [$item];
        }, $list);
    }

    /**
     * @group GH-7141
     */
    public function testOneToManyDefaultOrderByAsc()
    {
        $driver = $this->_loadDriver();
        $class  = new ClassMetadata(GH7141Article::class);

        $class->initializeReflection(new RuntimeReflectionService());
        $driver->loadMetadataForClass(GH7141Article::class, $class);


        $this->assertEquals(
            Criteria::ASC,
            $class->getMetadataValue('associationMappings')['tags']['orderBy']['position']
        );
    }

    public function testManyToManyDefaultOrderByAsc()
    {
        $driver = $this->_loadDriver();
        $class  = new ClassMetadata(GH7316Article::class);

        $class->initializeReflection(new RuntimeReflectionService());
        $driver->loadMetadataForClass(GH7316Article::class, $class);


        $this->assertEquals(
            Criteria::ASC,
            $class->getMetadataValue('associationMappings')['tags']['orderBy']['position']
        );
    }

    /**
     * @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(DDC889Class::class);
    }
}

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\Collections\Criteria;
6			use Doctrine\Common\Persistence\Mapping\RuntimeReflectionService;
7			use Doctrine\ORM\Mapping\ClassMetadata;
8			use Doctrine\ORM\Mapping\ClassMetadataFactory;
9			use Doctrine\ORM\Mapping\Driver\XmlDriver;
10			use Doctrine\Tests\Models\DDC117\DDC117Translation;
11			use Doctrine\Tests\Models\DDC3293\DDC3293User;
12			use Doctrine\Tests\Models\DDC3293\DDC3293UserPrefixed;
13			use Doctrine\Tests\Models\DDC889\DDC889Class;
14			use Doctrine\Tests\Models\Generic\SerializationModel;
15			use Doctrine\Tests\Models\GH7141\GH7141Article;
16			use Doctrine\Tests\Models\GH7316\GH7316Article;
17			use Doctrine\Tests\Models\ValueObjects\Name;
18			use Doctrine\Tests\Models\ValueObjects\Person;
19
20			class XmlMappingDriverTest extends AbstractMappingDriverTest
21			{
22			protected function _loadDriver()
23			{
24			return new XmlDriver(__DIR__ . DIRECTORY_SEPARATOR . 'xml');
25			}
26
27			public function testClassTableInheritanceDiscriminatorMap()
28			{
29			$mappingDriver = $this->_loadDriver();
30
31			$class = new ClassMetadata(CTI::class);
32			$class->initializeReflection(new RuntimeReflectionService());
33			$mappingDriver->loadMetadataForClass(CTI::class, $class);
34
35			$expectedMap = [
36			'foo' => CTIFoo::class,
37			'bar' => CTIBar::class,
38			'baz' => CTIBaz::class,
39			];
40
41			$this->assertEquals(3, count($class->discriminatorMap));
42			$this->assertEquals($expectedMap, $class->discriminatorMap);
43			}
44
45			/**
46			* @expectedException \Doctrine\ORM\Cache\CacheException
47			* @expectedExceptionMessage Entity association field "Doctrine\Tests\ORM\Mapping\XMLSLC#foo" not configured as part of the second-level cache.
48			*/
49			public function testFailingSecondLevelCacheAssociation()
50			{
51			$mappingDriver = $this->_loadDriver();
52
53			$class = new ClassMetadata(XMLSLC::class);
54			$mappingDriver->loadMetadataForClass(XMLSLC::class, $class);
55			}
56
57			public function testIdentifierWithAssociationKey()
58			{
59			$driver = $this->_loadDriver();
60			$em = $this->_getTestEntityManager();
61			$factory = new ClassMetadataFactory();
62
63			$em->getConfiguration()->setMetadataDriverImpl($driver);
64			$factory->setEntityManager($em);
65
66			$class = $factory->getMetadataFor(DDC117Translation::class);
67
68			$this->assertEquals(['language', 'article'], $class->identifier);
			0 ignored issues – show Bug introduced 2017-11-23 09:45 UTC by Report Bug Copy Issue Report Accessing `identifier` on the interface `Doctrine\Common\Persistence\Mapping\ClassMetadata` suggest that you code against a concrete implementation. How about adding an `instanceof` check? Loading history...
69			$this->assertArrayHasKey('article', $class->associationMappings);
			0 ignored issues – show Bug introduced 2017-11-23 09:45 UTC by Report Bug Copy Issue Report Accessing `associationMappings` on the interface `Doctrine\Common\Persistence\Mapping\ClassMetadata` suggest that you code against a concrete implementation. How about adding an `instanceof` check? Loading history...
70
71			$this->assertArrayHasKey('id', $class->associationMappings['article']);
72			$this->assertTrue($class->associationMappings['article']['id']);
73			}
74
75			public function testEmbeddableMapping()
76			{
77			$class = $this->createClassMetadata(Name::class);
78
79			$this->assertEquals(true, $class->isEmbeddedClass);
80			}
81
82			/**
83			* @group DDC-3293
84			* @group DDC-3477
85			* @group 1238
86			*/
87			public function testEmbeddedMappingsWithUseColumnPrefix()
88			{
89			$factory = new ClassMetadataFactory();
90			$em = $this->_getTestEntityManager();
91
92			$em->getConfiguration()->setMetadataDriverImpl($this->_loadDriver());
93			$factory->setEntityManager($em);
94
95			$this->assertEquals(
96			'__prefix__',
97			$factory->getMetadataFor(DDC3293UserPrefixed::class)
98			->embeddedClasses['address']['columnPrefix']
			0 ignored issues – show Bug introduced 2017-11-23 09:45 UTC by Report Bug Copy Issue Report Accessing `embeddedClasses` on the interface `Doctrine\Common\Persistence\Mapping\ClassMetadata` suggest that you code against a concrete implementation. How about adding an `instanceof` check? Loading history...
99			);
100			}
101
102			/**
103			* @group DDC-3293
104			* @group DDC-3477
105			* @group 1238
106			*/
107			public function testEmbeddedMappingsWithFalseUseColumnPrefix()
108			{
109			$factory = new ClassMetadataFactory();
110			$em = $this->_getTestEntityManager();
111
112			$em->getConfiguration()->setMetadataDriverImpl($this->_loadDriver());
113			$factory->setEntityManager($em);
114
115			$this->assertFalse(
116			$factory->getMetadataFor(DDC3293User::class)
117			->embeddedClasses['address']['columnPrefix']
			0 ignored issues – show Bug introduced 2017-11-23 09:45 UTC by Report Bug Copy Issue Report Accessing `embeddedClasses` on the interface `Doctrine\Common\Persistence\Mapping\ClassMetadata` suggest that you code against a concrete implementation. How about adding an `instanceof` check? Loading history...
118			);
119			}
120
121			public function testEmbeddedMapping()
122			{
123			$class = $this->createClassMetadata(Person::class);
124
125			$this->assertEquals(
126			[
127			'name' => [
128			'class' => Name::class,
129			'columnPrefix' => 'nm_',
130			'declaredField' => null,
131			'originalField' => null,
132			]
133			],
134			$class->embeddedClasses
135			);
136			}
137
138			/**
139			* @group DDC-1468
140			*
141			* @expectedException \Doctrine\Common\Persistence\Mapping\MappingException
142			* @expectedExceptionMessage Invalid mapping file 'Doctrine.Tests.Models.Generic.SerializationModel.dcm.xml' for class 'Doctrine\Tests\Models\Generic\SerializationModel'.
143			*/
144			public function testInvalidMappingFileException()
145			{
146			$this->createClassMetadata(SerializationModel::class);
147			}
148
149			/**
150			* @param string $xmlMappingFile
151			* @dataProvider dataValidSchema
152			* @group DDC-2429
153			*/
154			public function testValidateXmlSchema($xmlMappingFile)
155			{
156			$xsdSchemaFile = __DIR__ . '/../../../../../doctrine-mapping.xsd';
157			$dom = new \DOMDocument('UTF-8');
158
159			$dom->load($xmlMappingFile);
160
161			$this->assertTrue($dom->schemaValidate($xsdSchemaFile));
162			}
163
164			static public function dataValidSchema()
			0 ignored issues – show Coding Style introduced 2017-06-20 08:13 UTC by Report Bug Copy Issue Report As per PSR2, the `static` declaration should come after the visibility declaration. Loading history...
165			{
166			$list = glob(__DIR__ . '/xml/*.xml');
167			$invalid = [
168			'Doctrine.Tests.Models.DDC889.DDC889Class.dcm'
169			];
170
171			$list = array_filter($list, function($item) use ($invalid){
172			return ! in_array(pathinfo($item, PATHINFO_FILENAME), $invalid);
173			});
174
175			return array_map(function($item){
176			return [$item];
177			}, $list);
178			}
179
180			/**
181			* @group GH-7141
182			*/
183			public function testOneToManyDefaultOrderByAsc()
184			{
185			$driver = $this->_loadDriver();
186			$class = new ClassMetadata(GH7141Article::class);
187
188			$class->initializeReflection(new RuntimeReflectionService());
189			$driver->loadMetadataForClass(GH7141Article::class, $class);
190
191
192			$this->assertEquals(
193			Criteria::ASC,
194			$class->getMetadataValue('associationMappings')['tags']['orderBy']['position']
195			);
196			}
197
198			public function testManyToManyDefaultOrderByAsc()
199			{
200			$driver = $this->_loadDriver();
201			$class = new ClassMetadata(GH7316Article::class);
202
203			$class->initializeReflection(new RuntimeReflectionService());
204			$driver->loadMetadataForClass(GH7316Article::class, $class);
205
206
207			$this->assertEquals(
208			Criteria::ASC,
209			$class->getMetadataValue('associationMappings')['tags']['orderBy']['position']
210			);
211			}
212
213			/**
214			* @group DDC-889
215			* @expectedException \Doctrine\Common\Persistence\Mapping\MappingException
216			* @expectedExceptionMessage Invalid mapping file 'Doctrine.Tests.Models.DDC889.DDC889Class.dcm.xml' for class 'Doctrine\Tests\Models\DDC889\DDC889Class'.
217			*/
218			public function testinvalidEntityOrMappedSuperClassShouldMentionParentClasses()
219			{
220			$this->createClassMetadata(DDC889Class::class);
221			}
222			}
223
224			class CTI
225			{
226			public $id;
227			}
228
229			class CTIFoo extends CTI {}
230			class CTIBar extends CTI {}
231			class CTIBaz extends CTI {}
232
233			class XMLSLC
234			{
235			public $foo;
236			}
237			class XMLSLCFoo
238			{
239			public $id;
240			}
241

doctrine / orm

Pull Request — 2.6 (#7317)

XmlMappingDriverTest::_loadDriver() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like