EntityManagerTest - Code Metrics - Inspection of "Merge branch 'fix/#5796-catch-also-throwable-in-tr..." - doctrine/orm - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 687060...4bc29d )

by Marco

created 2017-09-02 11:58 UTC

EntityManagerTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	285
Duplicated Lines	7.02 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

Metric	Value
wmc	31
lcom	1
cbo	8
dl	20
loc	285
rs	9.8
c	0
b	0
f	0

30 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	5	1
A	testIsOpen()	0	6	1
A	testGetConnection()	0	4	1
A	testGetMetadataFactory()	0	4	1
A	testGetConfiguration()	0	4	1
A	testGetUnitOfWork()	0	4	1
A	testGetProxyFactory()	0	4	1
A	testGetEventManager()	0	4	1
A	testCreateNativeQuery()	0	7	1
A	testCreateNamedNativeQuery()	0	9	1
A	testCreateQueryBuilder()	0	4	1
A	testCreateQueryBuilderAliasValid()	0	13	1
A	testCreateQuery_DqlIsOptional()	0	4	1
A	testGetPartialReference()	0	7	1
A	testCreateQuery()	0	6	1
A	testCreateNamedQuery()	0	8	1
A	testThrowsExceptionOnNonObjectValues()	0	6	1
A	testAffectedByErrorIfClosedException()	0	8	1
A	testTransactionalAcceptsReturn()	0	8	1
A	testTransactionalAcceptsVariousCallables()	0	4	1
A	testTransactionalThrowsInvalidArgumentExceptionIfNonCallablePassed()	0	7	1
A	transactionalCallback()	0	5	1
A	testCreateInvalidConnection()	0	9	1
A	dataMethodsAffectedByNoObjectArguments()	10	10	1
A	dataAffectedByErrorIfClosedException()	10	10	1
A	testTransactionalReThrowsThrowables()	0	14	2
A	testClearManagerWithObject()	0	8	1
A	testClearManagerWithUnknownEntityName()	0	6	1
A	testClearManagerWithProxyClassName()	0	14	1
A	testClearManagerWithNullValue()	0	12	1

How to fix Duplicated Code

<?php

namespace Doctrine\Tests\ORM;

use Doctrine\Common\EventManager;
use Doctrine\Common\Persistence\Mapping\Driver\MappingDriver;
use Doctrine\Common\Persistence\Mapping\MappingException;
use Doctrine\DBAL\Connection;
use Doctrine\ORM\Configuration;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\Mapping\ClassMetadataFactory;
use Doctrine\ORM\NativeQuery;
use Doctrine\ORM\ORMException;
use Doctrine\ORM\ORMInvalidArgumentException;
use Doctrine\ORM\Proxy\ProxyFactory;
use Doctrine\ORM\Query;
use Doctrine\ORM\Query\ResultSetMapping;
use Doctrine\ORM\QueryBuilder;
use Doctrine\ORM\UnitOfWork;
use Doctrine\Tests\Models\CMS\CmsUser;
use Doctrine\Tests\Models\GeoNames\Country;
use Doctrine\Tests\OrmTestCase;

class EntityManagerTest extends OrmTestCase
{
    /**
     * @var EntityManager
     */
    private $_em;

    function setUp()

    {
        parent::setUp();
        $this->_em = $this->_getTestEntityManager();
    }

    /**
     * @group DDC-899
     */
    public function testIsOpen()
    {
        $this->assertTrue($this->_em->isOpen());
        $this->_em->close();
        $this->assertFalse($this->_em->isOpen());
    }

    public function testGetConnection()
    {
        $this->assertInstanceOf(Connection::class, $this->_em->getConnection());
    }

    public function testGetMetadataFactory()
    {
        $this->assertInstanceOf(ClassMetadataFactory::class, $this->_em->getMetadataFactory());
    }

    public function testGetConfiguration()
    {
        $this->assertInstanceOf(Configuration::class, $this->_em->getConfiguration());
    }

    public function testGetUnitOfWork()
    {
        $this->assertInstanceOf(UnitOfWork::class, $this->_em->getUnitOfWork());
    }

    public function testGetProxyFactory()
    {
        $this->assertInstanceOf(ProxyFactory::class, $this->_em->getProxyFactory());
    }

    public function testGetEventManager()
    {
        $this->assertInstanceOf(EventManager::class, $this->_em->getEventManager());
    }

    public function testCreateNativeQuery()
    {
        $rsm = new ResultSetMapping();
        $query = $this->_em->createNativeQuery('SELECT foo', $rsm);

        $this->assertSame('SELECT foo', $query->getSql());
    }

    /**
     * @covers \Doctrine\ORM\EntityManager::createNamedNativeQuery
     */
    public function testCreateNamedNativeQuery()
    {
        $rsm = new ResultSetMapping();
        $this->_em->getConfiguration()->addNamedNativeQuery('foo', 'SELECT foo', $rsm);

        $query = $this->_em->createNamedNativeQuery('foo');

        $this->assertInstanceOf(NativeQuery::class, $query);
    }

    public function testCreateQueryBuilder()
    {
        $this->assertInstanceOf(QueryBuilder::class, $this->_em->createQueryBuilder());
    }

    public function testCreateQueryBuilderAliasValid()
    {
        $q = $this->_em->createQueryBuilder()
             ->select('u')->from(CmsUser::class, 'u');
        $q2 = clone $q;

        $this->assertEquals('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u', $q->getQuery()->getDql());
        $this->assertEquals('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u', $q2->getQuery()->getDql());

        $q3 = clone $q;

        $this->assertEquals('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u', $q3->getQuery()->getDql());
    }

    public function testCreateQuery_DqlIsOptional()
    {
        $this->assertInstanceOf(Query::class, $this->_em->createQuery());
    }

    public function testGetPartialReference()
    {
        $user = $this->_em->getPartialReference(CmsUser::class, 42);
        $this->assertTrue($this->_em->contains($user));
        $this->assertEquals(42, $user->id);
        $this->assertNull($user->getName());
    }

    public function testCreateQuery()
    {
        $q = $this->_em->createQuery('SELECT 1');
        $this->assertInstanceOf(Query::class, $q);
        $this->assertEquals('SELECT 1', $q->getDql());
    }

    /**
     * @covers Doctrine\ORM\EntityManager::createNamedQuery
     */
    public function testCreateNamedQuery()
    {
        $this->_em->getConfiguration()->addNamedQuery('foo', 'SELECT 1');

        $query = $this->_em->createNamedQuery('foo');
        $this->assertInstanceOf(Query::class, $query);
        $this->assertEquals('SELECT 1', $query->getDql());
    }

    static public function dataMethodsAffectedByNoObjectArguments()

    {
        return [
            ['persist'],
            ['remove'],
            ['merge'],
            ['refresh'],
            ['detach']
        ];
    }

    /**
     * @dataProvider dataMethodsAffectedByNoObjectArguments
     */
    public function testThrowsExceptionOnNonObjectValues($methodName) {
        $this->expectException(ORMInvalidArgumentException::class);
        $this->expectExceptionMessage('EntityManager#' . $methodName . '() expects parameter 1 to be an entity object, NULL given.');

        $this->_em->$methodName(null);
    }

    static public function dataAffectedByErrorIfClosedException()

    {
        return [
            ['flush'],
            ['persist'],
            ['remove'],
            ['merge'],
            ['refresh'],
        ];
    }

    /**
     * @dataProvider dataAffectedByErrorIfClosedException
     * @param string $methodName
     */
    public function testAffectedByErrorIfClosedException($methodName)
    {
        $this->expectException(ORMException::class);
        $this->expectExceptionMessage('closed');

        $this->_em->close();
        $this->_em->$methodName(new \stdClass());
    }

    /**
     * @group DDC-1125
     */
    public function testTransactionalAcceptsReturn()
    {
        $return = $this->_em->transactional(function ($em) {

            return 'foo';
        });

        $this->assertEquals('foo', $return);
    }

    public function testTransactionalAcceptsVariousCallables()
    {
        $this->assertSame('callback', $this->_em->transactional([$this, 'transactionalCallback']));
    }

    public function testTransactionalThrowsInvalidArgumentExceptionIfNonCallablePassed()
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionMessage('Expected argument of type "callable", got "object"');

        $this->_em->transactional($this);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

    public function transactionalCallback($em)
    {
        $this->assertSame($this->_em, $em);
        return 'callback';
    }

    public function testCreateInvalidConnection()
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->expectExceptionMessage('Invalid $connection argument of type integer given: "1".');

        $config = new Configuration();
        $config->setMetadataDriverImpl($this->createMock(MappingDriver::class));
        EntityManager::create(1, $config);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

    /**
     * @group #5796
     */
    public function testTransactionalReThrowsThrowables()
    {
        try {
            $this->_em->transactional(function () {
                (function (array $value) {

                    // this only serves as an IIFE that throws a `TypeError`
                })(null);
            });

            self::fail('TypeError expected to be thrown');
        } catch (\TypeError $ignored) {
            self::assertFalse($this->_em->isOpen());
        }
    }

    /**
     * @group 6017
     */
    public function testClearManagerWithObject()
    {
        $entity = new Country(456, 'United Kingdom');

        $this->expectException(ORMInvalidArgumentException::class);

        $this->_em->clear($entity);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

    /**
     * @group 6017
     */
    public function testClearManagerWithUnknownEntityName()
    {
        $this->expectException(MappingException::class);

        $this->_em->clear(uniqid('nonExisting', true));
    }

    /**
     * @group 6017
     */
    public function testClearManagerWithProxyClassName()
    {
        $proxy = $this->_em->getReference(Country::class, ['id' => rand(457, 100000)]);

        $entity = new Country(456, 'United Kingdom');

        $this->_em->persist($entity);

        $this->assertTrue($this->_em->contains($entity));

        $this->_em->clear(get_class($proxy));

        $this->assertFalse($this->_em->contains($entity));
    }

    /**
     * @group 6017
     */
    public function testClearManagerWithNullValue()
    {
        $entity = new Country(456, 'United Kingdom');

        $this->_em->persist($entity);

        $this->assertTrue($this->_em->contains($entity));

        $this->_em->clear(null);

        $this->assertFalse($this->_em->contains($entity));
    }
}


1		<?php
2
3		namespace Doctrine\Tests\ORM;
4
5		use Doctrine\Common\EventManager;
6		use Doctrine\Common\Persistence\Mapping\Driver\MappingDriver;
7		use Doctrine\Common\Persistence\Mapping\MappingException;
8		use Doctrine\DBAL\Connection;
9		use Doctrine\ORM\Configuration;
10		use Doctrine\ORM\EntityManager;
11		use Doctrine\ORM\Mapping\ClassMetadataFactory;
12		use Doctrine\ORM\NativeQuery;
13		use Doctrine\ORM\ORMException;
14		use Doctrine\ORM\ORMInvalidArgumentException;
15		use Doctrine\ORM\Proxy\ProxyFactory;
16		use Doctrine\ORM\Query;
17		use Doctrine\ORM\Query\ResultSetMapping;
18		use Doctrine\ORM\QueryBuilder;
19		use Doctrine\ORM\UnitOfWork;
20		use Doctrine\Tests\Models\CMS\CmsUser;
21		use Doctrine\Tests\Models\GeoNames\Country;
22		use Doctrine\Tests\OrmTestCase;
23
24		class EntityManagerTest extends OrmTestCase
25		{
26		/**
27		* @var EntityManager
28		*/
29		private $_em;
30
31		function setUp()
		0 ignored issues – show Best Practice introduced 2015-12-29 18:56 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
32		{
33		parent::setUp();
34		$this->_em = $this->_getTestEntityManager();
35		}
36
37		/**
38		* @group DDC-899
39		*/
40		public function testIsOpen()
41		{
42		$this->assertTrue($this->_em->isOpen());
43		$this->_em->close();
44		$this->assertFalse($this->_em->isOpen());
45		}
46
47		public function testGetConnection()
48		{
49		$this->assertInstanceOf(Connection::class, $this->_em->getConnection());
50		}
51
52		public function testGetMetadataFactory()
53		{
54		$this->assertInstanceOf(ClassMetadataFactory::class, $this->_em->getMetadataFactory());
55		}
56
57		public function testGetConfiguration()
58		{
59		$this->assertInstanceOf(Configuration::class, $this->_em->getConfiguration());
60		}
61
62		public function testGetUnitOfWork()
63		{
64		$this->assertInstanceOf(UnitOfWork::class, $this->_em->getUnitOfWork());
65		}
66
67		public function testGetProxyFactory()
68		{
69		$this->assertInstanceOf(ProxyFactory::class, $this->_em->getProxyFactory());
70		}
71
72		public function testGetEventManager()
73		{
74		$this->assertInstanceOf(EventManager::class, $this->_em->getEventManager());
75		}
76
77		public function testCreateNativeQuery()
78		{
79		$rsm = new ResultSetMapping();
80		$query = $this->_em->createNativeQuery('SELECT foo', $rsm);
81
82		$this->assertSame('SELECT foo', $query->getSql());
83		}
84
85		/**
86		* @covers \Doctrine\ORM\EntityManager::createNamedNativeQuery
87		*/
88		public function testCreateNamedNativeQuery()
89		{
90		$rsm = new ResultSetMapping();
91		$this->_em->getConfiguration()->addNamedNativeQuery('foo', 'SELECT foo', $rsm);
92
93		$query = $this->_em->createNamedNativeQuery('foo');
94
95		$this->assertInstanceOf(NativeQuery::class, $query);
96		}
97
98		public function testCreateQueryBuilder()
99		{
100		$this->assertInstanceOf(QueryBuilder::class, $this->_em->createQueryBuilder());
101		}
102
103		public function testCreateQueryBuilderAliasValid()
104		{
105		$q = $this->_em->createQueryBuilder()
106		->select('u')->from(CmsUser::class, 'u');
107		$q2 = clone $q;
108
109		$this->assertEquals('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u', $q->getQuery()->getDql());
110		$this->assertEquals('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u', $q2->getQuery()->getDql());
111
112		$q3 = clone $q;
113
114		$this->assertEquals('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u', $q3->getQuery()->getDql());
115		}
116
117		public function testCreateQuery_DqlIsOptional()
118		{
119		$this->assertInstanceOf(Query::class, $this->_em->createQuery());
120		}
121
122		public function testGetPartialReference()
123		{
124		$user = $this->_em->getPartialReference(CmsUser::class, 42);
125		$this->assertTrue($this->_em->contains($user));
126		$this->assertEquals(42, $user->id);
127		$this->assertNull($user->getName());
128		}
129
130		public function testCreateQuery()
131		{
132		$q = $this->_em->createQuery('SELECT 1');
133		$this->assertInstanceOf(Query::class, $q);
134		$this->assertEquals('SELECT 1', $q->getDql());
135		}
136
137		/**
138		* @covers Doctrine\ORM\EntityManager::createNamedQuery
139		*/
140		public function testCreateNamedQuery()
141		{
142		$this->_em->getConfiguration()->addNamedQuery('foo', 'SELECT 1');
143
144		$query = $this->_em->createNamedQuery('foo');
145		$this->assertInstanceOf(Query::class, $query);
146		$this->assertEquals('SELECT 1', $query->getDql());
147		}
148
149	View Code Duplication	static public function dataMethodsAffectedByNoObjectArguments()
		0 ignored issues – show Coding Style introduced 2017-07-31 20:33 UTC by Report Bug Copy Issue Report As per PSR2, the `static` declaration should come after the visibility declaration. Loading history...
150		{
151		return [
152		['persist'],
153		['remove'],
154		['merge'],
155		['refresh'],
156		['detach']
157		];
158		}
159
160		/**
161		* @dataProvider dataMethodsAffectedByNoObjectArguments
162		*/
163		public function testThrowsExceptionOnNonObjectValues($methodName) {
164		$this->expectException(ORMInvalidArgumentException::class);
165		$this->expectExceptionMessage('EntityManager#' . $methodName . '() expects parameter 1 to be an entity object, NULL given.');
166
167		$this->_em->$methodName(null);
168		}
169
170	View Code Duplication	static public function dataAffectedByErrorIfClosedException()
		0 ignored issues – show Coding Style introduced 2017-07-31 20:33 UTC by Report Bug Copy Issue Report As per PSR2, the `static` declaration should come after the visibility declaration. Loading history...
171		{
172		return [
173		['flush'],
174		['persist'],
175		['remove'],
176		['merge'],
177		['refresh'],
178		];
179		}
180
181		/**
182		* @dataProvider dataAffectedByErrorIfClosedException
183		* @param string $methodName
184		*/
185		public function testAffectedByErrorIfClosedException($methodName)
186		{
187		$this->expectException(ORMException::class);
188		$this->expectExceptionMessage('closed');
189
190		$this->_em->close();
191		$this->_em->$methodName(new \stdClass());
192		}
193
194		/**
195		* @group DDC-1125
196		*/
197		public function testTransactionalAcceptsReturn()
198		{
199		$return = $this->_em->transactional(function ($em) {
		0 ignored issues – show Unused Code introduced 2015-12-29 18:56 UTC by Report Bug Copy Issue Report The parameter `$em` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
200		return 'foo';
201		});
202
203		$this->assertEquals('foo', $return);
204		}
205
206		public function testTransactionalAcceptsVariousCallables()
207		{
208		$this->assertSame('callback', $this->_em->transactional([$this, 'transactionalCallback']));
209		}
210
211		public function testTransactionalThrowsInvalidArgumentExceptionIfNonCallablePassed()
212		{
213		$this->expectException(\InvalidArgumentException::class);
214		$this->expectExceptionMessage('Expected argument of type "callable", got "object"');
215
216		$this->_em->transactional($this);
		0 ignored issues – show Documentation introduced 2015-12-29 18:56 UTC by Report Bug Copy Issue Report `$this` is of type `this<Doctrine\Tests\ORM\EntityManagerTest>`, but the function expects a `callable`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
217		}
218
219		public function transactionalCallback($em)
220		{
221		$this->assertSame($this->_em, $em);
222		return 'callback';
223		}
224
225		public function testCreateInvalidConnection()
226		{
227		$this->expectException(\InvalidArgumentException::class);
228		$this->expectExceptionMessage('Invalid $connection argument of type integer given: "1".');
229
230		$config = new Configuration();
231		$config->setMetadataDriverImpl($this->createMock(MappingDriver::class));
232		EntityManager::create(1, $config);
		0 ignored issues – show Documentation introduced 2017-06-20 08:13 UTC by Report Bug Copy Issue Report `1` is of type `integer`, but the function expects a `array\|object<Doctrine\DBAL\Connection>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
233		}
234
235		/**
236		* @group #5796
237		*/
238		public function testTransactionalReThrowsThrowables()
239		{
240		try {
241		$this->_em->transactional(function () {
242		(function (array $value) {
		0 ignored issues – show Unused Code introduced 2017-09-02 12:17 UTC by Report Bug Copy Issue Report The parameter `$value` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
243		// this only serves as an IIFE that throws a `TypeError`
244		})(null);
245		});
246
247		self::fail('TypeError expected to be thrown');
248		} catch (\TypeError $ignored) {
249		self::assertFalse($this->_em->isOpen());
250		}
251		}
252
253		/**
254		* @group 6017
255		*/
256		public function testClearManagerWithObject()
257		{
258		$entity = new Country(456, 'United Kingdom');
259
260		$this->expectException(ORMInvalidArgumentException::class);
261
262		$this->_em->clear($entity);
		0 ignored issues – show Documentation introduced 2017-06-20 08:13 UTC by Report Bug Copy Issue Report `$entity` is of type `object<Doctrine\Tests\Models\GeoNames\Country>`, but the function expects a `string\|null`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
263		}
264
265		/**
266		* @group 6017
267		*/
268		public function testClearManagerWithUnknownEntityName()
269		{
270		$this->expectException(MappingException::class);
271
272		$this->_em->clear(uniqid('nonExisting', true));
273		}
274
275		/**
276		* @group 6017
277		*/
278		public function testClearManagerWithProxyClassName()
279		{
280		$proxy = $this->_em->getReference(Country::class, ['id' => rand(457, 100000)]);
281
282		$entity = new Country(456, 'United Kingdom');
283
284		$this->_em->persist($entity);
285
286		$this->assertTrue($this->_em->contains($entity));
287
288		$this->_em->clear(get_class($proxy));
289
290		$this->assertFalse($this->_em->contains($entity));
291		}
292
293		/**
294		* @group 6017
295		*/
296		public function testClearManagerWithNullValue()
297		{
298		$entity = new Country(456, 'United Kingdom');
299
300		$this->_em->persist($entity);
301
302		$this->assertTrue($this->_em->contains($entity));
303
304		$this->_em->clear(null);
305
306		$this->assertFalse($this->_em->contains($entity));
307		}
308		}
309

doctrine / orm

Push — master ( 687060...4bc29d )

EntityManagerTest A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

30 Methods

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like