Sonata\DoctrineORMAdminBundle\Tests\Admin\FieldDescriptionTest

Complexity

Total Complexity

23

Size/Duplication

Total Lines	340
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	1

Importance

Changes	3
Bugs	1	Features	0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	testOptions()	0	61	2
B	testAssociationMapping()	0	26	1
A	testSetFieldMappingSetType()	0	12	1
A	testSetFieldMappingSetMappingType()	0	12	1
A	testSetFieldMappingSetFieldName()	0	12	1
A	testGetTargetEntity()	0	16	1
A	testIsIdentifierFromFieldMapping()	0	13	1
A	testGetFieldMapping()	0	13	1
A	testSetName()	0	7	1
A	testSetNameSetFieldNameToo()	0	7	1
A	testSetNameDoesNotSetFieldNameWhenSetBefore()	0	8	1
A	testGetParent()	0	8	1
A	testGetHelp()	0	7	1
A	testGetAdmin()	0	8	1
A	testGetAssociationAdmin()	0	14	1
A	testHasAssociationAdmin()	0	17	1
A	testGetValue()	0	12	1
A	testGetValueWhenCannotRetrieve()	0	11	1
A	testGetAssociationMapping()	0	12	1
A	testSetAssociationMappingAllowOnlyForArray()	0	5	1
A	testSetFieldMappingAllowOnlyForArray()	0	5	1
A	testGetValueForEmbeddedObject()	0	21	1

<?php

/*
 * This file is part of the Sonata Project package.
 *
 * (c) Thomas Rabaix <thomas.rabaix@sonata-project.org>
 *
 * 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 Sonata\DoctrineORMAdminBundle\Admin\FieldDescription;

class FieldDescriptionTest extends \PHPUnit_Framework_TestCase
{
    public function testOptions()
    {
        $field = new FieldDescription();
        $field->setOptions(array(
            'template' => 'foo',
            'type' => 'bar',
            'misc' => 'foobar',
        ));

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

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

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

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

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

        $field->mergeOption('non_existant', array('key1' => 'key_1', 'key2' => 'key_2'));

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

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

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

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

Consider adding a comment why this CATCH block is empty.

        }

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

        $expected = array(
            'misc' => 'foobar',
            'array' => array(
                'key1' => 'key_1',
                'key2' => 'key_2',
                'key3' => 'key_3',
            ),
            'non_existant' => array(
                'key1' => 'key_1',
                'key2' => 'key_2',
            ),
            'integer' => 1,
            'final' => 'test',
            'placeholder' => 'short_object_description_placeholder',
            'link_parameters' => array(),
        );

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

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

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

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

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

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

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

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

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

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

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

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

    public function testGetParent()
    {
        $adminMock = $this->getMock('Sonata\AdminBundle\Admin\AdminInterface');
        $field = new FieldDescription();
        $field->setParent($adminMock);

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

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

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

    public function testGetAdmin()
    {
        $adminMock = $this->getMock('Sonata\AdminBundle\Admin\AdminInterface');
        $field = new FieldDescription();
        $field->setAdmin($adminMock);

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

    public function testGetAssociationAdmin()
    {
        $adminMock = $this->getMockBuilder('Sonata\AdminBundle\Admin\Admin')
            ->disableOriginalConstructor()
            ->getMock();
        $adminMock->expects($this->once())
            ->method('setParentFieldDescription')
            ->with($this->isInstanceOf('Sonata\AdminBundle\Admin\FieldDescriptionInterface'));

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

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

    public function testHasAssociationAdmin()
    {
        $adminMock = $this->getMockBuilder('Sonata\AdminBundle\Admin\Admin')
            ->disableOriginalConstructor()
            ->getMock();
        $adminMock->expects($this->once())
            ->method('setParentFieldDescription')
            ->with($this->isInstanceOf('Sonata\AdminBundle\Admin\FieldDescriptionInterface'));

        $field = new FieldDescription();

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

        $field->setAssociationAdmin($adminMock);

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

    public function testGetValue()
    {
        $mockedObject = $this->getMock('MockedTestObject', array('myMethod'));
        $mockedObject->expects($this->once())
            ->method('myMethod')
            ->will($this->returnValue('myMethodValue'));

        $field = new FieldDescription();
        $field->setOption('code', 'myMethod');

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

    /**
     * @expectedException Sonata\AdminBundle\Exception\NoValueException
     */
    public function testGetValueWhenCannotRetrieve()
    {
        $mockedObject = $this->getMock('MockedTestObject', array('myMethod'));
        $mockedObject->expects($this->never())
            ->method('myMethod')
            ->will($this->returnValue('myMethodValue'));

        $field = new FieldDescription();

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

    public function testGetAssociationMapping()
    {
        $assocationMapping = array(
            'type' => 'integer',
            'fieldName' => 'position',
        );

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

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

    /**
     * @expectedException \RuntimeException
     */
    public function testSetAssociationMappingAllowOnlyForArray()
    {
        $field = new FieldDescription();
        $field->setAssociationMapping('test');

'test' is of type string, but the function expects a array.

    }

    /**
     * @expectedException \RuntimeException
     */
    public function testSetFieldMappingAllowOnlyForArray()
    {
        $field = new FieldDescription();
        $field->setFieldMapping('test');

'test' is of type string, but the function expects a array.

    }

    public function testSetFieldMappingSetType()
    {
        $fieldMapping = array(
            'type' => 'integer',
            'fieldName' => 'position',
        );

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

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

    public function testSetFieldMappingSetMappingType()
    {
        $fieldMapping = array(
            'type' => 'integer',
            'fieldName' => 'position',
        );

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

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

    public function testSetFieldMappingSetFieldName()
    {
        $fieldMapping = array(
            'type' => 'integer',
            'fieldName' => 'position',
        );

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

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

    public function testGetTargetEntity()
    {
        $assocationMapping = array(
            'type' => 'integer',
            'fieldName' => 'position',
            'targetEntity' => 'someValue',
        );

        $field = new FieldDescription();

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

        $field->setAssociationMapping($assocationMapping);

        $this->assertEquals('someValue', $field->getTargetEntity());
    }

    public function testIsIdentifierFromFieldMapping()
    {
        $fieldMapping = array(
            'type' => 'integer',
            'fieldName' => 'position',
            'id' => 'someId',
        );

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

        $this->assertEquals('someId', $field->isIdentifier());
    }

    public function testGetFieldMapping()
    {
        $fieldMapping = array(
            'type' => 'integer',
            'fieldName' => 'position',
            'id' => 'someId',
        );

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

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

    public function testGetValueForEmbeddedObject()
    {
        $mockedEmbeddedObject = $this->getMock('MockedTestObject', array('myMethod'));
        $mockedEmbeddedObject->expects($this->once())
                    ->method('myMethod')
                    ->will($this->returnValue('myMethodValue'));

        $mockedObject = $this->getMock('MockedTestObject', array('getMyEmbeddedObject'));
        $mockedObject->expects($this->once())
            ->method('getMyEmbeddedObject')
            ->will($this->returnValue($mockedEmbeddedObject));

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

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