FieldDescriptionTest::testGetValue() - Code Metrics - Inspection of "Use SonataAdmin master branch" - sonata-project/SonataDoctrineORMAdminBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#1073)

by Vincent

created 2020-07-17 07:02 UTC

FieldDescriptionTest::testGetValue() A

↳ Parent: FieldDescriptionTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	15
rs	9.7666
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

declare(strict_types=1);

/*
 * This file is part of the Sonata Project package.
 *
 * (c) Thomas Rabaix <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Sonata\DoctrineORMAdminBundle\Tests\Admin;

use PHPUnit\Framework\TestCase;
use Sonata\AdminBundle\Admin\AbstractAdmin;
use Sonata\AdminBundle\Admin\AdminInterface;
use Sonata\AdminBundle\Admin\FieldDescriptionInterface;
use Sonata\AdminBundle\Exception\NoValueException;
use Sonata\DoctrineORMAdminBundle\Admin\FieldDescription;

class FieldDescriptionTest extends TestCase
{
    public function testOptions(): void
    {
        $field = new FieldDescription();
        $field->setOptions([
            'template' => 'foo',
            'type' => 'bar',
            'misc' => 'foobar',
        ]);

        // test method shortcut
        $this->assertNull($field->getOption('template'));
        $this->assertNull($field->getOption('type'));

        $this->assertSame('foo', $field->getTemplate());
        $this->assertSame('bar', $field->getType());

        // test the default value option
        $this->assertSame('default', $field->getOption('template', 'default'));

        // test the merge options
        $field->setOption('array', ['key1' => 'val1']);
        $field->mergeOption('array', ['key1' => 'key_1', 'key2' => 'key_2']);

        $this->assertSame(['key1' => 'key_1', 'key2' => 'key_2'], $field->getOption('array'));

        $field->mergeOption('non_existent', ['key1' => 'key_1', 'key2' => 'key_2']);

        $this->assertSame(['key1' => 'key_1', 'key2' => 'key_2'], $field->getOption('array'));

        $field->mergeOptions(['array' => ['key3' => 'key_3']]);

        $this->assertSame(['key1' => 'key_1', 'key2' => 'key_2', 'key3' => 'key_3'], $field->getOption('array'));

        $field->setOption('integer', 1);

        try {
            $field->mergeOption('integer', []);
            $this->fail('no exception raised !!');
        } catch (\RuntimeException $e) {

        }

        $field->mergeOptions(['final' => 'test']);

        $expected = [
            'misc' => 'foobar',
            'placeholder' => 'short_object_description_placeholder',
            'link_parameters' => [],
            'array' => [
                'key1' => 'key_1',
                'key2' => 'key_2',
                'key3' => 'key_3',
            ],
            'non_existent' => [
                'key1' => 'key_1',
                'key2' => 'key_2',
            ],
            'integer' => 1,
            'final' => 'test',
        ];

        $this->assertSame($expected, $field->getOptions());
    }

    public function testAssociationMapping(): void
    {
        $field = new FieldDescription();
        $field->setAssociationMapping([
            'type' => 'integer',
            'fieldName' => 'position',
        ]);

        $this->assertSame('integer', $field->getType());
        $this->assertSame('integer', $field->getMappingType());
        $this->assertSame('position', $field->getFieldName());

        // cannot overwrite defined definition
        $field->setAssociationMapping([
            'type' => 'overwrite?',
            'fieldName' => 'overwritten',
        ]);

        $this->assertSame('integer', $field->getType());
        $this->assertSame('integer', $field->getMappingType());
        $this->assertSame('overwritten', $field->getFieldName());

        $field->setMappingType('string');
        $this->assertSame('string', $field->getMappingType());
        $this->assertSame('integer', $field->getType());
    }

    public function testSetName(): void
    {
        $field = new FieldDescription();
        $field->setName('New field description name');

        $this->assertSame($field->getName(), 'New field description name');
    }

    public function testSetNameSetFieldNameToo(): void
    {
        $field = new FieldDescription();
        $field->setName('New field description name');

        $this->assertSame($field->getFieldName(), 'New field description name');
    }

    public function testSetNameDoesNotSetFieldNameWhenSetBefore(): void
    {
        $field = new FieldDescription();
        $field->setFieldName('field name');
        $field->setName('New field description name');

        $this->assertSame($field->getFieldName(), 'field name');
    }

    public function testGetParent(): void
    {
        $adminMock = $this->createMock(AdminInterface::class);
        $field = new FieldDescription();
        $field->setParent($adminMock);

        $this->assertSame($adminMock, $field->getParent());
    }

    public function testGetHelp(): void
    {
        $field = new FieldDescription();
        $field->setHelp('help message');

        $this->assertSame($field->getHelp(), 'help message');
    }

    public function testGetAdmin(): void
    {
        $adminMock = $this->createMock(AdminInterface::class);
        $field = new FieldDescription();
        $field->setAdmin($adminMock);

        $this->assertSame($adminMock, $field->getAdmin());
    }

    public function testGetAssociationAdmin(): void
    {
        $adminMock = $this->createMock(AbstractAdmin::class);
        $adminMock->expects($this->once())
            ->method('setParentFieldDescription')
            ->with($this->isInstanceOf(FieldDescriptionInterface::class));

        $field = new FieldDescription();
        $field->setAssociationAdmin($adminMock);

        $this->assertSame($adminMock, $field->getAssociationAdmin());
    }

    public function testHasAssociationAdmin(): void
    {
        $adminMock = $this->createMock(AbstractAdmin::class);
        $adminMock->expects($this->once())
            ->method('setParentFieldDescription')
            ->with($this->isInstanceOf(FieldDescriptionInterface::class));

        $field = new FieldDescription();

        $this->assertFalse($field->hasAssociationAdmin());

        $field->setAssociationAdmin($adminMock);

        $this->assertTrue($field->hasAssociationAdmin());
    }

    public function testGetValue(): void
    {
        $mockedObject = $this->getMockBuilder('stdClass')
            ->setMethods(['myMethod'])
            ->getMock();
        $mockedObject->expects($this->once())
            ->method('myMethod')
            ->willReturn('myMethodValue');

        $field = new FieldDescription();
        $field->setFieldName('any string, but not null');
        $field->setOption('code', 'myMethod');

        $this->assertSame($field->getValue($mockedObject), 'myMethodValue');
    }

    public function testGetValueWhenCannotRetrieve(): void
    {
        $this->expectException(NoValueException::class);

        $mockedObject = $this->getMockBuilder('stdClass')
            ->setMethods(['myMethod'])
            ->getMock();
        $mockedObject->expects($this->never())
            ->method('myMethod')
            ->willReturn('myMethodValue');

        $field = new FieldDescription();
        $field->setFieldName('any string, but not null');

        $this->assertSame($field->getValue($mockedObject), 'myMethodValue');
    }

    public function testGetAssociationMapping(): void
    {
        $assocationMapping = [
            'type' => 'integer',
            'fieldName' => 'position',
        ];

        $field = new FieldDescription();
        $field->setAssociationMapping($assocationMapping);

        $this->assertSame($assocationMapping, $field->getAssociationMapping());
    }

    public function testSetFieldMappingSetType(): void
    {
        $fieldMapping = [
            'type' => 'integer',
            'fieldName' => 'position',
        ];

        $field = new FieldDescription();
        $field->setFieldMapping($fieldMapping);

        $this->assertSame('integer', $field->getType());
    }

    public function testSetFieldMappingSetMappingType(): void
    {
        $fieldMapping = [
            'type' => 'integer',
            'fieldName' => 'position',
        ];

        $field = new FieldDescription();
        $field->setFieldMapping($fieldMapping);

        $this->assertSame('integer', $field->getMappingType());
    }

    public function testSetFieldMappingSetFieldName(): void
    {
        $fieldMapping = [
            'type' => 'integer',
            'fieldName' => 'position',
        ];

        $field = new FieldDescription();
        $field->setFieldMapping($fieldMapping);

        $this->assertSame('position', $field->getFieldName());
    }

    public function testGetTargetEntity(): void
    {
        $assocationMapping = [
            'type' => 'integer',
            'fieldName' => 'position',
            'targetEntity' => 'someValue',
        ];

        $field = new FieldDescription();

        $this->assertNull($field->getTargetModel());

        $field->setAssociationMapping($assocationMapping);

        $this->assertSame('someValue', $field->getTargetModel());
    }

    public function testIsIdentifierFromFieldMapping(): void
    {
        $fieldMapping = [
            'type' => 'integer',
            'fieldName' => 'position',
            'id' => true,
        ];

        $field = new FieldDescription();
        $field->setFieldMapping($fieldMapping);

        $this->assertTrue($field->isIdentifier());
    }

    public function testGetFieldMapping(): void
    {
        $fieldMapping = [
            'type' => 'integer',
            'fieldName' => 'position',
            'id' => 'someId',
        ];

        $field = new FieldDescription();
        $field->setFieldMapping($fieldMapping);

        $this->assertSame($fieldMapping, $field->getFieldMapping());
    }

    public function testGetValueForEmbeddedObject(): void
    {
        $mockedEmbeddedObject = $this->getMockBuilder('stdClass')
            ->setMethods(['myMethod'])
            ->getMock();
        $mockedEmbeddedObject->expects($this->once())
                    ->method('myMethod')
                    ->willReturn('myMethodValue');

        $mockedObject = $this->getMockBuilder('stdClass')
            ->setMethods(['getMyEmbeddedObject'])
            ->getMock();
        $mockedObject->expects($this->once())
            ->method('getMyEmbeddedObject')
            ->willReturn($mockedEmbeddedObject);

        $field = new FieldDescription();
        $field->setFieldMapping([
            'declaredField' => 'myEmbeddedObject', 'type' => 'string', 'fieldName' => 'myEmbeddedObject.myMethod',
        ]);
        $field->setFieldName('myMethod');
        $field->setOption('code', 'myMethod');

        $this->assertSame('myMethodValue', $field->getValue($mockedObject));
    }

    public function testGetValueForMultiLevelEmbeddedObject(): void
    {
        $mockedChildEmbeddedObject = $this->getMockBuilder('stdClass')
            ->setMethods(['myMethod'])
            ->getMock();
        $mockedChildEmbeddedObject->expects($this->once())
            ->method('myMethod')
            ->willReturn('myMethodValue');
        $mockedEmbeddedObject = $this->getMockBuilder('stdClass')
            ->setMethods(['getChild'])
            ->getMock();
        $mockedEmbeddedObject->expects($this->once())
            ->method('getChild')
            ->willReturn($mockedChildEmbeddedObject);
        $mockedObject = $this->getMockBuilder('stdClass')
            ->setMethods(['getMyEmbeddedObject'])
            ->getMock();
        $mockedObject->expects($this->once())
            ->method('getMyEmbeddedObject')
            ->willReturn($mockedEmbeddedObject);
        $field = new FieldDescription();
        $field->setFieldMapping([
            'declaredField' => 'myEmbeddedObject.child', 'type' => 'string', 'fieldName' => 'myMethod',
        ]);
        $field->setFieldName('myMethod');
        $field->setOption('code', 'myMethod');
        $this->assertSame('myMethodValue', $field->getValue($mockedObject));
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* This file is part of the Sonata Project package.
7			*
8			* (c) Thomas Rabaix <[email protected]>
9			*
10			* For the full copyright and license information, please view the LICENSE
11			* file that was distributed with this source code.
12			*/
13
14			namespace Sonata\DoctrineORMAdminBundle\Tests\Admin;
15
16			use PHPUnit\Framework\TestCase;
17			use Sonata\AdminBundle\Admin\AbstractAdmin;
18			use Sonata\AdminBundle\Admin\AdminInterface;
19			use Sonata\AdminBundle\Admin\FieldDescriptionInterface;
20			use Sonata\AdminBundle\Exception\NoValueException;
21			use Sonata\DoctrineORMAdminBundle\Admin\FieldDescription;
22
23			class FieldDescriptionTest extends TestCase
24			{
25			public function testOptions(): void
26			{
27			$field = new FieldDescription();
28			$field->setOptions([
29			'template' => 'foo',
30			'type' => 'bar',
31			'misc' => 'foobar',
32			]);
33
34			// test method shortcut
35			$this->assertNull($field->getOption('template'));
36			$this->assertNull($field->getOption('type'));
37
38			$this->assertSame('foo', $field->getTemplate());
39			$this->assertSame('bar', $field->getType());
40
41			// test the default value option
42			$this->assertSame('default', $field->getOption('template', 'default'));
43
44			// test the merge options
45			$field->setOption('array', ['key1' => 'val1']);
46			$field->mergeOption('array', ['key1' => 'key_1', 'key2' => 'key_2']);
47
48			$this->assertSame(['key1' => 'key_1', 'key2' => 'key_2'], $field->getOption('array'));
49
50			$field->mergeOption('non_existent', ['key1' => 'key_1', 'key2' => 'key_2']);
51
52			$this->assertSame(['key1' => 'key_1', 'key2' => 'key_2'], $field->getOption('array'));
53
54			$field->mergeOptions(['array' => ['key3' => 'key_3']]);
55
56			$this->assertSame(['key1' => 'key_1', 'key2' => 'key_2', 'key3' => 'key_3'], $field->getOption('array'));
57
58			$field->setOption('integer', 1);
59
60			try {
61			$field->mergeOption('integer', []);
62			$this->fail('no exception raised !!');
63			} catch (\RuntimeException $e) {
			0 ignored issues – show Coding Style Comprehensibility introduced 2017-04-18 15:09 UTC by Report Bug Copy Issue Report Consider adding a comment why this CATCH block is empty. Loading history...
64			}
65
66			$field->mergeOptions(['final' => 'test']);
67
68			$expected = [
69			'misc' => 'foobar',
70			'placeholder' => 'short_object_description_placeholder',
71			'link_parameters' => [],
72			'array' => [
73			'key1' => 'key_1',
74			'key2' => 'key_2',
75			'key3' => 'key_3',
76			],
77			'non_existent' => [
78			'key1' => 'key_1',
79			'key2' => 'key_2',
80			],
81			'integer' => 1,
82			'final' => 'test',
83			];
84
85			$this->assertSame($expected, $field->getOptions());
86			}
87
88			public function testAssociationMapping(): void
89			{
90			$field = new FieldDescription();
91			$field->setAssociationMapping([
92			'type' => 'integer',
93			'fieldName' => 'position',
94			]);
95
96			$this->assertSame('integer', $field->getType());
97			$this->assertSame('integer', $field->getMappingType());
98			$this->assertSame('position', $field->getFieldName());
99
100			// cannot overwrite defined definition
101			$field->setAssociationMapping([
102			'type' => 'overwrite?',
103			'fieldName' => 'overwritten',
104			]);
105
106			$this->assertSame('integer', $field->getType());
107			$this->assertSame('integer', $field->getMappingType());
108			$this->assertSame('overwritten', $field->getFieldName());
109
110			$field->setMappingType('string');
111			$this->assertSame('string', $field->getMappingType());
112			$this->assertSame('integer', $field->getType());
113			}
114
115			public function testSetName(): void
116			{
117			$field = new FieldDescription();
118			$field->setName('New field description name');
119
120			$this->assertSame($field->getName(), 'New field description name');
121			}
122
123			public function testSetNameSetFieldNameToo(): void
124			{
125			$field = new FieldDescription();
126			$field->setName('New field description name');
127
128			$this->assertSame($field->getFieldName(), 'New field description name');
129			}
130
131			public function testSetNameDoesNotSetFieldNameWhenSetBefore(): void
132			{
133			$field = new FieldDescription();
134			$field->setFieldName('field name');
135			$field->setName('New field description name');
136
137			$this->assertSame($field->getFieldName(), 'field name');
138			}
139
140			public function testGetParent(): void
141			{
142			$adminMock = $this->createMock(AdminInterface::class);
143			$field = new FieldDescription();
144			$field->setParent($adminMock);
145
146			$this->assertSame($adminMock, $field->getParent());
147			}
148
149			public function testGetHelp(): void
150			{
151			$field = new FieldDescription();
152			$field->setHelp('help message');
153
154			$this->assertSame($field->getHelp(), 'help message');
155			}
156
157			public function testGetAdmin(): void
158			{
159			$adminMock = $this->createMock(AdminInterface::class);
160			$field = new FieldDescription();
161			$field->setAdmin($adminMock);
162
163			$this->assertSame($adminMock, $field->getAdmin());
164			}
165
166			public function testGetAssociationAdmin(): void
167			{
168			$adminMock = $this->createMock(AbstractAdmin::class);
169			$adminMock->expects($this->once())
170			->method('setParentFieldDescription')
171			->with($this->isInstanceOf(FieldDescriptionInterface::class));
172
173			$field = new FieldDescription();
174			$field->setAssociationAdmin($adminMock);
175
176			$this->assertSame($adminMock, $field->getAssociationAdmin());
177			}
178
179			public function testHasAssociationAdmin(): void
180			{
181			$adminMock = $this->createMock(AbstractAdmin::class);
182			$adminMock->expects($this->once())
183			->method('setParentFieldDescription')
184			->with($this->isInstanceOf(FieldDescriptionInterface::class));
185
186			$field = new FieldDescription();
187
188			$this->assertFalse($field->hasAssociationAdmin());
189
190			$field->setAssociationAdmin($adminMock);
191
192			$this->assertTrue($field->hasAssociationAdmin());
193			}
194
195			public function testGetValue(): void
196			{
197			$mockedObject = $this->getMockBuilder('stdClass')
198			->setMethods(['myMethod'])
199			->getMock();
200			$mockedObject->expects($this->once())
201			->method('myMethod')
202			->willReturn('myMethodValue');
203
204			$field = new FieldDescription();
205			$field->setFieldName('any string, but not null');
206			$field->setOption('code', 'myMethod');
207
208			$this->assertSame($field->getValue($mockedObject), 'myMethodValue');
209			}
210
211			public function testGetValueWhenCannotRetrieve(): void
212			{
213			$this->expectException(NoValueException::class);
214
215			$mockedObject = $this->getMockBuilder('stdClass')
216			->setMethods(['myMethod'])
217			->getMock();
218			$mockedObject->expects($this->never())
219			->method('myMethod')
220			->willReturn('myMethodValue');
221
222			$field = new FieldDescription();
223			$field->setFieldName('any string, but not null');
224
225			$this->assertSame($field->getValue($mockedObject), 'myMethodValue');
226			}
227
228			public function testGetAssociationMapping(): void
229			{
230			$assocationMapping = [
231			'type' => 'integer',
232			'fieldName' => 'position',
233			];
234
235			$field = new FieldDescription();
236			$field->setAssociationMapping($assocationMapping);
237
238			$this->assertSame($assocationMapping, $field->getAssociationMapping());
239			}
240
241			public function testSetFieldMappingSetType(): void
242			{
243			$fieldMapping = [
244			'type' => 'integer',
245			'fieldName' => 'position',
246			];
247
248			$field = new FieldDescription();
249			$field->setFieldMapping($fieldMapping);
250
251			$this->assertSame('integer', $field->getType());
252			}
253
254			public function testSetFieldMappingSetMappingType(): void
255			{
256			$fieldMapping = [
257			'type' => 'integer',
258			'fieldName' => 'position',
259			];
260
261			$field = new FieldDescription();
262			$field->setFieldMapping($fieldMapping);
263
264			$this->assertSame('integer', $field->getMappingType());
265			}
266
267			public function testSetFieldMappingSetFieldName(): void
268			{
269			$fieldMapping = [
270			'type' => 'integer',
271			'fieldName' => 'position',
272			];
273
274			$field = new FieldDescription();
275			$field->setFieldMapping($fieldMapping);
276
277			$this->assertSame('position', $field->getFieldName());
278			}
279
280			public function testGetTargetEntity(): void
281			{
282			$assocationMapping = [
283			'type' => 'integer',
284			'fieldName' => 'position',
285			'targetEntity' => 'someValue',
286			];
287
288			$field = new FieldDescription();
289
290			$this->assertNull($field->getTargetModel());
291
292			$field->setAssociationMapping($assocationMapping);
293
294			$this->assertSame('someValue', $field->getTargetModel());
295			}
296
297			public function testIsIdentifierFromFieldMapping(): void
298			{
299			$fieldMapping = [
300			'type' => 'integer',
301			'fieldName' => 'position',
302			'id' => true,
303			];
304
305			$field = new FieldDescription();
306			$field->setFieldMapping($fieldMapping);
307
308			$this->assertTrue($field->isIdentifier());
309			}
310
311			public function testGetFieldMapping(): void
312			{
313			$fieldMapping = [
314			'type' => 'integer',
315			'fieldName' => 'position',
316			'id' => 'someId',
317			];
318
319			$field = new FieldDescription();
320			$field->setFieldMapping($fieldMapping);
321
322			$this->assertSame($fieldMapping, $field->getFieldMapping());
323			}
324
325			public function testGetValueForEmbeddedObject(): void
326			{
327			$mockedEmbeddedObject = $this->getMockBuilder('stdClass')
328			->setMethods(['myMethod'])
329			->getMock();
330			$mockedEmbeddedObject->expects($this->once())
331			->method('myMethod')
332			->willReturn('myMethodValue');
333
334			$mockedObject = $this->getMockBuilder('stdClass')
335			->setMethods(['getMyEmbeddedObject'])
336			->getMock();
337			$mockedObject->expects($this->once())
338			->method('getMyEmbeddedObject')
339			->willReturn($mockedEmbeddedObject);
340
341			$field = new FieldDescription();
342			$field->setFieldMapping([
343			'declaredField' => 'myEmbeddedObject', 'type' => 'string', 'fieldName' => 'myEmbeddedObject.myMethod',
344			]);
345			$field->setFieldName('myMethod');
346			$field->setOption('code', 'myMethod');
347
348			$this->assertSame('myMethodValue', $field->getValue($mockedObject));
349			}
350
351			public function testGetValueForMultiLevelEmbeddedObject(): void
352			{
353			$mockedChildEmbeddedObject = $this->getMockBuilder('stdClass')
354			->setMethods(['myMethod'])
355			->getMock();
356			$mockedChildEmbeddedObject->expects($this->once())
357			->method('myMethod')
358			->willReturn('myMethodValue');
359			$mockedEmbeddedObject = $this->getMockBuilder('stdClass')
360			->setMethods(['getChild'])
361			->getMock();
362			$mockedEmbeddedObject->expects($this->once())
363			->method('getChild')
364			->willReturn($mockedChildEmbeddedObject);
365			$mockedObject = $this->getMockBuilder('stdClass')
366			->setMethods(['getMyEmbeddedObject'])
367			->getMock();
368			$mockedObject->expects($this->once())
369			->method('getMyEmbeddedObject')
370			->willReturn($mockedEmbeddedObject);
371			$field = new FieldDescription();
372			$field->setFieldMapping([
373			'declaredField' => 'myEmbeddedObject.child', 'type' => 'string', 'fieldName' => 'myMethod',
374			]);
375			$field->setFieldName('myMethod');
376			$field->setOption('code', 'myMethod');
377			$this->assertSame('myMethodValue', $field->getValue($mockedObject));
378			}
379			}
380

sonata-project / SonataDoctrineORMAdminBundle

Pull Request — master (#1073)

FieldDescriptionTest::testGetValue() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like