mirror of
https://github.com/friendica/friendica
synced 2025-05-15 11:04:11 +02:00
Fix tests & Router is now using Dependency Injection instead of DI Registry
This commit is contained in:
nupplaPhil
parent
d5a473abda
commit
f9d0e57f91
12 changed files with 54 additions and 29 deletions
|
|
@ -1,275 +0,0 @@
|
|||
<?php
|
||||
|
||||
namespace Friendica\Test\src\Core\Config\Cache;
|
||||
|
||||
use Friendica\Core\PConfig\Cache;
|
||||
use Friendica\Test\MockedTest;
|
||||
|
||||
class PConfigCacheTest extends MockedTest
|
||||
{
|
||||
public function dataTests()
|
||||
{
|
||||
return [
|
||||
'normal' => [
|
||||
'data' => [
|
||||
'system' => [
|
||||
'test' => 'it',
|
||||
'boolTrue' => true,
|
||||
'boolFalse' => false,
|
||||
'int' => 235,
|
||||
'dec' => 2.456,
|
||||
'array' => ['1', 2, '3', true, false],
|
||||
],
|
||||
'config' => [
|
||||
'a' => 'value',
|
||||
],
|
||||
]
|
||||
]
|
||||
];
|
||||
}
|
||||
|
||||
private function assertConfigValues($data, Cache $configCache, $uid)
|
||||
{
|
||||
foreach ($data as $cat => $values) {
|
||||
foreach ($values as $key => $value) {
|
||||
$this->assertEquals($data[$cat][$key], $configCache->get($uid, $cat, $key));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Test the setP() and getP() methods
|
||||
*
|
||||
* @dataProvider dataTests
|
||||
*/
|
||||
public function testSetGet($data)
|
||||
{
|
||||
$configCache = new Cache();
|
||||
$uid = 345;
|
||||
|
||||
foreach ($data as $cat => $values) {
|
||||
foreach ($values as $key => $value) {
|
||||
$configCache->set($uid, $cat, $key, $value);
|
||||
}
|
||||
}
|
||||
|
||||
$this->assertConfigValues($data, $configCache, $uid);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Test the getP() method with a category
|
||||
*/
|
||||
public function testGetCat()
|
||||
{
|
||||
$configCache = new Cache();
|
||||
$uid = 345;
|
||||
|
||||
$configCache->load($uid, [
|
||||
'system' => [
|
||||
'key1' => 'value1',
|
||||
'key2' => 'value2',
|
||||
],
|
||||
'config' => [
|
||||
'key3' => 'value3',
|
||||
],
|
||||
]);
|
||||
|
||||
$this->assertEquals([
|
||||
'key1' => 'value1',
|
||||
'key2' => 'value2',
|
||||
], $configCache->get($uid, 'system'));
|
||||
|
||||
// test explicit cat with null as key
|
||||
$this->assertEquals([
|
||||
'key1' => 'value1',
|
||||
'key2' => 'value2',
|
||||
], $configCache->get($uid, 'system', null));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test the deleteP() method
|
||||
*
|
||||
* @dataProvider dataTests
|
||||
*/
|
||||
public function testDelete($data)
|
||||
{
|
||||
$configCache = new Cache();
|
||||
$uid = 345;
|
||||
|
||||
foreach ($data as $cat => $values) {
|
||||
foreach ($values as $key => $value) {
|
||||
$configCache->set($uid, $cat, $key, $value);
|
||||
}
|
||||
}
|
||||
|
||||
foreach ($data as $cat => $values) {
|
||||
foreach ($values as $key => $value) {
|
||||
$configCache->delete($uid, $cat, $key);
|
||||
}
|
||||
}
|
||||
|
||||
$this->assertEmpty($configCache->getAll());
|
||||
}
|
||||
|
||||
/**
|
||||
* Test the keyDiff() method with result
|
||||
*
|
||||
* @dataProvider dataTests
|
||||
*/
|
||||
public function testKeyDiffWithResult($data)
|
||||
{
|
||||
$configCache = new Cache();
|
||||
|
||||
$diffConfig = [
|
||||
'fakeCat' => [
|
||||
'fakeKey' => 'value',
|
||||
]
|
||||
];
|
||||
|
||||
$this->assertEquals($diffConfig, $configCache->keyDiff($diffConfig));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test the keyDiff() method without result
|
||||
*
|
||||
* @dataProvider dataTests
|
||||
*/
|
||||
public function testKeyDiffWithoutResult($data)
|
||||
{
|
||||
$configCache = new Cache();
|
||||
|
||||
$configCache->load(1, $data);
|
||||
|
||||
$diffConfig = $configCache->getAll();
|
||||
|
||||
$this->assertEmpty($configCache->keyDiff($diffConfig));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test the default hiding of passwords inside the cache
|
||||
*/
|
||||
public function testPasswordHide()
|
||||
{
|
||||
$configCache = new Cache();
|
||||
|
||||
$configCache->load(1, [
|
||||
'database' => [
|
||||
'password' => 'supersecure',
|
||||
'username' => 'notsecured',
|
||||
]
|
||||
]);
|
||||
|
||||
$this->assertEquals('supersecure', $configCache->get(1, 'database', 'password'));
|
||||
$this->assertNotEquals('supersecure', print_r($configCache->get(1, 'database', 'password'), true));
|
||||
$this->assertEquals('notsecured', print_r($configCache->get(1, 'database', 'username'), true));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test disabling the hiding of passwords inside the cache
|
||||
*/
|
||||
public function testPasswordShow()
|
||||
{
|
||||
$configCache = new Cache(false);
|
||||
|
||||
$configCache->load(1, [
|
||||
'database' => [
|
||||
'password' => 'supersecure',
|
||||
'username' => 'notsecured',
|
||||
]
|
||||
]);
|
||||
|
||||
$this->assertEquals('supersecure', $configCache->get(1, 'database', 'password'));
|
||||
$this->assertEquals('supersecure', print_r($configCache->get(1, 'database', 'password'), true));
|
||||
$this->assertEquals('notsecured', print_r($configCache->get(1, 'database', 'username'), true));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test a empty password
|
||||
*/
|
||||
public function testEmptyPassword()
|
||||
{
|
||||
$configCache = new Cache();
|
||||
|
||||
$configCache->load(1, [
|
||||
'database' => [
|
||||
'password' => '',
|
||||
'username' => '',
|
||||
]
|
||||
]);
|
||||
|
||||
$this->assertEmpty($configCache->get(1, 'database', 'password'));
|
||||
$this->assertEmpty($configCache->get(1, 'database', 'username'));
|
||||
}
|
||||
|
||||
public function testWrongTypePassword()
|
||||
{
|
||||
$configCache = new Cache();
|
||||
|
||||
$configCache->load(1, [
|
||||
'database' => [
|
||||
'password' => new \stdClass(),
|
||||
'username' => '',
|
||||
]
|
||||
]);
|
||||
|
||||
$this->assertNotEmpty($configCache->get(1, 'database', 'password'));
|
||||
$this->assertEmpty($configCache->get(1, 'database', 'username'));
|
||||
|
||||
$configCache = new Cache();
|
||||
|
||||
$configCache->load(1, [
|
||||
'database' => [
|
||||
'password' => 23,
|
||||
'username' => '',
|
||||
],
|
||||
]);
|
||||
|
||||
$this->assertEquals(23, $configCache->get(1, 'database', 'password'));
|
||||
$this->assertEmpty($configCache->get(1, 'database', 'username'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test two different UID configs and make sure that there is no overlapping possible
|
||||
*/
|
||||
public function testTwoUid()
|
||||
{
|
||||
$configCache = new Cache();
|
||||
|
||||
$configCache->load(1, [
|
||||
'cat1' => [
|
||||
'key1' => 'value1',
|
||||
],
|
||||
]);
|
||||
|
||||
|
||||
$configCache->load(2, [
|
||||
'cat2' => [
|
||||
'key2' => 'value2',
|
||||
],
|
||||
]);
|
||||
|
||||
$this->assertEquals('value1', $configCache->get(1, 'cat1', 'key1'));
|
||||
$this->assertEquals('value2', $configCache->get(2, 'cat2', 'key2'));
|
||||
|
||||
$this->assertNull($configCache->get(1, 'cat2', 'key2'));
|
||||
$this->assertNull($configCache->get(2, 'cat1', 'key1'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test when using an invalid UID
|
||||
* @todo check it the clean way before using the config class
|
||||
*/
|
||||
public function testInvalidUid()
|
||||
{
|
||||
// bad UID!
|
||||
$uid = null;
|
||||
|
||||
$configCache = new Cache();
|
||||
|
||||
$this->assertNull($configCache->get($uid, 'cat1', 'cat2'));
|
||||
|
||||
$this->assertFalse($configCache->set($uid, 'cat1', 'key1', 'doesn\'t matter!'));
|
||||
$this->assertFalse($configCache->delete($uid, 'cat1', 'key1'));
|
||||
}
|
||||
}
|
||||
|
|
@ -1,12 +1,12 @@
|
|||
<?php
|
||||
|
||||
namespace Friendica\Test\src\Core\Config\Cache;
|
||||
namespace Friendica\Test\src\Core\Config;
|
||||
|
||||
use Friendica\Core\Config\Cache;
|
||||
use Friendica\Test\MockedTest;
|
||||
use ParagonIE\HiddenString\HiddenString;
|
||||
|
||||
class ConfigCacheTest extends MockedTest
|
||||
class CacheTest extends MockedTest
|
||||
{
|
||||
public function dataTests()
|
||||
{
|
||||
|
|
@ -9,7 +9,7 @@ use Friendica\Test\MockedTest;
|
|||
use Mockery\MockInterface;
|
||||
use Mockery;
|
||||
|
||||
abstract class ConfigurationTest extends MockedTest
|
||||
abstract class ConfigTest extends MockedTest
|
||||
{
|
||||
/** @var ConfigModel|MockInterface */
|
||||
protected $configModel;
|
||||
|
|
@ -4,7 +4,7 @@ namespace Friendica\Test\src\Core\Config;
|
|||
|
||||
use Friendica\Core\Config\JitConfig;
|
||||
|
||||
class JitConfigurationTest extends ConfigurationTest
|
||||
class JitConfigTest extends ConfigTest
|
||||
{
|
||||
public function getInstance()
|
||||
{
|
||||
|
|
@ -1,145 +0,0 @@
|
|||
<?php
|
||||
|
||||
namespace Friendica\Test\src\Core\Config;
|
||||
|
||||
use Friendica\Core\PConfig\JitPConfig;
|
||||
|
||||
class JitPConfigurationTest extends PConfigurationTest
|
||||
{
|
||||
public function getInstance()
|
||||
{
|
||||
return new JitPConfig($this->configCache, $this->configModel);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider dataConfigLoad
|
||||
*/
|
||||
public function testLoad(int $uid, array $data, array $possibleCats, array $load)
|
||||
{
|
||||
$this->configModel->shouldReceive('isConnected')
|
||||
->andReturn(true)
|
||||
->times(count($load));
|
||||
|
||||
foreach ($load as $loadCat) {
|
||||
$this->configModel->shouldReceive('load')
|
||||
->with($uid, $loadCat)
|
||||
->andReturn([$loadCat => $data[$loadCat]])
|
||||
->once();
|
||||
}
|
||||
|
||||
parent::testLoad($uid, $data, $possibleCats, $load);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider dataDoubleLoad
|
||||
*/
|
||||
public function testCacheLoadDouble(int $uid, array $data1, array $data2, array $expect)
|
||||
{
|
||||
$this->configModel->shouldReceive('isConnected')
|
||||
->andReturn(true)
|
||||
->times(count($data1) + count($data2));
|
||||
|
||||
foreach ($data1 as $cat => $data) {
|
||||
$this->configModel->shouldReceive('load')
|
||||
->with($uid, $cat)
|
||||
->andReturn([$cat => $data])
|
||||
->once();
|
||||
}
|
||||
|
||||
|
||||
foreach ($data2 as $cat => $data) {
|
||||
$this->configModel->shouldReceive('load')
|
||||
->with($uid, $cat)
|
||||
->andReturn([$cat => $data])
|
||||
->once();
|
||||
}
|
||||
|
||||
parent::testCacheLoadDouble($uid, $data1, $data2, $expect);
|
||||
|
||||
// Assert the expected categories
|
||||
foreach ($data2 as $cat => $data) {
|
||||
$this->assertConfig($uid, $cat, $expect[$cat]);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider dataTests
|
||||
*/
|
||||
public function testSetGetWithoutDB(int $uid, $data)
|
||||
{
|
||||
$this->configModel->shouldReceive('isConnected')
|
||||
->andReturn(false)
|
||||
->times(2);
|
||||
|
||||
parent::testSetGetWithoutDB($uid, $data);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider dataTests
|
||||
*/
|
||||
public function testSetGetWithDB(int $uid, $data)
|
||||
{
|
||||
$this->configModel->shouldReceive('isConnected')
|
||||
->andReturn(true)
|
||||
->times(2);
|
||||
|
||||
parent::testSetGetWithDB($uid, $data);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider dataTests
|
||||
*/
|
||||
public function testGetWithRefresh(int $uid, $data)
|
||||
{
|
||||
$this->configModel->shouldReceive('isConnected')
|
||||
->andReturn(true)
|
||||
->times(3);
|
||||
|
||||
// mocking one get without result
|
||||
$this->configModel->shouldReceive('get')
|
||||
->with($uid, 'test', 'it')
|
||||
->andReturn(null)
|
||||
->once();
|
||||
|
||||
// mocking the data get
|
||||
$this->configModel->shouldReceive('get')
|
||||
->with($uid, 'test', 'it')
|
||||
->andReturn($data)
|
||||
->once();
|
||||
|
||||
// mocking second get
|
||||
$this->configModel->shouldReceive('get')
|
||||
->with($uid, 'test', 'not')
|
||||
->andReturn(null)
|
||||
->once();
|
||||
|
||||
parent::testGetWithRefresh($uid, $data);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider dataTests
|
||||
*/
|
||||
public function testDeleteWithoutDB(int $uid, $data)
|
||||
{
|
||||
$this->configModel->shouldReceive('isConnected')
|
||||
->andReturn(false)
|
||||
->times(3);
|
||||
|
||||
parent::testDeleteWithoutDB($uid, $data);
|
||||
}
|
||||
|
||||
public function testDeleteWithDB()
|
||||
{
|
||||
$this->configModel->shouldReceive('isConnected')
|
||||
->andReturn(true)
|
||||
->times(5);
|
||||
|
||||
// mocking one get without result
|
||||
$this->configModel->shouldReceive('get')
|
||||
->with(42, 'test', 'it')
|
||||
->andReturn(null)
|
||||
->once();
|
||||
|
||||
parent::testDeleteWithDB();
|
||||
}
|
||||
}
|
||||
|
|
@ -1,475 +0,0 @@
|
|||
<?php
|
||||
|
||||
namespace Friendica\Test\src\Core\Config;
|
||||
|
||||
use Friendica\Core\PConfig\Cache;
|
||||
use Friendica\Core\BasePConfig;
|
||||
use Friendica\Model\Config\PConfig as PConfigModel;
|
||||
use Friendica\Test\MockedTest;
|
||||
use Mockery;
|
||||
use Mockery\MockInterface;
|
||||
|
||||
abstract class PConfigurationTest extends MockedTest
|
||||
{
|
||||
/** @var PConfigModel|MockInterface */
|
||||
protected $configModel;
|
||||
|
||||
/** @var Cache */
|
||||
protected $configCache;
|
||||
|
||||
/** @var BasePConfig */
|
||||
protected $testedConfig;
|
||||
|
||||
/**
|
||||
* Assert a config tree
|
||||
*
|
||||
* @param int $uid The uid to assert
|
||||
* @param string $cat The category to assert
|
||||
* @param array $data The result data array
|
||||
*/
|
||||
protected function assertConfig(int $uid, string $cat, array $data)
|
||||
{
|
||||
$result = $this->testedConfig->getCache()->getAll();
|
||||
|
||||
$this->assertNotEmpty($result);
|
||||
$this->assertArrayHasKey($uid, $result);
|
||||
$this->assertArrayHasKey($cat, $result[$uid]);
|
||||
$this->assertArraySubset($data, $result[$uid][$cat]);
|
||||
}
|
||||
|
||||
|
||||
protected function setUp()
|
||||
{
|
||||
parent::setUp();
|
||||
|
||||
// Create the config model
|
||||
$this->configModel = Mockery::mock(PConfigModel::class);
|
||||
$this->configCache = new Cache();
|
||||
}
|
||||
|
||||
/**
|
||||
* @return BasePConfig
|
||||
*/
|
||||
public abstract function getInstance();
|
||||
|
||||
public function dataTests()
|
||||
{
|
||||
return [
|
||||
'string' => ['uid' => 1, 'data' => 'it'],
|
||||
'boolTrue' => ['uid' => 2, 'data' => true],
|
||||
'boolFalse' => ['uid' => 3, 'data' => false],
|
||||
'integer' => ['uid' => 4, 'data' => 235],
|
||||
'decimal' => ['uid' => 5, 'data' => 2.456],
|
||||
'array' => ['uid' => 6, 'data' => ['1', 2, '3', true, false]],
|
||||
'boolIntTrue' => ['uid' => 7, 'data' => 1],
|
||||
'boolIntFalse' => ['uid' => 8, 'data' => 0],
|
||||
];
|
||||
}
|
||||
|
||||
public function dataConfigLoad()
|
||||
{
|
||||
$data = [
|
||||
'system' => [
|
||||
'key1' => 'value1',
|
||||
'key2' => 'value2',
|
||||
'key3' => 'value3',
|
||||
],
|
||||
'config' => [
|
||||
'key1' => 'value1a',
|
||||
'key4' => 'value4',
|
||||
],
|
||||
'other' => [
|
||||
'key5' => 'value5',
|
||||
'key6' => 'value6',
|
||||
],
|
||||
];
|
||||
|
||||
return [
|
||||
'system' => [
|
||||
'uid' => 1,
|
||||
'data' => $data,
|
||||
'possibleCats' => [
|
||||
'system',
|
||||
'config',
|
||||
'other'
|
||||
],
|
||||
'load' => [
|
||||
'system',
|
||||
],
|
||||
],
|
||||
'other' => [
|
||||
'uid' => 2,
|
||||
'data' => $data,
|
||||
'possibleCats' => [
|
||||
'system',
|
||||
'config',
|
||||
'other'
|
||||
],
|
||||
'load' => [
|
||||
'other',
|
||||
],
|
||||
],
|
||||
'config' => [
|
||||
'uid' => 3,
|
||||
'data' => $data,
|
||||
'possibleCats' => [
|
||||
'system',
|
||||
'config',
|
||||
'other'
|
||||
],
|
||||
'load' => [
|
||||
'config',
|
||||
],
|
||||
],
|
||||
'all' => [
|
||||
'uid' => 4,
|
||||
'data' => $data,
|
||||
'possibleCats' => [
|
||||
'system',
|
||||
'config',
|
||||
'other'
|
||||
],
|
||||
'load' => [
|
||||
'system',
|
||||
'config',
|
||||
'other'
|
||||
],
|
||||
],
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Test the configuration initialization
|
||||
* @dataProvider dataConfigLoad
|
||||
*/
|
||||
public function testSetUp(int $uid, array $data)
|
||||
{
|
||||
$this->testedConfig = $this->getInstance();
|
||||
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
|
||||
|
||||
$this->assertEmpty($this->testedConfig->getCache()->getAll());
|
||||
}
|
||||
|
||||
/**
|
||||
* Test the configuration load() method
|
||||
*/
|
||||
public function testLoad(int $uid, array $data, array $possibleCats, array $load)
|
||||
{
|
||||
$this->testedConfig = $this->getInstance();
|
||||
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
|
||||
|
||||
foreach ($load as $loadedCats) {
|
||||
$this->testedConfig->load($uid, $loadedCats);
|
||||
}
|
||||
|
||||
// Assert at least loaded cats are loaded
|
||||
foreach ($load as $loadedCats) {
|
||||
$this->assertConfig($uid, $loadedCats, $data[$loadedCats]);
|
||||
}
|
||||
}
|
||||
|
||||
public function dataDoubleLoad()
|
||||
{
|
||||
return [
|
||||
'config' => [
|
||||
'uid' => 1,
|
||||
'data1' => [
|
||||
'config' => [
|
||||
'key1' => 'value1',
|
||||
'key2' => 'value2',
|
||||
],
|
||||
],
|
||||
'data2' => [
|
||||
'config' => [
|
||||
'key1' => 'overwritten!',
|
||||
'key3' => 'value3',
|
||||
],
|
||||
],
|
||||
'expect' => [
|
||||
'config' => [
|
||||
// load should overwrite values everytime!
|
||||
'key1' => 'overwritten!',
|
||||
'key2' => 'value2',
|
||||
'key3' => 'value3',
|
||||
],
|
||||
],
|
||||
],
|
||||
'other' => [
|
||||
'uid' => 1,
|
||||
'data1' => [
|
||||
'config' => [
|
||||
'key12' => 'data4',
|
||||
'key45' => 7,
|
||||
],
|
||||
'other' => [
|
||||
'key1' => 'value1',
|
||||
'key2' => 'value2',
|
||||
],
|
||||
],
|
||||
'data2' => [
|
||||
'other' => [
|
||||
'key1' => 'overwritten!',
|
||||
'key3' => 'value3',
|
||||
],
|
||||
'config' => [
|
||||
'key45' => 45,
|
||||
'key52' => true,
|
||||
]
|
||||
],
|
||||
'expect' => [
|
||||
'other' => [
|
||||
// load should overwrite values everytime!
|
||||
'key1' => 'overwritten!',
|
||||
'key2' => 'value2',
|
||||
'key3' => 'value3',
|
||||
],
|
||||
'config' => [
|
||||
'key12' => 'data4',
|
||||
'key45' => 45,
|
||||
'key52' => true,
|
||||
],
|
||||
],
|
||||
],
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Test the configuration load() method with overwrite
|
||||
*/
|
||||
public function testCacheLoadDouble(int $uid, array $data1, array $data2, array $expect)
|
||||
{
|
||||
$this->testedConfig = $this->getInstance();
|
||||
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
|
||||
|
||||
foreach ($data1 as $cat => $data) {
|
||||
$this->testedConfig->load($uid, $cat);
|
||||
}
|
||||
|
||||
// Assert at least loaded cats are loaded
|
||||
foreach ($data1 as $cat => $data) {
|
||||
$this->assertConfig($uid, $cat, $data);
|
||||
}
|
||||
|
||||
foreach ($data2 as $cat => $data) {
|
||||
$this->testedConfig->load($uid, $cat);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Test the configuration get() and set() methods without adapter
|
||||
*
|
||||
* @dataProvider dataTests
|
||||
*/
|
||||
public function testSetGetWithoutDB(int $uid, $data)
|
||||
{
|
||||
$this->testedConfig = $this->getInstance();
|
||||
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
|
||||
|
||||
$this->assertTrue($this->testedConfig->set($uid, 'test', 'it', $data));
|
||||
|
||||
$this->assertEquals($data, $this->testedConfig->get($uid, 'test', 'it'));
|
||||
$this->assertEquals($data, $this->testedConfig->getCache()->get($uid, 'test', 'it'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test the configuration get() and set() methods with a model/db
|
||||
*
|
||||
* @dataProvider dataTests
|
||||
*/
|
||||
public function testSetGetWithDB(int $uid, $data)
|
||||
{
|
||||
$this->configModel->shouldReceive('set')
|
||||
->with($uid, 'test', 'it', $data)
|
||||
->andReturn(true)
|
||||
->once();
|
||||
|
||||
$this->testedConfig = $this->getInstance();
|
||||
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
|
||||
|
||||
$this->assertTrue($this->testedConfig->set($uid, 'test', 'it', $data));
|
||||
|
||||
$this->assertEquals($data, $this->testedConfig->get($uid, 'test', 'it'));
|
||||
$this->assertEquals($data, $this->testedConfig->getCache()->get($uid, 'test', 'it'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test the configuration get() method with wrong value and no db
|
||||
*/
|
||||
public function testGetWrongWithoutDB()
|
||||
{
|
||||
$this->testedConfig = $this->getInstance();
|
||||
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
|
||||
|
||||
// without refresh
|
||||
$this->assertNull($this->testedConfig->get(0, 'test', 'it'));
|
||||
|
||||
/// beware that the cache returns '!<unset>!' and not null for a non existing value
|
||||
$this->assertNull($this->testedConfig->getCache()->get(0, 'test', 'it'));
|
||||
|
||||
// with default value
|
||||
$this->assertEquals('default', $this->testedConfig->get(0, 'test', 'it', 'default'));
|
||||
|
||||
// with default value and refresh
|
||||
$this->assertEquals('default', $this->testedConfig->get(0, 'test', 'it', 'default', true));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test the configuration get() method with refresh
|
||||
*
|
||||
* @dataProvider dataTests
|
||||
*/
|
||||
public function testGetWithRefresh(int $uid, $data)
|
||||
{
|
||||
$this->configCache->load($uid, ['test' => ['it' => 'now']]);
|
||||
|
||||
$this->testedConfig = $this->getInstance();
|
||||
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
|
||||
|
||||
// without refresh
|
||||
$this->assertEquals('now', $this->testedConfig->get($uid, 'test', 'it'));
|
||||
$this->assertEquals('now', $this->testedConfig->getCache()->get($uid, 'test', 'it'));
|
||||
|
||||
// with refresh
|
||||
$this->assertEquals($data, $this->testedConfig->get($uid, 'test', 'it', null, true));
|
||||
$this->assertEquals($data, $this->testedConfig->getCache()->get($uid, 'test', 'it'));
|
||||
|
||||
// without refresh and wrong value and default
|
||||
$this->assertEquals('default', $this->testedConfig->get($uid, 'test', 'not', 'default'));
|
||||
$this->assertNull($this->testedConfig->getCache()->get($uid, 'test', 'not'));
|
||||
}
|
||||
|
||||
/**
|
||||
* Test the configuration delete() method without a model/db
|
||||
*
|
||||
* @dataProvider dataTests
|
||||
*/
|
||||
public function testDeleteWithoutDB(int $uid, $data)
|
||||
{
|
||||
$this->configCache->load($uid, ['test' => ['it' => $data]]);
|
||||
|
||||
$this->testedConfig = $this->getInstance();
|
||||
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
|
||||
|
||||
$this->assertEquals($data, $this->testedConfig->get($uid, 'test', 'it'));
|
||||
$this->assertEquals($data, $this->testedConfig->getCache()->get($uid, 'test', 'it'));
|
||||
|
||||
$this->assertTrue($this->testedConfig->delete($uid, 'test', 'it'));
|
||||
$this->assertNull($this->testedConfig->get($uid, 'test', 'it'));
|
||||
$this->assertNull($this->testedConfig->getCache()->get($uid, 'test', 'it'));
|
||||
|
||||
$this->assertEmpty($this->testedConfig->getCache()->getAll());
|
||||
}
|
||||
|
||||
/**
|
||||
* Test the configuration delete() method with a model/db
|
||||
*/
|
||||
public function testDeleteWithDB()
|
||||
{
|
||||
$uid = 42;
|
||||
|
||||
$this->configCache->load($uid, ['test' => ['it' => 'now', 'quarter' => 'true']]);
|
||||
|
||||
$this->configModel->shouldReceive('delete')
|
||||
->with($uid, 'test', 'it')
|
||||
->andReturn(false)
|
||||
->once();
|
||||
$this->configModel->shouldReceive('delete')
|
||||
->with($uid, 'test', 'second')
|
||||
->andReturn(true)
|
||||
->once();
|
||||
$this->configModel->shouldReceive('delete')
|
||||
->with($uid, 'test', 'third')
|
||||
->andReturn(false)
|
||||
->once();
|
||||
$this->configModel->shouldReceive('delete')
|
||||
->with($uid, 'test', 'quarter')
|
||||
->andReturn(true)
|
||||
->once();
|
||||
|
||||
$this->testedConfig = $this->getInstance();
|
||||
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
|
||||
|
||||
// directly set the value to the cache
|
||||
$this->testedConfig->getCache()->set($uid, 'test', 'it', 'now');
|
||||
|
||||
$this->assertEquals('now', $this->testedConfig->get($uid, 'test', 'it'));
|
||||
$this->assertEquals('now', $this->testedConfig->getCache()->get($uid, 'test', 'it'));
|
||||
|
||||
// delete from cache only
|
||||
$this->assertTrue($this->testedConfig->delete($uid, 'test', 'it'));
|
||||
// delete from db only
|
||||
$this->assertTrue($this->testedConfig->delete($uid, 'test', 'second'));
|
||||
// no delete
|
||||
$this->assertFalse($this->testedConfig->delete($uid, 'test', 'third'));
|
||||
// delete both
|
||||
$this->assertTrue($this->testedConfig->delete($uid, 'test', 'quarter'));
|
||||
|
||||
$this->assertEmpty($this->testedConfig->getCache()->getAll());
|
||||
}
|
||||
|
||||
public function dataMultiUid()
|
||||
{
|
||||
return [
|
||||
'normal' => [
|
||||
'data1' => [
|
||||
'uid' => 1,
|
||||
'data' => [
|
||||
'cat1' => [
|
||||
'key1' => 'value1',
|
||||
],
|
||||
'cat2' => [
|
||||
'key2' => 'value2',
|
||||
]
|
||||
],
|
||||
],
|
||||
'data2' => [
|
||||
'uid' => 2,
|
||||
'data' => [
|
||||
'cat1' => [
|
||||
'key1' => 'value1a',
|
||||
],
|
||||
'cat2' => [
|
||||
'key2' => 'value2',
|
||||
],
|
||||
],
|
||||
],
|
||||
],
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Test if multiple uids for caching are usable without errors
|
||||
* @dataProvider dataMultiUid
|
||||
*/
|
||||
public function testMultipleUidsWithCache(array $data1, array $data2)
|
||||
{
|
||||
$this->configCache->load($data1['uid'], $data1['data']);
|
||||
$this->configCache->load($data2['uid'], $data2['data']);
|
||||
|
||||
$this->testedConfig = $this->getInstance();
|
||||
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
|
||||
|
||||
$this->assertConfig($data1['uid'], 'cat1', $data1['data']['cat1']);
|
||||
$this->assertConfig($data1['uid'], 'cat2', $data1['data']['cat2']);
|
||||
$this->assertConfig($data2['uid'], 'cat1', $data2['data']['cat1']);
|
||||
$this->assertConfig($data2['uid'], 'cat2', $data2['data']['cat2']);
|
||||
}
|
||||
|
||||
/**
|
||||
* Test when using an invalid UID
|
||||
* @todo check it the clean way before using the config class
|
||||
*/
|
||||
public function testInvalidUid()
|
||||
{
|
||||
// bad UID!
|
||||
$uid = 0;
|
||||
|
||||
$this->testedConfig = $this->getInstance();
|
||||
|
||||
$this->assertNull($this->testedConfig->get($uid, 'cat1', 'cat2'));
|
||||
$this->assertEquals('fallback!', $this->testedConfig->get($uid, 'cat1', 'cat2', 'fallback!'));
|
||||
|
||||
$this->assertFalse($this->testedConfig->set($uid, 'cat1', 'key1', 'doesn\'t matter!'));
|
||||
$this->assertFalse($this->testedConfig->delete($uid, 'cat1', 'key1'));
|
||||
}
|
||||
}
|
||||
|
|
@ -4,7 +4,7 @@ namespace Friendica\Test\src\Core\Config;
|
|||
|
||||
use Friendica\Core\Config\PreloadConfig;
|
||||
|
||||
class PreloadConfigurationTest extends ConfigurationTest
|
||||
class PreloadConfigTest extends ConfigTest
|
||||
{
|
||||
public function getInstance()
|
||||
{
|
||||
|
|
@ -1,137 +0,0 @@
|
|||
<?php
|
||||
|
||||
namespace Friendica\Test\src\Core\Config;
|
||||
|
||||
use Friendica\Core\PConfig\PreloadPConfig;
|
||||
|
||||
class PreloadPConfigurationTest extends PConfigurationTest
|
||||
{
|
||||
public function getInstance()
|
||||
{
|
||||
return new PreloadPConfig($this->configCache, $this->configModel);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider dataConfigLoad
|
||||
*/
|
||||
public function testLoad(int $uid, array $data, array $possibleCats, array $load)
|
||||
{
|
||||
$this->configModel->shouldReceive('isConnected')
|
||||
->andReturn(true)
|
||||
->once();
|
||||
|
||||
$this->configModel->shouldReceive('load')
|
||||
->with($uid)
|
||||
->andReturn($data)
|
||||
->once();
|
||||
|
||||
parent::testLoad($uid, $data, $possibleCats, $load);
|
||||
|
||||
// Assert that every category is loaded everytime
|
||||
foreach ($data as $cat => $values) {
|
||||
$this->assertConfig($uid, $cat, $values);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider dataDoubleLoad
|
||||
*/
|
||||
public function testCacheLoadDouble(int $uid, array $data1, array $data2, array $expect)
|
||||
{
|
||||
$this->configModel->shouldReceive('isConnected')
|
||||
->andReturn(true)
|
||||
->once();
|
||||
|
||||
$this->configModel->shouldReceive('load')
|
||||
->with($uid)
|
||||
->andReturn($data1)
|
||||
->once();
|
||||
|
||||
parent::testCacheLoadDouble($uid, $data1, $data2, $expect);
|
||||
|
||||
// Assert that every category is loaded everytime and is NOT overwritten
|
||||
foreach ($data1 as $cat => $values) {
|
||||
$this->assertConfig($uid, $cat, $values);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider dataTests
|
||||
*/
|
||||
public function testSetGetWithoutDB(int $uid, $data)
|
||||
{
|
||||
$this->configModel->shouldReceive('isConnected')
|
||||
->andReturn(false)
|
||||
->times(3);
|
||||
|
||||
parent::testSetGetWithoutDB($uid, $data);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider dataTests
|
||||
*/
|
||||
public function testSetGetWithDB(int $uid, $data)
|
||||
{
|
||||
$this->configModel->shouldReceive('isConnected')
|
||||
->andReturn(true)
|
||||
->twice();
|
||||
|
||||
$this->configModel->shouldReceive('load')
|
||||
->with($uid)
|
||||
->andReturn(['config' => []])
|
||||
->once();
|
||||
|
||||
parent::testSetGetWithDB($uid, $data);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider dataTests
|
||||
*/
|
||||
public function testGetWithRefresh(int $uid, $data)
|
||||
{
|
||||
$this->configModel->shouldReceive('isConnected')
|
||||
->andReturn(true)
|
||||
->times(2);
|
||||
|
||||
// constructor loading
|
||||
$this->configModel->shouldReceive('load')
|
||||
->with($uid)
|
||||
->andReturn(['config' => []])
|
||||
->once();
|
||||
|
||||
// mocking one get
|
||||
$this->configModel->shouldReceive('get')
|
||||
->with($uid, 'test', 'it')
|
||||
->andReturn($data)
|
||||
->once();
|
||||
|
||||
parent::testGetWithRefresh($uid, $data);
|
||||
}
|
||||
|
||||
/**
|
||||
* @dataProvider dataTests
|
||||
*/
|
||||
public function testDeleteWithoutDB(int $uid, $data)
|
||||
{
|
||||
$this->configModel->shouldReceive('isConnected')
|
||||
->andReturn(false)
|
||||
->times(4);
|
||||
|
||||
parent::testDeleteWithoutDB($uid, $data);
|
||||
}
|
||||
|
||||
public function testDeleteWithDB()
|
||||
{
|
||||
$this->configModel->shouldReceive('isConnected')
|
||||
->andReturn(true)
|
||||
->times(5);
|
||||
|
||||
// constructor loading
|
||||
$this->configModel->shouldReceive('load')
|
||||
->with(42)
|
||||
->andReturn(['config' => []])
|
||||
->once();
|
||||
|
||||
parent::testDeleteWithDB();
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue