Friendica/friendica-github
1
0
Fork 0
mirror of https://github.com/friendica/friendica synced 2025-04-26 17:50:11 +00:00
Code Issues Projects Releases Packages Wiki Activity

Refactor Cache/Lock to DICE

Browse source 
- Refactor Cache classes
- Refactor Lock classes
- Improved test speed (removed some seperate class annotations)
This commit is contained in:
Philipp Holzer 2019-08-03 20:48:56 +02:00
parent b95d4f41b9
commit d56bd28a07
No known key found for this signature in database
GPG key ID: D8365C3D36B77D90
40 changed files with 766 additions and 621 deletions
Download patch file Download diff file Expand all files Collapse all files

2
tests/src/Core/Cache/APCuCacheDriverTest.php
View file

@ -17,7 +17,7 @@ class APCuCacheDriverTest extends MemoryCacheTest
protected function getInstance()
{
$this->cache = new APCuCache();
$this->cache = new APCuCache('localhost');
return $this->cache;
}

2
tests/src/Core/Cache/ArrayCacheDriverTest.php
View file

@ -8,7 +8,7 @@ class ArrayCacheDriverTest extends MemoryCacheTest
{
protected function getInstance()
{
$this->cache = new ArrayCache();
$this->cache = new ArrayCache('localhost');
return $this->cache;
}

34
tests/src/Core/Cache/CacheTest.php
View file

@ -4,15 +4,10 @@ namespace Friendica\Test\src\Core\Cache;
use Friendica\Core\Cache\MemcachedCacheDriver;
use Friendica\Test\MockedTest;
use Friendica\Test\Util\AppMockTrait;
use Friendica\Test\Util\VFSTrait;
use Friendica\Util\PidFile;
abstract class CacheTest extends MockedTest
{
use VFSTrait;
use AppMockTrait;
/**
* @var int Start time of the mock (used for time operations)
*/
@ -30,6 +25,7 @@ abstract class CacheTest extends MockedTest
/**
* Dataset for test setting different types in the cache
*
* @return array
*/
public function dataTypesInCache()
@ -48,6 +44,7 @@ abstract class CacheTest extends MockedTest
/**
* Dataset for simple value sets/gets
*
* @return array
*/
public function dataSimple()
@ -66,12 +63,6 @@ abstract class CacheTest extends MockedTest
protected function setUp()
{
$this->setUpVfsDir();
$this->mockApp($this->root);
$this->app
->shouldReceive('getHostname')
->andReturn('friendica.local');
parent::setUp();
$this->instance = $this->getInstance();
@ -82,10 +73,12 @@ abstract class CacheTest extends MockedTest
/**
* @small
* @dataProvider dataSimple
*
* @param mixed $value1 a first
* @param mixed $value2 a second
*/
function testSimple($value1, $value2) {
function testSimple($value1, $value2)
{
$this->assertNull($this->instance->get('value1'));
$this->instance->set('value1', $value1);
@ -110,12 +103,14 @@ abstract class CacheTest extends MockedTest
/**
* @small
* @dataProvider dataSimple
*
* @param mixed $value1 a first
* @param mixed $value2 a second
* @param mixed $value3 a third
* @param mixed $value4 a fourth
*/
function testClear($value1, $value2, $value3, $value4) {
function testClear($value1, $value2, $value3, $value4)
{
$value = 'ipsum lorum';
$this->instance->set('1_value1', $value1);
$this->instance->set('1_value2', $value2);
@ -166,7 +161,8 @@ abstract class CacheTest extends MockedTest
/**
* @medium
*/
function testTTL() {
function testTTL()
{
$this->markTestSkipped('taking too much time without mocking');
$this->assertNull($this->instance->get('value1'));
@ -183,10 +179,13 @@ abstract class CacheTest extends MockedTest
/**
* @small
*
* @param $data mixed the data to store in the cache
*
* @dataProvider dataTypesInCache
*/
function testDifferentTypesInCache($data) {
function testDifferentTypesInCache($data)
{
$this->instance->set('val', $data);
$received = $this->instance->get('val');
$this->assertEquals($data, $received, 'Value type changed from ' . gettype($data) . ' to ' . gettype($received));
@ -194,12 +193,15 @@ abstract class CacheTest extends MockedTest
/**
* @small
*
* @param mixed $value1 a first
* @param mixed $value2 a second
* @param mixed $value3 a third
*
* @dataProvider dataSimple
*/
public function testGetAllKeys($value1, $value2, $value3) {
public function testGetAllKeys($value1, $value2, $value3)
{
if ($this->cache instanceof MemcachedCacheDriver) {
$this->markTestSkipped('Memcached doesn\'t support getAllKeys anymore');
}

139
tests/src/Core/Cache/DatabaseCacheDriverTest.php
View file

@ -3,33 +3,40 @@
namespace Friendica\Test\src\Core\Cache;
use Friendica\Core\Cache;
use Friendica\Factory\CacheDriverFactory;
use Friendica\Test\Util\DbaCacheMockTrait;
use Friendica\Factory\ConfigFactory;
use Friendica\Test\DatabaseTestTrait;
use Friendica\Test\Util\Database\StaticDatabase;
use Friendica\Test\Util\VFSTrait;
use Friendica\Util\ConfigFileLoader;
use Friendica\Util\Profiler;
use Psr\Log\NullLogger;
/**
* @runTestsInSeparateProcesses
* @preserveGlobalState disabled
*/
class DatabaseCacheDriverTest extends CacheTest
{
use DbaCacheMockTrait;
use DatabaseTestTrait;
use VFSTrait;
public function setUp()
protected function setUp()
{
$this->mockUtcNow($this->startTime);
$this->mockConnected();
$this->mockConnect();
// The first "clear" at setup
$this->mockClear(false, true, 2);
$this->setUpVfsDir();
parent::setUp();
}
protected function getInstance()
{
$this->cache = CacheDriverFactory::create('database');
$logger = new NullLogger();
$profiler = \Mockery::mock(Profiler::class);
$profiler->shouldReceive('saveTimestamp')->withAnyArgs()->andReturn(true);
// load real config to avoid mocking every config-entry which is related to the Database class
$configFactory = new ConfigFactory();
$loader = new ConfigFileLoader($this->root->url());
$configCache = $configFactory->createCache($loader);
$dba = new StaticDatabase($configCache, $profiler, $logger);
$this->cache = new Cache\DatabaseCacheDriver('database', $dba);
return $this->cache;
}
@ -38,104 +45,4 @@ class DatabaseCacheDriverTest extends CacheTest
$this->cache->clear(false);
parent::tearDown();
}
/**
* {@inheritdoc}
* @dataProvider dataSimple
*/
public function testSimple($value1, $value2)
{
// assertNull
$this->mockGet('value1', null, $this->startTime, 1);
// assertEquals
$this->mockSet('value1', $value1, Cache::FIVE_MINUTES, $this->startTime, true, 1);
$this->mockGet('value1', $value1, $this->startTime, 1);
// assertEquals
$this->mockSet('value1', $value2, Cache::FIVE_MINUTES, $this->startTime, true, 1);
$this->mockGet('value1', $value2, $this->startTime, 1);
// assertEquals
$this->mockSet('value2', $value1, Cache::FIVE_MINUTES, $this->startTime, true, 1);
$this->mockGet('value2', $value1, $this->startTime, 1);
// assertNull
$this->mockGet('not_set', null, $this->startTime, 1);
// assertNull
$this->mockDelete('value1', true, 1);
$this->mockGet('value1', null, $this->startTime, 1);
parent::testSimple($value1, $value2);
}
/**
* {@inheritdoc}
* @dataProvider dataSimple
*/
public function testClear($value1, $value2, $value3, $value4)
{
// assert Equals
$this->mockSet('1_value1', $value1, Cache::FIVE_MINUTES, $this->startTime, true, 1);
$this->mockSet('1_value2', $value2, Cache::FIVE_MINUTES, $this->startTime, true, 1);
$this->mockSet('2_value1', $value3, Cache::FIVE_MINUTES, $this->startTime, true, 1);
$this->mockSet('3_value1', $value4, Cache::FIVE_MINUTES, $this->startTime, true, 1);
$this->mockGet('1_value1', $value1, $this->startTime, 2);
$this->mockGet('1_value2', $value2, $this->startTime, 2);
$this->mockGet('2_value1', $value3, $this->startTime, 2);
$this->mockGet('3_value1', $value4, $this->startTime, 2);
// assertTrue
$this->mockClear(true, true, 1);
$this->mockClear(false, true, 1);
// assertEquals
$this->mockGet('1_value1', null, $this->startTime, 1);
$this->mockGet('1_value2', null, $this->startTime, 1);
$this->mockGet('2_value3', null, $this->startTime, 1);
$this->mockGet('3_value4', null, $this->startTime, 1);
parent::testClear($value1, $value2, $value3, $value4);
}
/**
* {@inheritdoc}
* @dataProvider dataTypesInCache
*/
public function testDifferentTypesInCache($data)
{
$this->mockSet('val', $data, Cache::FIVE_MINUTES, $this->startTime, true, 1);
$this->mockGet('val', $data, $this->startTime, 1);
parent::testDifferentTypesInCache($data);
}
/**
* {@inheritdoc}
* @dataProvider dataSimple
*/
public function testGetAllKeys($value1, $value2, $value3)
{
$this->mockSet('value1', $value1, Cache::FIVE_MINUTES, $this->startTime, true, 1);
$this->mockSet('value2', $value2,Cache::FIVE_MINUTES, $this->startTime, true, 1);
$this->mockSet('test_value3', $value3, Cache::FIVE_MINUTES, $this->startTime, true, 1);
$result = [
['k' => 'value1'],
['k' => 'value2'],
['k' => 'test_value3'],
];
$this->mockGetAllKeys(null, $result, $this->startTime, 1);
$result = [
['k' => 'test_value3'],
];
$this->mockGetAllKeys('test', $result, $this->startTime, 1);
parent::testGetAllKeys($value1, $value2, $value3);
}
}

14
tests/src/Core/Cache/MemcacheCacheDriverTest.php
View file

@ -1,9 +1,9 @@
<?php
namespace Friendica\Test\src\Core\Cache;
use Friendica\Factory\CacheDriverFactory;
use Friendica\Core\Cache\MemcacheCacheDriver;
use Friendica\Core\Config\Configuration;
/**
* @requires extension memcache
@ -12,19 +12,19 @@ class MemcacheCacheDriverTest extends MemoryCacheTest
{
protected function getInstance()
{
$this->configMock
$configMock = \Mockery::mock(Configuration::class);
$configMock
->shouldReceive('get')
->with('system', 'memcache_host')
->andReturn('localhost');
$this->configMock
$configMock
->shouldReceive('get')
->with('system', 'memcache_port')
->andReturn(11211);
$this->cache = CacheDriverFactory::create('memcache');
$this->cache = new MemcacheCacheDriver('localhost', $configMock);
return $this->cache;
}
public function tearDown()

12
tests/src/Core/Cache/MemcachedCacheDriverTest.php
View file

@ -3,7 +3,9 @@
namespace Friendica\Test\src\Core\Cache;
use Friendica\Factory\CacheDriverFactory;
use Friendica\Core\Cache\MemcachedCacheDriver;
use Friendica\Core\Config\Configuration;
use Psr\Log\NullLogger;
/**
* @requires extension memcached
@ -12,12 +14,16 @@ class MemcachedCacheDriverTest extends MemoryCacheTest
{
protected function getInstance()
{
$this->configMock
$configMock = \Mockery::mock(Configuration::class);
$configMock
->shouldReceive('get')
->with('system', 'memcached_hosts')
->andReturn([0 => 'localhost, 11211']);
$this->cache = CacheDriverFactory::create('memcached');
$logger = new NullLogger();
$this->cache = new MemcachedCacheDriver('localhost', $configMock, $logger);
return $this->cache;
}

24
tests/src/Core/Cache/MemoryCacheTest.php
View file

@ -3,8 +3,6 @@
namespace Friendica\Test\src\Core\Cache;
use Friendica\Core\Cache\IMemoryCacheDriver;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
abstract class MemoryCacheTest extends CacheTest
{
@ -17,11 +15,6 @@ abstract class MemoryCacheTest extends CacheTest
{
parent::setUp();
$logger = new NullLogger();
$this->dice->shouldReceive('create')
->with(LoggerInterface::class)
->andReturn($logger);
if (!($this->instance instanceof IMemoryCacheDriver)) {
throw new \Exception('MemoryCacheTest unsupported');
}
@ -31,7 +24,8 @@ abstract class MemoryCacheTest extends CacheTest
* @small
* @dataProvider dataSimple
*/
function testCompareSet($value1, $value2) {
function testCompareSet($value1, $value2)
{
$this->assertNull($this->instance->get('value1'));
$this->instance->add('value1', $value1);
@ -47,7 +41,8 @@ abstract class MemoryCacheTest extends CacheTest
* @small
* @dataProvider dataSimple
*/
function testNegativeCompareSet($value1, $value2) {
function testNegativeCompareSet($value1, $value2)
{
$this->assertNull($this->instance->get('value1'));
$this->instance->add('value1', $value1);
@ -64,7 +59,8 @@ abstract class MemoryCacheTest extends CacheTest
* @small
* @dataProvider dataSimple
*/
function testCompareDelete($data) {
function testCompareDelete($data)
{
$this->assertNull($this->instance->get('value1'));
$this->instance->add('value1', $data);
@ -78,7 +74,8 @@ abstract class MemoryCacheTest extends CacheTest
* @small
* @dataProvider dataSimple
*/
function testNegativeCompareDelete($data) {
function testNegativeCompareDelete($data)
{
$this->assertNull($this->instance->get('value1'));
$this->instance->add('value1', $data);
@ -95,7 +92,8 @@ abstract class MemoryCacheTest extends CacheTest
* @small
* @dataProvider dataSimple
*/
function testAdd($value1, $value2) {
function testAdd($value1, $value2)
{
$this->assertNull($this->instance->get('value1'));
$this->instance->add('value1', $value1);
@ -111,4 +109,4 @@ abstract class MemoryCacheTest extends CacheTest
$this->assertEquals($value2, $received, 'Value was not overwritten by add');
$this->assertNotEquals($value1, $received, 'Value was not overwritten by any other value');
}
}
}

19
tests/src/Core/Cache/RedisCacheDriverTest.php
View file

@ -3,7 +3,8 @@
namespace Friendica\Test\src\Core\Cache;
use Friendica\Factory\CacheDriverFactory;
use Friendica\Core\Cache\RedisCacheDriver;
use Friendica\Core\Config\Configuration;
/**
* @requires extension redis
@ -12,27 +13,27 @@ class RedisCacheDriverTest extends MemoryCacheTest
{
protected function getInstance()
{
$this->configMock
$configMock = \Mockery::mock(Configuration::class);
$configMock
->shouldReceive('get')
->with('system', 'redis_host')
->andReturn('localhost');
$this->configMock
$configMock
->shouldReceive('get')
->with('system', 'redis_port')
->andReturn(null);
$this->configMock
$configMock
->shouldReceive('get')
->with('system', 'redis_db')
->with('system', 'redis_db', 0)
->andReturn(3);
$this->configMock
$configMock
->shouldReceive('get')
->with('system', 'redis_password')
->andReturn(null);
$this->cache = CacheDriverFactory::create('redis');
$this->cache = new RedisCacheDriver('localhost', $configMock);
return $this->cache;
}

3
tests/src/Core/Lock/APCuCacheLockDriverTest.php
View file

@ -2,7 +2,6 @@
namespace Friendica\Test\src\Core\Lock;
use Friendica\Core\Cache\APCuCache;
use Friendica\Core\Lock\CacheLockDriver;
@ -19,6 +18,6 @@ class APCuCacheLockDriverTest extends LockTest
protected function getInstance()
{
return new CacheLockDriver(new APCuCache());
return new CacheLockDriver(new APCuCache('localhost'));
}
}

3
tests/src/Core/Lock/ArrayCacheLockDriverTest.php
View file

@ -2,7 +2,6 @@
namespace Friendica\Test\src\Core\Lock;
use Friendica\Core\Cache\ArrayCache;
use Friendica\Core\Lock\CacheLockDriver;
@ -10,7 +9,7 @@ class ArrayCacheLockDriverTest extends LockTest
{
protected function getInstance()
{
return new CacheLockDriver(new ArrayCache());
return new CacheLockDriver(new ArrayCache('localhost'));
}
public function testLockTTL()

113
tests/src/Core/Lock/DatabaseLockDriverTest.php
View file

@ -2,117 +2,42 @@
namespace Friendica\Test\src\Core\Lock;
use Friendica\Core\Cache;
use Friendica\Core\Lock\DatabaseLockDriver;
use Friendica\Test\Util\DbaLockMockTrait;
use Friendica\Factory\ConfigFactory;
use Friendica\Test\DatabaseTestTrait;
use Friendica\Test\Util\Database\StaticDatabase;
use Friendica\Test\Util\VFSTrait;
use Friendica\Util\ConfigFileLoader;
use Friendica\Util\Profiler;
use Psr\Log\NullLogger;
/**
* @runTestsInSeparateProcesses
* @preserveGlobalState disabled
*/
class DatabaseLockDriverTest extends LockTest
{
use DbaLockMockTrait;
use VFSTrait;
use DatabaseTestTrait;
protected $pid = 123;
protected function setUp()
{
$this->mockConnected();
$this->mockConnect();
$this->mockReleaseAll($this->pid, 2);
$this->setUpVfsDir();
parent::setUp();
}
protected function getInstance()
{
return new DatabaseLockDriver($this->pid);
}
$logger = new NullLogger();
$profiler = \Mockery::mock(Profiler::class);
$profiler->shouldReceive('saveTimestamp')->withAnyArgs()->andReturn(true);
public function testLock()
{
$this->mockIsLocked('foo', false, $this->startTime, 1);
$this->mockAcquireLock('foo', Cache::FIVE_MINUTES, false, $this->pid, false, $this->startTime, 1);
$this->mockIsLocked('foo', true, $this->startTime, 1);
$this->mockIsLocked('bar', false, $this->startTime, 1);
// load real config to avoid mocking every config-entry which is related to the Database class
$configFactory = new ConfigFactory();
$loader = new ConfigFileLoader($this->root->url());
$configCache = $configFactory->createCache($loader);
parent::testLock();
}
$dba = new StaticDatabase($configCache, $profiler, $logger);
public function testDoubleLock()
{
$this->mockIsLocked('foo', false, $this->startTime, 1);
$this->mockAcquireLock('foo', Cache::FIVE_MINUTES, false, $this->pid, false, $this->startTime, 1);
$this->mockIsLocked('foo', true, $this->startTime, 1);
$this->mockAcquireLock('foo', Cache::FIVE_MINUTES, true, $this->pid, true, $this->startTime, 1);
parent::testDoubleLock();
}
public function testReleaseLock()
{
$this->mockIsLocked('foo', false, $this->startTime, 1);
$this->mockAcquireLock('foo', Cache::FIVE_MINUTES, false, $this->pid, false, $this->startTime, 1);
$this->mockIsLocked('foo', true, $this->startTime, 1);
$this->mockReleaseLock('foo', $this->pid, 1);
$this->mockIsLocked('foo', false, $this->startTime, 1);
parent::testReleaseLock();
}
public function testReleaseAll()
{
$this->mockAcquireLock('foo', Cache::FIVE_MINUTES, false, $this->pid, false, $this->startTime, 1);
$this->mockAcquireLock('bar', Cache::FIVE_MINUTES, false, $this->pid, false, $this->startTime, 1);
$this->mockAcquireLock('nice', Cache::FIVE_MINUTES, false, $this->pid, false, $this->startTime, 1);
$this->mockIsLocked('foo', true, $this->startTime, 1);
$this->mockIsLocked('bar', true, $this->startTime, 1);
$this->mockIsLocked('nice', true, $this->startTime, 1);
$this->mockReleaseAll($this->pid, 1);
$this->mockIsLocked('foo', false, $this->startTime, 1);
$this->mockIsLocked('bar', false, $this->startTime, 1);
$this->mockIsLocked('nice', false, $this->startTime, 1);
parent::testReleaseAll();
}
public function testReleaseAfterUnlock()
{
$this->mockIsLocked('foo', false, $this->startTime, 1);
$this->mockIsLocked('bar', false, $this->startTime, 1);
$this->mockIsLocked('nice', false, $this->startTime, 1);
$this->mockAcquireLock('foo', Cache::FIVE_MINUTES, false, $this->pid, false, $this->startTime, 1);
$this->mockAcquireLock('bar', Cache::FIVE_MINUTES, false, $this->pid, false, $this->startTime, 1);
$this->mockAcquireLock('nice', Cache::FIVE_MINUTES, false, $this->pid, false, $this->startTime, 1);
$this->mockReleaseLock('foo', $this->pid, 1);
$this->mockIsLocked('foo', false, $this->startTime, 1);
$this->mockIsLocked('bar', true, $this->startTime, 1);
$this->mockIsLocked('nice', true, $this->startTime, 1);
$this->mockReleaseAll($this->pid, 1);
$this->mockIsLocked('bar', false, $this->startTime, 1);
$this->mockIsLocked('nice', false, $this->startTime, 1);
parent::testReleaseAfterUnlock();
}
public function testReleaseWitTTL()
{
$this->mockIsLocked('test', false, $this->startTime, 1);
$this->mockAcquireLock('test', 10, false, $this->pid, false, $this->startTime, 1);
$this->mockIsLocked('test', true, $this->startTime, 1);
$this->mockReleaseLock('test', $this->pid, 1);
$this->mockIsLocked('test', false, $this->startTime, 1);
parent::testReleaseWitTTL();
return new DatabaseLockDriver($dba, $this->pid);
}
}

38
tests/src/Core/Lock/LockTest.php
View file

@ -3,16 +3,9 @@
namespace Friendica\Test\src\Core\Lock;
use Friendica\Test\MockedTest;
use Friendica\Test\Util\AppMockTrait;
use Friendica\Test\Util\VFSTrait;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
abstract class LockTest extends MockedTest
{
use VFSTrait;
use AppMockTrait;
/**
* @var int Start time of the mock (used for time operations)
*/
@ -27,19 +20,8 @@ abstract class LockTest extends MockedTest
protected function setUp()
{
// Reusable App object
$this->setUpVfsDir();
$this->mockApp($this->root);
$this->app
->shouldReceive('getHostname')
->andReturn('friendica.local');
$logger = new NullLogger();
$this->dice->shouldReceive('create')
->with(LoggerInterface::class)
->andReturn($logger);
parent::setUp();
$this->instance = $this->getInstance();
$this->instance->releaseAll();
}
@ -53,7 +35,8 @@ abstract class LockTest extends MockedTest
/**
* @small
*/
public function testLock() {
public function testLock()
{
$this->assertFalse($this->instance->isLocked('foo'));
$this->assertTrue($this->instance->acquireLock('foo', 1));
$this->assertTrue($this->instance->isLocked('foo'));
@ -63,7 +46,8 @@ abstract class LockTest extends MockedTest
/**
* @small
*/
public function testDoubleLock() {
public function testDoubleLock()
{
$this->assertFalse($this->instance->isLocked('foo'));
$this->assertTrue($this->instance->acquireLock('foo', 1));
$this->assertTrue($this->instance->isLocked('foo'));
@ -74,7 +58,8 @@ abstract class LockTest extends MockedTest
/**
* @small
*/
public function testReleaseLock() {
public function testReleaseLock()
{
$this->assertFalse($this->instance->isLocked('foo'));
$this->assertTrue($this->instance->acquireLock('foo', 1));
$this->assertTrue($this->instance->isLocked('foo'));
@ -85,7 +70,8 @@ abstract class LockTest extends MockedTest
/**
* @small
*/
public function testReleaseAll() {
public function testReleaseAll()
{
$this->assertTrue($this->instance->acquireLock('foo', 1));
$this->assertTrue($this->instance->acquireLock('bar', 1));
$this->assertTrue($this->instance->acquireLock('nice', 1));
@ -104,7 +90,8 @@ abstract class LockTest extends MockedTest
/**
* @small
*/
public function testReleaseAfterUnlock() {
public function testReleaseAfterUnlock()
{
$this->assertFalse($this->instance->isLocked('foo'));
$this->assertFalse($this->instance->isLocked('bar'));
$this->assertFalse($this->instance->isLocked('nice'));
@ -139,7 +126,8 @@ abstract class LockTest extends MockedTest
/**
* @medium
*/
function testLockTTL() {
function testLockTTL()
{
$this->markTestSkipped('taking too much time without mocking');
$this->assertFalse($this->instance->isLocked('foo'));

12
tests/src/Core/Lock/MemcacheCacheLockDriverTest.php
View file

@ -3,7 +3,8 @@
namespace Friendica\Test\src\Core\Lock;
use Friendica\Factory\CacheDriverFactory;
use Friendica\Core\Cache\MemcacheCacheDriver;
use Friendica\Core\Config\Configuration;
use Friendica\Core\Lock\CacheLockDriver;
/**
@ -13,16 +14,17 @@ class MemcacheCacheLockDriverTest extends LockTest
{
protected function getInstance()
{
$this->configMock
$configMock = \Mockery::mock(Configuration::class);
$configMock
->shouldReceive('get')
->with('system', 'memcache_host')
->andReturn('localhost');
$this->configMock
$configMock
->shouldReceive('get')
->with('system', 'memcache_port')
->andReturn(11211);
return new CacheLockDriver(CacheDriverFactory::create('memcache'));
return new CacheLockDriver(new MemcacheCacheDriver('localhost', $configMock));
}
}

12
tests/src/Core/Lock/MemcachedCacheLockDriverTest.php
View file

@ -3,8 +3,10 @@
namespace Friendica\Test\src\Core\Lock;
use Friendica\Factory\CacheDriverFactory;
use Friendica\Core\Cache\MemcachedCacheDriver;
use Friendica\Core\Config\Configuration;
use Friendica\Core\Lock\CacheLockDriver;
use Psr\Log\NullLogger;
/**
* @requires extension memcached
@ -13,11 +15,15 @@ class MemcachedCacheLockDriverTest extends LockTest
{
protected function getInstance()
{
$this->configMock
$configMock = \Mockery::mock(Configuration::class);
$configMock
->shouldReceive('get')
->with('system', 'memcached_hosts')
->andReturn([0 => 'localhost, 11211']);
return new CacheLockDriver(CacheDriverFactory::create('memcached'));
$logger = new NullLogger();
return new CacheLockDriver(new MemcachedCacheDriver('localhost', $configMock, $logger));
}
}

19
tests/src/Core/Lock/RedisCacheLockDriverTest.php
View file

@ -3,8 +3,9 @@
namespace Friendica\Test\src\Core\Lock;
use Friendica\Core\Cache\RedisCacheDriver;
use Friendica\Core\Config\Configuration;
use Friendica\Core\Lock\CacheLockDriver;
use Friendica\Factory\CacheDriverFactory;
/**
* @requires extension redis
@ -13,26 +14,26 @@ class RedisCacheLockDriverTest extends LockTest
{
protected function getInstance()
{
$this->configMock
$configMock = \Mockery::mock(Configuration::class);
$configMock
->shouldReceive('get')
->with('system', 'redis_host')
->andReturn('localhost');
$this->configMock
$configMock
->shouldReceive('get')
->with('system', 'redis_port')
->andReturn(null);
$this->configMock
$configMock
->shouldReceive('get')
->with('system', 'redis_db')
->with('system', 'redis_db', 0)
->andReturn(3);
$this->configMock
$configMock
->shouldReceive('get')
->with('system', 'redis_password')
->andReturn(null);
return new CacheLockDriver(CacheDriverFactory::create('redis'));
return new CacheLockDriver(new RedisCacheDriver('localhost', $configMock));
}
}

19
tests/src/Core/Lock/SemaphoreLockDriverTest.php
View file

@ -2,6 +2,10 @@
namespace Friendica\Test\src\Core\Lock;
use Dice\Dice;
use Friendica\App;
use Friendica\BaseObject;
use Friendica\Core\Config\Configuration;
use Friendica\Core\Lock\SemaphoreLockDriver;
class SemaphoreLockDriverTest extends LockTest
@ -10,12 +14,21 @@ class SemaphoreLockDriverTest extends LockTest
{
parent::setUp();
$this->app->shouldReceive('getHostname')->andReturn('friendica.local');
$dice = \Mockery::mock(Dice::class)->makePartial();
$this->configMock
$app = \Mockery::mock(App::class);
$app->shouldReceive('getHostname')->andReturn('friendica.local');
$dice->shouldReceive('create')->with(App::class)->andReturn($app);
$configMock = \Mockery::mock(Configuration::class);
$configMock
->shouldReceive('get')
->with('system', 'temppath')
->with('system', 'temppath', NULL, false)
->andReturn('/tmp/');
$dice->shouldReceive('create')->with(Configuration::class)->andReturn($configMock);
// @todo Because "get_temppath()" is using static methods, we have to initialize the BaseObject
BaseObject::setDependencyInjection($dice);
}
protected function getInstance()