InMemoryCacheTest::setMultple() - Code Metrics - subjective-php/psr-cache-helper - Measure and Improve Code Quality continuously with Scrutinizer

InMemoryCacheTest::setMultple() A
last analyzed 2024-04-04 18:21 UTC

↳ Parent: InMemoryCacheTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	7
c	0
b	0
f	0
nc	1
nop	0
dl	0
loc	9
rs	10

<?php

namespace SubjectivePHPTest\Psr\SimpleCache;

use ArrayObject;
use DateTime;
use SubjectivePHP\Psr\SimpleCache\InMemoryCache;

/**
 * @coversDefaultClass \SubjectivePHP\Psr\SimpleCache\InMemoryCache
 * @covers ::__construct
 * @covers ::<private>
 */
final class InMemoryCacheTest extends \PHPUnit\Framework\TestCase
{
    /**
     * @test
     * @covers ::get
     *
     * @return void
     */
    public function get()
    {
        $container = new ArrayObject();
        $cache = new InMemoryCache($container);
        $dateTime = new DateTime();
        $container['foo'] = ['data' => $dateTime, 'expires' => PHP_INT_MAX];
        $this->assertEquals($dateTime, $cache->get('foo'));
    }

    /**
     * @test
     * @covers ::get
     *
     * @return void
     */
    public function getKeyNotFound()
    {
        $cache = new InMemoryCache(new ArrayObject());
        $default = new \StdClass();
        $this->assertSame($default, $cache->get('foo', $default));
    }

    /**
     * @test
     * @covers ::get
     *
     * @return void
     */
    public function getExpired()
    {
        $container = new ArrayObject();
        $container['foo'] = ['data' => new DateTime(), 'expires' => -10];
        $cache = new InMemoryCache($container);
        $this->assertNull($cache->get('foo'));
    }

    /**
     * @test
     * @covers ::getMultiple
     *
     * @return void
     */
    public function getMultple()
    {
        $cache = new InMemoryCache(new ArrayObject());
        $default = new \StdClass();
        $dateTime = new \DateTime();
        $exception = new \RuntimeException();
        $cache->set('foo', $dateTime);
        $cache->set('bar', $exception);
        $actual = $cache->getMultiple(['foo', 'baz', 'bar'], $default);
        $this->assertEquals($dateTime, $actual['foo']);
        $this->assertSame($default, $actual['baz']);
        $this->assertEquals($exception, $actual['bar']);
    }

    /**
     * @test
     * @covers ::set
     *
     * @return void
     */
    public function setWithIntegerTTL()
    {
        $container = new ArrayObject();
        $cache = new InMemoryCache($container);
        $dateTime = new \DateTime();
        $this->assertTrue($cache->set('foo', $dateTime, 3600));
        $this->assertSame(
            [
                'foo' => [
                    'data' => $dateTime,
                    'expires' => time() + 3600,
                ],
            ],
            $container->getArrayCopy()
        );
    }

    /**
     * @test
     * @covers ::set
     *
     * @return void
     */
    public function setWithNullTTL()
    {
        $dateTime = new \DateTime();
        $cache = new InMemoryCache(new ArrayObject());
        $this->assertTrue($cache->set('foo', $dateTime));
        $this->assertEquals($dateTime, $cache->get('foo'));
    }

    /**
     * @test
     * @covers ::setMultiple
     *
     * @return void
     */
    public function setMultple()
    {
        $ttl = \DateInterval::createFromDateString('1 day');
        $dateTime = new \DateTime();
        $exception = new \RuntimeException();
        $cache = new InMemoryCache(new ArrayObject());
        $this->assertTrue($cache->setMultiple(['foo' => $dateTime, 'bar' => $exception], $ttl));
        $this->assertEquals($dateTime, $cache->get('foo'));
        $this->assertEquals($exception, $cache->get('bar'));
    }

    /**
     * @test
     * @covers ::delete
     *
     * @return void
     */
    public function delete()
    {
        $cache = new InMemoryCache(new ArrayObject());
        $dateTime = new DateTime();
        $cache->set('foo', $dateTime);
        $cache->delete('foo');
        $this->assertNull($cache->get('foo'));
    }

    /**
     * @test
     * @covers ::deleteMultiple
     *
     * @return void
     */
    public function deleteMultiple()
    {
        $cache = new InMemoryCache(new ArrayObject());
        $cache->set('foo', 'foo');
        $cache->set('bar', 'bar');
        $cache->set('baz', 'baz');

        $cache->deleteMultiple(['foo', 'bar']);
        $this->assertNull($cache->get('foo'));
        $this->assertNull($cache->get('bar'));
        $this->assertSame('baz', $cache->get('baz'));
    }

    /**
     * @test
     * @covers ::clear
     *
     * @return void
     */
    public function clear()
    {
        $container = new ArrayObject();
        $cache = new InMemoryCache($container);
        $cache->set('foo', 'foo');
        $cache->set('bar', 'bar');
        $cache->set('baz', 'baz');

        $cache->clear();

        $this->assertSame([], $container->getArrayCopy());
    }

    /**
     * @test
     * @covers ::has
     *
     * @return void
     */
    public function has()
    {
        $cache = new InMemoryCache(new ArrayObject());
        $cache->set('foo', 'foo');
        $this->assertTrue($cache->has('foo'));
        $this->assertFalse($cache->has('bar'));
    }
}


1			<?php
2
3			namespace SubjectivePHPTest\Psr\SimpleCache;
4
5			use ArrayObject;
6			use DateTime;
7			use SubjectivePHP\Psr\SimpleCache\InMemoryCache;
8
9			/**
10			* @coversDefaultClass \SubjectivePHP\Psr\SimpleCache\InMemoryCache
11			* @covers ::__construct
12			* @covers ::<private>
13			*/
14			final class InMemoryCacheTest extends \PHPUnit\Framework\TestCase
15			{
16			/**
17			* @test
18			* @covers ::get
19			*
20			* @return void
21			*/
22			public function get()
23			{
24			$container = new ArrayObject();
25			$cache = new InMemoryCache($container);
26			$dateTime = new DateTime();
27			$container['foo'] = ['data' => $dateTime, 'expires' => PHP_INT_MAX];
28			$this->assertEquals($dateTime, $cache->get('foo'));
29			}
30
31			/**
32			* @test
33			* @covers ::get
34			*
35			* @return void
36			*/
37			public function getKeyNotFound()
38			{
39			$cache = new InMemoryCache(new ArrayObject());
40			$default = new \StdClass();
41			$this->assertSame($default, $cache->get('foo', $default));
42			}
43
44			/**
45			* @test
46			* @covers ::get
47			*
48			* @return void
49			*/
50			public function getExpired()
51			{
52			$container = new ArrayObject();
53			$container['foo'] = ['data' => new DateTime(), 'expires' => -10];
54			$cache = new InMemoryCache($container);
55			$this->assertNull($cache->get('foo'));
56			}
57
58			/**
59			* @test
60			* @covers ::getMultiple
61			*
62			* @return void
63			*/
64			public function getMultple()
65			{
66			$cache = new InMemoryCache(new ArrayObject());
67			$default = new \StdClass();
68			$dateTime = new \DateTime();
69			$exception = new \RuntimeException();
70			$cache->set('foo', $dateTime);
71			$cache->set('bar', $exception);
72			$actual = $cache->getMultiple(['foo', 'baz', 'bar'], $default);
73			$this->assertEquals($dateTime, $actual['foo']);
74			$this->assertSame($default, $actual['baz']);
75			$this->assertEquals($exception, $actual['bar']);
76			}
77
78			/**
79			* @test
80			* @covers ::set
81			*
82			* @return void
83			*/
84			public function setWithIntegerTTL()
85			{
86			$container = new ArrayObject();
87			$cache = new InMemoryCache($container);
88			$dateTime = new \DateTime();
89			$this->assertTrue($cache->set('foo', $dateTime, 3600));
90			$this->assertSame(
91			[
92			'foo' => [
93			'data' => $dateTime,
94			'expires' => time() + 3600,
95			],
96			],
97			$container->getArrayCopy()
98			);
99			}
100
101			/**
102			* @test
103			* @covers ::set
104			*
105			* @return void
106			*/
107			public function setWithNullTTL()
108			{
109			$dateTime = new \DateTime();
110			$cache = new InMemoryCache(new ArrayObject());
111			$this->assertTrue($cache->set('foo', $dateTime));
112			$this->assertEquals($dateTime, $cache->get('foo'));
113			}
114
115			/**
116			* @test
117			* @covers ::setMultiple
118			*
119			* @return void
120			*/
121			public function setMultple()
122			{
123			$ttl = \DateInterval::createFromDateString('1 day');
124			$dateTime = new \DateTime();
125			$exception = new \RuntimeException();
126			$cache = new InMemoryCache(new ArrayObject());
127			$this->assertTrue($cache->setMultiple(['foo' => $dateTime, 'bar' => $exception], $ttl));
128			$this->assertEquals($dateTime, $cache->get('foo'));
129			$this->assertEquals($exception, $cache->get('bar'));
130			}
131
132			/**
133			* @test
134			* @covers ::delete
135			*
136			* @return void
137			*/
138			public function delete()
139			{
140			$cache = new InMemoryCache(new ArrayObject());
141			$dateTime = new DateTime();
142			$cache->set('foo', $dateTime);
143			$cache->delete('foo');
144			$this->assertNull($cache->get('foo'));
145			}
146
147			/**
148			* @test
149			* @covers ::deleteMultiple
150			*
151			* @return void
152			*/
153			public function deleteMultiple()
154			{
155			$cache = new InMemoryCache(new ArrayObject());
156			$cache->set('foo', 'foo');
157			$cache->set('bar', 'bar');
158			$cache->set('baz', 'baz');
159
160			$cache->deleteMultiple(['foo', 'bar']);
161			$this->assertNull($cache->get('foo'));
162			$this->assertNull($cache->get('bar'));
163			$this->assertSame('baz', $cache->get('baz'));
164			}
165
166			/**
167			* @test
168			* @covers ::clear
169			*
170			* @return void
171			*/
172			public function clear()
173			{
174			$container = new ArrayObject();
175			$cache = new InMemoryCache($container);
176			$cache->set('foo', 'foo');
177			$cache->set('bar', 'bar');
178			$cache->set('baz', 'baz');
179
180			$cache->clear();
181
182			$this->assertSame([], $container->getArrayCopy());
183			}
184
185			/**
186			* @test
187			* @covers ::has
188			*
189			* @return void
190			*/
191			public function has()
192			{
193			$cache = new InMemoryCache(new ArrayObject());
194			$cache->set('foo', 'foo');
195			$this->assertTrue($cache->has('foo'));
196			$this->assertFalse($cache->has('bar'));
197			}
198			}
199

subjective-php / psr-cache-helper

InMemoryCacheTest::setMultple() A last analyzed 2024-04-04 18:21 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

InMemoryCacheTest::setMultple() A
last analyzed 2024-04-04 18:21 UTC