ReferenceProxyTest::createProduct() - 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 18:46 UTC

ReferenceProxyTest::createProduct() A

↳ Parent: ReferenceProxyTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	11
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	11
c	0
b	0
f	0
rs	9.4285
cc	1
eloc	7
nc	1
nop	0

<?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 <[email protected]>
 * @author Benjamin Eberlei <[email protected]>
 */
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());

    }

    /**
     * @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.");
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->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');
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->em->flush();
        $this->em->clear();

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

        self::assertEquals('Doctrine 2 Cookbook', $entity->getName());
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 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.");
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::assertEquals($id, $entity->getId());
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($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.");
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::assertEquals($id, $entity->getId());
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($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.");
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::assertEquals('Doctrine Cookbook', $entity->getName());
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::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());
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::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(ECommerceProduct::class, ['id' => 123]);

        $proxyClass = new \ReflectionClass($proxy);

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

        $entity->initializeProxy();
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::assertTrue($entity->isProxyInitialized());
    }
}


Pull Request — develop (#6719)

ReferenceProxyTest::createProduct() 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

1		<?php
2
3		declare(strict_types=1);
4
5		namespace Doctrine\Tests\ORM\Functional;
6
7		use Doctrine\ORM\Proxy\Factory\ProxyFactory;
8		use Doctrine\ORM\Proxy\Factory\StaticProxyFactory;
9		use Doctrine\ORM\Utility\StaticClassNameConverter;
10		use Doctrine\Tests\Models\Company\CompanyAuction;
11		use Doctrine\Tests\Models\ECommerce\ECommerceProduct;
12		use Doctrine\Tests\Models\ECommerce\ECommerceShipping;
13		use Doctrine\Tests\OrmFunctionalTestCase;
14		use ProxyManager\GeneratorStrategy\FileWriterGeneratorStrategy;
15		use ProxyManager\Proxy\GhostObjectInterface;
16
17		/**
18		* Tests the generation of a proxy object for lazy loading.
19		*
20		* @author Giorgio Sironi <[email protected]>
21		* @author Benjamin Eberlei <[email protected]>
22		*/
23		class ReferenceProxyTest extends OrmFunctionalTestCase
24		{
25		/**
26		* @var ProxyFactory
27		*/
28		private $factory;
29
30		protected function setUp()
31		{
32		$this->useModelSet('ecommerce');
33		$this->useModelSet('company');
34
35		parent::setUp();
36
37		$configuration = $this->em->getConfiguration();
38
39		$configuration->setProxyNamespace(__NAMESPACE__ . '\\ProxyTest');
40		$configuration->setProxyDir(__DIR__ . '/../../Proxies');
41		$configuration->setAutoGenerateProxyClasses(StaticProxyFactory::AUTOGENERATE_ALWAYS);
42
43		$this->factory = new StaticProxyFactory($this->em, $configuration->buildGhostObjectFactory());
44		}
45
46		public function createProduct()
47		{
48		$product = new ECommerceProduct();
49		$product->setName('Doctrine Cookbook');
50		$this->em->persist($product);
51
52		$this->em->flush();
53		$this->em->clear();
54
55		return $product->getId();
56		}
57
58		public function createAuction()
59		{
60		$event = new CompanyAuction();
61		$event->setData('Doctrine Cookbook');
62		$this->em->persist($event);
63
64		$this->em->flush();
65		$this->em->clear();
66
67		return $event->getId();
68		}
69
70		public function testLazyLoadsFieldValuesFromDatabase()
71		{
72		$id = $this->createProduct();
73
74		$productProxy = $this->em->getReference(ECommerceProduct::class, ['id' => $id]);
75
76		self::assertEquals('Doctrine Cookbook', $productProxy->getName());
77		}
78
79		/**
80		* @group DDC-727
81		*/
82	View Code Duplication	public function testAccessMetatadaForProxy()
83		{
84		$id = $this->createProduct();
85
86		$entity = $this->em->getReference(ECommerceProduct::class , $id);
87		$class = $this->em->getClassMetadata(get_class($entity));
88
89		self::assertEquals(ECommerceProduct::class, $class->getClassName());
		0 ignored issues – show Bug introduced 2017-08-03 00:10 UTC by Report Bug Copy Issue Report The method `getClassName()` does not seem to exist on `object<Doctrine\Common\P...\Mapping\ClassMetadata>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
90		}
91
92		/**
93		* @group DDC-1033
94		*/
95	View Code Duplication	public function testReferenceFind()
96		{
97		$id = $this->createProduct();
98
99		$entity = $this->em->getReference(ECommerceProduct::class , $id);
100		$entity2 = $this->em->find(ECommerceProduct::class , $id);
101
102		self::assertSame($entity, $entity2);
103		self::assertEquals('Doctrine Cookbook', $entity2->getName());
104		}
105
106		/**
107		* @group DDC-1033
108		*/
109		public function testCloneProxy()
110		{
111		$id = $this->createProduct();
112
113		/* @var $entity ECommerceProduct */
114		$entity = $this->em->getReference(ECommerceProduct::class , $id);
115
116		/* @var $clone ECommerceProduct */
117		$clone = clone $entity;
118
119		self::assertEquals($id, $entity->getId());
120		self::assertEquals('Doctrine Cookbook', $entity->getName());
121
122		self::assertFalse($this->em->contains($clone), "Cloning a reference proxy should return an unmanaged/detached entity.");
123		self::assertTrue($this->em->contains($entity), "Real instance should be managed");
124		self::assertEquals($id, $clone->getId(), "Cloning a reference proxy should return same id.");
125		self::assertEquals('Doctrine Cookbook', $clone->getName(), "Cloning a reference proxy should return same product name.");
126		self::assertEquals('Doctrine Cookbook', $entity->getName(), "Real instance should contain the real data too");
127
128		// domain logic, Product::__clone sets isCloned public property
129		self::assertTrue($clone->isCloned);
130		self::assertFalse($entity->isCloned);
131		}
132
133		/**
134		* @group DDC-733
135		*/
136		public function testInitializeProxy()
137		{
138		$id = $this->createProduct();
139
140		/* @var $entity ECommerceProduct\|GhostObjectInterface */
141		$entity = $this->em->getReference(ECommerceProduct::class , $id);
142
143		self::assertFalse($entity->isProxyInitialized(), "Pre-Condition: Object is unitialized proxy.");
		0 ignored issues – show Bug introduced 2016-01-30 14:44 UTC by Report Bug Copy Issue Report The method `isProxyInitialized` does only exist in `ProxyManager\Proxy\GhostObjectInterface`, but not in `Doctrine\Tests\Models\ECommerce\ECommerceProduct`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: 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. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
144
145		$this->em->getUnitOfWork()->initializeObject($entity);
146
147		self::assertTrue($entity->isProxyInitialized(), "Should be initialized after called UnitOfWork::initializeObject()");
148		}
149
150		/**
151		* @group DDC-1163
152		*/
153	View Code Duplication	public function testInitializeChangeAndFlushProxy()
154		{
155		$id = $this->createProduct();
156
157		/* @var $entity ECommerceProduct\|GhostObjectInterface */
158		$entity = $this->em->getReference(ECommerceProduct::class , $id);
159
160		$entity->setName('Doctrine 2 Cookbook');
		0 ignored issues – show Bug introduced 2017-09-22 09:54 UTC by Report Bug Copy Issue Report The method `setName` does only exist in `Doctrine\Tests\Models\ECommerce\ECommerceProduct`, but not in `ProxyManager\Proxy\GhostObjectInterface`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: 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. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
161
162		$this->em->flush();
163		$this->em->clear();
164
165		/* @var $entity ECommerceProduct\|GhostObjectInterface */
166		$entity = $this->em->getReference(ECommerceProduct::class , $id);
167
168		self::assertEquals('Doctrine 2 Cookbook', $entity->getName());
		0 ignored issues – show Bug introduced 2016-01-30 14:44 UTC by Report Bug Copy Issue Report The method `getName` does only exist in `Doctrine\Tests\Models\ECommerce\ECommerceProduct`, but not in `ProxyManager\Proxy\GhostObjectInterface`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: 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. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
169		}
170
171	View Code Duplication	public function testDoNotInitializeProxyOnGettingTheIdentifier()
172		{
173		$id = $this->createProduct();
174
175		/* @var $entity ECommerceProduct\|GhostObjectInterface */
176		$entity = $this->em->getReference(ECommerceProduct::class , $id);
177
178		self::assertFalse($entity->isProxyInitialized(), "Pre-Condition: Object is unitialized proxy.");
		0 ignored issues – show Bug introduced 2016-01-30 14:44 UTC by Report Bug Copy Issue Report The method `isProxyInitialized` does only exist in `ProxyManager\Proxy\GhostObjectInterface`, but not in `Doctrine\Tests\Models\ECommerce\ECommerceProduct`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: 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. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
179		self::assertEquals($id, $entity->getId());
		0 ignored issues – show Bug introduced 2017-09-22 09:54 UTC by Report Bug Copy Issue Report The method `getId` does only exist in `Doctrine\Tests\Models\ECommerce\ECommerceProduct`, but not in `ProxyManager\Proxy\GhostObjectInterface`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: 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. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
180		self::assertFalse($entity->isProxyInitialized(), "Getting the identifier doesn't initialize the proxy.");
181		}
182
183		/**
184		* @group DDC-1625
185		*/
186	View Code Duplication	public function testDoNotInitializeProxyOnGettingTheIdentifier_DDC_1625()
187		{
188		$id = $this->createAuction();
189
190		/* @var $entity CompanyAuction\|GhostObjectInterface */
191		$entity = $this->em->getReference(CompanyAuction::class , $id);
192
193		self::assertFalse($entity->isProxyInitialized(), "Pre-Condition: Object is unitialized proxy.");
		0 ignored issues – show Bug introduced 2016-01-30 14:44 UTC by Report Bug Copy Issue Report The method `isProxyInitialized` does only exist in `ProxyManager\Proxy\GhostObjectInterface`, but not in `Doctrine\Tests\Models\Company\CompanyAuction`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: 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. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
194		self::assertEquals($id, $entity->getId());
		0 ignored issues – show Bug introduced 2017-09-22 09:54 UTC by Report Bug Copy Issue Report The method `getId` does only exist in `Doctrine\Tests\Models\Company\CompanyAuction`, but not in `ProxyManager\Proxy\GhostObjectInterface`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: 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. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
195		self::assertFalse($entity->isProxyInitialized(), "Getting the identifier doesn't initialize the proxy when extending.");
196		}
197
198		public function testDoNotInitializeProxyOnGettingTheIdentifierAndReturnTheRightType()
199		{
200		$product = new ECommerceProduct();
201		$product->setName('Doctrine Cookbook');
202
203		$shipping = new ECommerceShipping();
204		$shipping->setDays(1);
205		$product->setShipping($shipping);
206
207		$this->em->persist($product);
208		$this->em->flush();
209		$this->em->clear();
210
211		$id = $shipping->getId();
212
213		/* @var $entity ECommerceProduct\|GhostObjectInterface */
214		$product = $this->em->getRepository(ECommerceProduct::class)->find($product->getId());
215
216		$entity = $product->getShipping();
217
218		self::assertFalse($entity->isProxyInitialized(), "Pre-Condition: Object is unitialized proxy.");
219		self::assertEquals($id, $entity->getId());
220		self::assertSame($id, $entity->getId(), "Check that the id's are the same value, and type.");
221		self::assertFalse($entity->isProxyInitialized(), "Getting the identifier doesn't initialize the proxy.");
222		}
223
224	View Code Duplication	public function testInitializeProxyOnGettingSomethingOtherThanTheIdentifier()
225		{
226		$id = $this->createProduct();
227
228		/* @var $entity ECommerceProduct\|GhostObjectInterface */
229		$entity = $this->em->getReference(ECommerceProduct::class , $id);
230
231		self::assertFalse($entity->isProxyInitialized(), "Pre-Condition: Object is unitialized proxy.");
		0 ignored issues – show Bug introduced 2016-01-30 14:44 UTC by Report Bug Copy Issue Report The method `isProxyInitialized` does only exist in `ProxyManager\Proxy\GhostObjectInterface`, but not in `Doctrine\Tests\Models\ECommerce\ECommerceProduct`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: 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. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
232		self::assertEquals('Doctrine Cookbook', $entity->getName());
		0 ignored issues – show Bug introduced 2017-09-22 09:54 UTC by Report Bug Copy Issue Report The method `getName` does only exist in `Doctrine\Tests\Models\ECommerce\ECommerceProduct`, but not in `ProxyManager\Proxy\GhostObjectInterface`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: 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. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
233		self::assertTrue($entity->isProxyInitialized(), "Getting something other than the identifier initializes the proxy.");
234		}
235
236		/**
237		* @group DDC-1604
238		*/
239		public function testCommonPersistenceProxy()
240		{
241		$id = $this->createProduct();
242
243		/* @var $entity ECommerceProduct\|GhostObjectInterface */
244		$entity = $this->em->getReference(ECommerceProduct::class , $id);
245
246		$className = StaticClassNameConverter::getClass($entity);
247
248		self::assertInstanceOf(GhostObjectInterface::class, $entity);
249		self::assertFalse($entity->isProxyInitialized());
		0 ignored issues – show Bug introduced 2016-01-30 14:44 UTC by Report Bug Copy Issue Report The method `isProxyInitialized` does only exist in `ProxyManager\Proxy\GhostObjectInterface`, but not in `Doctrine\Tests\Models\ECommerce\ECommerceProduct`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: 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. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
250		self::assertEquals(ECommerceProduct::class, $className);
251
252		$proxyManagerConfiguration = $this->em->getConfiguration()->getProxyManagerConfiguration();
253
254		self::assertInstanceOf(
255		FileWriterGeneratorStrategy::class,
256		$proxyManagerConfiguration->getGeneratorStrategy(),
257		'Proxies are being written to disk in this test'
258		);
259
260		$proxy = $this->factory->getProxy(ECommerceProduct::class, ['id' => 123]);
261
262		$proxyClass = new \ReflectionClass($proxy);
263
264		self::assertFileExists($proxyClass->getFileName());
265
266		$entity->initializeProxy();
		0 ignored issues – show Bug introduced 2017-09-22 13:00 UTC by Report Bug Copy Issue Report The method `initializeProxy` does only exist in `ProxyManager\Proxy\GhostObjectInterface`, but not in `Doctrine\Tests\Models\ECommerce\ECommerceProduct`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: 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. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
267
268		self::assertTrue($entity->isProxyInitialized());
269		}
270		}
271

doctrine / orm

Pull Request — develop (#6719)

ReferenceProxyTest::createProduct() 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

Duplication Side-by-Side

Filter issues like