ClassMetadataFactoryTest::testGetMetadataFor() - Code Metrics - Inspection of "Fix Metadata Caching when it changes in EventListe..." - doctrine/persistence - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#21)

unknown

created 2018-10-23 16:36 UTC

ClassMetadataFactoryTest::testGetMetadataFor() A

↳ Parent: ClassMetadataFactoryTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace Doctrine\Tests\Common\Persistence\Mapping;

use Doctrine\Common\Cache\ArrayCache;
use Doctrine\Common\Cache\Cache;
use Doctrine\Common\Persistence\Mapping\AbstractClassMetadataFactory;
use Doctrine\Common\Persistence\Mapping\ClassMetadata;
use Doctrine\Common\Persistence\Mapping\Driver\MappingDriver;
use Doctrine\Common\Persistence\Mapping\MappingException;
use Doctrine\Common\Persistence\Mapping\ReflectionService;
use Doctrine\Tests\DoctrineTestCase;
use PHPUnit_Framework_MockObject_MockObject;
use stdClass;

/**
 * @covers \Doctrine\Common\Persistence\Mapping\AbstractClassMetadataFactory
 */
class ClassMetadataFactoryTest extends DoctrineTestCase
{
    /** @var TestClassMetadataFactory */
    private $cmf;

    public function setUp()
    {
        $driver    = $this->createMock(MappingDriver::class);
        $metadata  = $this->createMock(ClassMetadata::class);
        $this->cmf = new TestClassMetadataFactory($driver, $metadata);
    }

    public function testGetCacheDriver()
    {
        self::assertNull($this->cmf->getCacheDriver());
        $cache = new ArrayCache();
        $this->cmf->setCacheDriver($cache);
        self::assertSame($cache, $this->cmf->getCacheDriver());
    }

    public function testGetMetadataFor()
    {
        $metadata = $this->cmf->getMetadataFor('stdClass');

        self::assertInstanceOf(ClassMetadata::class, $metadata);
        self::assertTrue($this->cmf->hasMetadataFor('stdClass'));
    }

    public function testGetMetadataForAbsentClass()
    {
        $this->expectException(MappingException::class);
        $this->cmf->getMetadataFor(__NAMESPACE__ . '\AbsentClass');
    }

    public function testGetParentMetadata()
    {
        $metadata = $this->cmf->getMetadataFor(ChildEntity::class);

        self::assertInstanceOf(ClassMetadata::class, $metadata);
        self::assertTrue($this->cmf->hasMetadataFor(ChildEntity::class));
        self::assertTrue($this->cmf->hasMetadataFor(RootEntity::class));
    }

    public function testGetCachedMetadata()
    {
        $metadata = $this->createMock(ClassMetadata::class);
        $cache    = new ArrayCache();
        $cache->save(ChildEntity::class . '$CLASSMETADATA', $metadata);

        $this->cmf->setCacheDriver($cache);

        self::assertSame($metadata, $this->cmf->getMetadataFor(ChildEntity::class));
    }

    public function testCacheGetMetadataFor()
    {
        $cache = new ArrayCache();
        $this->cmf->setCacheDriver($cache);

        $loadedMetadata = $this->cmf->getMetadataFor(ChildEntity::class);

        self::assertSame($loadedMetadata, $cache->fetch(ChildEntity::class . '$CLASSMETADATA'));
    }

    public function testGetAliasedMetadata()
    {
        $this->cmf->getMetadataFor('prefix:ChildEntity');

        self::assertTrue($this->cmf->hasMetadataFor(__NAMESPACE__ . '\ChildEntity'));
        self::assertTrue($this->cmf->hasMetadataFor('prefix:ChildEntity'));
    }

    /**
     * @group DCOM-270
     */
    public function testGetInvalidAliasedMetadata()
    {
        $this->expectException(MappingException::class);
        $this->expectExceptionMessage(
            'Class \'Doctrine\Tests\Common\Persistence\Mapping\ChildEntity:Foo\' does not exist'
        );

        $this->cmf->getMetadataFor('prefix:ChildEntity:Foo');
    }

    /**
     * @group DCOM-270
     */
    public function testClassIsTransient()
    {
        self::assertTrue($this->cmf->isTransient('prefix:ChildEntity:Foo'));
    }

    public function testWillFallbackOnNotLoadedMetadata()
    {
        $classMetadata = $this->createMock(ClassMetadata::class);

        $this->cmf->fallbackCallback = static function () use ($classMetadata) {
            return $classMetadata;
        };

        $this->cmf->metadata = null;

        self::assertSame($classMetadata, $this->cmf->getMetadataFor('Foo'));
    }

    public function testWillFailOnFallbackFailureWithNotLoadedMetadata()
    {
        $this->cmf->fallbackCallback = static function () {
            return null;
        };

        $this->cmf->metadata = null;

        $this->expectException(MappingException::class);

        $this->cmf->getMetadataFor('Foo');
    }

    /**
     * @group 717
     */
    public function testWillIgnoreCacheEntriesThatAreNotMetadataInstances()
    {
        /** @var Cache|PHPUnit_Framework_MockObject_MockObject $cacheDriver */
        $cacheDriver = $this->createMock(Cache::class);

        $this->cmf->setCacheDriver($cacheDriver);

        $cacheDriver->expects(self::once())->method('fetch')->with('Foo$CLASSMETADATA')->willReturn(new stdClass());

        /** @var ClassMetadata $metadata */
        $metadata = $this->createMock(ClassMetadata::class);

        /** @var PHPUnit_Framework_MockObject_MockObject|stdClass|callable $fallbackCallback */
        $fallbackCallback = $this->getMockBuilder(stdClass::class)->setMethods(['__invoke'])->getMock();

        $fallbackCallback->expects(self::any())->method('__invoke')->willReturn($metadata);

        $this->cmf->fallbackCallback = $fallbackCallback;

        self::assertSame($metadata, $this->cmf->getMetadataFor('Foo'));
    }

    public function testFallbackMetadataShouldBeCached()
    {
        /** @var Cache|PHPUnit_Framework_MockObject_MockObject $cacheDriver */
        $cacheDriver = $this->createMock(Cache::class);
        $cacheDriver->expects($this->once())->method('save');

        $this->cmf->setCacheDriver($cacheDriver);

        $classMetadata = $this->createMock(ClassMetadata::class);

        $this->cmf->fallbackCallback = static function () use ($classMetadata) {
            return $classMetadata;
        };

        $this->cmf->getMetadataFor('Foo');
    }

    public function testSetMetadataForShouldUpdateCache()
    {
        /** @var Cache|PHPUnit_Framework_MockObject_MockObject $cacheDriver */
        $cacheDriver = $this->createMock(Cache::class);
        $cacheDriver->expects($this->once())->method('save');

        $this->cmf->setCacheDriver($cacheDriver);

        $classMetadata = $this->createMock(ClassMetadata::class);
        $this->cmf->setMetadataFor('Foo', $classMetadata);
    }
}

class TestClassMetadataFactory extends AbstractClassMetadataFactory
{
    /** @var MappingDriver */
    public $driver;

    /** @var ClassMetadata|null */
    public $metadata;

    /** @var callable|null */
    public $fallbackCallback;

    public function __construct($driver, $metadata)
    {
        $this->driver   = $driver;
        $this->metadata = $metadata;
    }

    /**
     * @param string[] $nonSuperclassParents
     */
    protected function doLoadMetadata($class, $parent, $rootEntityFound, array $nonSuperclassParents)
    {
    }

    protected function getFqcnFromAlias($namespaceAlias, $simpleClassName)
    {
        return __NAMESPACE__ . '\\' . $simpleClassName;
    }

    protected function initialize()
    {
    }

    protected function newClassMetadataInstance($className)
    {
        return $this->metadata;
    }

    protected function getDriver()
    {
        return $this->driver;
    }
    protected function wakeupReflection(ClassMetadata $class, ReflectionService $reflService)
    {
    }

    protected function initializeReflection(ClassMetadata $class, ReflectionService $reflService)
    {
    }

    protected function isEntity(ClassMetadata $class)
    {
        return true;
    }

    protected function onNotFoundMetadata($className)
    {
        if (! $this->fallbackCallback) {
            return null;
        }

        return ($this->fallbackCallback)();
    }

    public function isTransient($class)
    {
        return true;
    }
}

class RootEntity
{
}

class ChildEntity extends RootEntity
{
}


1			<?php
2
3			namespace Doctrine\Tests\Common\Persistence\Mapping;
4
5			use Doctrine\Common\Cache\ArrayCache;
6			use Doctrine\Common\Cache\Cache;
7			use Doctrine\Common\Persistence\Mapping\AbstractClassMetadataFactory;
8			use Doctrine\Common\Persistence\Mapping\ClassMetadata;
9			use Doctrine\Common\Persistence\Mapping\Driver\MappingDriver;
10			use Doctrine\Common\Persistence\Mapping\MappingException;
11			use Doctrine\Common\Persistence\Mapping\ReflectionService;
12			use Doctrine\Tests\DoctrineTestCase;
13			use PHPUnit_Framework_MockObject_MockObject;
14			use stdClass;
15
16			/**
17			* @covers \Doctrine\Common\Persistence\Mapping\AbstractClassMetadataFactory
18			*/
19			class ClassMetadataFactoryTest extends DoctrineTestCase
20			{
21			/** @var TestClassMetadataFactory */
22			private $cmf;
23
24			public function setUp()
25			{
26			$driver = $this->createMock(MappingDriver::class);
27			$metadata = $this->createMock(ClassMetadata::class);
28			$this->cmf = new TestClassMetadataFactory($driver, $metadata);
29			}
30
31			public function testGetCacheDriver()
32			{
33			self::assertNull($this->cmf->getCacheDriver());
34			$cache = new ArrayCache();
35			$this->cmf->setCacheDriver($cache);
36			self::assertSame($cache, $this->cmf->getCacheDriver());
37			}
38
39			public function testGetMetadataFor()
40			{
41			$metadata = $this->cmf->getMetadataFor('stdClass');
42
43			self::assertInstanceOf(ClassMetadata::class, $metadata);
44			self::assertTrue($this->cmf->hasMetadataFor('stdClass'));
45			}
46
47			public function testGetMetadataForAbsentClass()
48			{
49			$this->expectException(MappingException::class);
50			$this->cmf->getMetadataFor(__NAMESPACE__ . '\AbsentClass');
51			}
52
53			public function testGetParentMetadata()
54			{
55			$metadata = $this->cmf->getMetadataFor(ChildEntity::class);
56
57			self::assertInstanceOf(ClassMetadata::class, $metadata);
58			self::assertTrue($this->cmf->hasMetadataFor(ChildEntity::class));
59			self::assertTrue($this->cmf->hasMetadataFor(RootEntity::class));
60			}
61
62			public function testGetCachedMetadata()
63			{
64			$metadata = $this->createMock(ClassMetadata::class);
65			$cache = new ArrayCache();
66			$cache->save(ChildEntity::class . '$CLASSMETADATA', $metadata);
67
68			$this->cmf->setCacheDriver($cache);
69
70			self::assertSame($metadata, $this->cmf->getMetadataFor(ChildEntity::class));
71			}
72
73			public function testCacheGetMetadataFor()
74			{
75			$cache = new ArrayCache();
76			$this->cmf->setCacheDriver($cache);
77
78			$loadedMetadata = $this->cmf->getMetadataFor(ChildEntity::class);
79
80			self::assertSame($loadedMetadata, $cache->fetch(ChildEntity::class . '$CLASSMETADATA'));
81			}
82
83			public function testGetAliasedMetadata()
84			{
85			$this->cmf->getMetadataFor('prefix:ChildEntity');
86
87			self::assertTrue($this->cmf->hasMetadataFor(__NAMESPACE__ . '\ChildEntity'));
88			self::assertTrue($this->cmf->hasMetadataFor('prefix:ChildEntity'));
89			}
90
91			/**
92			* @group DCOM-270
93			*/
94			public function testGetInvalidAliasedMetadata()
95			{
96			$this->expectException(MappingException::class);
97			$this->expectExceptionMessage(
98			'Class \'Doctrine\Tests\Common\Persistence\Mapping\ChildEntity:Foo\' does not exist'
99			);
100
101			$this->cmf->getMetadataFor('prefix:ChildEntity:Foo');
102			}
103
104			/**
105			* @group DCOM-270
106			*/
107			public function testClassIsTransient()
108			{
109			self::assertTrue($this->cmf->isTransient('prefix:ChildEntity:Foo'));
110			}
111
112			public function testWillFallbackOnNotLoadedMetadata()
113			{
114			$classMetadata = $this->createMock(ClassMetadata::class);
115
116			$this->cmf->fallbackCallback = static function () use ($classMetadata) {
117			return $classMetadata;
118			};
119
120			$this->cmf->metadata = null;
121
122			self::assertSame($classMetadata, $this->cmf->getMetadataFor('Foo'));
123			}
124
125			public function testWillFailOnFallbackFailureWithNotLoadedMetadata()
126			{
127			$this->cmf->fallbackCallback = static function () {
128			return null;
129			};
130
131			$this->cmf->metadata = null;
132
133			$this->expectException(MappingException::class);
134
135			$this->cmf->getMetadataFor('Foo');
136			}
137
138			/**
139			* @group 717
140			*/
141			public function testWillIgnoreCacheEntriesThatAreNotMetadataInstances()
142			{
143			/** @var Cache\|PHPUnit_Framework_MockObject_MockObject $cacheDriver */
144			$cacheDriver = $this->createMock(Cache::class);
145
146			$this->cmf->setCacheDriver($cacheDriver);
147
148			$cacheDriver->expects(self::once())->method('fetch')->with('Foo$CLASSMETADATA')->willReturn(new stdClass());
149
150			/** @var ClassMetadata $metadata */
151			$metadata = $this->createMock(ClassMetadata::class);
152
153			/** @var PHPUnit_Framework_MockObject_MockObject\|stdClass\|callable $fallbackCallback */
154			$fallbackCallback = $this->getMockBuilder(stdClass::class)->setMethods(['__invoke'])->getMock();
155
156			$fallbackCallback->expects(self::any())->method('__invoke')->willReturn($metadata);
157
158			$this->cmf->fallbackCallback = $fallbackCallback;
159
160			self::assertSame($metadata, $this->cmf->getMetadataFor('Foo'));
161			}
162
163			public function testFallbackMetadataShouldBeCached()
164			{
165			/** @var Cache\|PHPUnit_Framework_MockObject_MockObject $cacheDriver */
166			$cacheDriver = $this->createMock(Cache::class);
167			$cacheDriver->expects($this->once())->method('save');
168
169			$this->cmf->setCacheDriver($cacheDriver);
170
171			$classMetadata = $this->createMock(ClassMetadata::class);
172
173			$this->cmf->fallbackCallback = static function () use ($classMetadata) {
174			return $classMetadata;
175			};
176
177			$this->cmf->getMetadataFor('Foo');
178			}
179
180			public function testSetMetadataForShouldUpdateCache()
181			{
182			/** @var Cache\|PHPUnit_Framework_MockObject_MockObject $cacheDriver */
183			$cacheDriver = $this->createMock(Cache::class);
184			$cacheDriver->expects($this->once())->method('save');
185
186			$this->cmf->setCacheDriver($cacheDriver);
187
188			$classMetadata = $this->createMock(ClassMetadata::class);
189			$this->cmf->setMetadataFor('Foo', $classMetadata);
190			}
191			}
192
193			class TestClassMetadataFactory extends AbstractClassMetadataFactory
194			{
195			/** @var MappingDriver */
196			public $driver;
197
198			/** @var ClassMetadata\|null */
199			public $metadata;
200
201			/** @var callable\|null */
202			public $fallbackCallback;
203
204			public function __construct($driver, $metadata)
205			{
206			$this->driver = $driver;
207			$this->metadata = $metadata;
208			}
209
210			/**
211			* @param string[] $nonSuperclassParents
212			*/
213			protected function doLoadMetadata($class, $parent, $rootEntityFound, array $nonSuperclassParents)
214			{
215			}
216
217			protected function getFqcnFromAlias($namespaceAlias, $simpleClassName)
218			{
219			return __NAMESPACE__ . '\\' . $simpleClassName;
220			}
221
222			protected function initialize()
223			{
224			}
225
226			protected function newClassMetadataInstance($className)
227			{
228			return $this->metadata;
229			}
230
231			protected function getDriver()
232			{
233			return $this->driver;
234			}
235			protected function wakeupReflection(ClassMetadata $class, ReflectionService $reflService)
236			{
237			}
238
239			protected function initializeReflection(ClassMetadata $class, ReflectionService $reflService)
240			{
241			}
242
243			protected function isEntity(ClassMetadata $class)
244			{
245			return true;
246			}
247
248			protected function onNotFoundMetadata($className)
249			{
250			if (! $this->fallbackCallback) {
251			return null;
252			}
253
254			return ($this->fallbackCallback)();
255			}
256
257			public function isTransient($class)
258			{
259			return true;
260			}
261			}
262
263			class RootEntity
264			{
265			}
266
267			class ChildEntity extends RootEntity
268			{
269			}
270

doctrine / persistence

Pull Request — master (#21)

ClassMetadataFactoryTest::testGetMetadataFor() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like