DriverChainTest::testDefaultDriverGetAllClassNames() - Code Metrics - Inspection of "Drop backwards-compatibility layer" - doctrine/persistence - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — 1.4.x (#106)

by Grégoire

created 2020-05-11 17:00 UTC

testDefaultDriverGetAllClassNames() A

↳ Parent: DriverChainTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	22
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	13
dl	0
loc	22
rs	9.8333
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

namespace Doctrine\Tests\Persistence\Mapping;

use Doctrine\Persistence\Mapping\ClassMetadata;
use Doctrine\Persistence\Mapping\Driver\MappingDriver;
use Doctrine\Persistence\Mapping\Driver\MappingDriverChain;
use Doctrine\Persistence\Mapping\MappingException;
use Doctrine\Tests\DoctrineTestCase;
use PHPUnit_Framework_MockObject_MockObject;

class DriverChainTest extends DoctrineTestCase
{
    public function testDelegateToMatchingNamespaceDriver()
    {
        $className = DriverChainEntity::class;
        /** @var ClassMetadata|PHPUnit_Framework_MockObject_MockObject $classMetadata */
        $classMetadata = $this->createMock(ClassMetadata::class);

        $chain = new MappingDriverChain();

        /** @var MappingDriver|PHPUnit_Framework_MockObject_MockObject $driver1 */
        $driver1 = $this->createMock(MappingDriver::class);
        $driver1->expects($this->never())
                ->method('loadMetadataForClass');
        $driver1->expectS($this->never())
                ->method('isTransient');

        /** @var MappingDriver|PHPUnit_Framework_MockObject_MockObject $driver2 */
        $driver2 = $this->createMock(MappingDriver::class);
        $driver2->expects($this->at(0))
                ->method('loadMetadataForClass')
                ->with($this->equalTo($className), $this->equalTo($classMetadata));
        $driver2->expects($this->at(1))
                ->method('isTransient')
                ->with($this->equalTo($className))
                ->will($this->returnValue(true));

        $chain->addDriver($driver1, 'Doctrine\Tests\Models\Company');
        $chain->addDriver($driver2, 'Doctrine\Tests\Common\Persistence\Mapping');

        $chain->loadMetadataForClass($className, $classMetadata);

        self::assertTrue($chain->isTransient($className));
    }

    public function testLoadMetadataShouldThrowMappingExceptionWhenNoDelegatorWasFound()
    {
        $className = DriverChainEntity::class;
        /** @var ClassMetadata|PHPUnit_Framework_MockObject_MockObject $classMetadata */
        $classMetadata = $this->createMock(ClassMetadata::class);

        $chain = new MappingDriverChain();

        $this->expectException(MappingException::class);
        $chain->loadMetadataForClass($className, $classMetadata);
    }

    public function testGatherAllClassNames()
    {
        $chain = new MappingDriverChain();

        /** @var MappingDriver|PHPUnit_Framework_MockObject_MockObject $driver1 */
        $driver1 = $this->createMock(MappingDriver::class);
        $driver1->expects($this->once())
                ->method('getAllClassNames')
                ->will($this->returnValue(['Doctrine\Tests\Models\Company\Foo']));

        /** @var MappingDriver|PHPUnit_Framework_MockObject_MockObject $driver2 */
        $driver2 = $this->createMock(MappingDriver::class);
        $driver2->expects($this->once())
                ->method('getAllClassNames')
                ->will($this->returnValue(['Doctrine\Tests\ORM\Mapping\Bar', 'Doctrine\Tests\ORM\Mapping\Baz', 'FooBarBaz']));

        $chain->addDriver($driver1, 'Doctrine\Tests\Models\Company');
        $chain->addDriver($driver2, 'Doctrine\Tests\ORM\Mapping');

        self::assertSame([
            'Doctrine\Tests\Models\Company\Foo',
            'Doctrine\Tests\ORM\Mapping\Bar',
            'Doctrine\Tests\ORM\Mapping\Baz',
        ], $chain->getAllClassNames());
    }

    /**
     * @group DDC-706
     */
    public function testIsTransient()
    {
        /** @var MappingDriver|PHPUnit_Framework_MockObject_MockObject $driver1 */
        $driver1 = $this->createMock(MappingDriver::class);
        $chain   = new MappingDriverChain();
        $chain->addDriver($driver1, 'Doctrine\Tests\Models\CMS');

        self::assertTrue($chain->isTransient('stdClass'), 'stdClass isTransient');
    }

    /**
     * @group DDC-1412
     */
    public function testDefaultDriver()
    {
        $companyDriver    = $this->createMock(MappingDriver::class);
        $defaultDriver    = $this->createMock(MappingDriver::class);
        $entityClassName  = 'Doctrine\Tests\ORM\Mapping\DriverChainEntity';
        $managerClassName = 'Doctrine\Tests\Models\Company\CompanyManager';
        $chain            = new MappingDriverChain();

        $companyDriver->expects($this->never())
            ->method('loadMetadataForClass');
        $companyDriver->expects($this->once())
            ->method('isTransient')
            ->with($this->equalTo($managerClassName))
            ->will($this->returnValue(false));

        $defaultDriver->expects($this->never())
            ->method('loadMetadataForClass');
        $defaultDriver->expects($this->once())
            ->method('isTransient')
            ->with($this->equalTo($entityClassName))
            ->will($this->returnValue(true));

        self::assertNull($chain->getDefaultDriver());

        $chain->setDefaultDriver($defaultDriver);
        $chain->addDriver($companyDriver, 'Doctrine\Tests\Models\Company');

        self::assertSame($defaultDriver, $chain->getDefaultDriver());

        self::assertTrue($chain->isTransient($entityClassName));
        self::assertFalse($chain->isTransient($managerClassName));
    }

    public function testDefaultDriverGetAllClassNames()
    {
        /** @var MappingDriver|PHPUnit_Framework_MockObject_MockObject $companyDriver */
        $companyDriver = $this->createMock(MappingDriver::class);
        /** @var MappingDriver|PHPUnit_Framework_MockObject_MockObject $defaultDriver */
        $defaultDriver = $this->createMock(MappingDriver::class);
        $chain         = new MappingDriverChain();

        $companyDriver->expects($this->once())
            ->method('getAllClassNames')
            ->will($this->returnValue(['Doctrine\Tests\Models\Company\Foo']));

        $defaultDriver->expects($this->once())
            ->method('getAllClassNames')
            ->will($this->returnValue(['Other\Class']));

        $chain->setDefaultDriver($defaultDriver);
        $chain->addDriver($companyDriver, 'Doctrine\Tests\Models\Company');

        $classNames = $chain->getAllClassNames();

        self::assertSame(['Doctrine\Tests\Models\Company\Foo', 'Other\Class'], $classNames);
    }
}

class DriverChainEntity
{
}


1			<?php
2
3			namespace Doctrine\Tests\Persistence\Mapping;
4
5			use Doctrine\Persistence\Mapping\ClassMetadata;
6			use Doctrine\Persistence\Mapping\Driver\MappingDriver;
7			use Doctrine\Persistence\Mapping\Driver\MappingDriverChain;
8			use Doctrine\Persistence\Mapping\MappingException;
9			use Doctrine\Tests\DoctrineTestCase;
10			use PHPUnit_Framework_MockObject_MockObject;
11
12			class DriverChainTest extends DoctrineTestCase
13			{
14			public function testDelegateToMatchingNamespaceDriver()
15			{
16			$className = DriverChainEntity::class;
17			/** @var ClassMetadata\|PHPUnit_Framework_MockObject_MockObject $classMetadata */
18			$classMetadata = $this->createMock(ClassMetadata::class);
19
20			$chain = new MappingDriverChain();
21
22			/** @var MappingDriver\|PHPUnit_Framework_MockObject_MockObject $driver1 */
23			$driver1 = $this->createMock(MappingDriver::class);
24			$driver1->expects($this->never())
25			->method('loadMetadataForClass');
26			$driver1->expectS($this->never())
27			->method('isTransient');
28
29			/** @var MappingDriver\|PHPUnit_Framework_MockObject_MockObject $driver2 */
30			$driver2 = $this->createMock(MappingDriver::class);
31			$driver2->expects($this->at(0))
32			->method('loadMetadataForClass')
33			->with($this->equalTo($className), $this->equalTo($classMetadata));
34			$driver2->expects($this->at(1))
35			->method('isTransient')
36			->with($this->equalTo($className))
37			->will($this->returnValue(true));
38
39			$chain->addDriver($driver1, 'Doctrine\Tests\Models\Company');
40			$chain->addDriver($driver2, 'Doctrine\Tests\Common\Persistence\Mapping');
41
42			$chain->loadMetadataForClass($className, $classMetadata);
43
44			self::assertTrue($chain->isTransient($className));
45			}
46
47			public function testLoadMetadataShouldThrowMappingExceptionWhenNoDelegatorWasFound()
48			{
49			$className = DriverChainEntity::class;
50			/** @var ClassMetadata\|PHPUnit_Framework_MockObject_MockObject $classMetadata */
51			$classMetadata = $this->createMock(ClassMetadata::class);
52
53			$chain = new MappingDriverChain();
54
55			$this->expectException(MappingException::class);
56			$chain->loadMetadataForClass($className, $classMetadata);
57			}
58
59			public function testGatherAllClassNames()
60			{
61			$chain = new MappingDriverChain();
62
63			/** @var MappingDriver\|PHPUnit_Framework_MockObject_MockObject $driver1 */
64			$driver1 = $this->createMock(MappingDriver::class);
65			$driver1->expects($this->once())
66			->method('getAllClassNames')
67			->will($this->returnValue(['Doctrine\Tests\Models\Company\Foo']));
68
69			/** @var MappingDriver\|PHPUnit_Framework_MockObject_MockObject $driver2 */
70			$driver2 = $this->createMock(MappingDriver::class);
71			$driver2->expects($this->once())
72			->method('getAllClassNames')
73			->will($this->returnValue(['Doctrine\Tests\ORM\Mapping\Bar', 'Doctrine\Tests\ORM\Mapping\Baz', 'FooBarBaz']));
74
75			$chain->addDriver($driver1, 'Doctrine\Tests\Models\Company');
76			$chain->addDriver($driver2, 'Doctrine\Tests\ORM\Mapping');
77
78			self::assertSame([
79			'Doctrine\Tests\Models\Company\Foo',
80			'Doctrine\Tests\ORM\Mapping\Bar',
81			'Doctrine\Tests\ORM\Mapping\Baz',
82			], $chain->getAllClassNames());
83			}
84
85			/**
86			* @group DDC-706
87			*/
88			public function testIsTransient()
89			{
90			/** @var MappingDriver\|PHPUnit_Framework_MockObject_MockObject $driver1 */
91			$driver1 = $this->createMock(MappingDriver::class);
92			$chain = new MappingDriverChain();
93			$chain->addDriver($driver1, 'Doctrine\Tests\Models\CMS');
94
95			self::assertTrue($chain->isTransient('stdClass'), 'stdClass isTransient');
96			}
97
98			/**
99			* @group DDC-1412
100			*/
101			public function testDefaultDriver()
102			{
103			$companyDriver = $this->createMock(MappingDriver::class);
104			$defaultDriver = $this->createMock(MappingDriver::class);
105			$entityClassName = 'Doctrine\Tests\ORM\Mapping\DriverChainEntity';
106			$managerClassName = 'Doctrine\Tests\Models\Company\CompanyManager';
107			$chain = new MappingDriverChain();
108
109			$companyDriver->expects($this->never())
110			->method('loadMetadataForClass');
111			$companyDriver->expects($this->once())
112			->method('isTransient')
113			->with($this->equalTo($managerClassName))
114			->will($this->returnValue(false));
115
116			$defaultDriver->expects($this->never())
117			->method('loadMetadataForClass');
118			$defaultDriver->expects($this->once())
119			->method('isTransient')
120			->with($this->equalTo($entityClassName))
121			->will($this->returnValue(true));
122
123			self::assertNull($chain->getDefaultDriver());
124
125			$chain->setDefaultDriver($defaultDriver);
126			$chain->addDriver($companyDriver, 'Doctrine\Tests\Models\Company');
127
128			self::assertSame($defaultDriver, $chain->getDefaultDriver());
129
130			self::assertTrue($chain->isTransient($entityClassName));
131			self::assertFalse($chain->isTransient($managerClassName));
132			}
133
134			public function testDefaultDriverGetAllClassNames()
135			{
136			/** @var MappingDriver\|PHPUnit_Framework_MockObject_MockObject $companyDriver */
137			$companyDriver = $this->createMock(MappingDriver::class);
138			/** @var MappingDriver\|PHPUnit_Framework_MockObject_MockObject $defaultDriver */
139			$defaultDriver = $this->createMock(MappingDriver::class);
140			$chain = new MappingDriverChain();
141
142			$companyDriver->expects($this->once())
143			->method('getAllClassNames')
144			->will($this->returnValue(['Doctrine\Tests\Models\Company\Foo']));
145
146			$defaultDriver->expects($this->once())
147			->method('getAllClassNames')
148			->will($this->returnValue(['Other\Class']));
149
150			$chain->setDefaultDriver($defaultDriver);
151			$chain->addDriver($companyDriver, 'Doctrine\Tests\Models\Company');
152
153			$classNames = $chain->getAllClassNames();
154
155			self::assertSame(['Doctrine\Tests\Models\Company\Foo', 'Other\Class'], $classNames);
156			}
157			}
158
159			class DriverChainEntity
160			{
161			}
162

doctrine / persistence

Pull Request — 1.4.x (#106)

testDefaultDriverGetAllClassNames() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like