DDC2231ObjectManagerAwareEntity::injectObjectManager() - Code Metrics - Inspection of "Ensure `ObjectManagerAware` and `EntityManagerAwar..." - doctrine/orm - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — develop (#6867)

by Marco

created 2017-12-06 08:10 UTC

injectObjectManager() A

↳ Parent: DDC2231ObjectManagerAwareEntity

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	2

<?php

declare(strict_types=1);

namespace Doctrine\Tests\ORM\Functional\Ticket;

use Doctrine\Common\Persistence\Mapping\ClassMetadata as CommonMetadata;
use Doctrine\Common\Persistence\ObjectManager;
use Doctrine\Common\Persistence\ObjectManagerAware;
use Doctrine\ORM\Annotation as ORM;
use Doctrine\ORM\EntityManagerAware;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\Mapping\ClassMetadata;
use Doctrine\ORM\Tools\ToolsException;
use ProxyManager\Proxy\GhostObjectInterface;

/**
 * @group DDC-2231
 */
class DDC2231Test extends \Doctrine\Tests\OrmFunctionalTestCase
{
    /**
     * @var DDC2231EntityManagerAwareEntity
     */
    private $persistedEntityManagerAwareEntity;

    /**
     * @var DDC2231ObjectManagerAwareEntity
     */
    private $persistedObjectManagerAwareEntity;

    protected function setUp()
    {
        parent::setUp();

        try {
            $this->schemaTool->createSchema([
                $this->em->getClassMetadata(DDC2231EntityManagerAwareEntity::class),
                $this->em->getClassMetadata(DDC2231ObjectManagerAwareEntity::class),
            ]);
        } catch (ToolsException $ignored) {
            // ignore - schema already exists
        }

        $this->persistedEntityManagerAwareEntity = new DDC2231EntityManagerAwareEntity();
        $this->persistedObjectManagerAwareEntity = new DDC2231ObjectManagerAwareEntity();

        $this->em->persist($this->persistedEntityManagerAwareEntity);
        $this->em->persist($this->persistedObjectManagerAwareEntity);
        $this->em->flush();
        $this->em->clear();
    }

    public function testInjectEntityManagerInProxyIfInitializedInUow()
    {
        /* @var $emAware DDC2231EntityManagerAwareEntity|GhostObjectInterface */
        $emAware = $this->em->getReference(
            DDC2231EntityManagerAwareEntity::class,
            $this->persistedEntityManagerAwareEntity->id
        );

        self::assertInstanceOf(GhostObjectInterface::class, $emAware);
        self::assertInstanceOf(DDC2231EntityManagerAwareEntity::class, $emAware);
        self::assertInstanceOf(EntityManagerAware::class, $emAware);
        self::assertFalse($emAware->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::assertSame($this->em, $emAware->em);

        $emAware->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::assertSame($this->em, $emAware->em);
    }

    public function testInjectEntityManagerInFetchedInstance()
    {
        /* @var $emAware DDC2231EntityManagerAwareEntity */
        $emAware = $this->em->find(
            DDC2231EntityManagerAwareEntity::class,
            $this->persistedEntityManagerAwareEntity->id
        );

        self::assertInstanceOf(DDC2231EntityManagerAwareEntity::class, $emAware);
        self::assertInstanceOf(EntityManagerAware::class, $emAware);
        self::assertNotInstanceOf(GhostObjectInterface::class, $emAware);
        self::assertSame($this->em, $emAware->em);
    }

    public function testInjectObjectManagerInProxyIfInitializedInUow()
    {
        /* @var $omAware DDC2231ObjectManagerAwareEntity|GhostObjectInterface */
        $omAware = $this->em->getReference(
            DDC2231ObjectManagerAwareEntity::class,
            $this->persistedObjectManagerAwareEntity->id
        );

        self::assertInstanceOf(GhostObjectInterface::class, $omAware);
        self::assertInstanceOf(DDC2231ObjectManagerAwareEntity::class, $omAware);
        self::assertInstanceOf(ObjectManagerAware::class, $omAware);
        self::assertFalse($omAware->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::assertSame($this->em, $omAware->om);

        $omAware->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::assertSame($this->em, $omAware->om);
    }

    public function testInjectObjectManagerInFetchedInstance()
    {
        /* @var $omAware DDC2231ObjectManagerAwareEntity */
        $omAware = $this->em->find(
            DDC2231ObjectManagerAwareEntity::class,
            $this->persistedObjectManagerAwareEntity->id
        );

        self::assertInstanceOf(DDC2231ObjectManagerAwareEntity::class, $omAware);
        self::assertInstanceOf(ObjectManagerAware::class, $omAware);
        self::assertNotInstanceOf(GhostObjectInterface::class, $omAware);
        self::assertSame($this->em, $omAware->om);
    }
}


/** @ORM\Entity */
class DDC2231EntityManagerAwareEntity implements EntityManagerAware
{
    /** @ORM\Id @ORM\Column(type="integer") @ORM\GeneratedValue */
    public $id;

    /** @var EntityManagerInterface|null */
    public $em;

    public function injectEntityManager(EntityManagerInterface $entityManager, ClassMetadata $classMetadata) : void
    {
        $this->em = $entityManager;
    }
}


/** @ORM\Entity */
class DDC2231ObjectManagerAwareEntity implements ObjectManagerAware
{
    /** @ORM\Id @ORM\Column(type="integer") @ORM\GeneratedValue */
    public $id;

    /** @var ObjectManager|null */
    public $om;

    public function injectObjectManager(ObjectManager $objectManager, CommonMetadata $classMetadata) : void
    {
        $this->om = $objectManager;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Doctrine\Tests\ORM\Functional\Ticket;
6
7		use Doctrine\Common\Persistence\Mapping\ClassMetadata as CommonMetadata;
8		use Doctrine\Common\Persistence\ObjectManager;
9		use Doctrine\Common\Persistence\ObjectManagerAware;
10		use Doctrine\ORM\Annotation as ORM;
11		use Doctrine\ORM\EntityManagerAware;
12		use Doctrine\ORM\EntityManagerInterface;
13		use Doctrine\ORM\Mapping\ClassMetadata;
14		use Doctrine\ORM\Tools\ToolsException;
15		use ProxyManager\Proxy\GhostObjectInterface;
16
17		/**
18		* @group DDC-2231
19		*/
20		class DDC2231Test extends \Doctrine\Tests\OrmFunctionalTestCase
21		{
22		/**
23		* @var DDC2231EntityManagerAwareEntity
24		*/
25		private $persistedEntityManagerAwareEntity;
26
27		/**
28		* @var DDC2231ObjectManagerAwareEntity
29		*/
30		private $persistedObjectManagerAwareEntity;
31
32		protected function setUp()
33		{
34		parent::setUp();
35
36		try {
37		$this->schemaTool->createSchema([
38		$this->em->getClassMetadata(DDC2231EntityManagerAwareEntity::class),
39		$this->em->getClassMetadata(DDC2231ObjectManagerAwareEntity::class),
40		]);
41		} catch (ToolsException $ignored) {
42		// ignore - schema already exists
43		}
44
45		$this->persistedEntityManagerAwareEntity = new DDC2231EntityManagerAwareEntity();
46		$this->persistedObjectManagerAwareEntity = new DDC2231ObjectManagerAwareEntity();
47
48		$this->em->persist($this->persistedEntityManagerAwareEntity);
49		$this->em->persist($this->persistedObjectManagerAwareEntity);
50		$this->em->flush();
51		$this->em->clear();
52		}
53
54	View Code Duplication	public function testInjectEntityManagerInProxyIfInitializedInUow()
55		{
56		/* @var $emAware DDC2231EntityManagerAwareEntity\|GhostObjectInterface */
57		$emAware = $this->em->getReference(
58		DDC2231EntityManagerAwareEntity::class,
59		$this->persistedEntityManagerAwareEntity->id
60		);
61
62		self::assertInstanceOf(GhostObjectInterface::class, $emAware);
63		self::assertInstanceOf(DDC2231EntityManagerAwareEntity::class, $emAware);
64		self::assertInstanceOf(EntityManagerAware::class, $emAware);
65		self::assertFalse($emAware->isProxyInitialized());
		0 ignored issues – show Bug introduced 2017-12-06 09:12 UTC by Report Bug Copy Issue Report The method `isProxyInitialized` does only exist in `ProxyManager\Proxy\GhostObjectInterface`, but not in `Doctrine\Tests\ORM\Funct...ntityManagerAwareEntity`. 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...
66		self::assertSame($this->em, $emAware->em);
67
68		$emAware->initializeProxy();
		0 ignored issues – show Bug introduced 2017-12-06 09:12 UTC by Report Bug Copy Issue Report The method `initializeProxy` does only exist in `ProxyManager\Proxy\GhostObjectInterface`, but not in `Doctrine\Tests\ORM\Funct...ntityManagerAwareEntity`. 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...
69
70		self::assertSame($this->em, $emAware->em);
71		}
72
73	View Code Duplication	public function testInjectEntityManagerInFetchedInstance()
74		{
75		/* @var $emAware DDC2231EntityManagerAwareEntity */
76		$emAware = $this->em->find(
77		DDC2231EntityManagerAwareEntity::class,
78		$this->persistedEntityManagerAwareEntity->id
79		);
80
81		self::assertInstanceOf(DDC2231EntityManagerAwareEntity::class, $emAware);
82		self::assertInstanceOf(EntityManagerAware::class, $emAware);
83		self::assertNotInstanceOf(GhostObjectInterface::class, $emAware);
84		self::assertSame($this->em, $emAware->em);
85		}
86
87	View Code Duplication	public function testInjectObjectManagerInProxyIfInitializedInUow()
88		{
89		/* @var $omAware DDC2231ObjectManagerAwareEntity\|GhostObjectInterface */
90		$omAware = $this->em->getReference(
91		DDC2231ObjectManagerAwareEntity::class,
92		$this->persistedObjectManagerAwareEntity->id
93		);
94
95		self::assertInstanceOf(GhostObjectInterface::class, $omAware);
96		self::assertInstanceOf(DDC2231ObjectManagerAwareEntity::class, $omAware);
97		self::assertInstanceOf(ObjectManagerAware::class, $omAware);
98		self::assertFalse($omAware->isProxyInitialized());
		0 ignored issues – show Bug introduced 2017-12-06 09:12 UTC by Report Bug Copy Issue Report The method `isProxyInitialized` does only exist in `ProxyManager\Proxy\GhostObjectInterface`, but not in `Doctrine\Tests\ORM\Funct...bjectManagerAwareEntity`. 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...
99		self::assertSame($this->em, $omAware->om);
100
101		$omAware->initializeProxy();
		0 ignored issues – show Bug introduced 2017-12-06 09:12 UTC by Report Bug Copy Issue Report The method `initializeProxy` does only exist in `ProxyManager\Proxy\GhostObjectInterface`, but not in `Doctrine\Tests\ORM\Funct...bjectManagerAwareEntity`. 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...
102
103		self::assertSame($this->em, $omAware->om);
104		}
105
106	View Code Duplication	public function testInjectObjectManagerInFetchedInstance()
107		{
108		/* @var $omAware DDC2231ObjectManagerAwareEntity */
109		$omAware = $this->em->find(
110		DDC2231ObjectManagerAwareEntity::class,
111		$this->persistedObjectManagerAwareEntity->id
112		);
113
114		self::assertInstanceOf(DDC2231ObjectManagerAwareEntity::class, $omAware);
115		self::assertInstanceOf(ObjectManagerAware::class, $omAware);
116		self::assertNotInstanceOf(GhostObjectInterface::class, $omAware);
117		self::assertSame($this->em, $omAware->om);
118		}
119		}
120
121
122		/** @ORM\Entity */
123		class DDC2231EntityManagerAwareEntity implements EntityManagerAware
124		{
125		/** @ORM\Id @ORM\Column(type="integer") @ORM\GeneratedValue */
126		public $id;
127
128		/** @var EntityManagerInterface\|null */
129		public $em;
130
131		public function injectEntityManager(EntityManagerInterface $entityManager, ClassMetadata $classMetadata) : void
132		{
133		$this->em = $entityManager;
134		}
135		}
136
137
138		/** @ORM\Entity */
139		class DDC2231ObjectManagerAwareEntity implements ObjectManagerAware
140		{
141		/** @ORM\Id @ORM\Column(type="integer") @ORM\GeneratedValue */
142		public $id;
143
144		/** @var ObjectManager\|null */
145		public $om;
146
147		public function injectObjectManager(ObjectManager $objectManager, CommonMetadata $classMetadata) : void
148		{
149		$this->om = $objectManager;
150		}
151		}
152

doctrine / orm

Pull Request — develop (#6867)

injectObjectManager() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like