ChainCacheTest::testOnlyFetchFirstOne() - Code Metrics - Inspection of "Merge pull request #132 from doctrine/scrutinizer-..." - doctrine/cache - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( a8b991...dda2b8 )

by Marco

created 2015-12-31 17:56 UTC

ChainCacheTest::testOnlyFetchFirstOne() A

↳ Parent: ChainCacheTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	12
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Metric	Value
dl	0
loc	12
rs	9.4286
cc	1
eloc	7
nc	1
nop	0

<?php

namespace Doctrine\Tests\Common\Cache;

use Doctrine\Common\Cache\ApcCache;
use Doctrine\Common\Cache\ArrayCache;
use Doctrine\Common\Cache\ChainCache;

class ChainCacheTest extends CacheTest
{
    protected function _getCacheDriver()
    {
        return new ChainCache(array(new ArrayCache()));
    }

    public function testLifetime()
    {
        $this->markTestSkipped('The ChainCache test uses ArrayCache which does not implement TTL currently.');
    }

    public function testGetStats()
    {
        $cache = $this->_getCacheDriver();
        $stats = $cache->getStats();

        $this->assertInternalType('array', $stats);
    }

    public function testOnlyFetchFirstOne()
    {
        $cache1 = new ArrayCache();
        $cache2 = $this->getMockForAbstractClass('Doctrine\Common\Cache\CacheProvider');

        $cache2->expects($this->never())->method('doFetch');

        $chainCache = new ChainCache(array($cache1, $cache2));
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $chainCache->save('id', 'bar');

        $this->assertEquals('bar', $chainCache->fetch('id'));
    }

    public function testFetchPropagateToFastestCache()
    {
        $cache1 = new ArrayCache();
        $cache2 = new ArrayCache();

        $cache2->save('bar', 'value');

        $chainCache = new ChainCache(array($cache1, $cache2));

        $this->assertFalse($cache1->contains('bar'));

        $result = $chainCache->fetch('bar');

        $this->assertEquals('value', $result);
        $this->assertTrue($cache2->contains('bar'));
    }

    public function testNamespaceIsPropagatedToAllProviders()
    {
        $cache1 = new ArrayCache();
        $cache2 = new ArrayCache();

        $chainCache = new ChainCache(array($cache1, $cache2));
        $chainCache->setNamespace('bar');

        $this->assertEquals('bar', $cache1->getNamespace());
        $this->assertEquals('bar', $cache2->getNamespace());
    }

    public function testDeleteToAllProviders()
    {
        $cache1 = $this->getMockForAbstractClass('Doctrine\Common\Cache\CacheProvider');
        $cache2 = $this->getMockForAbstractClass('Doctrine\Common\Cache\CacheProvider');

        $cache1->expects($this->once())->method('doDelete');
        $cache2->expects($this->once())->method('doDelete');

        $chainCache = new ChainCache(array($cache1, $cache2));
        $chainCache->delete('bar');
    }

    public function testFlushToAllProviders()
    {
        $cache1 = $this->getMockForAbstractClass('Doctrine\Common\Cache\CacheProvider');
        $cache2 = $this->getMockForAbstractClass('Doctrine\Common\Cache\CacheProvider');

        $cache1->expects($this->once())->method('doFlush');
        $cache2->expects($this->once())->method('doFlush');

        $chainCache = new ChainCache(array($cache1, $cache2));
        $chainCache->flushAll();
    }

    protected function isSharedStorage()
    {
        return false;
    }
}

1			<?php
2
3			namespace Doctrine\Tests\Common\Cache;
4
5			use Doctrine\Common\Cache\ApcCache;
6			use Doctrine\Common\Cache\ArrayCache;
7			use Doctrine\Common\Cache\ChainCache;
8
9			class ChainCacheTest extends CacheTest
10			{
11			protected function _getCacheDriver()
12			{
13			return new ChainCache(array(new ArrayCache()));
14			}
15
16			public function testLifetime()
17			{
18			$this->markTestSkipped('The ChainCache test uses ArrayCache which does not implement TTL currently.');
19			}
20
21			public function testGetStats()
22			{
23			$cache = $this->_getCacheDriver();
24			$stats = $cache->getStats();
25
26			$this->assertInternalType('array', $stats);
27			}
28
29			public function testOnlyFetchFirstOne()
30			{
31			$cache1 = new ArrayCache();
32			$cache2 = $this->getMockForAbstractClass('Doctrine\Common\Cache\CacheProvider');
33
34			$cache2->expects($this->never())->method('doFetch');
35
36			$chainCache = new ChainCache(array($cache1, $cache2));
			0 ignored issues – show Documentation introduced 2015-12-31 17:39 UTC by Report Bug Copy Issue Report `array($cache1, $cache2)` is of type `array<integer,object<Doc...ckObject_MockObject>"}>`, but the function expects a `array<integer,object<Doc...n\Cache\CacheProvider>>`. 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...
37			$chainCache->save('id', 'bar');
38
39			$this->assertEquals('bar', $chainCache->fetch('id'));
40			}
41
42			public function testFetchPropagateToFastestCache()
43			{
44			$cache1 = new ArrayCache();
45			$cache2 = new ArrayCache();
46
47			$cache2->save('bar', 'value');
48
49			$chainCache = new ChainCache(array($cache1, $cache2));
50
51			$this->assertFalse($cache1->contains('bar'));
52
53			$result = $chainCache->fetch('bar');
54
55			$this->assertEquals('value', $result);
56			$this->assertTrue($cache2->contains('bar'));
57			}
58
59			public function testNamespaceIsPropagatedToAllProviders()
60			{
61			$cache1 = new ArrayCache();
62			$cache2 = new ArrayCache();
63
64			$chainCache = new ChainCache(array($cache1, $cache2));
65			$chainCache->setNamespace('bar');
66
67			$this->assertEquals('bar', $cache1->getNamespace());
68			$this->assertEquals('bar', $cache2->getNamespace());
69			}
70
71			public function testDeleteToAllProviders()
72			{
73			$cache1 = $this->getMockForAbstractClass('Doctrine\Common\Cache\CacheProvider');
74			$cache2 = $this->getMockForAbstractClass('Doctrine\Common\Cache\CacheProvider');
75
76			$cache1->expects($this->once())->method('doDelete');
77			$cache2->expects($this->once())->method('doDelete');
78
79			$chainCache = new ChainCache(array($cache1, $cache2));
80			$chainCache->delete('bar');
81			}
82
83			public function testFlushToAllProviders()
84			{
85			$cache1 = $this->getMockForAbstractClass('Doctrine\Common\Cache\CacheProvider');
86			$cache2 = $this->getMockForAbstractClass('Doctrine\Common\Cache\CacheProvider');
87
88			$cache1->expects($this->once())->method('doFlush');
89			$cache2->expects($this->once())->method('doFlush');
90
91			$chainCache = new ChainCache(array($cache1, $cache2));
92			$chainCache->flushAll();
93			}
94
95			protected function isSharedStorage()
96			{
97			return false;
98			}
99			}

doctrine / cache

Push — master ( a8b991...dda2b8 )

ChainCacheTest::testOnlyFetchFirstOne() A

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like