ResultCacheTest::testEnableResultCacheParams() - Code Metrics - Inspection of "Split and remove AbstractQuery#useResultCache()" - doctrine/orm - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Pull Request — master (#7214)

unknown

created 2018-05-07 10:22 UTC

ResultCacheTest::testEnableResultCacheParams() B

↳ Parent: ResultCacheTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	24
Code Lines	16

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	16
nc	1
nop	0
dl	0
loc	24
rs	8.9713
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace Doctrine\Tests\ORM\Functional;

use Doctrine\Common\Cache\ArrayCache;
use Doctrine\DBAL\Types\Type as DBALType;
use Doctrine\ORM\Exception\ORMException;
use Doctrine\ORM\NativeQuery;
use Doctrine\ORM\Query;
use Doctrine\ORM\Query\ResultSetMapping;
use Doctrine\Tests\Models\CMS\CmsArticle;
use Doctrine\Tests\Models\CMS\CmsUser;
use Doctrine\Tests\OrmFunctionalTestCase;
use function count;

/**
 * ResultCacheTest
 */
class ResultCacheTest extends OrmFunctionalTestCase
{
    /** @var \ReflectionProperty */
    private $cacheDataReflection;

    protected function setUp() : void
    {
        $this->cacheDataReflection = new \ReflectionProperty(ArrayCache::class, 'data');
        $this->cacheDataReflection->setAccessible(true);

        $this->useModelSet('cms');

        parent::setUp();
    }

    /**
     * @return  int
     */
    private function getCacheSize(ArrayCache $cache)
    {
        return count($this->cacheDataReflection->getValue($cache));
    }

    public function testResultCache() : void
    {
        $user = new CmsUser();

        $user->name     = 'Roman';
        $user->username = 'romanb';
        $user->status   = 'dev';

        $this->em->persist($user);
        $this->em->flush();

        $query = $this->em->createQuery('select ux from Doctrine\Tests\Models\CMS\CmsUser ux');
        $cache = new ArrayCache();

        $query->setResultCacheDriver($cache)->setResultCacheId('my_cache_id');

        self::assertFalse($cache->contains('my_cache_id'));

        $users = $query->getResult();

        self::assertTrue($cache->contains('my_cache_id'));
        self::assertCount(1, $users);
        self::assertEquals('Roman', $users[0]->name);

        $this->em->clear();

        $query2 = $this->em->createQuery('select ux from Doctrine\Tests\Models\CMS\CmsUser ux');
        $query2->setResultCacheDriver($cache)->setResultCacheId('my_cache_id');

        $users = $query2->getResult();

        self::assertTrue($cache->contains('my_cache_id'));
        self::assertCount(1, $users);
        self::assertEquals('Roman', $users[0]->name);
    }

    public function testSetResultCacheId() : void
    {
        $cache = new ArrayCache();
        $query = $this->em->createQuery('select ux from Doctrine\Tests\Models\CMS\CmsUser ux');

        $query->setResultCacheDriver($cache);
        $query->setResultCacheId('testing_result_cache_id');

        self::assertFalse($cache->contains('testing_result_cache_id'));

        $users = $query->getResult();


        self::assertTrue($cache->contains('testing_result_cache_id'));
    }

    public function testEnableResultCache() : void
    {
        $cache = new ArrayCache();
        $query = $this->em->createQuery('select ux from Doctrine\Tests\Models\CMS\CmsUser ux');

        $query->enableResultCache(); // FIXME: This line does not affect anything. The test should be rethought.
        $query->setResultCacheDriver($cache);
        $query->setResultCacheId('testing_result_cache_id');
        $users = $query->getResult();


        $this->assertTrue($cache->contains('testing_result_cache_id'));

        $this->em->getConfiguration()->setResultCacheImpl(new ArrayCache());
    }

    /**
     * @group DDC-1026
     */
    public function testEnableResultCacheParams() : void
    {
        $cache    = new ArrayCache();
        $sqlCount = count($this->sqlLoggerStack->queries);
        $query    = $this->em->createQuery('select ux from Doctrine\Tests\Models\CMS\CmsUser ux WHERE ux.id = ?1');

        $query->setParameter(1, 1);
        $query->setResultCacheDriver($cache);
        $query->enableResultCache();
        $query->getResult();

        $query->setParameter(1, 2);
        $query->getResult();

        $this->assertCount($sqlCount + 2, $this->sqlLoggerStack->queries, 'Two non-cached queries.');

        $query->setParameter(1, 1);
        $query->enableResultCache();
        $query->getResult();

        $query->setParameter(1, 2);
        $query->getResult();

        $this->assertCount($sqlCount + 2, $this->sqlLoggerStack->queries, 'The next two sql should have been cached, but were not.');
    }

    public function testDisableResultCache() : void
    {
        $cache = new ArrayCache();
        $query = $this->em->createQuery('select ux from Doctrine\Tests\Models\CMS\CmsUser ux');

        $query->setResultCacheDriver($cache);
        $query->setResultCacheId('testing_result_cache_id');
        $query->disableResultCache();
        $users = $query->getResult();


        $this->assertFalse($cache->contains('testing_result_cache_id'));

        $this->em->getConfiguration()->setResultCacheImpl(new ArrayCache());
    }

    /**
     * @throws ORMException
     */
    public function testNativeQueryResultCaching() : NativeQuery
    {
        $cache = new ArrayCache();
        $rsm   = new ResultSetMapping();

        $rsm->addScalarResult('id', 'u', DBALType::getType('integer'));

        $query = $this->em->createNativeQuery('select u.id FROM cms_users u WHERE u.id = ?', $rsm);

        $query->setParameter(1, 10);
        $query->setResultCacheDriver($cache)->enableResultCache();

        self::assertEquals(0, $this->getCacheSize($cache));

        $query->getResult();

        self::assertEquals(1, $this->getCacheSize($cache));

        return $query;
    }

    /**
     * @param string $query
     * @depends testNativeQueryResultCaching
     */
    public function testResultCacheNotDependsOnQueryHints($query) : void
    {
        $cache      = $query->getResultCacheDriver();
        $cacheCount = $this->getCacheSize($cache);

        $query->setHint('foo', 'bar');
        $query->getResult();

        self::assertEquals($cacheCount, $this->getCacheSize($cache));
    }

    /**
     * @param <type> $query

     * @depends testNativeQueryResultCaching
     */
    public function testResultCacheDependsOnParameters($query) : void
    {
        $cache      = $query->getResultCacheDriver();
        $cacheCount = $this->getCacheSize($cache);

        $query->setParameter(1, 50);
        $query->getResult();

        self::assertEquals($cacheCount + 1, $this->getCacheSize($cache));
    }

    /**
     * @param <type> $query

     * @depends testNativeQueryResultCaching
     */
    public function testResultCacheNotDependsOnHydrationMode($query) : void
    {
        $cache      = $query->getResultCacheDriver();
        $cacheCount = $this->getCacheSize($cache);

        self::assertNotEquals(Query::HYDRATE_ARRAY, $query->getHydrationMode());
        $query->getArrayResult();

        self::assertEquals($cacheCount, $this->getCacheSize($cache));
    }

    /**
     * @group DDC-909
     */
    public function testResultCacheWithObjectParameter() : void
    {
        $user1           = new CmsUser();
        $user1->name     = 'Roman';
        $user1->username = 'romanb';
        $user1->status   = 'dev';

        $user2           = new CmsUser();
        $user2->name     = 'Benjamin';
        $user2->username = 'beberlei';
        $user2->status   = 'dev';

        $article        = new CmsArticle();
        $article->text  = 'foo';
        $article->topic = 'baz';
        $article->user  = $user1;

        $this->em->persist($article);
        $this->em->persist($user1);
        $this->em->persist($user2);
        $this->em->flush();

        $query = $this->em->createQuery('select a from Doctrine\Tests\Models\CMS\CmsArticle a WHERE a.user = ?1');
        $query->setParameter(1, $user1);

        $cache = new ArrayCache();

        $query->setResultCacheDriver($cache)->enableResultCache();

        $articles = $query->getResult();

        self::assertCount(1, $articles);
        self::assertEquals('baz', $articles[0]->topic);

        $this->em->clear();

        $query2 = $this->em->createQuery('select a from Doctrine\Tests\Models\CMS\CmsArticle a WHERE a.user = ?1');
        $query2->setParameter(1, $user1);

        $query2->setResultCacheDriver($cache)->enableResultCache();

        $articles = $query2->getResult();

        self::assertCount(1, $articles);
        self::assertEquals('baz', $articles[0]->topic);

        $query3 = $this->em->createQuery('select a from Doctrine\Tests\Models\CMS\CmsArticle a WHERE a.user = ?1');
        $query3->setParameter(1, $user2);

        $query3->setResultCacheDriver($cache)->enableResultCache();

        $articles = $query3->getResult();

        self::assertCount(0, $articles);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Doctrine\Tests\ORM\Functional;
6
7			use Doctrine\Common\Cache\ArrayCache;
8			use Doctrine\DBAL\Types\Type as DBALType;
9			use Doctrine\ORM\Exception\ORMException;
10			use Doctrine\ORM\NativeQuery;
11			use Doctrine\ORM\Query;
12			use Doctrine\ORM\Query\ResultSetMapping;
13			use Doctrine\Tests\Models\CMS\CmsArticle;
14			use Doctrine\Tests\Models\CMS\CmsUser;
15			use Doctrine\Tests\OrmFunctionalTestCase;
16			use function count;
17
18			/**
19			* ResultCacheTest
20			*/
21			class ResultCacheTest extends OrmFunctionalTestCase
22			{
23			/** @var \ReflectionProperty */
24			private $cacheDataReflection;
25
26			protected function setUp() : void
27			{
28			$this->cacheDataReflection = new \ReflectionProperty(ArrayCache::class, 'data');
29			$this->cacheDataReflection->setAccessible(true);
30
31			$this->useModelSet('cms');
32
33			parent::setUp();
34			}
35
36			/**
37			* @return int
38			*/
39			private function getCacheSize(ArrayCache $cache)
40			{
41			return count($this->cacheDataReflection->getValue($cache));
42			}
43
44			public function testResultCache() : void
45			{
46			$user = new CmsUser();
47
48			$user->name = 'Roman';
49			$user->username = 'romanb';
50			$user->status = 'dev';
51
52			$this->em->persist($user);
53			$this->em->flush();
54
55			$query = $this->em->createQuery('select ux from Doctrine\Tests\Models\CMS\CmsUser ux');
56			$cache = new ArrayCache();
57
58			$query->setResultCacheDriver($cache)->setResultCacheId('my_cache_id');
59
60			self::assertFalse($cache->contains('my_cache_id'));
61
62			$users = $query->getResult();
63
64			self::assertTrue($cache->contains('my_cache_id'));
65			self::assertCount(1, $users);
66			self::assertEquals('Roman', $users[0]->name);
67
68			$this->em->clear();
69
70			$query2 = $this->em->createQuery('select ux from Doctrine\Tests\Models\CMS\CmsUser ux');
71			$query2->setResultCacheDriver($cache)->setResultCacheId('my_cache_id');
72
73			$users = $query2->getResult();
74
75			self::assertTrue($cache->contains('my_cache_id'));
76			self::assertCount(1, $users);
77			self::assertEquals('Roman', $users[0]->name);
78			}
79
80			public function testSetResultCacheId() : void
81			{
82			$cache = new ArrayCache();
83			$query = $this->em->createQuery('select ux from Doctrine\Tests\Models\CMS\CmsUser ux');
84
85			$query->setResultCacheDriver($cache);
86			$query->setResultCacheId('testing_result_cache_id');
87
88			self::assertFalse($cache->contains('testing_result_cache_id'));
89
90			$users = $query->getResult();
			0 ignored issues – show Unused Code introduced 2017-11-23 09:45 UTC by Report Bug Copy Issue Report The assignment to `$users` is dead and can be removed. Loading history...
91
92			self::assertTrue($cache->contains('testing_result_cache_id'));
93			}
94
95			public function testEnableResultCache() : void
96			{
97			$cache = new ArrayCache();
98			$query = $this->em->createQuery('select ux from Doctrine\Tests\Models\CMS\CmsUser ux');
99
100			$query->enableResultCache(); // FIXME: This line does not affect anything. The test should be rethought.
101			$query->setResultCacheDriver($cache);
102			$query->setResultCacheId('testing_result_cache_id');
103			$users = $query->getResult();
			0 ignored issues – show Unused Code introduced 2018-05-06 22:24 UTC by Report Bug Copy Issue Report The assignment to `$users` is dead and can be removed. Loading history...
104
105			$this->assertTrue($cache->contains('testing_result_cache_id'));
106
107			$this->em->getConfiguration()->setResultCacheImpl(new ArrayCache());
108			}
109
110			/**
111			* @group DDC-1026
112			*/
113			public function testEnableResultCacheParams() : void
114			{
115			$cache = new ArrayCache();
116			$sqlCount = count($this->sqlLoggerStack->queries);
117			$query = $this->em->createQuery('select ux from Doctrine\Tests\Models\CMS\CmsUser ux WHERE ux.id = ?1');
118
119			$query->setParameter(1, 1);
120			$query->setResultCacheDriver($cache);
121			$query->enableResultCache();
122			$query->getResult();
123
124			$query->setParameter(1, 2);
125			$query->getResult();
126
127			$this->assertCount($sqlCount + 2, $this->sqlLoggerStack->queries, 'Two non-cached queries.');
128
129			$query->setParameter(1, 1);
130			$query->enableResultCache();
131			$query->getResult();
132
133			$query->setParameter(1, 2);
134			$query->getResult();
135
136			$this->assertCount($sqlCount + 2, $this->sqlLoggerStack->queries, 'The next two sql should have been cached, but were not.');
137			}
138
139			public function testDisableResultCache() : void
140			{
141			$cache = new ArrayCache();
142			$query = $this->em->createQuery('select ux from Doctrine\Tests\Models\CMS\CmsUser ux');
143
144			$query->setResultCacheDriver($cache);
145			$query->setResultCacheId('testing_result_cache_id');
146			$query->disableResultCache();
147			$users = $query->getResult();
			0 ignored issues – show Unused Code introduced 2018-05-06 22:24 UTC by Report Bug Copy Issue Report The assignment to `$users` is dead and can be removed. Loading history...
148
149			$this->assertFalse($cache->contains('testing_result_cache_id'));
150
151			$this->em->getConfiguration()->setResultCacheImpl(new ArrayCache());
152			}
153
154			/**
155			* @throws ORMException
156			*/
157			public function testNativeQueryResultCaching() : NativeQuery
158			{
159			$cache = new ArrayCache();
160			$rsm = new ResultSetMapping();
161
162			$rsm->addScalarResult('id', 'u', DBALType::getType('integer'));
163
164			$query = $this->em->createNativeQuery('select u.id FROM cms_users u WHERE u.id = ?', $rsm);
165
166			$query->setParameter(1, 10);
167			$query->setResultCacheDriver($cache)->enableResultCache();
168
169			self::assertEquals(0, $this->getCacheSize($cache));
170
171			$query->getResult();
172
173			self::assertEquals(1, $this->getCacheSize($cache));
174
175			return $query;
176			}
177
178			/**
179			* @param string $query
180			* @depends testNativeQueryResultCaching
181			*/
182			public function testResultCacheNotDependsOnQueryHints($query) : void
183			{
184			$cache = $query->getResultCacheDriver();
185			$cacheCount = $this->getCacheSize($cache);
186
187			$query->setHint('foo', 'bar');
188			$query->getResult();
189
190			self::assertEquals($cacheCount, $this->getCacheSize($cache));
191			}
192
193			/**
194			* @param <type> $query
			0 ignored issues – show Documentation Bug introduced 2018-03-26 20:28 UTC by Report Bug Copy Issue Report The doc comment `<type>` at position `0` could not be parsed: Unknown type name '<' at position 0 in <type>. Loading history...
195			* @depends testNativeQueryResultCaching
196			*/
197			public function testResultCacheDependsOnParameters($query) : void
198			{
199			$cache = $query->getResultCacheDriver();
200			$cacheCount = $this->getCacheSize($cache);
201
202			$query->setParameter(1, 50);
203			$query->getResult();
204
205			self::assertEquals($cacheCount + 1, $this->getCacheSize($cache));
206			}
207
208			/**
209			* @param <type> $query
			0 ignored issues – show Documentation Bug introduced 2018-03-26 20:28 UTC by Report Bug Copy Issue Report The doc comment `<type>` at position `0` could not be parsed: Unknown type name '<' at position 0 in <type>. Loading history...
210			* @depends testNativeQueryResultCaching
211			*/
212			public function testResultCacheNotDependsOnHydrationMode($query) : void
213			{
214			$cache = $query->getResultCacheDriver();
215			$cacheCount = $this->getCacheSize($cache);
216
217			self::assertNotEquals(Query::HYDRATE_ARRAY, $query->getHydrationMode());
218			$query->getArrayResult();
219
220			self::assertEquals($cacheCount, $this->getCacheSize($cache));
221			}
222
223			/**
224			* @group DDC-909
225			*/
226			public function testResultCacheWithObjectParameter() : void
227			{
228			$user1 = new CmsUser();
229			$user1->name = 'Roman';
230			$user1->username = 'romanb';
231			$user1->status = 'dev';
232
233			$user2 = new CmsUser();
234			$user2->name = 'Benjamin';
235			$user2->username = 'beberlei';
236			$user2->status = 'dev';
237
238			$article = new CmsArticle();
239			$article->text = 'foo';
240			$article->topic = 'baz';
241			$article->user = $user1;
242
243			$this->em->persist($article);
244			$this->em->persist($user1);
245			$this->em->persist($user2);
246			$this->em->flush();
247
248			$query = $this->em->createQuery('select a from Doctrine\Tests\Models\CMS\CmsArticle a WHERE a.user = ?1');
249			$query->setParameter(1, $user1);
250
251			$cache = new ArrayCache();
252
253			$query->setResultCacheDriver($cache)->enableResultCache();
254
255			$articles = $query->getResult();
256
257			self::assertCount(1, $articles);
258			self::assertEquals('baz', $articles[0]->topic);
259
260			$this->em->clear();
261
262			$query2 = $this->em->createQuery('select a from Doctrine\Tests\Models\CMS\CmsArticle a WHERE a.user = ?1');
263			$query2->setParameter(1, $user1);
264
265			$query2->setResultCacheDriver($cache)->enableResultCache();
266
267			$articles = $query2->getResult();
268
269			self::assertCount(1, $articles);
270			self::assertEquals('baz', $articles[0]->topic);
271
272			$query3 = $this->em->createQuery('select a from Doctrine\Tests\Models\CMS\CmsArticle a WHERE a.user = ?1');
273			$query3->setParameter(1, $user2);
274
275			$query3->setResultCacheDriver($cache)->enableResultCache();
276
277			$articles = $query3->getResult();
278
279			self::assertCount(0, $articles);
280			}
281			}
282

doctrine / orm

Pull Request — master (#7214)

ResultCacheTest::testEnableResultCacheParams() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like