Doctrine\Tests\Common\Persistence\TestObjectMetadata

Complexity

Total Complexity

18

Size/Duplication

Total Lines	89
Duplicated Lines	0 %

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	isCollectionValuedAssociation()	0	3	1
A	getAssociationMappedByTargetField()	0	4	1
A	getIdentifier()	0	3	1
A	hasAssociation()	0	3	1
A	getAssociationNames()	0	3	1
A	isSingleValuedAssociation()	0	3	1
A	isAssociationInverseSide()	0	3	1
A	initializeReflection()	0	2	1
A	getReflectionClass()	0	3	1
A	wakeupReflection()	0	2	1
A	getName()	0	3	1
A	getFieldNames()	0	3	1
A	getIdentifierValues()	0	2	1
A	hasField()	0	3	1
A	getTypeOfField()	0	4	1
A	getAssociationTargetClass()	0	3	1
A	isIdentifier()	0	3	1
A	getIdentifierFieldNames()	0	2	1

<?php

namespace Doctrine\Tests\Common\Persistence;

use BadMethodCallException;
use Doctrine\Common\Persistence\ObjectManager;
use Doctrine\Common\Persistence\PersistentObject;
use Doctrine\Common\Persistence\Mapping\ClassMetadata;
use Doctrine\Common\Persistence\Mapping\ReflectionService;
use InvalidArgumentException;
use RuntimeException;

/**
 * @group DDC-1448
 */
class PersistentObjectTest extends \Doctrine\Tests\DoctrineTestCase
{
    private $cm;
    private $om;
    private $object;

    public function setUp()
    {
        $this->cm = new TestObjectMetadata;
        $this->om = $this->createMock(ObjectManager::class);
        $this->om->expects($this->any())->method('getClassMetadata')
                 ->will($this->returnValue($this->cm));
        $this->object = new TestObject;
        PersistentObject::setObjectManager($this->om);
        $this->object->injectObjectManager($this->om, $this->cm);
    }

    public function testGetObjectManager()
    {
        self::assertSame($this->om, PersistentObject::getObjectManager());
    }

    public function testNonMatchingObjectManager()
    {
        $this->expectException(RuntimeException::class);
        $om = $this->createMock(ObjectManager::class);
        $this->object->injectObjectManager($om, $this->cm);
    }

    public function testGetField()
    {
        self::assertEquals('beberlei', $this->object->getName());
    }

    public function testSetField()
    {
        $this->object->setName("test");
        self::assertEquals("test", $this->object->getName());
    }

    public function testGetIdentifier()
    {
        self::assertEquals(1, $this->object->getId());
    }

    public function testSetIdentifier()
    {
        $this->expectException(BadMethodCallException::class);
        $this->object->setId(2);
    }

    public function testSetUnknownField()
    {
        $this->expectException(BadMethodCallException::class);
        $this->object->setUnknown("test");
    }

    public function testGetUnknownField()
    {
        $this->expectException(BadMethodCallException::class);
        $this->object->getUnknown();
    }

    public function testUndefinedMethod()
    {
        $this->expectException(BadMethodCallException::class);
        $this->expectExceptionMessage("There is no method");
        (new TestObject)->undefinedMethod();

The method undefinedMethod() does not exist on Doctrine\Tests\Common\Persistence\TestObject. Since you implemented __call, consider adding a @method annotation.

    }

    public function testGetToOneAssociation()
    {
        self::assertNull($this->object->getParent());
    }

    public function testSetToOneAssociation()
    {
        $parent = new TestObject();
        $this->object->setParent($parent);
        self::assertSame($parent, $this->object->getParent($parent));
    }

    public function testSetInvalidToOneAssociation()
    {
        $parent = new \stdClass();

        $this->expectException(InvalidArgumentException::class);
        $this->object->setParent($parent);
    }

    public function testSetToOneAssociationNull()
    {
        $parent = new TestObject();
        $this->object->setParent($parent);
        $this->object->setParent(null);
        self::assertNull($this->object->getParent());
    }

    public function testAddToManyAssociation()
    {
        $child = new TestObject();
        $this->object->addChildren($child);

        self::assertSame($this->object, $child->getParent());

The method getParent() does not exist on Doctrine\Tests\Common\Persistence\TestObject. Since you implemented __call, consider adding a @method annotation.

        self::assertEquals(1, count($this->object->getChildren()));

        $child = new TestObject();
        $this->object->addChildren($child);

        self::assertEquals(2, count($this->object->getChildren()));
    }

    public function testAddInvalidToManyAssociation()
    {
        $this->expectException(InvalidArgumentException::class);
        $this->object->addChildren(new \stdClass());
    }

    public function testNoObjectManagerSet()
    {
        PersistentObject::setObjectManager(null);
        $child = new TestObject();

        $this->expectException(RuntimeException::class);
        $child->setName("test");

The method setName() does not exist on Doctrine\Tests\Common\Persistence\TestObject. Since you implemented __call, consider adding a @method annotation.

    }

    public function testInvalidMethod()
    {
        $this->expectException(BadMethodCallException::class);
        $this->object->asdf();
    }

    public function testAddInvalidCollection()
    {
        $this->expectException(BadMethodCallException::class);
        $this->object->addAsdf(new \stdClass());
    }
}

class TestObject extends PersistentObject
{
    protected $id   = 1;
    protected $name = 'beberlei';
    protected $parent;
    protected $children;
}

class TestObjectMetadata implements ClassMetadata
{

    public function getAssociationMappedByTargetField($assocName)
    {
        $assoc = ['children' => 'parent'];
        return $assoc[$assocName];
    }

    public function getAssociationNames()
    {
        return ['parent', 'children'];
    }

    public function getAssociationTargetClass($assocName)
    {
        return __NAMESPACE__ . '\TestObject';
    }

    public function getFieldNames()
    {
        return ['id', 'name'];
    }

    public function getIdentifier()
    {
        return ['id'];
    }

    public function getName()
    {
        return __NAMESPACE__ . '\TestObject';
    }

    public function getReflectionClass()
    {
        return new \ReflectionClass($this->getName());
    }

    public function getTypeOfField($fieldName)
    {
        $types = ['id' => 'integer', 'name' => 'string'];
        return $types[$fieldName];
    }

    public function hasAssociation($fieldName)
    {
        return in_array($fieldName, ['parent', 'children']);
    }

    public function hasField($fieldName)
    {
        return in_array($fieldName, ['id', 'name']);
    }

    public function isAssociationInverseSide($assocName)
    {
        return ($assocName === 'children');
    }

    public function isCollectionValuedAssociation($fieldName)
    {
        return ($fieldName === 'children');
    }

    public function isIdentifier($fieldName)
    {
        return $fieldName === 'id';
    }

    public function isSingleValuedAssociation($fieldName)
    {
        return $fieldName === 'parent';
    }

    public function getIdentifierValues($entity)
    {
    }

    public function getIdentifierFieldNames()
    {
    }

    public function initializeReflection(ReflectionService $reflService)

The parameter $reflService is not used and could be removed.

    {
    }

    public function wakeupReflection(ReflectionService $reflService)

The parameter $reflService is not used and could be removed.

    {
    }
}