Doctrine\Tests\ORM\Functional\ReferenceProxyTest

Complexity

Total Complexity

14

Size/Duplication

Total Lines	251
Duplicated Lines	27.09 %

Coupling/Cohesion

Components	1
Dependencies	12

Importance

Changes	3
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	15	1
A	createProduct()	0	11	1
A	createAuction()	0	11	1
A	testLazyLoadsFieldValuesFromDatabase()	0	8	1
A	testAccessMetatadaForProxy()	9	9	1
A	testReferenceFind()	10	10	1
A	testCloneProxy()	0	23	1
A	testInitializeProxy()	0	13	1
A	testInitializeChangeAndFlushProxy()	16	17	1
A	testDoNotInitializeProxyOnGettingTheIdentifier()	11	11	1
A	testDoNotInitializeProxyOnGettingTheIdentifier_DDC_1625()	11	11	1
B	testDoNotInitializeProxyOnGettingTheIdentifierAndReturnTheRightType()	0	25	1
A	testInitializeProxyOnGettingSomethingOtherThanTheIdentifier()	11	11	1
B	testCommonPersistenceProxy()	0	34	1

<?php

declare(strict_types=1);

namespace Doctrine\Tests\ORM\Functional;

use Doctrine\ORM\Proxy\Factory\ProxyFactory;
use Doctrine\ORM\Proxy\Factory\StaticProxyFactory;
use Doctrine\ORM\Utility\StaticClassNameConverter;
use Doctrine\Tests\Models\Company\CompanyAuction;
use Doctrine\Tests\Models\ECommerce\ECommerceProduct;
use Doctrine\Tests\Models\ECommerce\ECommerceShipping;
use Doctrine\Tests\OrmFunctionalTestCase;
use ProxyManager\GeneratorStrategy\FileWriterGeneratorStrategy;
use ProxyManager\Proxy\GhostObjectInterface;

/**
 * Tests the generation of a proxy object for lazy loading.
 *
 * @author Giorgio Sironi <piccoloprincipeazzurro@gmail.com>
 * @author Benjamin Eberlei <kontakt@beberlei.de>
 */
class ReferenceProxyTest extends OrmFunctionalTestCase
{
    /**
     * @var ProxyFactory
     */
    private $factory;

    protected function setUp()
    {
        $this->useModelSet('ecommerce');
        $this->useModelSet('company');

        parent::setUp();

        $configuration = $this->em->getConfiguration();

        $configuration->setProxyNamespace(__NAMESPACE__ . '\\ProxyTest');
        $configuration->setProxyDir(__DIR__ . '/../../Proxies');
        $configuration->setAutoGenerateProxyClasses(StaticProxyFactory::AUTOGENERATE_ALWAYS);

        $this->factory = new StaticProxyFactory($this->em, $configuration->buildGhostObjectFactory());
    }

    public function createProduct()
    {
        $product = new ECommerceProduct();
        $product->setName('Doctrine Cookbook');
        $this->em->persist($product);

        $this->em->flush();
        $this->em->clear();

        return $product->getId();
    }

    public function createAuction()
    {
        $event = new CompanyAuction();
        $event->setData('Doctrine Cookbook');
        $this->em->persist($event);

        $this->em->flush();
        $this->em->clear();

        return $event->getId();
    }

    public function testLazyLoadsFieldValuesFromDatabase()
    {
        $id = $this->createProduct();

        $productProxy = $this->em->getReference(ECommerceProduct::class, ['id' => $id]);

        self::assertEquals('Doctrine Cookbook', $productProxy->getName());
    }

    /**
     * @group DDC-727
     */
    public function testAccessMetatadaForProxy()
    {
        $id = $this->createProduct();

        $entity = $this->em->getReference(ECommerceProduct::class , $id);
        $class = $this->em->getClassMetadata(get_class($entity));

        self::assertEquals(ECommerceProduct::class, $class->getClassName());

The method getClassName() does not seem to exist on object<Doctrine\Common\Persistence\Mapping\ClassMetadata>.

    }

    /**
     * @group DDC-1033
     */
    public function testReferenceFind()
    {
        $id = $this->createProduct();

        $entity = $this->em->getReference(ECommerceProduct::class , $id);
        $entity2 = $this->em->find(ECommerceProduct::class , $id);

        self::assertSame($entity, $entity2);
        self::assertEquals('Doctrine Cookbook', $entity2->getName());
    }

    /**
     * @group DDC-1033
     */
    public function testCloneProxy()
    {
        $id = $this->createProduct();

        /* @var $entity ECommerceProduct */
        $entity = $this->em->getReference(ECommerceProduct::class , $id);

        /* @var $clone ECommerceProduct */
        $clone = clone $entity;

        self::assertEquals($id, $entity->getId());
        self::assertEquals('Doctrine Cookbook', $entity->getName());

        self::assertFalse($this->em->contains($clone), "Cloning a reference proxy should return an unmanaged/detached entity.");
        self::assertTrue($this->em->contains($entity), "Real instance should be managed");
        self::assertEquals($id, $clone->getId(), "Cloning a reference proxy should return same id.");
        self::assertEquals('Doctrine Cookbook', $clone->getName(), "Cloning a reference proxy should return same product name.");
        self::assertEquals('Doctrine Cookbook', $entity->getName(), "Real instance should contain the real data too");

        // domain logic, Product::__clone sets isCloned public property
        self::assertTrue($clone->isCloned);
        self::assertFalse($entity->isCloned);
    }

    /**
     * @group DDC-733
     */
    public function testInitializeProxy()
    {
        $id = $this->createProduct();

        /* @var $entity ECommerceProduct|GhostObjectInterface */
        $entity = $this->em->getReference(ECommerceProduct::class , $id);

        self::assertFalse($entity->isProxyInitialized(), "Pre-Condition: Object is unitialized proxy.");

The method isProxyInitialized does only exist in ProxyManager\Proxy\GhostObjectInterface, but not in Doctrine\Tests\Models\ECommerce\ECommerceProduct.

        $this->em->getUnitOfWork()->initializeObject($entity);

        self::assertTrue($entity->isProxyInitialized(), "Should be initialized after called UnitOfWork::initializeObject()");
    }

    /**
     * @group DDC-1163
     */
    public function testInitializeChangeAndFlushProxy()
    {
        $id = $this->createProduct();

        /* @var $entity ECommerceProduct|GhostObjectInterface */
        $entity = $this->em->getReference(ECommerceProduct::class , $id);

        $entity->setName('Doctrine 2 Cookbook');

The method setName does only exist in Doctrine\Tests\Models\ECommerce\ECommerceProduct, but not in ProxyManager\Proxy\GhostObjectInterface.

        $this->em->flush();
        $this->em->clear();

        /* @var $entity ECommerceProduct|GhostObjectInterface */
        $entity = $this->em->getReference(ECommerceProduct::class , $id);

        self::assertEquals('Doctrine 2 Cookbook', $entity->getName());

The method getName does only exist in Doctrine\Tests\Models\ECommerce\ECommerceProduct, but not in ProxyManager\Proxy\GhostObjectInterface.

    }

    public function testDoNotInitializeProxyOnGettingTheIdentifier()
    {
        $id = $this->createProduct();

        /* @var $entity ECommerceProduct|GhostObjectInterface */
        $entity = $this->em->getReference(ECommerceProduct::class , $id);

        self::assertFalse($entity->isProxyInitialized(), "Pre-Condition: Object is unitialized proxy.");

The method isProxyInitialized does only exist in ProxyManager\Proxy\GhostObjectInterface, but not in Doctrine\Tests\Models\ECommerce\ECommerceProduct.

        self::assertEquals($id, $entity->getId());

The method getId does only exist in Doctrine\Tests\Models\ECommerce\ECommerceProduct, but not in ProxyManager\Proxy\GhostObjectInterface.

        self::assertFalse($entity->isProxyInitialized(), "Getting the identifier doesn't initialize the proxy.");
    }

    /**
     * @group DDC-1625
     */
    public function testDoNotInitializeProxyOnGettingTheIdentifier_DDC_1625()
    {
        $id = $this->createAuction();

        /* @var $entity CompanyAuction|GhostObjectInterface */
        $entity = $this->em->getReference(CompanyAuction::class , $id);

        self::assertFalse($entity->isProxyInitialized(), "Pre-Condition: Object is unitialized proxy.");

The method isProxyInitialized does only exist in ProxyManager\Proxy\GhostObjectInterface, but not in Doctrine\Tests\Models\Company\CompanyAuction.

        self::assertEquals($id, $entity->getId());

The method getId does only exist in Doctrine\Tests\Models\Company\CompanyAuction, but not in ProxyManager\Proxy\GhostObjectInterface.

        self::assertFalse($entity->isProxyInitialized(), "Getting the identifier doesn't initialize the proxy when extending.");
    }

    public function testDoNotInitializeProxyOnGettingTheIdentifierAndReturnTheRightType()
    {
        $product = new ECommerceProduct();
        $product->setName('Doctrine Cookbook');

        $shipping = new ECommerceShipping();
        $shipping->setDays(1);
        $product->setShipping($shipping);

        $this->em->persist($product);
        $this->em->flush();
        $this->em->clear();

        $id = $shipping->getId();

        /* @var $entity ECommerceProduct|GhostObjectInterface */
        $product = $this->em->getRepository(ECommerceProduct::class)->find($product->getId());

        $entity = $product->getShipping();

        self::assertFalse($entity->isProxyInitialized(), "Pre-Condition: Object is unitialized proxy.");
        self::assertEquals($id, $entity->getId());
        self::assertSame($id, $entity->getId(), "Check that the id's are the same value, and type.");
        self::assertFalse($entity->isProxyInitialized(), "Getting the identifier doesn't initialize the proxy.");
    }

    public function testInitializeProxyOnGettingSomethingOtherThanTheIdentifier()
    {
        $id = $this->createProduct();

        /* @var $entity ECommerceProduct|GhostObjectInterface */
        $entity = $this->em->getReference(ECommerceProduct::class , $id);

        self::assertFalse($entity->isProxyInitialized(), "Pre-Condition: Object is unitialized proxy.");

The method isProxyInitialized does only exist in ProxyManager\Proxy\GhostObjectInterface, but not in Doctrine\Tests\Models\ECommerce\ECommerceProduct.

        self::assertEquals('Doctrine Cookbook', $entity->getName());

The method getName does only exist in Doctrine\Tests\Models\ECommerce\ECommerceProduct, but not in ProxyManager\Proxy\GhostObjectInterface.

        self::assertTrue($entity->isProxyInitialized(), "Getting something other than the identifier initializes the proxy.");
    }

    /**
     * @group DDC-1604
     */
    public function testCommonPersistenceProxy()
    {
        $id = $this->createProduct();

        /* @var $entity ECommerceProduct|GhostObjectInterface */
        $entity = $this->em->getReference(ECommerceProduct::class , $id);

        $className = StaticClassNameConverter::getClass($entity);

        self::assertInstanceOf(GhostObjectInterface::class, $entity);
        self::assertFalse($entity->isProxyInitialized());

The method isProxyInitialized does only exist in ProxyManager\Proxy\GhostObjectInterface, but not in Doctrine\Tests\Models\ECommerce\ECommerceProduct.

        self::assertEquals(ECommerceProduct::class, $className);

        $proxyManagerConfiguration = $this->em->getConfiguration()->getProxyManagerConfiguration();

        self::assertInstanceOf(
            FileWriterGeneratorStrategy::class,
            $proxyManagerConfiguration->getGeneratorStrategy(),
            'Proxies are being written to disk in this test'
        );

        $proxy = $this->factory->getProxy(
            $this->em->getClassMetadata(ECommerceProduct::class),

$this->em->getClassMetadata(\Doctrine\Tests\Models\ECommerce\ECommerceProduct::class) is of type object<Doctrine\Common\Persistence\Mapping\ClassMetadata>, but the function expects a object<Doctrine\ORM\Mapping\ClassMetadata>.

            ['id' => 123]
        );

        $proxyClass = new \ReflectionClass($proxy);

        self::assertFileExists($proxyClass->getFileName());

        $entity->initializeProxy();

The method initializeProxy does only exist in ProxyManager\Proxy\GhostObjectInterface, but not in Doctrine\Tests\Models\ECommerce\ECommerceProduct.

        self::assertTrue($entity->isProxyInitialized());
    }
}