ProxyFactoryTest::testFriendObjectsDoNotLazyLoadIfNotAccessingLazyState() - Code Metrics - Inspection of "Replace proxy layer with ProxyManager's layer" - doctrine/orm - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions
Pull Request — develop (#6719)

by Marco
created 2017-09-23 14:07 UTC
testFriendObjectsDoNotLazyLoadIfNotAccessingLazyState() A

↳ Parent: ProxyFactoryTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	20
Code Lines	10
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
dl	0
loc	20
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	10
nc	1
nop	0
<?php

declare(strict_types=1);

namespace Doctrine\Tests\ORM\Proxy;

use Doctrine\ORM\EntityNotFoundException;
use Doctrine\ORM\Mapping\ClassMetadata;
use Doctrine\ORM\Mapping\ClassMetadataBuildingContext;
use Doctrine\ORM\Mapping\ClassMetadataFactory;
use Doctrine\ORM\Persisters\Entity\BasicEntityPersister;
use Doctrine\ORM\Proxy\Factory\StaticProxyFactory;
use Doctrine\ORM\Reflection\RuntimeReflectionService;
use Doctrine\Tests\Mocks\ConnectionMock;
use Doctrine\Tests\Mocks\DriverMock;
use Doctrine\Tests\Mocks\EntityManagerMock;
use Doctrine\Tests\Mocks\UnitOfWorkMock;
use Doctrine\Tests\Models\Company\CompanyEmployee;
use Doctrine\Tests\Models\ECommerce\ECommerceFeature;
use Doctrine\Tests\Models\FriendObject\ComparableObject;
use Doctrine\Tests\OrmTestCase;
use ProxyManager\Proxy\GhostObjectInterface;

/**
 * Test the proxy generator. Its work is generating on-the-fly subclasses of a given model, which implement the Proxy pattern.
 * @author Giorgio Sironi <[email protected]>
 */
class ProxyFactoryTest extends OrmTestCase
{
    /**
     * @var ConnectionMock
     */
    private $connectionMock;

    /**
     * @var UnitOfWorkMock
     */
    private $uowMock;

    /**
     * @var EntityManagerMock
     */
    private $emMock;

    /**
     * @var StaticProxyFactory
     */
    private $proxyFactory;

    /**
     * @var ClassMetadataBuildingContext
     */
    private $metadataBuildingContext;

    /**
     * {@inheritDoc}
     */
    protected function setUp()
    {
        parent::setUp();

        $this->metadataBuildingContext = new ClassMetadataBuildingContext(
            $this->createMock(ClassMetadataFactory::class),
            new RuntimeReflectionService()
        );
        $this->connectionMock          = new ConnectionMock([], new DriverMock());
        $this->emMock                  = EntityManagerMock::create($this->connectionMock);
        $this->uowMock                 = new UnitOfWorkMock($this->emMock);

        $this->emMock->setUnitOfWork($this->uowMock);

        $this->proxyFactory = new StaticProxyFactory(
            $this->emMock,
            $this->emMock->getConfiguration()->buildGhostObjectFactory()
        );
    }

    public function testReferenceProxyDelegatesLoadingToThePersister()
    {
        $identifier    = ['id' => 42];
        $classMetaData = $this->emMock->getClassMetadata(ECommerceFeature::class);

        $persister = $this
            ->getMockBuilder(BasicEntityPersister::class)
            ->setConstructorArgs([$this->emMock, $classMetaData])
            ->setMethods(['loadById'])
            ->getMock();

        $persister
            ->expects($this->atLeastOnce())
            ->method('loadById')
            ->with(
                $identifier,
                self::logicalAnd(
                    self::isInstanceOf(GhostObjectInterface::class),
                    self::isInstanceOf(ECommerceFeature::class)
                )
            )
            ->will($this->returnValue(new \stdClass()));

        $this->uowMock->setEntityPersister(ECommerceFeature::class, $persister);

        /* @var $proxy GhostObjectInterface|ECommerceFeature */
        $proxy = $this->proxyFactory->getProxy(ECommerceFeature::class, $identifier);

        $proxy->getDescription();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    /**
     * @group DDC-1771
     */
    public function testSkipAbstractClassesOnGeneration()
    {
        $cm = new ClassMetadata(AbstractClass::class, $this->metadataBuildingContext);

        self::assertNotNull($cm->getReflectionClass());

        $num = $this->proxyFactory->generateProxyClasses([$cm]);

        self::assertEquals(0, $num, "No proxies generated.");
    }

    /**
     * @group DDC-2432
     */
    public function testFailedProxyLoadingDoesNotMarkTheProxyAsInitialized()
    {
        $classMetaData = $this->emMock->getClassMetadata(ECommerceFeature::class);

        $persister = $this
            ->getMockBuilder(BasicEntityPersister::class)
            ->setConstructorArgs([$this->emMock, $classMetaData])
            ->setMethods(['load'])
            ->getMock();

        $persister
            ->expects($this->atLeastOnce())
            ->method('load')
            ->will($this->returnValue(null));

        $this->uowMock->setEntityPersister(ECommerceFeature::class, $persister);

        /* @var $proxy GhostObjectInterface|ECommerceFeature */
        $proxy = $this->proxyFactory->getProxy(ECommerceFeature::class, ['id' => 42]);

        try {
            $proxy->getDescription();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            $this->fail('An exception was expected to be raised');
        } catch (EntityNotFoundException $exception) {

        }

        self::assertFalse($proxy->isProxyInitialized());
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    /**
     * @group DDC-2432
     */
    public function testFailedProxyCloningDoesNotMarkTheProxyAsInitialized()
    {
        $classMetaData = $this->emMock->getClassMetadata(ECommerceFeature::class);

        $persister = $this
            ->getMockBuilder(BasicEntityPersister::class)
            ->setConstructorArgs([$this->emMock, $classMetaData])
            ->setMethods(['load'])
            ->getMock();

        $persister
            ->expects($this->atLeastOnce())
            ->method('load')
            ->will($this->returnValue(null));

        $this->uowMock->setEntityPersister(ECommerceFeature::class, $persister);

        /* @var $proxy GhostObjectInterface|ECommerceFeature */
        $proxy = $this->proxyFactory->getProxy(ECommerceFeature::class, ['id' => 42]);

        try {
            $cloned = clone $proxy;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            $this->fail('An exception was expected to be raised');
        } catch (EntityNotFoundException $exception) {

        }

        self::assertFalse($proxy->isProxyInitialized());
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    public function testProxyClonesParentFields()
    {
        $identifier    = ['id' => 42];
        $classMetaData = $this->emMock->getClassMetadata(CompanyEmployee::class);

        $persister = $this
            ->getMockBuilder(BasicEntityPersister::class)
            ->setConstructorArgs([$this->emMock, $classMetaData])
            ->setMethods(['loadById'])
            ->getMock();

        $persister
            ->expects(self::atLeastOnce())
            ->method('loadById')
            ->with(
                $identifier,
                self::logicalAnd(
                    self::isInstanceOf(GhostObjectInterface::class),
                    self::isInstanceOf(CompanyEmployee::class)
                )
            )
            ->willReturnCallback(function (array $id, CompanyEmployee $companyEmployee) {
                $companyEmployee->setSalary(1000); // A property on the CompanyEmployee
                $companyEmployee->setName('Bob'); // A property on the parent class, CompanyPerson

                return $companyEmployee;
            });

        $this->uowMock->setEntityPersister(CompanyEmployee::class, $persister);

        /* @var $proxy GhostObjectInterface|CompanyEmployee */
        $proxy = $this->proxyFactory->getProxy(CompanyEmployee::class, $identifier);

        $cloned = clone $proxy;

        self::assertSame(42, $cloned->getId(), 'Expected the Id to be cloned');
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        self::assertSame(1000, $cloned->getSalary(), 'Expect properties on the CompanyEmployee class to be cloned');
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        self::assertSame('Bob', $cloned->getName(), 'Expect properties on the CompanyPerson class to be cloned');
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    public function testFriendObjectsDoNotLazyLoadIfNotAccessingLazyState()
    {
        /* @var $persister BasicEntityPersister|\PHPUnit_Framework_MockObject_MockObject */
        $persister = $this->createMock(BasicEntityPersister::class);
        $persister->expects(self::never())->method('loadById');
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $this->uowMock->setEntityPersister(ComparableObject::class, $persister);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        /* @var $comparable ComparableObject|GhostObjectInterface */
        $comparable = $this->proxyFactory->getProxy(ComparableObject::class, ['id' => 123]);

        self::assertInstanceOf(ComparableObject::class, $comparable);
        self::assertInstanceOf(GhostObjectInterface::class, $comparable);
        self::assertFalse($comparable->isProxyInitialized());
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        // due to implementation details, identity check is not reading lazy state:
        self::assertTrue($comparable->equalTo($comparable));
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

        self::assertFalse($comparable->isProxyInitialized());
    }

    public function testFriendObjectsLazyLoadWhenAccessingLazyState()
    {
        /* @var $persister BasicEntityPersister|\PHPUnit_Framework_MockObject_MockObject */
        $persister = $this
            ->getMockBuilder(BasicEntityPersister::class)
            ->setConstructorArgs([$this->emMock, $this->emMock->getClassMetadata(ComparableObject::class)])
            ->setMethods(['loadById'])
            ->getMock();

        $persister
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects(self::exactly(2))
            ->method('loadById')
            ->with(
                self::logicalOr(['id' => 123], ['id' => 456]),
                self::logicalAnd(
                    self::isInstanceOf(GhostObjectInterface::class),
                    self::isInstanceOf(ComparableObject::class)
                )
            )
            ->willReturnCallback(function (array $id, ComparableObject $comparableObject) {
                $comparableObject->setComparedFieldValue(\json_encode($id));

                return $comparableObject;
            });

        $this->uowMock->setEntityPersister(ComparableObject::class, $persister);

        /* @var $comparable1 ComparableObject|GhostObjectInterface */
        $comparable1 = $this->proxyFactory->getProxy(ComparableObject::class, ['id' => 123]);
        /* @var $comparable2 ComparableObject|GhostObjectInterface */
        $comparable2 = $this->proxyFactory->getProxy(ComparableObject::class, ['id' => 456]);

        self::assertInstanceOf(ComparableObject::class, $comparable1);
        self::assertInstanceOf(ComparableObject::class, $comparable2);
        self::assertInstanceOf(GhostObjectInterface::class, $comparable1);
        self::assertInstanceOf(GhostObjectInterface::class, $comparable2);
        self::assertNotSame($comparable1, $comparable2);
        self::assertFalse($comparable1->isProxyInitialized());
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        self::assertFalse($comparable2->isProxyInitialized());

        // due to implementation details, identity check is not reading lazy state:
        self::assertFalse($comparable1->equalTo($comparable2));
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

        self::assertTrue($comparable1->isProxyInitialized());
        self::assertTrue($comparable2->isProxyInitialized());
    }
}

abstract class AbstractClass
{

}

Pull Request — develop (#6719)

testFriendObjectsDoNotLazyLoadIfNotAccessingLazyState() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

doctrine / orm

Pull Request — develop (#6719)

testFriendObjectsDoNotLazyLoadIfNotAccessingLazyState() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like
