FieldDescriptionTest::testGetValue() - Code Metrics - sonata-project/SonataDoctrineORMAdminBundle - Measure and Improve Code Quality continuously with Scrutinizer

FieldDescriptionTest::testGetValue() A
last analyzed 2020-08-28 02:03 UTC

↳ 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 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 testSetAssociationMappingAllowOnlyForArray(): void
    {
        $this->expectException(\RuntimeException::class);

        $field = new FieldDescription();
        $field->setAssociationMapping('test');
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    public function testSetFieldMappingAllowOnlyForArray(): void
    {
        $this->expectException(\RuntimeException::class);

        $field = new FieldDescription();
        $field->setFieldMapping('test');
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    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 testGetAdmin(): void
150			{
151			$adminMock = $this->createMock(AdminInterface::class);
152			$field = new FieldDescription();
153			$field->setAdmin($adminMock);
154
155			$this->assertSame($adminMock, $field->getAdmin());
156			}
157
158			public function testGetAssociationAdmin(): void
159			{
160			$adminMock = $this->createMock(AbstractAdmin::class);
161			$adminMock->expects($this->once())
162			->method('setParentFieldDescription')
163			->with($this->isInstanceOf(FieldDescriptionInterface::class));
164
165			$field = new FieldDescription();
166			$field->setAssociationAdmin($adminMock);
167
168			$this->assertSame($adminMock, $field->getAssociationAdmin());
169			}
170
171			public function testHasAssociationAdmin(): void
172			{
173			$adminMock = $this->createMock(AbstractAdmin::class);
174			$adminMock->expects($this->once())
175			->method('setParentFieldDescription')
176			->with($this->isInstanceOf(FieldDescriptionInterface::class));
177
178			$field = new FieldDescription();
179
180			$this->assertFalse($field->hasAssociationAdmin());
181
182			$field->setAssociationAdmin($adminMock);
183
184			$this->assertTrue($field->hasAssociationAdmin());
185			}
186
187			public function testGetValue(): void
188			{
189			$mockedObject = $this->getMockBuilder('stdClass')
190			->setMethods(['myMethod'])
191			->getMock();
192			$mockedObject->expects($this->once())
193			->method('myMethod')
194			->willReturn('myMethodValue');
195
196			$field = new FieldDescription();
197			$field->setFieldName('any string, but not null');
198			$field->setOption('code', 'myMethod');
199
200			$this->assertSame($field->getValue($mockedObject), 'myMethodValue');
201			}
202
203			public function testGetValueWhenCannotRetrieve(): void
204			{
205			$this->expectException(NoValueException::class);
206
207			$mockedObject = $this->getMockBuilder('stdClass')
208			->setMethods(['myMethod'])
209			->getMock();
210			$mockedObject->expects($this->never())
211			->method('myMethod')
212			->willReturn('myMethodValue');
213
214			$field = new FieldDescription();
215			$field->setFieldName('any string, but not null');
216
217			$this->assertSame($field->getValue($mockedObject), 'myMethodValue');
218			}
219
220			public function testGetAssociationMapping(): void
221			{
222			$assocationMapping = [
223			'type' => 'integer',
224			'fieldName' => 'position',
225			];
226
227			$field = new FieldDescription();
228			$field->setAssociationMapping($assocationMapping);
229
230			$this->assertSame($assocationMapping, $field->getAssociationMapping());
231			}
232
233			public function testSetAssociationMappingAllowOnlyForArray(): void
234			{
235			$this->expectException(\RuntimeException::class);
236
237			$field = new FieldDescription();
238			$field->setAssociationMapping('test');
			0 ignored issues – show Documentation introduced 2015-11-23 21:03 UTC by Report Bug Copy Issue Report `'test'` is of type `string`, but the function expects a `array`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
239			}
240
241			public function testSetFieldMappingAllowOnlyForArray(): void
242			{
243			$this->expectException(\RuntimeException::class);
244
245			$field = new FieldDescription();
246			$field->setFieldMapping('test');
			0 ignored issues – show Documentation introduced 2015-11-23 21:03 UTC by Report Bug Copy Issue Report `'test'` is of type `string`, but the function expects a `array`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
247			}
248
249			public function testSetFieldMappingSetType(): void
250			{
251			$fieldMapping = [
252			'type' => 'integer',
253			'fieldName' => 'position',
254			];
255
256			$field = new FieldDescription();
257			$field->setFieldMapping($fieldMapping);
258
259			$this->assertSame('integer', $field->getType());
260			}
261
262			public function testSetFieldMappingSetMappingType(): void
263			{
264			$fieldMapping = [
265			'type' => 'integer',
266			'fieldName' => 'position',
267			];
268
269			$field = new FieldDescription();
270			$field->setFieldMapping($fieldMapping);
271
272			$this->assertSame('integer', $field->getMappingType());
273			}
274
275			public function testSetFieldMappingSetFieldName(): void
276			{
277			$fieldMapping = [
278			'type' => 'integer',
279			'fieldName' => 'position',
280			];
281
282			$field = new FieldDescription();
283			$field->setFieldMapping($fieldMapping);
284
285			$this->assertSame('position', $field->getFieldName());
286			}
287
288			public function testGetTargetEntity(): void
289			{
290			$assocationMapping = [
291			'type' => 'integer',
292			'fieldName' => 'position',
293			'targetEntity' => 'someValue',
294			];
295
296			$field = new FieldDescription();
297
298			$this->assertNull($field->getTargetModel());
299
300			$field->setAssociationMapping($assocationMapping);
301
302			$this->assertSame('someValue', $field->getTargetModel());
303			}
304
305			public function testIsIdentifierFromFieldMapping(): void
306			{
307			$fieldMapping = [
308			'type' => 'integer',
309			'fieldName' => 'position',
310			'id' => true,
311			];
312
313			$field = new FieldDescription();
314			$field->setFieldMapping($fieldMapping);
315
316			$this->assertTrue($field->isIdentifier());
317			}
318
319			public function testGetFieldMapping(): void
320			{
321			$fieldMapping = [
322			'type' => 'integer',
323			'fieldName' => 'position',
324			'id' => 'someId',
325			];
326
327			$field = new FieldDescription();
328			$field->setFieldMapping($fieldMapping);
329
330			$this->assertSame($fieldMapping, $field->getFieldMapping());
331			}
332
333			public function testGetValueForEmbeddedObject(): void
334			{
335			$mockedEmbeddedObject = $this->getMockBuilder('stdClass')
336			->setMethods(['myMethod'])
337			->getMock();
338			$mockedEmbeddedObject->expects($this->once())
339			->method('myMethod')
340			->willReturn('myMethodValue');
341
342			$mockedObject = $this->getMockBuilder('stdClass')
343			->setMethods(['getMyEmbeddedObject'])
344			->getMock();
345			$mockedObject->expects($this->once())
346			->method('getMyEmbeddedObject')
347			->willReturn($mockedEmbeddedObject);
348
349			$field = new FieldDescription();
350			$field->setFieldMapping([
351			'declaredField' => 'myEmbeddedObject', 'type' => 'string', 'fieldName' => 'myEmbeddedObject.myMethod',
352			]);
353			$field->setFieldName('myMethod');
354			$field->setOption('code', 'myMethod');
355
356			$this->assertSame('myMethodValue', $field->getValue($mockedObject));
357			}
358
359			public function testGetValueForMultiLevelEmbeddedObject(): void
360			{
361			$mockedChildEmbeddedObject = $this->getMockBuilder('stdClass')
362			->setMethods(['myMethod'])
363			->getMock();
364			$mockedChildEmbeddedObject->expects($this->once())
365			->method('myMethod')
366			->willReturn('myMethodValue');
367			$mockedEmbeddedObject = $this->getMockBuilder('stdClass')
368			->setMethods(['getChild'])
369			->getMock();
370			$mockedEmbeddedObject->expects($this->once())
371			->method('getChild')
372			->willReturn($mockedChildEmbeddedObject);
373			$mockedObject = $this->getMockBuilder('stdClass')
374			->setMethods(['getMyEmbeddedObject'])
375			->getMock();
376			$mockedObject->expects($this->once())
377			->method('getMyEmbeddedObject')
378			->willReturn($mockedEmbeddedObject);
379			$field = new FieldDescription();
380			$field->setFieldMapping([
381			'declaredField' => 'myEmbeddedObject.child', 'type' => 'string', 'fieldName' => 'myMethod',
382			]);
383			$field->setFieldName('myMethod');
384			$field->setOption('code', 'myMethod');
385			$this->assertSame('myMethodValue', $field->getValue($mockedObject));
386			}
387			}
388

sonata-project / SonataDoctrineORMAdminBundle

FieldDescriptionTest::testGetValue() A last analyzed 2020-08-28 02:03 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

FieldDescriptionTest::testGetValue() A
last analyzed 2020-08-28 02:03 UTC