MetadataTest::testGetAssociationMappingWillThrowAMetadataExceptionIfTheMappingCannotBeFound() - Code Metrics - Inspection of "Feature/0.3.0" - alex-patterson-webdev/doctrine-query-filter - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#4)

by Alex

created 2021-04-28 22:25 UTC

testGetAssociationMappingWillThrowAMetadataExceptionIfTheMappingCannotBeFound() A

↳ Parent: MetadataTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	32
Code Lines	22

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	22
c	0
b	0
f	0
dl	0
loc	32
rs	9.568
cc	1
nc	1
nop	0

<?php

declare(strict_types=1);

namespace ArpTest\DoctrineQueryFilter\Metadata;

use Arp\DoctrineQueryFilter\Metadata\Exception\MetadataException;
use Arp\DoctrineQueryFilter\Metadata\Metadata;
use Arp\DoctrineQueryFilter\Metadata\MetadataInterface;
use Doctrine\ORM\Mapping\ClassMetadata;
use Doctrine\ORM\Mapping\MappingException;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

/**
 * @covers \Arp\DoctrineQueryFilter\Metadata\Metadata
 *
 * @author  Alex Patterson <[email protected]>
 * @package ArpTest\DoctrineQueryFilter\Metadata
 */
final class MetadataTest extends TestCase
{
    /**
     * @var ClassMetadata&MockObject
     */
    private $classMetadata;

    /**
     * Prepare the test case dependencies
     */
    public function setUp(): void
    {
        $this->classMetadata = $this->createMock(ClassMetadata::class);
    }

    /**
     * Assert that the class implements MetadataInterface
     */
    public function testImplementsMetadataInterface(): void
    {
        $metadata = new Metadata($this->classMetadata);

        $this->assertInstanceOf(MetadataInterface::class, $metadata);
    }

    /**
     * Assert that getName() will return the entity class name
     */
    public function testGetNameWillReturnTheEntityClassName(): void
    {
        $className = 'Foo';

        $metadata = new Metadata($this->classMetadata);

        $this->classMetadata->expects($this->once())
            ->method('getName')
            ->willReturn($className);

        $this->assertSame($className, $metadata->getName());
    }

    /**
     * Assert a boolean FALSE is returned when calling hasField() with an unknown field
     */
    public function testHasFieldWillReturnFalseForNonExistingField(): void
    {
        $metadata = new Metadata($this->classMetadata);

        $fieldName = 'testFieldName';

        $this->classMetadata->expects($this->once())
            ->method('hasField')
            ->with($fieldName)
            ->willReturn(false);

        $this->assertFalse($metadata->hasField($fieldName));
    }

    /**
     * Assert a boolean FALSE is returned when calling hasField() with an unknown field
     */
    public function testHasFieldWillReturnTrueForExistingField(): void
    {
        $metadata = new Metadata($this->classMetadata);

        $fieldName = 'testFieldName';

        $this->classMetadata->expects($this->once())
            ->method('hasField')
            ->with($fieldName)
            ->willReturn(true);

        $this->assertTrue($metadata->hasField($fieldName));
    }

    /**
     * Assert that a failure to load field mapping will raise a MappingException error
     *
     * @throws MetadataException
     */
    public function testGetFieldMappingWillThrowAMetadataExceptionIfTheMappingCannotBeFound(): void
    {
        $metadata = new Metadata($this->classMetadata);

        $className = 'FooClassName';
        $fieldName = 'fooFieldName';

        $exceptionMessage = 'This is a test mapping exception message';
        $exceptionCode = 456;
        $exception = new MappingException($exceptionMessage, $exceptionCode);

        $this->classMetadata->expects($this->once())
            ->method('getFieldMapping')
            ->with($fieldName)
            ->willThrowException($exception);

        $this->classMetadata->expects($this->once())
            ->method('getName')
            ->willReturn($className);

        $this->expectException(MetadataException::class);
        $this->expectExceptionCode($exceptionCode);
        $this->expectExceptionMessage(
            sprintf(
                'Unable to find field mapping for field \'%s::%s\': %s',
                $className,
                $fieldName,
                $exceptionMessage
            )
        );

        $metadata->getFieldMapping($fieldName);
    }

    /**
     * Assert that mapping data is correctly returned from calls to getFieldMapping()
     *
     * @throws MetadataException
     */
    public function testGetFieldMappingWillReturnMappingData(): void
    {
        $metadata = new Metadata($this->classMetadata);

        $fieldName = 'fooFieldName';
        $mappingData = [
            'name' => $fieldName,
            'type' => 'test',
            'hello' => 123,
        ];

        $this->classMetadata->expects($this->once())
            ->method('getFieldMapping')
            ->with($fieldName)
            ->willReturn($mappingData);

        $this->assertSame($mappingData, $metadata->getFieldMapping($fieldName));
    }

    /**
     * Assert that calls to getFieldType() that fail will throw a MappingException
     *
     * @throws MetadataException
     */
    public function testGetFieldTypeWillThrowMetadataExceptionIfNotMappingTypeCanBeResolved(): void
    {
        $metadata = new Metadata($this->classMetadata);

        $className = 'FooClassName';
        $fieldName = 'fooFieldName';
        $mappingData = [
            'name' => $className,
            // missing the mapping data 'type' will the expected error
        ];

        $this->classMetadata->expects($this->once())
            ->method('getFieldMapping')
            ->with($fieldName)
            ->willReturn($mappingData);

        $this->classMetadata->expects($this->once())
            ->method('getName')
            ->willReturn($className);

        $this->expectException(MetadataException::class);
        $this->expectExceptionMessage(
            sprintf('Unable to resolve field data type for \'%s::%s\'', $className, $fieldName)
        );

        $metadata->getFieldType($fieldName);
    }

    /**
     * Assert that calls to getFieldType() will return the mapped column type
     *
     * @throws MetadataException
     */
    public function testGetFieldTypeWillReturnTheMappedType(): void
    {
        $metadata = new Metadata($this->classMetadata);

        $className = 'FooClassName';
        $fieldName = 'fooFieldName';
        $type = 'string';

        $mappingData = [
            'name' => $className,
            'type' => $type
        ];

        $this->classMetadata->expects($this->once())
            ->method('getFieldMapping')
            ->with($fieldName)
            ->willReturn($mappingData);

        $this->assertSame($type, $metadata->getFieldType($fieldName));
    }

    /**
     * Assert a boolean FALSE is returned when calling hasAssociation() with an unknown relationship
     */
    public function testHasAssociationWillReturnFalseForNonExistingField(): void
    {
        $metadata = new Metadata($this->classMetadata);

        $fieldName = 'testFieldName';

        $this->classMetadata->expects($this->once())
            ->method('hasAssociation')
            ->with($fieldName)
            ->willReturn(false);

        $this->assertFalse($metadata->hasAssociation($fieldName));
    }

    /**
     * Assert a boolean TRUE is returned when calling hasAssociation() with an known relationship
     */
    public function testHasAssociationWillReturnTrueForExistingField(): void
    {
        $metadata = new Metadata($this->classMetadata);

        $fieldName = 'testFieldName';

        $this->classMetadata->expects($this->once())
            ->method('hasAssociation')
            ->with($fieldName)
            ->willReturn(true);

        $this->assertTrue($metadata->hasAssociation($fieldName));
    }

    /**
     * Assert that a failure to load association mapping will raise a MappingException error
     *
     * @throws MetadataException
     */
    public function testGetAssociationMappingWillThrowAMetadataExceptionIfTheMappingCannotBeFound(): void
    {
        $metadata = new Metadata($this->classMetadata);

        $className = 'BarClassName';
        $fieldName = 'barFieldName';

        $exceptionCode = 999;
        $exceptionMessage = 'This is a test association mapping exception message';
        $exception = new MappingException($exceptionMessage, $exceptionCode);

        $this->classMetadata->expects($this->once())
            ->method('getAssociationMapping')
            ->with($fieldName)
            ->willThrowException($exception);

        $this->classMetadata->expects($this->once())
            ->method('getName')
            ->willReturn($className);

        $this->expectException(MetadataException::class);
        $this->expectExceptionCode($exceptionCode);
        $this->expectExceptionMessage(
            sprintf(
                'Unable to find association mapping for field \'%s::%s\': %s',
                $className,
                $fieldName,
                $exceptionMessage
            )
        );

        $metadata->getAssociationMapping($fieldName);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace ArpTest\DoctrineQueryFilter\Metadata;
6
7			use Arp\DoctrineQueryFilter\Metadata\Exception\MetadataException;
8			use Arp\DoctrineQueryFilter\Metadata\Metadata;
9			use Arp\DoctrineQueryFilter\Metadata\MetadataInterface;
10			use Doctrine\ORM\Mapping\ClassMetadata;
11			use Doctrine\ORM\Mapping\MappingException;
12			use PHPUnit\Framework\MockObject\MockObject;
13			use PHPUnit\Framework\TestCase;
14
15			/**
16			* @covers \Arp\DoctrineQueryFilter\Metadata\Metadata
17			*
18			* @author Alex Patterson <[email protected]>
19			* @package ArpTest\DoctrineQueryFilter\Metadata
20			*/
21			final class MetadataTest extends TestCase
22			{
23			/**
24			* @var ClassMetadata&MockObject
25			*/
26			private $classMetadata;
27
28			/**
29			* Prepare the test case dependencies
30			*/
31			public function setUp(): void
32			{
33			$this->classMetadata = $this->createMock(ClassMetadata::class);
34			}
35
36			/**
37			* Assert that the class implements MetadataInterface
38			*/
39			public function testImplementsMetadataInterface(): void
40			{
41			$metadata = new Metadata($this->classMetadata);
42
43			$this->assertInstanceOf(MetadataInterface::class, $metadata);
44			}
45
46			/**
47			* Assert that getName() will return the entity class name
48			*/
49			public function testGetNameWillReturnTheEntityClassName(): void
50			{
51			$className = 'Foo';
52
53			$metadata = new Metadata($this->classMetadata);
54
55			$this->classMetadata->expects($this->once())
56			->method('getName')
57			->willReturn($className);
58
59			$this->assertSame($className, $metadata->getName());
60			}
61
62			/**
63			* Assert a boolean FALSE is returned when calling hasField() with an unknown field
64			*/
65			public function testHasFieldWillReturnFalseForNonExistingField(): void
66			{
67			$metadata = new Metadata($this->classMetadata);
68
69			$fieldName = 'testFieldName';
70
71			$this->classMetadata->expects($this->once())
72			->method('hasField')
73			->with($fieldName)
74			->willReturn(false);
75
76			$this->assertFalse($metadata->hasField($fieldName));
77			}
78
79			/**
80			* Assert a boolean FALSE is returned when calling hasField() with an unknown field
81			*/
82			public function testHasFieldWillReturnTrueForExistingField(): void
83			{
84			$metadata = new Metadata($this->classMetadata);
85
86			$fieldName = 'testFieldName';
87
88			$this->classMetadata->expects($this->once())
89			->method('hasField')
90			->with($fieldName)
91			->willReturn(true);
92
93			$this->assertTrue($metadata->hasField($fieldName));
94			}
95
96			/**
97			* Assert that a failure to load field mapping will raise a MappingException error
98			*
99			* @throws MetadataException
100			*/
101			public function testGetFieldMappingWillThrowAMetadataExceptionIfTheMappingCannotBeFound(): void
102			{
103			$metadata = new Metadata($this->classMetadata);
104
105			$className = 'FooClassName';
106			$fieldName = 'fooFieldName';
107
108			$exceptionMessage = 'This is a test mapping exception message';
109			$exceptionCode = 456;
110			$exception = new MappingException($exceptionMessage, $exceptionCode);
111
112			$this->classMetadata->expects($this->once())
113			->method('getFieldMapping')
114			->with($fieldName)
115			->willThrowException($exception);
116
117			$this->classMetadata->expects($this->once())
118			->method('getName')
119			->willReturn($className);
120
121			$this->expectException(MetadataException::class);
122			$this->expectExceptionCode($exceptionCode);
123			$this->expectExceptionMessage(
124			sprintf(
125			'Unable to find field mapping for field \'%s::%s\': %s',
126			$className,
127			$fieldName,
128			$exceptionMessage
129			)
130			);
131
132			$metadata->getFieldMapping($fieldName);
133			}
134
135			/**
136			* Assert that mapping data is correctly returned from calls to getFieldMapping()
137			*
138			* @throws MetadataException
139			*/
140			public function testGetFieldMappingWillReturnMappingData(): void
141			{
142			$metadata = new Metadata($this->classMetadata);
143
144			$fieldName = 'fooFieldName';
145			$mappingData = [
146			'name' => $fieldName,
147			'type' => 'test',
148			'hello' => 123,
149			];
150
151			$this->classMetadata->expects($this->once())
152			->method('getFieldMapping')
153			->with($fieldName)
154			->willReturn($mappingData);
155
156			$this->assertSame($mappingData, $metadata->getFieldMapping($fieldName));
157			}
158
159			/**
160			* Assert that calls to getFieldType() that fail will throw a MappingException
161			*
162			* @throws MetadataException
163			*/
164			public function testGetFieldTypeWillThrowMetadataExceptionIfNotMappingTypeCanBeResolved(): void
165			{
166			$metadata = new Metadata($this->classMetadata);
167
168			$className = 'FooClassName';
169			$fieldName = 'fooFieldName';
170			$mappingData = [
171			'name' => $className,
172			// missing the mapping data 'type' will the expected error
173			];
174
175			$this->classMetadata->expects($this->once())
176			->method('getFieldMapping')
177			->with($fieldName)
178			->willReturn($mappingData);
179
180			$this->classMetadata->expects($this->once())
181			->method('getName')
182			->willReturn($className);
183
184			$this->expectException(MetadataException::class);
185			$this->expectExceptionMessage(
186			sprintf('Unable to resolve field data type for \'%s::%s\'', $className, $fieldName)
187			);
188
189			$metadata->getFieldType($fieldName);
190			}
191
192			/**
193			* Assert that calls to getFieldType() will return the mapped column type
194			*
195			* @throws MetadataException
196			*/
197			public function testGetFieldTypeWillReturnTheMappedType(): void
198			{
199			$metadata = new Metadata($this->classMetadata);
200
201			$className = 'FooClassName';
202			$fieldName = 'fooFieldName';
203			$type = 'string';
204
205			$mappingData = [
206			'name' => $className,
207			'type' => $type
208			];
209
210			$this->classMetadata->expects($this->once())
211			->method('getFieldMapping')
212			->with($fieldName)
213			->willReturn($mappingData);
214
215			$this->assertSame($type, $metadata->getFieldType($fieldName));
216			}
217
218			/**
219			* Assert a boolean FALSE is returned when calling hasAssociation() with an unknown relationship
220			*/
221			public function testHasAssociationWillReturnFalseForNonExistingField(): void
222			{
223			$metadata = new Metadata($this->classMetadata);
224
225			$fieldName = 'testFieldName';
226
227			$this->classMetadata->expects($this->once())
228			->method('hasAssociation')
229			->with($fieldName)
230			->willReturn(false);
231
232			$this->assertFalse($metadata->hasAssociation($fieldName));
233			}
234
235			/**
236			* Assert a boolean TRUE is returned when calling hasAssociation() with an known relationship
237			*/
238			public function testHasAssociationWillReturnTrueForExistingField(): void
239			{
240			$metadata = new Metadata($this->classMetadata);
241
242			$fieldName = 'testFieldName';
243
244			$this->classMetadata->expects($this->once())
245			->method('hasAssociation')
246			->with($fieldName)
247			->willReturn(true);
248
249			$this->assertTrue($metadata->hasAssociation($fieldName));
250			}
251
252			/**
253			* Assert that a failure to load association mapping will raise a MappingException error
254			*
255			* @throws MetadataException
256			*/
257			public function testGetAssociationMappingWillThrowAMetadataExceptionIfTheMappingCannotBeFound(): void
258			{
259			$metadata = new Metadata($this->classMetadata);
260
261			$className = 'BarClassName';
262			$fieldName = 'barFieldName';
263
264			$exceptionCode = 999;
265			$exceptionMessage = 'This is a test association mapping exception message';
266			$exception = new MappingException($exceptionMessage, $exceptionCode);
267
268			$this->classMetadata->expects($this->once())
269			->method('getAssociationMapping')
270			->with($fieldName)
271			->willThrowException($exception);
272
273			$this->classMetadata->expects($this->once())
274			->method('getName')
275			->willReturn($className);
276
277			$this->expectException(MetadataException::class);
278			$this->expectExceptionCode($exceptionCode);
279			$this->expectExceptionMessage(
280			sprintf(
281			'Unable to find association mapping for field \'%s::%s\': %s',
282			$className,
283			$fieldName,
284			$exceptionMessage
285			)
286			);
287
288			$metadata->getAssociationMapping($fieldName);
289			}
290			}
291

alex-patterson-webdev / doctrine-query-filter

Pull Request — master (#4)

testGetAssociationMappingWillThrowAMetadataExceptionIfTheMappingCannotBeFound() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like