mirror of
https://github.com/Karaka-Management/phpOMS.git
synced 2026-01-11 17:58:41 +00:00
315 lines
9.1 KiB
PHP
315 lines
9.1 KiB
PHP
<?php
|
|
/**
|
|
* Orange Management
|
|
*
|
|
* PHP Version 7.4
|
|
*
|
|
* @package tests
|
|
* @copyright Dennis Eichhorn
|
|
* @license OMS License 1.0
|
|
* @version 1.0.0
|
|
* @link https://orange-management.org
|
|
*/
|
|
declare(strict_types=1);
|
|
|
|
namespace phpOMS\tests\DataStorage\Cache\Connection;
|
|
|
|
use phpOMS\DataStorage\Cache\CacheStatus;
|
|
use phpOMS\DataStorage\Cache\CacheType;
|
|
use phpOMS\DataStorage\Cache\Connection\FileCache;
|
|
use phpOMS\Utils\TestUtils;
|
|
|
|
/**
|
|
* @testdox phpOMS\tests\DataStorage\Cache\Connection\FileCacheTest: File cache connection
|
|
*
|
|
* @internal
|
|
*/
|
|
class FileCacheTest extends \PHPUnit\Framework\TestCase
|
|
{
|
|
protected FileCache $cache;
|
|
|
|
protected function setUp() : void
|
|
{
|
|
if (\file_exists(__DIR__ . '/Cache')) {
|
|
\rmdir(__DIR__ . '/Cache');
|
|
}
|
|
|
|
$this->cache = new FileCache(__DIR__ . '/Cache');
|
|
}
|
|
|
|
protected function tearDown() : void
|
|
{
|
|
$this->cache->flushAll();
|
|
|
|
if (\file_exists(__DIR__ . '/Cache')) {
|
|
\rmdir(__DIR__ . '/Cache');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @testdox The file cache connection has the expected default values after initialization
|
|
*/
|
|
public function testDefault() : void
|
|
{
|
|
self::assertEquals('', $this->cache->getPrefix());
|
|
self::assertEquals(CacheType::FILE, $this->cache->getType());
|
|
self::assertTrue(\is_dir(__DIR__ . '/Cache'));
|
|
self::assertTrue($this->cache->flushAll());
|
|
self::assertEquals(50, $this->cache->getThreshold());
|
|
self::assertNull($this->cache->get('test'));
|
|
self::assertEquals(
|
|
[
|
|
'status' => CacheStatus::OK,
|
|
'count' => 0,
|
|
'size' => 0,
|
|
],
|
|
$this->cache->stats()
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @testdox The connection to a dedicated cache directory can be established (none-exising directories get created)
|
|
*/
|
|
public function testConnect() : void
|
|
{
|
|
self::assertEquals(CacheStatus::OK, $this->cache->getStatus());
|
|
}
|
|
|
|
/**
|
|
* @testdox Different cache data (types) can be set and returned
|
|
*/
|
|
public function testSetInputOutput() : void
|
|
{
|
|
$this->cache->set('key1', 'testVal');
|
|
self::assertEquals('testVal', $this->cache->get('key1'));
|
|
|
|
$this->cache->set('key2', false);
|
|
self::assertFalse($this->cache->get('key2'));
|
|
|
|
$this->cache->set('key3', null);
|
|
self::assertNull($this->cache->get('key3'));
|
|
|
|
$this->cache->set('key4', 4);
|
|
self::assertEquals(4, $this->cache->get('key4'));
|
|
|
|
$this->cache->set('key5', 5.12);
|
|
self::assertEquals(5.12, $this->cache->get('key5'));
|
|
|
|
$this->cache->set('key6', ['asdf', 1, true, 2.3]);
|
|
self::assertEquals(['asdf', 1, true, 2.3], $this->cache->get('key6'));
|
|
|
|
$this->cache->set('key7', new FileCacheSerializable());
|
|
self::assertEquals('abc', $this->cache->get('key7')->val);
|
|
|
|
$this->cache->set('key8', new FileCacheJsonSerializable());
|
|
self::assertEquals('abc', $this->cache->get('key8')->val);
|
|
}
|
|
|
|
/**
|
|
* @testdox Cache data can bet added and returned
|
|
*/
|
|
public function testAddInputOutput() : void
|
|
{
|
|
self::assertTrue($this->cache->add('addKey', 'testValAdd'));
|
|
self::assertEquals('testValAdd', $this->cache->get('addKey'));
|
|
}
|
|
|
|
/**
|
|
* @testdox Cache data cannot be added if it already exists
|
|
*/
|
|
public function testInvalidOverwrite() : void
|
|
{
|
|
self::assertTrue($this->cache->add('addKey', 'testValAdd'));
|
|
self::assertFalse($this->cache->add('addKey', 'testValAdd2'));
|
|
self::assertEquals('testValAdd', $this->cache->get('addKey'));
|
|
}
|
|
|
|
/**
|
|
* @testdox Existing cache data can be replaced
|
|
*/
|
|
public function testReplace() : void
|
|
{
|
|
$this->cache->set('key4', 4);
|
|
self::assertEquals(4, $this->cache->get('key4'));
|
|
|
|
self::assertTrue($this->cache->replace('key4', 5));
|
|
self::assertEquals(5, $this->cache->get('key4'));
|
|
}
|
|
|
|
/**
|
|
* @testdox None-existing cache data cannot be replaced
|
|
*/
|
|
public function testInvalidReplace() : void
|
|
{
|
|
self::assertFalse($this->cache->replace('keyInvalid', 5));
|
|
}
|
|
|
|
/**
|
|
* @testdox Existing cache data can be deleted
|
|
*/
|
|
public function testDelete() : void
|
|
{
|
|
$this->cache->set('key4', 4);
|
|
self::assertEquals(4, $this->cache->get('key4'));
|
|
|
|
self::assertTrue($this->cache->delete('key4'));
|
|
self::assertNull($this->cache->get('key4'));
|
|
}
|
|
|
|
/**
|
|
* @testdox The cache correctly handles general cache information
|
|
*/
|
|
public function testStats() : void
|
|
{
|
|
$this->cache->set('key1', 'testVal');
|
|
self::assertEquals('testVal', $this->cache->get('key1'));
|
|
|
|
$this->cache->set('key2', false);
|
|
self::assertFalse($this->cache->get('key2'));
|
|
|
|
self::assertEquals(
|
|
[
|
|
'status' => CacheStatus::OK,
|
|
'count' => 2,
|
|
'size' => 17,
|
|
],
|
|
$this->cache->stats()
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @testdox The cache can be flushed
|
|
*/
|
|
public function testFlush() : void
|
|
{
|
|
$this->cache->set('key1', 'testVal');
|
|
self::assertEquals('testVal', $this->cache->get('key1'));
|
|
|
|
$this->cache->set('key2', false);
|
|
self::assertFalse($this->cache->get('key2'));
|
|
|
|
self::assertTrue($this->cache->flushAll());
|
|
self::assertNull($this->cache->get('key5'));
|
|
|
|
self::assertEquals(
|
|
[
|
|
'status' => CacheStatus::OK,
|
|
'count' => 0,
|
|
'size' => 0,
|
|
],
|
|
$this->cache->stats()
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @testdox Cache data can be set and returned with expiration limits
|
|
*/
|
|
public function testUnexpiredInputOutput() : void
|
|
{
|
|
$this->cache->set('key1', 'testVal', 1);
|
|
self::assertEquals('testVal', $this->cache->get('key1'));
|
|
}
|
|
|
|
/**
|
|
* @testdox Expired cache data cannot be returned
|
|
*/
|
|
public function testExpiredInputOutput() : void
|
|
{
|
|
$this->cache->set('key2', 'testVal2', 1);
|
|
self::assertEquals('testVal2', $this->cache->get('key2', 1));
|
|
\sleep(2);
|
|
self::assertNull($this->cache->get('key2', 1));
|
|
self::assertNull($this->cache->get('key2')); // this causes a side effect of deleting the outdated cache element!!!
|
|
}
|
|
|
|
/**
|
|
* @testdox Expired cache data can be forced to return
|
|
*/
|
|
public function testForceExpiredInputOutput() : void
|
|
{
|
|
$this->cache->set('key2', 'testVal2', 1);
|
|
\sleep(2);
|
|
self::assertEquals('testVal2', $this->cache->get('key2', 10));
|
|
}
|
|
|
|
/**
|
|
* @testdox Unexpired cache data connot be delete if lower expiration is defined
|
|
*/
|
|
public function testInvalidDeleteUnexpired() : void
|
|
{
|
|
$this->cache->set('key4', 'testVal4', 60);
|
|
self::assertFalse($this->cache->delete('key4', 0));
|
|
}
|
|
|
|
/**
|
|
* @testdox Expired cache data can be deleted if equal expiration is defined
|
|
*/
|
|
public function testDeleteExpired() : void
|
|
{
|
|
$this->cache->set('key4', 'testVal4', 1);
|
|
\sleep(2);
|
|
self::assertTrue($this->cache->delete('key4', 1));
|
|
}
|
|
|
|
/**
|
|
* @testdox Unexpired data can be force deleted with lower expiration date
|
|
*/
|
|
public function testForceDeleteUnexpired() : void
|
|
{
|
|
$this->cache->set('key5', 'testVal5', 10000);
|
|
\sleep(2);
|
|
self::assertFalse($this->cache->delete('key5', 1000000));
|
|
self::assertTrue($this->cache->delete('key5', 1));
|
|
}
|
|
|
|
/**
|
|
* @testdox Cach data can be flushed by expiration date
|
|
*/
|
|
public function testFlushExpired() : void
|
|
{
|
|
$this->cache->set('key6', 'testVal6', 1);
|
|
\sleep(2);
|
|
|
|
$this->cache->flush(0);
|
|
self::assertNull($this->cache->get('key6', 0));
|
|
}
|
|
|
|
/**
|
|
* @testdox A bad cache status will prevent all cache actions
|
|
*/
|
|
public function testBadCacheStatus() : void
|
|
{
|
|
TestUtils::setMember($this->cache, 'status', CacheStatus::FAILURE);
|
|
|
|
$this->cache->set('key1', 'testVal');
|
|
self::assertFalse($this->cache->add('key2', 'testVal2'));
|
|
self::assertNull($this->cache->get('key1'));
|
|
self::assertFalse($this->cache->replace('key1', 5));
|
|
self::assertFalse($this->cache->delete('key1'));
|
|
self::assertFalse($this->cache->flushAll());
|
|
self::assertFalse($this->cache->flush());
|
|
self::assertEquals([], $this->cache->stats());
|
|
}
|
|
|
|
/**
|
|
* @testdox A invalid cache connection will throw an InvalidConnectionConfigException
|
|
*/
|
|
public function testInvalidCachePath() : void
|
|
{
|
|
self::expectException(\phpOMS\DataStorage\Cache\Exception\InvalidConnectionConfigException::class);
|
|
|
|
$cache = new FileCache('/etc/invalidPathOrPermission^$:?><');
|
|
}
|
|
|
|
/**
|
|
* @testdox A invalid data type will throw an InvalidArgumentException
|
|
*/
|
|
public function testInvalidDataType() : void
|
|
{
|
|
self::expectException(\InvalidArgumentException::class);
|
|
|
|
$this->cache->add('invalid', $this->cache);
|
|
|
|
}
|
|
}
|