EntityManagerTest::testCreateQuery() - Code Metrics - Inspection of "Merge branch 'feature/#6136-better-exception-messa..." - doctrine/orm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( f1bf04...e7856f )

by Marco

created 2016-11-18 08:21 UTC

EntityManagerTest::testCreateQuery() A

↳ Parent: EntityManagerTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	6
c	0
b	0
f	0
rs	9.4285
cc	1
eloc	4
nc	1
nop	0

<?php

namespace Doctrine\Tests\ORM;

use Doctrine\Common\Persistence\Mapping\Driver\MappingDriver;
use Doctrine\ORM\Configuration;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\ORMException;
use Doctrine\ORM\ORMInvalidArgumentException;
use Doctrine\ORM\Query\ResultSetMapping;
use Doctrine\Tests\OrmTestCase;

class EntityManagerTest extends OrmTestCase
{
    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('Doctrine\DBAL\Connection', $this->_em->getConnection());
    }

    public function testGetMetadataFactory()
    {
        $this->assertInstanceOf('Doctrine\ORM\Mapping\ClassMetadataFactory', $this->_em->getMetadataFactory());
    }

    public function testGetConfiguration()
    {
        $this->assertInstanceOf('Doctrine\ORM\Configuration', $this->_em->getConfiguration());
    }

    public function testGetUnitOfWork()
    {
        $this->assertInstanceOf('Doctrine\ORM\UnitOfWork', $this->_em->getUnitOfWork());
    }

    public function testGetProxyFactory()
    {
        $this->assertInstanceOf('Doctrine\ORM\Proxy\ProxyFactory', $this->_em->getProxyFactory());
    }

    public function testGetEventManager()
    {
        $this->assertInstanceOf('Doctrine\Common\EventManager', $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('Doctrine\ORM\NativeQuery', $query);
    }

    public function testCreateQueryBuilder()
    {
        $this->assertInstanceOf('Doctrine\ORM\QueryBuilder', $this->_em->createQueryBuilder());
    }

    public function testCreateQueryBuilderAliasValid()
    {
        $q = $this->_em->createQueryBuilder()
             ->select('u')->from('Doctrine\Tests\Models\CMS\CmsUser', '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('Doctrine\ORM\Query', $this->_em->createQuery());
    }

    public function testGetPartialReference()
    {
        $user = $this->_em->getPartialReference('Doctrine\Tests\Models\CMS\CmsUser', 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('Doctrine\ORM\Query', $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('Doctrine\ORM\Query', $query);
        $this->assertEquals('SELECT 1', $query->getDql());
    }

    static public function dataMethodsAffectedByNoObjectArguments()
    {
        return array(
            array('persist'),
            array('remove'),
            array('merge'),
            array('refresh'),
            array('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 array(
            array('flush'),
            array('persist'),
            array('remove'),
            array('merge'),
            array('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(array($this, 'transactionalCallback')));
    }

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

        $this->_em->transactional($this);
    }

    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);
    }
}


1			<?php
2
3			namespace Doctrine\Tests\ORM;
4
5			use Doctrine\Common\Persistence\Mapping\Driver\MappingDriver;
6			use Doctrine\ORM\Configuration;
7			use Doctrine\ORM\EntityManager;
8			use Doctrine\ORM\ORMException;
9			use Doctrine\ORM\ORMInvalidArgumentException;
10			use Doctrine\ORM\Query\ResultSetMapping;
11			use Doctrine\Tests\OrmTestCase;
12
13			class EntityManagerTest extends OrmTestCase
14			{
15			private $_em;
16
17			function setUp()
18			{
19			parent::setUp();
20			$this->_em = $this->_getTestEntityManager();
21			}
22
23			/**
24			* @group DDC-899
25			*/
26			public function testIsOpen()
27			{
28			$this->assertTrue($this->_em->isOpen());
29			$this->_em->close();
30			$this->assertFalse($this->_em->isOpen());
31			}
32
33			public function testGetConnection()
34			{
35			$this->assertInstanceOf('Doctrine\DBAL\Connection', $this->_em->getConnection());
36			}
37
38			public function testGetMetadataFactory()
39			{
40			$this->assertInstanceOf('Doctrine\ORM\Mapping\ClassMetadataFactory', $this->_em->getMetadataFactory());
41			}
42
43			public function testGetConfiguration()
44			{
45			$this->assertInstanceOf('Doctrine\ORM\Configuration', $this->_em->getConfiguration());
46			}
47
48			public function testGetUnitOfWork()
49			{
50			$this->assertInstanceOf('Doctrine\ORM\UnitOfWork', $this->_em->getUnitOfWork());
51			}
52
53			public function testGetProxyFactory()
54			{
55			$this->assertInstanceOf('Doctrine\ORM\Proxy\ProxyFactory', $this->_em->getProxyFactory());
56			}
57
58			public function testGetEventManager()
59			{
60			$this->assertInstanceOf('Doctrine\Common\EventManager', $this->_em->getEventManager());
61			}
62
63			public function testCreateNativeQuery()
64			{
65			$rsm = new ResultSetMapping();
66			$query = $this->_em->createNativeQuery('SELECT foo', $rsm);
67
68			$this->assertSame('SELECT foo', $query->getSql());
69			}
70
71			/**
72			* @covers Doctrine\ORM\EntityManager::createNamedNativeQuery
73			*/
74			public function testCreateNamedNativeQuery()
75			{
76			$rsm = new ResultSetMapping();
77			$this->_em->getConfiguration()->addNamedNativeQuery('foo', 'SELECT foo', $rsm);
78
79			$query = $this->_em->createNamedNativeQuery('foo');
80
81			$this->assertInstanceOf('Doctrine\ORM\NativeQuery', $query);
82			}
83
84			public function testCreateQueryBuilder()
85			{
86			$this->assertInstanceOf('Doctrine\ORM\QueryBuilder', $this->_em->createQueryBuilder());
87			}
88
89			public function testCreateQueryBuilderAliasValid()
90			{
91			$q = $this->_em->createQueryBuilder()
92			->select('u')->from('Doctrine\Tests\Models\CMS\CmsUser', 'u');
93			$q2 = clone $q;
94
95			$this->assertEquals('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u', $q->getQuery()->getDql());
96			$this->assertEquals('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u', $q2->getQuery()->getDql());
97
98			$q3 = clone $q;
99
100			$this->assertEquals('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u', $q3->getQuery()->getDql());
101			}
102
103			public function testCreateQuery_DqlIsOptional()
104			{
105			$this->assertInstanceOf('Doctrine\ORM\Query', $this->_em->createQuery());
106			}
107
108			public function testGetPartialReference()
109			{
110			$user = $this->_em->getPartialReference('Doctrine\Tests\Models\CMS\CmsUser', 42);
111			$this->assertTrue($this->_em->contains($user));
112			$this->assertEquals(42, $user->id);
113			$this->assertNull($user->getName());
114			}
115
116			public function testCreateQuery()
117			{
118			$q = $this->_em->createQuery('SELECT 1');
119			$this->assertInstanceOf('Doctrine\ORM\Query', $q);
120			$this->assertEquals('SELECT 1', $q->getDql());
121			}
122
123			/**
124			* @covers Doctrine\ORM\EntityManager::createNamedQuery
125			*/
126			public function testCreateNamedQuery()
127			{
128			$this->_em->getConfiguration()->addNamedQuery('foo', 'SELECT 1');
129
130			$query = $this->_em->createNamedQuery('foo');
131			$this->assertInstanceOf('Doctrine\ORM\Query', $query);
132			$this->assertEquals('SELECT 1', $query->getDql());
133			}
134
135			static public function dataMethodsAffectedByNoObjectArguments()
136			{
137			return array(
138			array('persist'),
139			array('remove'),
140			array('merge'),
141			array('refresh'),
142			array('detach')
143			);
144			}
145
146			/**
147			* @dataProvider dataMethodsAffectedByNoObjectArguments
148			*/
149			public function testThrowsExceptionOnNonObjectValues($methodName) {
150			$this->expectException(ORMInvalidArgumentException::class);
151			$this->expectExceptionMessage('EntityManager#' . $methodName . '() expects parameter 1 to be an entity object, NULL given.');
152
153			$this->_em->$methodName(null);
154			}
155
156			static public function dataAffectedByErrorIfClosedException()
157			{
158			return array(
159			array('flush'),
160			array('persist'),
161			array('remove'),
162			array('merge'),
163			array('refresh'),
164			);
165			}
166
167			/**
168			* @dataProvider dataAffectedByErrorIfClosedException
169			* @param string $methodName
170			*/
171			public function testAffectedByErrorIfClosedException($methodName)
172			{
173			$this->expectException(ORMException::class);
174			$this->expectExceptionMessage('closed');
175
176			$this->_em->close();
177			$this->_em->$methodName(new \stdClass());
178			}
179
180			/**
181			* @group DDC-1125
182			*/
183			public function testTransactionalAcceptsReturn()
184			{
185			$return = $this->_em->transactional(function ($em) {
186			return 'foo';
187			});
188
189			$this->assertEquals('foo', $return);
190			}
191
192			public function testTransactionalAcceptsVariousCallables()
193			{
194			$this->assertSame('callback', $this->_em->transactional(array($this, 'transactionalCallback')));
195			}
196
197			public function testTransactionalThrowsInvalidArgumentExceptionIfNonCallablePassed()
198			{
199			$this->expectException(\InvalidArgumentException::class);
200			$this->expectExceptionMessage('Expected argument of type "callable", got "object"');
201
202			$this->_em->transactional($this);
203			}
204
205			public function transactionalCallback($em)
206			{
207			$this->assertSame($this->_em, $em);
208			return 'callback';
209			}
210
211			public function testCreateInvalidConnection()
212			{
213			$this->expectException(\InvalidArgumentException::class);
214			$this->expectExceptionMessage('Invalid $connection argument of type integer given: "1".');
215
216			$config = new Configuration();
217			$config->setMetadataDriverImpl($this->createMock(MappingDriver::class));
218			EntityManager::create(1, $config);
219			}
220			}
221

doctrine / orm

Push — master ( f1bf04...e7856f )

EntityManagerTest::testCreateQuery() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like