Friendica/friendica-github
1
0
Fork 0
mirror of https://github.com/friendica/friendica synced 2025-04-27 18:30:12 +00:00
Code Issues Projects Releases Packages Wiki Activity

Fix wrong $this->assert...() with `self::assert...()

Browse source
This commit is contained in:
Philipp 2020-10-17 14:19:57 +02:00
parent b3e5621d37
commit efaec26b1d
No known key found for this signature in database
GPG key ID: 9A28B7D4FF5667BD
63 changed files with 1192 additions and 1192 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -97,25 +97,25 @@ abstract class CacheTest extends MockedTest
*/
function testSimple($value1, $value2)
{
$this->assertNull($this->instance->get('value1'));
self::assertNull($this->instance->get('value1'));
$this->instance->set('value1', $value1);
$received = $this->instance->get('value1');
$this->assertEquals($value1, $received, 'Value received from cache not equal to the original');
self::assertEquals($value1, $received, 'Value received from cache not equal to the original');
$this->instance->set('value1', $value2);
$received = $this->instance->get('value1');
$this->assertEquals($value2, $received, 'Value not overwritten by second set');
self::assertEquals($value2, $received, 'Value not overwritten by second set');
$this->instance->set('value2', $value1);
$received2 = $this->instance->get('value2');
$this->assertEquals($value2, $received, 'Value changed while setting other variable');
$this->assertEquals($value1, $received2, 'Second value not equal to original');
self::assertEquals($value2, $received, 'Value changed while setting other variable');
self::assertEquals($value1, $received2, 'Second value not equal to original');
$this->assertNull($this->instance->get('not_set'), 'Unset value not equal to null');
self::assertNull($this->instance->get('not_set'), 'Unset value not equal to null');
$this->assertTrue($this->instance->delete('value1'));
$this->assertNull($this->instance->get('value1'));
self::assertTrue($this->instance->delete('value1'));
self::assertNull($this->instance->get('value1'));
}
/**
@ -135,7 +135,7 @@ abstract class CacheTest extends MockedTest
$this->instance->set('2_value1', $value3);
$this->instance->set('3_value1', $value4);
$this->assertEquals([
self::assertEquals([
'1_value1' => $value1,
'1_value2' => $value2,
'2_value1' => $value3,
@ -147,9 +147,9 @@ abstract class CacheTest extends MockedTest
'3_value1' => $this->instance->get('3_value1'),
]);
$this->assertTrue($this->instance->clear());
self::assertTrue($this->instance->clear());
$this->assertEquals([
self::assertEquals([
'1_value1' => $value1,
'1_value2' => $value2,
'2_value1' => $value3,
@ -161,9 +161,9 @@ abstract class CacheTest extends MockedTest
'3_value1' => $this->instance->get('3_value1'),
]);
$this->assertTrue($this->instance->clear(false));
self::assertTrue($this->instance->clear(false));
$this->assertEquals([
self::assertEquals([
'1_value1' => null,
'1_value2' => null,
'2_value3' => null,
@ -183,16 +183,16 @@ abstract class CacheTest extends MockedTest
{
$this->markTestSkipped('taking too much time without mocking');
$this->assertNull($this->instance->get('value1'));
self::assertNull($this->instance->get('value1'));
$value = 'foobar';
$this->instance->set('value1', $value, 1);
$received = $this->instance->get('value1');
$this->assertEquals($value, $received, 'Value received from cache not equal to the original');
self::assertEquals($value, $received, 'Value received from cache not equal to the original');
sleep(2);
$this->assertNull($this->instance->get('value1'));
self::assertNull($this->instance->get('value1'));
}
/**
@ -206,7 +206,7 @@ abstract class CacheTest extends MockedTest
{
$this->instance->set('val', $data);
$received = $this->instance->get('val');
$this->assertEquals($data, $received, 'Value type changed from ' . gettype($data) . ' to ' . gettype($received));
self::assertEquals($data, $received, 'Value type changed from ' . gettype($data) . ' to ' . gettype($received));
}
/**
@ -220,20 +220,20 @@ abstract class CacheTest extends MockedTest
*/
public function testGetAllKeys($value1, $value2, $value3)
{
$this->assertTrue($this->instance->set('value1', $value1));
$this->assertTrue($this->instance->set('value2', $value2));
$this->assertTrue($this->instance->set('test_value3', $value3));
self::assertTrue($this->instance->set('value1', $value1));
self::assertTrue($this->instance->set('value2', $value2));
self::assertTrue($this->instance->set('test_value3', $value3));
$list = $this->instance->getAllKeys();
$this->assertContains('value1', $list);
$this->assertContains('value2', $list);
$this->assertContains('test_value3', $list);
self::assertContains('value1', $list);
self::assertContains('value2', $list);
self::assertContains('test_value3', $list);
$list = $this->instance->getAllKeys('test');
$this->assertContains('test_value3', $list);
$this->assertNotContains('value1', $list);
$this->assertNotContains('value2', $list);
self::assertContains('test_value3', $list);
self::assertNotContains('value1', $list);
self::assertNotContains('value2', $list);
}
}

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

@ -45,15 +45,15 @@ abstract class MemoryCacheTest extends CacheTest
*/
function testCompareSet($value1, $value2)
{
$this->assertNull($this->instance->get('value1'));
self::assertNull($this->instance->get('value1'));
$this->instance->add('value1', $value1);
$received = $this->instance->get('value1');
$this->assertEquals($value1, $received, 'Value received from cache not equal to the original');
self::assertEquals($value1, $received, 'Value received from cache not equal to the original');
$this->instance->compareSet('value1', $value1, $value2);
$received = $this->instance->get('value1');
$this->assertEquals($value2, $received, 'Value not overwritten by compareSet');
self::assertEquals($value2, $received, 'Value not overwritten by compareSet');
}
/**
@ -62,16 +62,16 @@ abstract class MemoryCacheTest extends CacheTest
*/
function testNegativeCompareSet($value1, $value2)
{
$this->assertNull($this->instance->get('value1'));
self::assertNull($this->instance->get('value1'));
$this->instance->add('value1', $value1);
$received = $this->instance->get('value1');
$this->assertEquals($value1, $received, 'Value received from cache not equal to the original');
self::assertEquals($value1, $received, 'Value received from cache not equal to the original');
$this->instance->compareSet('value1', 'wrong', $value2);
$received = $this->instance->get('value1');
$this->assertNotEquals($value2, $received, 'Value was wrongly overwritten by compareSet');
$this->assertEquals($value1, $received, 'Value was wrongly overwritten by any other value');
self::assertNotEquals($value2, $received, 'Value was wrongly overwritten by compareSet');
self::assertEquals($value1, $received, 'Value was wrongly overwritten by any other value');
}
/**
@ -80,13 +80,13 @@ abstract class MemoryCacheTest extends CacheTest
*/
function testCompareDelete($data)
{
$this->assertNull($this->instance->get('value1'));
self::assertNull($this->instance->get('value1'));
$this->instance->add('value1', $data);
$received = $this->instance->get('value1');
$this->assertEquals($data, $received, 'Value received from cache not equal to the original');
self::assertEquals($data, $received, 'Value received from cache not equal to the original');
$this->instance->compareDelete('value1', $data);
$this->assertNull($this->instance->get('value1'), 'Value was not deleted by compareDelete');
self::assertNull($this->instance->get('value1'), 'Value was not deleted by compareDelete');
}
/**
@ -95,16 +95,16 @@ abstract class MemoryCacheTest extends CacheTest
*/
function testNegativeCompareDelete($data)
{
$this->assertNull($this->instance->get('value1'));
self::assertNull($this->instance->get('value1'));
$this->instance->add('value1', $data);
$received = $this->instance->get('value1');
$this->assertEquals($data, $received, 'Value received from cache not equal to the original');
self::assertEquals($data, $received, 'Value received from cache not equal to the original');
$this->instance->compareDelete('value1', 'wrong');
$this->assertNotNull($this->instance->get('value1'), 'Value was wrongly compareDeleted');
self::assertNotNull($this->instance->get('value1'), 'Value was wrongly compareDeleted');
$this->instance->compareDelete('value1', $data);
$this->assertNull($this->instance->get('value1'), 'Value was wrongly NOT deleted by compareDelete');
self::assertNull($this->instance->get('value1'), 'Value was wrongly NOT deleted by compareDelete');
}
/**
@ -113,19 +113,19 @@ abstract class MemoryCacheTest extends CacheTest
*/
function testAdd($value1, $value2)
{
$this->assertNull($this->instance->get('value1'));
self::assertNull($this->instance->get('value1'));
$this->instance->add('value1', $value1);
$this->instance->add('value1', $value2);
$received = $this->instance->get('value1');
$this->assertNotEquals($value2, $received, 'Value was wrongly overwritten by add');
$this->assertEquals($value1, $received, 'Value was wrongly overwritten by any other value');
self::assertNotEquals($value2, $received, 'Value was wrongly overwritten by add');
self::assertEquals($value1, $received, 'Value was wrongly overwritten by any other value');
$this->instance->delete('value1');
$this->instance->add('value1', $value2);
$received = $this->instance->get('value1');
$this->assertEquals($value2, $received, 'Value was not overwritten by add');
$this->assertNotEquals($value1, $received, 'Value was not overwritten by any other value');
self::assertEquals($value2, $received, 'Value was not overwritten by add');
self::assertNotEquals($value1, $received, 'Value was not overwritten by any other value');
}
}

70
tests/src/Core/Config/CacheTest.php
View file

@ -52,7 +52,7 @@ class CacheTest extends MockedTest
{
foreach ($data as $cat => $values) {
foreach ($values as $key => $value) {
$this->assertEquals($data[$cat][$key], $configCache->get($cat, $key));
self::assertEquals($data[$cat][$key], $configCache->get($cat, $key));
}
}
}
@ -66,7 +66,7 @@ class CacheTest extends MockedTest
$configCache = new Cache();
$configCache->load($data);
$this->assertConfigValues($data, $configCache);
self::assertConfigValues($data, $configCache);
}
/**
@ -87,26 +87,26 @@ class CacheTest extends MockedTest
// doesn't override - Low Priority due Config file
$configCache->load($override, Cache::SOURCE_FILE);
$this->assertConfigValues($data, $configCache);
self::assertConfigValues($data, $configCache);
// override the value - High Prio due Server Env
$configCache->load($override, Cache::SOURCE_ENV);
$this->assertEquals($override['system']['test'], $configCache->get('system', 'test'));
$this->assertEquals($override['system']['boolTrue'], $configCache->get('system', 'boolTrue'));
self::assertEquals($override['system']['test'], $configCache->get('system', 'test'));
self::assertEquals($override['system']['boolTrue'], $configCache->get('system', 'boolTrue'));
// Don't overwrite server ENV variables - even in load mode
$configCache->load($data, Cache::SOURCE_DB);
$this->assertEquals($override['system']['test'], $configCache->get('system', 'test'));
$this->assertEquals($override['system']['boolTrue'], $configCache->get('system', 'boolTrue'));
self::assertEquals($override['system']['test'], $configCache->get('system', 'test'));
self::assertEquals($override['system']['boolTrue'], $configCache->get('system', 'boolTrue'));
// Overwrite ENV variables with ENV variables
$configCache->load($data, Cache::SOURCE_ENV);
$this->assertConfigValues($data, $configCache);
$this->assertNotEquals($override['system']['test'], $configCache->get('system', 'test'));
$this->assertNotEquals($override['system']['boolTrue'], $configCache->get('system', 'boolTrue'));
self::assertConfigValues($data, $configCache);
self::assertNotEquals($override['system']['test'], $configCache->get('system', 'test'));
self::assertNotEquals($override['system']['boolTrue'], $configCache->get('system', 'boolTrue'));
}
/**
@ -118,15 +118,15 @@ class CacheTest extends MockedTest
// empty dataset
$configCache->load([]);
$this->assertEmpty($configCache->getAll());
self::assertEmpty($configCache->getAll());
// wrong dataset
$configCache->load(['system' => 'not_array']);
$this->assertEmpty($configCache->getAll());
self::assertEmpty($configCache->getAll());
// incomplete dataset (key is integer ID of the array)
$configCache->load(['system' => ['value']]);
$this->assertEquals('value', $configCache->get('system', 0));
self::assertEquals('value', $configCache->get('system', 0));
}
/**
@ -140,8 +140,8 @@ class CacheTest extends MockedTest
$all = $configCache->getAll();
$this->assertContains($data['system'], $all);
$this->assertContains($data['config'], $all);
self::assertContains($data['system'], $all);
self::assertContains($data['config'], $all);
}
/**
@ -158,7 +158,7 @@ class CacheTest extends MockedTest
}
}
$this->assertConfigValues($data, $configCache);
self::assertConfigValues($data, $configCache);
}
/**
@ -168,7 +168,7 @@ class CacheTest extends MockedTest
{
$configCache = new Cache();
$this->assertNull($configCache->get('something', 'value'));
self::assertNull($configCache->get('something', 'value'));
}
/**
@ -186,13 +186,13 @@ class CacheTest extends MockedTest
],
]);
$this->assertEquals([
self::assertEquals([
'key1' => 'value1',
'key2' => 'value2',
], $configCache->get('system'));
// explicit null as key
$this->assertEquals([
self::assertEquals([
'key1' => 'value1',
'key2' => 'value2',
], $configCache->get('system', null));
@ -212,7 +212,7 @@ class CacheTest extends MockedTest
}
}
$this->assertEmpty($configCache->getAll());
self::assertEmpty($configCache->getAll());
}
/**
@ -229,7 +229,7 @@ class CacheTest extends MockedTest
]
];
$this->assertEquals($diffConfig, $configCache->keyDiff($diffConfig));
self::assertEquals($diffConfig, $configCache->keyDiff($diffConfig));
}
/**
@ -242,7 +242,7 @@ class CacheTest extends MockedTest
$diffConfig = $configCache->getAll();
$this->assertEmpty($configCache->keyDiff($diffConfig));
self::assertEmpty($configCache->keyDiff($diffConfig));
}
/**
@ -257,9 +257,9 @@ class CacheTest extends MockedTest
],
]);
$this->assertEquals('supersecure', $configCache->get('database', 'password'));
$this->assertNotEquals('supersecure', print_r($configCache->get('database', 'password'), true));
$this->assertEquals('notsecured', print_r($configCache->get('database', 'username'), true));
self::assertEquals('supersecure', $configCache->get('database', 'password'));
self::assertNotEquals('supersecure', print_r($configCache->get('database', 'password'), true));
self::assertEquals('notsecured', print_r($configCache->get('database', 'username'), true));
}
/**
@ -274,9 +274,9 @@ class CacheTest extends MockedTest
],
], false);
$this->assertEquals('supersecure', $configCache->get('database', 'password'));
$this->assertEquals('supersecure', print_r($configCache->get('database', 'password'), true));
$this->assertEquals('notsecured', print_r($configCache->get('database', 'username'), true));
self::assertEquals('supersecure', $configCache->get('database', 'password'));
self::assertEquals('supersecure', print_r($configCache->get('database', 'password'), true));
self::assertEquals('notsecured', print_r($configCache->get('database', 'username'), true));
}
/**
@ -291,9 +291,9 @@ class CacheTest extends MockedTest
]
]);
$this->assertNotEmpty($configCache->get('database', 'password'));
$this->assertInstanceOf(HiddenString::class, $configCache->get('database', 'password'));
$this->assertEmpty($configCache->get('database', 'username'));
self::assertNotEmpty($configCache->get('database', 'password'));
self::assertInstanceOf(HiddenString::class, $configCache->get('database', 'password'));
self::assertEmpty($configCache->get('database', 'username'));
}
public function testWrongTypePassword()
@ -305,8 +305,8 @@ class CacheTest extends MockedTest
]
]);
$this->assertNotEmpty($configCache->get('database', 'password'));
$this->assertEmpty($configCache->get('database', 'username'));
self::assertNotEmpty($configCache->get('database', 'password'));
self::assertEmpty($configCache->get('database', 'username'));
$configCache = new Cache([
'database' => [
@ -315,7 +315,7 @@ class CacheTest extends MockedTest
]
]);
$this->assertEquals(23, $configCache->get('database', 'password'));
$this->assertEmpty($configCache->get('database', 'username'));
self::assertEquals(23, $configCache->get('database', 'password'));
self::assertEmpty($configCache->get('database', 'username'));
}
}

92
tests/src/Core/Config/ConfigTest.php
View file

@ -49,9 +49,9 @@ abstract class ConfigTest extends MockedTest
{
$result = $this->testedConfig->getCache()->getAll();
$this->assertNotEmpty($result);
$this->assertArrayHasKey($cat, $result);
$this->assertArraySubset($data, $result[$cat]);
self::assertNotEmpty($result);
self::assertArrayHasKey($cat, $result);
self::assertArraySubset($data, $result[$cat]);
}
@ -161,10 +161,10 @@ abstract class ConfigTest extends MockedTest
->once();
$this->testedConfig = $this->getInstance();
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
self::assertInstanceOf(Cache::class, $this->testedConfig->getCache());
// assert config is loaded everytime
$this->assertConfig('config', $data['config']);
self::assertConfig('config', $data['config']);
}
/**
@ -173,7 +173,7 @@ abstract class ConfigTest extends MockedTest
public function testLoad(array $data, array $possibleCats, array $load)
{
$this->testedConfig = $this->getInstance();
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
self::assertInstanceOf(Cache::class, $this->testedConfig->getCache());
foreach ($load as $loadedCats) {
$this->testedConfig->load($loadedCats);
@ -181,7 +181,7 @@ abstract class ConfigTest extends MockedTest
// Assert at least loaded cats are loaded
foreach ($load as $loadedCats) {
$this->assertConfig($loadedCats, $data[$loadedCats]);
self::assertConfig($loadedCats, $data[$loadedCats]);
}
}
@ -254,7 +254,7 @@ abstract class ConfigTest extends MockedTest
public function testCacheLoadDouble(array $data1, array $data2, array $expect)
{
$this->testedConfig = $this->getInstance();
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
self::assertInstanceOf(Cache::class, $this->testedConfig->getCache());
foreach ($data1 as $cat => $data) {
$this->testedConfig->load($cat);
@ -262,7 +262,7 @@ abstract class ConfigTest extends MockedTest
// Assert at least loaded cats are loaded
foreach ($data1 as $cat => $data) {
$this->assertConfig($cat, $data);
self::assertConfig($cat, $data);
}
foreach ($data2 as $cat => $data) {
@ -279,9 +279,9 @@ abstract class ConfigTest extends MockedTest
$this->configModel->shouldReceive('load')->withAnyArgs()->andReturn([])->once();
$this->testedConfig = $this->getInstance();
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
self::assertInstanceOf(Cache::class, $this->testedConfig->getCache());
$this->assertEmpty($this->testedConfig->getCache()->getAll());
self::assertEmpty($this->testedConfig->getCache()->getAll());
}
/**
@ -296,12 +296,12 @@ abstract class ConfigTest extends MockedTest
->times(3);
$this->testedConfig = $this->getInstance();
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
self::assertInstanceOf(Cache::class, $this->testedConfig->getCache());
$this->assertTrue($this->testedConfig->set('test', 'it', $data));
self::assertTrue($this->testedConfig->set('test', 'it', $data));
$this->assertEquals($data, $this->testedConfig->get('test', 'it'));
$this->assertEquals($data, $this->testedConfig->getCache()->get('test', 'it'));
self::assertEquals($data, $this->testedConfig->get('test', 'it'));
self::assertEquals($data, $this->testedConfig->getCache()->get('test', 'it'));
}
/**
@ -314,12 +314,12 @@ abstract class ConfigTest extends MockedTest
$this->configModel->shouldReceive('set')->with('test', 'it', $data)->andReturn(true)->once();
$this->testedConfig = $this->getInstance();
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
self::assertInstanceOf(Cache::class, $this->testedConfig->getCache());
$this->assertTrue($this->testedConfig->set('test', 'it', $data));
self::assertTrue($this->testedConfig->set('test', 'it', $data));
$this->assertEquals($data, $this->testedConfig->get('test', 'it'));
$this->assertEquals($data, $this->testedConfig->getCache()->get('test', 'it'));
self::assertEquals($data, $this->testedConfig->get('test', 'it'));
self::assertEquals($data, $this->testedConfig->getCache()->get('test', 'it'));
}
/**
@ -328,19 +328,19 @@ abstract class ConfigTest extends MockedTest
public function testGetWrongWithoutDB()
{
$this->testedConfig = $this->getInstance();
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
self::assertInstanceOf(Cache::class, $this->testedConfig->getCache());
// without refresh
$this->assertNull($this->testedConfig->get('test', 'it'));
self::assertNull($this->testedConfig->get('test', 'it'));
/// beware that the cache returns '!<unset>!' and not null for a non existing value
$this->assertNull($this->testedConfig->getCache()->get('test', 'it'));
self::assertNull($this->testedConfig->getCache()->get('test', 'it'));
// with default value
$this->assertEquals('default', $this->testedConfig->get('test', 'it', 'default'));
self::assertEquals('default', $this->testedConfig->get('test', 'it', 'default'));
// with default value and refresh
$this->assertEquals('default', $this->testedConfig->get('test', 'it', 'default', true));
self::assertEquals('default', $this->testedConfig->get('test', 'it', 'default', true));
}
/**
@ -353,19 +353,19 @@ abstract class ConfigTest extends MockedTest
$this->configCache->load(['test' => ['it' => 'now']], Cache::SOURCE_FILE);
$this->testedConfig = $this->getInstance();
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
self::assertInstanceOf(Cache::class, $this->testedConfig->getCache());
// without refresh
$this->assertEquals('now', $this->testedConfig->get('test', 'it'));
$this->assertEquals('now', $this->testedConfig->getCache()->get('test', 'it'));
self::assertEquals('now', $this->testedConfig->get('test', 'it'));
self::assertEquals('now', $this->testedConfig->getCache()->get('test', 'it'));
// with refresh
$this->assertEquals($data, $this->testedConfig->get('test', 'it', null, true));
$this->assertEquals($data, $this->testedConfig->getCache()->get('test', 'it'));
self::assertEquals($data, $this->testedConfig->get('test', 'it', null, true));
self::assertEquals($data, $this->testedConfig->getCache()->get('test', 'it'));
// without refresh and wrong value and default
$this->assertEquals('default', $this->testedConfig->get('test', 'not', 'default'));
$this->assertNull($this->testedConfig->getCache()->get('test', 'not'));
self::assertEquals('default', $this->testedConfig->get('test', 'not', 'default'));
self::assertNull($this->testedConfig->getCache()->get('test', 'not'));
}
/**
@ -378,16 +378,16 @@ abstract class ConfigTest extends MockedTest
$this->configCache->load(['test' => ['it' => $data]], Cache::SOURCE_FILE);
$this->testedConfig = $this->getInstance();
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
self::assertInstanceOf(Cache::class, $this->testedConfig->getCache());
$this->assertEquals($data, $this->testedConfig->get('test', 'it'));
$this->assertEquals($data, $this->testedConfig->getCache()->get('test', 'it'));
self::assertEquals($data, $this->testedConfig->get('test', 'it'));
self::assertEquals($data, $this->testedConfig->getCache()->get('test', 'it'));
$this->assertTrue($this->testedConfig->delete('test', 'it'));
$this->assertNull($this->testedConfig->get('test', 'it'));
$this->assertNull($this->testedConfig->getCache()->get('test', 'it'));
self::assertTrue($this->testedConfig->delete('test', 'it'));
self::assertNull($this->testedConfig->get('test', 'it'));
self::assertNull($this->testedConfig->getCache()->get('test', 'it'));
$this->assertEmpty($this->testedConfig->getCache()->getAll());
self::assertEmpty($this->testedConfig->getCache()->getAll());
}
/**
@ -415,23 +415,23 @@ abstract class ConfigTest extends MockedTest
->once();
$this->testedConfig = $this->getInstance();
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
self::assertInstanceOf(Cache::class, $this->testedConfig->getCache());
// directly set the value to the cache
$this->testedConfig->getCache()->set('test', 'it', 'now');
$this->assertEquals('now', $this->testedConfig->get('test', 'it'));
$this->assertEquals('now', $this->testedConfig->getCache()->get('test', 'it'));
self::assertEquals('now', $this->testedConfig->get('test', 'it'));
self::assertEquals('now', $this->testedConfig->getCache()->get('test', 'it'));
// delete from cache only
$this->assertTrue($this->testedConfig->delete('test', 'it'));
self::assertTrue($this->testedConfig->delete('test', 'it'));
// delete from db only
$this->assertTrue($this->testedConfig->delete('test', 'second'));
self::assertTrue($this->testedConfig->delete('test', 'second'));
// no delete
$this->assertFalse($this->testedConfig->delete('test', 'third'));
self::assertFalse($this->testedConfig->delete('test', 'third'));
// delete both
$this->assertTrue($this->testedConfig->delete('test', 'quarter'));
self::assertTrue($this->testedConfig->delete('test', 'quarter'));
$this->assertEmpty($this->testedConfig->getCache()->getAll());
self::assertEmpty($this->testedConfig->getCache()->getAll());
}
}

2
tests/src/Core/Config/JitConfigTest.php
View file

@ -100,7 +100,7 @@ class JitConfigTest extends ConfigTest
// Assert the expected categories
foreach ($data2 as $cat => $data) {
$this->assertConfig($cat, $expect[$cat]);
self::assertConfig($cat, $expect[$cat]);
}
}

4
tests/src/Core/Config/PreloadConfigTest.php
View file

@ -59,7 +59,7 @@ class PreloadConfigTest extends ConfigTest
// Assert that every category is loaded everytime
foreach ($data as $cat => $values) {
$this->assertConfig($cat, $values);
self::assertConfig($cat, $values);
}
}
@ -80,7 +80,7 @@ class PreloadConfigTest extends ConfigTest
// Assert that every category is loaded everytime and is NOT overwritten
foreach ($data1 as $cat => $values) {
$this->assertConfig($cat, $values);
self::assertConfig($cat, $values);
}
}

66
tests/src/Core/InstallerTest.php
View file

@ -104,7 +104,7 @@ class InstallerTest extends MockedTest
'help' => $help]
];
$this->assertArraySubset($subSet, $assertionArray, false, "expected subset: " . PHP_EOL . print_r($subSet, true) . PHP_EOL . "current subset: " . print_r($assertionArray, true));
self::assertArraySubset($subSet, $assertionArray, false, "expected subset: " . PHP_EOL . print_r($subSet, true) . PHP_EOL . "current subset: " . print_r($assertionArray, true));
}
/**
@ -152,11 +152,11 @@ class InstallerTest extends MockedTest
$this->setFunctions(['openssl_pkey_new' => false]);
$install = new Installer();
$this->assertFalse($install->checkKeys());
self::assertFalse($install->checkKeys());
$this->setFunctions(['openssl_pkey_new' => true]);
$install = new Installer();
$this->assertTrue($install->checkKeys());
self::assertTrue($install->checkKeys());
}
/**
@ -167,8 +167,8 @@ class InstallerTest extends MockedTest
$this->mockFunctionL10TCalls();
$this->setFunctions(['curl_init' => false, 'imagecreatefromjpeg' => true]);
$install = new Installer();
$this->assertFalse($install->checkFunctions());
$this->assertCheckExist(3,
self::assertFalse($install->checkFunctions());
self::assertCheckExist(3,
'libCurl PHP module',
'Error: libCURL PHP module required but not installed.',
false,
@ -178,8 +178,8 @@ class InstallerTest extends MockedTest
$this->mockFunctionL10TCalls();
$this->setFunctions(['imagecreatefromjpeg' => false]);
$install = new Installer();
$this->assertFalse($install->checkFunctions());
$this->assertCheckExist(4,
self::assertFalse($install->checkFunctions());
self::assertCheckExist(4,
'GD graphics PHP module',
'Error: GD graphics PHP module with JPEG support required but not installed.',
false,
@ -189,8 +189,8 @@ class InstallerTest extends MockedTest
$this->mockFunctionL10TCalls();
$this->setFunctions(['openssl_public_encrypt' => false]);
$install = new Installer();
$this->assertFalse($install->checkFunctions());
$this->assertCheckExist(5,
self::assertFalse($install->checkFunctions());
self::assertCheckExist(5,
'OpenSSL PHP module',
'Error: openssl PHP module required but not installed.',
false,
@ -200,8 +200,8 @@ class InstallerTest extends MockedTest
$this->mockFunctionL10TCalls();
$this->setFunctions(['mb_strlen' => false]);
$install = new Installer();
$this->assertFalse($install->checkFunctions());
$this->assertCheckExist(6,
self::assertFalse($install->checkFunctions());
self::assertCheckExist(6,
'mb_string PHP module',
'Error: mb_string PHP module required but not installed.',
false,
@ -211,8 +211,8 @@ class InstallerTest extends MockedTest
$this->mockFunctionL10TCalls();
$this->setFunctions(['iconv_strlen' => false]);
$install = new Installer();
$this->assertFalse($install->checkFunctions());
$this->assertCheckExist(7,
self::assertFalse($install->checkFunctions());
self::assertCheckExist(7,
'iconv PHP module',
'Error: iconv PHP module required but not installed.',
false,
@ -222,8 +222,8 @@ class InstallerTest extends MockedTest
$this->mockFunctionL10TCalls();
$this->setFunctions(['posix_kill' => false]);
$install = new Installer();
$this->assertFalse($install->checkFunctions());
$this->assertCheckExist(8,
self::assertFalse($install->checkFunctions());
self::assertCheckExist(8,
'POSIX PHP module',
'Error: POSIX PHP module required but not installed.',
false,
@ -233,8 +233,8 @@ class InstallerTest extends MockedTest
$this->mockFunctionL10TCalls();
$this->setFunctions(['json_encode' => false]);
$install = new Installer();
$this->assertFalse($install->checkFunctions());
$this->assertCheckExist(9,
self::assertFalse($install->checkFunctions());
self::assertCheckExist(9,
'JSON PHP module',
'Error: JSON PHP module required but not installed.',
false,
@ -244,8 +244,8 @@ class InstallerTest extends MockedTest
$this->mockFunctionL10TCalls();
$this->setFunctions(['finfo_open' => false]);
$install = new Installer();
$this->assertFalse($install->checkFunctions());
$this->assertCheckExist(10,
self::assertFalse($install->checkFunctions());
self::assertCheckExist(10,
'File Information PHP module',
'Error: File Information PHP module required but not installed.',
false,
@ -264,7 +264,7 @@ class InstallerTest extends MockedTest
'finfo_open' => true,
]);
$install = new Installer();
$this->assertTrue($install->checkFunctions());
self::assertTrue($install->checkFunctions());
}
/**
@ -274,17 +274,17 @@ class InstallerTest extends MockedTest
{
$this->l10nMock->shouldReceive('t')->andReturnUsing(function ($args) { return $args; });
$this->assertTrue($this->root->hasChild('config/local.config.php'));
self::assertTrue($this->root->hasChild('config/local.config.php'));
$install = new Installer();
$this->assertTrue($install->checkLocalIni());
self::assertTrue($install->checkLocalIni());
$this->delConfigFile('local.config.php');
$this->assertFalse($this->root->hasChild('config/local.config.php'));
self::assertFalse($this->root->hasChild('config/local.config.php'));
$install = new Installer();
$this->assertTrue($install->checkLocalIni());
self::assertTrue($install->checkLocalIni());
}
/**
@ -330,8 +330,8 @@ class InstallerTest extends MockedTest
$install = new Installer();
$this->assertFalse($install->checkHtAccess('https://test'));
$this->assertSame('test Error', $install->getChecks()[0]['error_msg']['msg']);
self::assertFalse($install->checkHtAccess('https://test'));
self::assertSame('test Error', $install->getChecks()[0]['error_msg']['msg']);
}
/**
@ -377,7 +377,7 @@ class InstallerTest extends MockedTest
$install = new Installer();
$this->assertTrue($install->checkHtAccess('https://test'));
self::assertTrue($install->checkHtAccess('https://test'));
}
/**
@ -396,9 +396,9 @@ class InstallerTest extends MockedTest
$install = new Installer();
// even there is no supported type, Imagick should return true (because it is not required)
$this->assertTrue($install->checkImagick());
self::assertTrue($install->checkImagick());
$this->assertCheckExist(1,
self::assertCheckExist(1,
$this->l10nMock->t('ImageMagick supports GIF'),
'',
true,
@ -422,8 +422,8 @@ class InstallerTest extends MockedTest
$install = new Installer();
// even there is no supported type, Imagick should return true (because it is not required)
$this->assertTrue($install->checkImagick());
$this->assertCheckExist(1,
self::assertTrue($install->checkImagick());
self::assertCheckExist(1,
$this->l10nMock->t('ImageMagick supports GIF'),
'',
false,
@ -439,8 +439,8 @@ class InstallerTest extends MockedTest
$install = new Installer();
// even there is no supported type, Imagick should return true (because it is not required)
$this->assertTrue($install->checkImagick());
$this->assertCheckExist(0,
self::assertTrue($install->checkImagick());
self::assertCheckExist(0,
'ImageMagick PHP extension is not installed',
'',
false,

2
tests/src/Core/L10nTest.php
View file

@ -109,6 +109,6 @@ class L10nTest extends MockedTest
*/
public function testDetectLanguage(array $server, array $get, string $default, string $assert)
{
$this->assertEquals($assert, L10n::detectLanguage($server, $get, $default));
self::assertEquals($assert, L10n::detectLanguage($server, $get, $default));
}
}

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

@ -56,10 +56,10 @@ abstract class LockTest extends MockedTest
*/
public function testLock()
{
$this->assertFalse($this->instance->isLocked('foo'));
$this->assertTrue($this->instance->acquire('foo', 1));
$this->assertTrue($this->instance->isLocked('foo'));
$this->assertFalse($this->instance->isLocked('bar'));
self::assertFalse($this->instance->isLocked('foo'));
self::assertTrue($this->instance->acquire('foo', 1));
self::assertTrue($this->instance->isLocked('foo'));
self::assertFalse($this->instance->isLocked('bar'));
}
/**
@ -67,11 +67,11 @@ abstract class LockTest extends MockedTest
*/
public function testDoubleLock()
{
$this->assertFalse($this->instance->isLocked('foo'));
$this->assertTrue($this->instance->acquire('foo', 1));
$this->assertTrue($this->instance->isLocked('foo'));
self::assertFalse($this->instance->isLocked('foo'));
self::assertTrue($this->instance->acquire('foo', 1));
self::assertTrue($this->instance->isLocked('foo'));
// We already locked it
$this->assertTrue($this->instance->acquire('foo', 1));
self::assertTrue($this->instance->acquire('foo', 1));
}
/**
@ -79,11 +79,11 @@ abstract class LockTest extends MockedTest
*/
public function testReleaseLock()
{
$this->assertFalse($this->instance->isLocked('foo'));
$this->assertTrue($this->instance->acquire('foo', 1));
$this->assertTrue($this->instance->isLocked('foo'));
self::assertFalse($this->instance->isLocked('foo'));
self::assertTrue($this->instance->acquire('foo', 1));
self::assertTrue($this->instance->isLocked('foo'));
$this->instance->release('foo');
$this->assertFalse($this->instance->isLocked('foo'));
self::assertFalse($this->instance->isLocked('foo'));
}
/**
@ -91,19 +91,19 @@ abstract class LockTest extends MockedTest
*/
public function testReleaseAll()
{
$this->assertTrue($this->instance->acquire('foo', 1));
$this->assertTrue($this->instance->acquire('bar', 1));
$this->assertTrue($this->instance->acquire('nice', 1));
self::assertTrue($this->instance->acquire('foo', 1));
self::assertTrue($this->instance->acquire('bar', 1));
self::assertTrue($this->instance->acquire('nice', 1));
$this->assertTrue($this->instance->isLocked('foo'));
$this->assertTrue($this->instance->isLocked('bar'));
$this->assertTrue($this->instance->isLocked('nice'));
self::assertTrue($this->instance->isLocked('foo'));
self::assertTrue($this->instance->isLocked('bar'));
self::assertTrue($this->instance->isLocked('nice'));
$this->assertTrue($this->instance->releaseAll());
self::assertTrue($this->instance->releaseAll());
$this->assertFalse($this->instance->isLocked('foo'));
$this->assertFalse($this->instance->isLocked('bar'));
$this->assertFalse($this->instance->isLocked('nice'));
self::assertFalse($this->instance->isLocked('foo'));
self::assertFalse($this->instance->isLocked('bar'));
self::assertFalse($this->instance->isLocked('nice'));
}
/**
@ -111,23 +111,23 @@ abstract class LockTest extends MockedTest
*/
public function testReleaseAfterUnlock()
{
$this->assertFalse($this->instance->isLocked('foo'));
$this->assertFalse($this->instance->isLocked('bar'));
$this->assertFalse($this->instance->isLocked('nice'));
$this->assertTrue($this->instance->acquire('foo', 1));
$this->assertTrue($this->instance->acquire('bar', 1));
$this->assertTrue($this->instance->acquire('nice', 1));
self::assertFalse($this->instance->isLocked('foo'));
self::assertFalse($this->instance->isLocked('bar'));
self::assertFalse($this->instance->isLocked('nice'));
self::assertTrue($this->instance->acquire('foo', 1));
self::assertTrue($this->instance->acquire('bar', 1));
self::assertTrue($this->instance->acquire('nice', 1));
$this->assertTrue($this->instance->release('foo'));
self::assertTrue($this->instance->release('foo'));
$this->assertFalse($this->instance->isLocked('foo'));
$this->assertTrue($this->instance->isLocked('bar'));
$this->assertTrue($this->instance->isLocked('nice'));
self::assertFalse($this->instance->isLocked('foo'));
self::assertTrue($this->instance->isLocked('bar'));
self::assertTrue($this->instance->isLocked('nice'));
$this->assertTrue($this->instance->releaseAll());
self::assertTrue($this->instance->releaseAll());
$this->assertFalse($this->instance->isLocked('bar'));
$this->assertFalse($this->instance->isLocked('nice'));
self::assertFalse($this->instance->isLocked('bar'));
self::assertFalse($this->instance->isLocked('nice'));
}
/**
@ -135,11 +135,11 @@ abstract class LockTest extends MockedTest
*/
public function testReleaseWitTTL()
{
$this->assertFalse($this->instance->isLocked('test'));
$this->assertTrue($this->instance->acquire('test', 1, 10));
$this->assertTrue($this->instance->isLocked('test'));
$this->assertTrue($this->instance->release('test'));
$this->assertFalse($this->instance->isLocked('test'));
self::assertFalse($this->instance->isLocked('test'));
self::assertTrue($this->instance->acquire('test', 1, 10));
self::assertTrue($this->instance->isLocked('test'));
self::assertTrue($this->instance->release('test'));
self::assertFalse($this->instance->isLocked('test'));
}
/**
@ -147,19 +147,19 @@ abstract class LockTest extends MockedTest
*/
public function testGetLocks()
{
$this->assertTrue($this->instance->acquire('foo', 1));
$this->assertTrue($this->instance->acquire('bar', 1));
$this->assertTrue($this->instance->acquire('nice', 1));
self::assertTrue($this->instance->acquire('foo', 1));
self::assertTrue($this->instance->acquire('bar', 1));
self::assertTrue($this->instance->acquire('nice', 1));
$this->assertTrue($this->instance->isLocked('foo'));
$this->assertTrue($this->instance->isLocked('bar'));
$this->assertTrue($this->instance->isLocked('nice'));
self::assertTrue($this->instance->isLocked('foo'));
self::assertTrue($this->instance->isLocked('bar'));
self::assertTrue($this->instance->isLocked('nice'));
$locks = $this->instance->getLocks();
$this->assertContains('foo', $locks);
$this->assertContains('bar', $locks);
$this->assertContains('nice', $locks);
self::assertContains('foo', $locks);
self::assertContains('bar', $locks);
self::assertContains('nice', $locks);
}
/**
@ -167,19 +167,19 @@ abstract class LockTest extends MockedTest
*/
public function testGetLocksWithPrefix()
{
$this->assertTrue($this->instance->acquire('foo', 1));
$this->assertTrue($this->instance->acquire('test1', 1));
$this->assertTrue($this->instance->acquire('test2', 1));
self::assertTrue($this->instance->acquire('foo', 1));
self::assertTrue($this->instance->acquire('test1', 1));
self::assertTrue($this->instance->acquire('test2', 1));
$this->assertTrue($this->instance->isLocked('foo'));
$this->assertTrue($this->instance->isLocked('test1'));
$this->assertTrue($this->instance->isLocked('test2'));
self::assertTrue($this->instance->isLocked('foo'));
self::assertTrue($this->instance->isLocked('test1'));
self::assertTrue($this->instance->isLocked('test2'));
$locks = $this->instance->getLocks('test');
$this->assertContains('test1', $locks);
$this->assertContains('test2', $locks);
$this->assertNotContains('foo', $locks);
self::assertContains('test1', $locks);
self::assertContains('test2', $locks);
self::assertNotContains('foo', $locks);
}
/**
@ -189,25 +189,25 @@ abstract class LockTest extends MockedTest
{
$this->markTestSkipped('taking too much time without mocking');
$this->assertFalse($this->instance->isLocked('foo'));
$this->assertFalse($this->instance->isLocked('bar'));
self::assertFalse($this->instance->isLocked('foo'));
self::assertFalse($this->instance->isLocked('bar'));
// TODO [nupplaphil] - Because of the Datetime-Utils for the database, we have to wait a FULL second between the checks to invalidate the db-locks/cache
$this->assertTrue($this->instance->acquire('foo', 2, 1));
$this->assertTrue($this->instance->acquire('bar', 2, 3));
self::assertTrue($this->instance->acquire('foo', 2, 1));
self::assertTrue($this->instance->acquire('bar', 2, 3));
$this->assertTrue($this->instance->isLocked('foo'));
$this->assertTrue($this->instance->isLocked('bar'));
self::assertTrue($this->instance->isLocked('foo'));
self::assertTrue($this->instance->isLocked('bar'));
sleep(2);
$this->assertFalse($this->instance->isLocked('foo'));
$this->assertTrue($this->instance->isLocked('bar'));
self::assertFalse($this->instance->isLocked('foo'));
self::assertTrue($this->instance->isLocked('bar'));
sleep(2);
$this->assertFalse($this->instance->isLocked('foo'));
$this->assertFalse($this->instance->isLocked('bar'));
self::assertFalse($this->instance->isLocked('foo'));
self::assertFalse($this->instance->isLocked('bar'));
}
/**
@ -215,7 +215,7 @@ abstract class LockTest extends MockedTest
*/
public function testReleaseLockWithoutLock()
{
$this->assertFalse($this->instance->isLocked('wrongLock'));
$this->assertFalse($this->instance->release('wrongLock'));
self::assertFalse($this->instance->isLocked('wrongLock'));
self::assertFalse($this->instance->release('wrongLock'));
}
}

20
tests/src/Core/Lock/SemaphoreLockTest.php
View file

@ -73,9 +73,9 @@ class SemaphoreLockTest extends LockTest
$file = get_temppath() . '/test.sem';
touch($file);
$this->assertTrue(file_exists($file));
$this->assertFalse($this->instance->release('test', false));
$this->assertTrue(file_exists($file));
self::assertTrue(file_exists($file));
self::assertFalse($this->instance->release('test', false));
self::assertTrue(file_exists($file));
}
/**
@ -90,9 +90,9 @@ class SemaphoreLockTest extends LockTest
$file = get_temppath() . '/test.sem';
touch($file);
$this->assertTrue(file_exists($file));
$this->assertFalse($this->instance->release('test', true));
$this->assertTrue(file_exists($file));
self::assertTrue(file_exists($file));
self::assertFalse($this->instance->release('test', true));
self::assertTrue(file_exists($file));
}
/**
@ -103,9 +103,9 @@ class SemaphoreLockTest extends LockTest
$file = get_temppath() . '/test.sem';
touch($file);
$this->assertTrue(file_exists($file));
$this->assertTrue($this->instance->acquire('test'));
$this->assertTrue($this->instance->isLocked('test'));
$this->assertTrue($this->instance->release('test'));
self::assertTrue(file_exists($file));
self::assertTrue($this->instance->acquire('test'));
self::assertTrue($this->instance->isLocked('test'));
self::assertTrue($this->instance->release('test'));
}
}

52
tests/src/Core/PConfig/CacheTest.php
View file

@ -51,7 +51,7 @@ class CacheTest extends MockedTest
{
foreach ($data as $cat => $values) {
foreach ($values as $key => $value) {
$this->assertEquals($data[$cat][$key], $configCache->get($uid, $cat, $key));
self::assertEquals($data[$cat][$key], $configCache->get($uid, $cat, $key));
}
}
}
@ -72,7 +72,7 @@ class CacheTest extends MockedTest
}
}
$this->assertConfigValues($data, $configCache, $uid);
self::assertConfigValues($data, $configCache, $uid);
}
@ -94,13 +94,13 @@ class CacheTest extends MockedTest
],
]);
$this->assertEquals([
self::assertEquals([
'key1' => 'value1',
'key2' => 'value2',
], $configCache->get($uid, 'system'));
// test explicit cat with null as key
$this->assertEquals([
self::assertEquals([
'key1' => 'value1',
'key2' => 'value2',
], $configCache->get($uid, 'system', null));
@ -128,7 +128,7 @@ class CacheTest extends MockedTest
}
}
$this->assertEmpty($configCache->getAll());
self::assertEmpty($configCache->getAll());
}
/**
@ -146,7 +146,7 @@ class CacheTest extends MockedTest
]
];
$this->assertEquals($diffConfig, $configCache->keyDiff($diffConfig));
self::assertEquals($diffConfig, $configCache->keyDiff($diffConfig));
}
/**
@ -162,7 +162,7 @@ class CacheTest extends MockedTest
$diffConfig = $configCache->getAll();
$this->assertEmpty($configCache->keyDiff($diffConfig));
self::assertEmpty($configCache->keyDiff($diffConfig));
}
/**
@ -179,9 +179,9 @@ class CacheTest extends MockedTest
]
]);
$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));
self::assertEquals('supersecure', $configCache->get(1, 'database', 'password'));
self::assertNotEquals('supersecure', print_r($configCache->get(1, 'database', 'password'), true));
self::assertEquals('notsecured', print_r($configCache->get(1, 'database', 'username'), true));
}
/**
@ -198,9 +198,9 @@ class CacheTest extends MockedTest
]
]);
$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));
self::assertEquals('supersecure', $configCache->get(1, 'database', 'password'));
self::assertEquals('supersecure', print_r($configCache->get(1, 'database', 'password'), true));
self::assertEquals('notsecured', print_r($configCache->get(1, 'database', 'username'), true));
}
/**
@ -217,8 +217,8 @@ class CacheTest extends MockedTest
]
]);
$this->assertEmpty($configCache->get(1, 'database', 'password'));
$this->assertEmpty($configCache->get(1, 'database', 'username'));
self::assertEmpty($configCache->get(1, 'database', 'password'));
self::assertEmpty($configCache->get(1, 'database', 'username'));
}
public function testWrongTypePassword()
@ -232,8 +232,8 @@ class CacheTest extends MockedTest
]
]);
$this->assertNotEmpty($configCache->get(1, 'database', 'password'));
$this->assertEmpty($configCache->get(1, 'database', 'username'));
self::assertNotEmpty($configCache->get(1, 'database', 'password'));
self::assertEmpty($configCache->get(1, 'database', 'username'));
$configCache = new Cache();
@ -244,8 +244,8 @@ class CacheTest extends MockedTest
],
]);
$this->assertEquals(23, $configCache->get(1, 'database', 'password'));
$this->assertEmpty($configCache->get(1, 'database', 'username'));
self::assertEquals(23, $configCache->get(1, 'database', 'password'));
self::assertEmpty($configCache->get(1, 'database', 'username'));
}
/**
@ -268,11 +268,11 @@ class CacheTest extends MockedTest
],
]);
$this->assertEquals('value1', $configCache->get(1, 'cat1', 'key1'));
$this->assertEquals('value2', $configCache->get(2, 'cat2', 'key2'));
self::assertEquals('value1', $configCache->get(1, 'cat1', 'key1'));
self::assertEquals('value2', $configCache->get(2, 'cat2', 'key2'));
$this->assertNull($configCache->get(1, 'cat2', 'key2'));
$this->assertNull($configCache->get(2, 'cat1', 'key1'));
self::assertNull($configCache->get(1, 'cat2', 'key2'));
self::assertNull($configCache->get(2, 'cat1', 'key1'));
}
/**
@ -286,9 +286,9 @@ class CacheTest extends MockedTest
$configCache = new Cache();
$this->assertNull($configCache->get($uid, 'cat1', 'cat2'));
self::assertNull($configCache->get($uid, 'cat1', 'cat2'));
$this->assertFalse($configCache->set($uid, 'cat1', 'key1', 'doesn\'t matter!'));
$this->assertFalse($configCache->delete($uid, 'cat1', 'key1'));
self::assertFalse($configCache->set($uid, 'cat1', 'key1', 'doesn\'t matter!'));
self::assertFalse($configCache->delete($uid, 'cat1', 'key1'));
}
}

2
tests/src/Core/PConfig/JitPConfigTest.php
View file

@ -78,7 +78,7 @@ class JitPConfigTest extends PConfigTest
// Assert the expected categories
foreach ($data2 as $cat => $data) {
$this->assertConfig($uid, $cat, $expect[$cat]);
self::assertConfig($uid, $cat, $expect[$cat]);
}
}

108
tests/src/Core/PConfig/PConfigTest.php
View file

@ -50,10 +50,10 @@ abstract class PConfigTest extends MockedTest
{
$result = $this->testedConfig->getCache()->getAll();
$this->assertNotEmpty($result);
$this->assertArrayHasKey($uid, $result);
$this->assertArrayHasKey($cat, $result[$uid]);
$this->assertArraySubset($data, $result[$uid][$cat]);
self::assertNotEmpty($result);
self::assertArrayHasKey($uid, $result);
self::assertArrayHasKey($cat, $result[$uid]);
self::assertArraySubset($data, $result[$uid][$cat]);
}
@ -164,9 +164,9 @@ abstract class PConfigTest extends MockedTest
public function testSetUp(int $uid, array $data)
{
$this->testedConfig = $this->getInstance();
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
self::assertInstanceOf(Cache::class, $this->testedConfig->getCache());
$this->assertEmpty($this->testedConfig->getCache()->getAll());
self::assertEmpty($this->testedConfig->getCache()->getAll());
}
/**
@ -175,7 +175,7 @@ abstract class PConfigTest extends MockedTest
public function testLoad(int $uid, array $data, array $possibleCats, array $load)
{
$this->testedConfig = $this->getInstance();
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
self::assertInstanceOf(Cache::class, $this->testedConfig->getCache());
foreach ($load as $loadedCats) {
$this->testedConfig->load($uid, $loadedCats);
@ -183,7 +183,7 @@ abstract class PConfigTest extends MockedTest
// Assert at least loaded cats are loaded
foreach ($load as $loadedCats) {
$this->assertConfig($uid, $loadedCats, $data[$loadedCats]);
self::assertConfig($uid, $loadedCats, $data[$loadedCats]);
}
}
@ -258,7 +258,7 @@ abstract class PConfigTest extends MockedTest
public function testCacheLoadDouble(int $uid, array $data1, array $data2, array $expect)
{
$this->testedConfig = $this->getInstance();
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
self::assertInstanceOf(Cache::class, $this->testedConfig->getCache());
foreach ($data1 as $cat => $data) {
$this->testedConfig->load($uid, $cat);
@ -266,7 +266,7 @@ abstract class PConfigTest extends MockedTest
// Assert at least loaded cats are loaded
foreach ($data1 as $cat => $data) {
$this->assertConfig($uid, $cat, $data);
self::assertConfig($uid, $cat, $data);
}
foreach ($data2 as $cat => $data) {
@ -282,12 +282,12 @@ abstract class PConfigTest extends MockedTest
public function testSetGetWithoutDB(int $uid, $data)
{
$this->testedConfig = $this->getInstance();
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
self::assertInstanceOf(Cache::class, $this->testedConfig->getCache());
$this->assertTrue($this->testedConfig->set($uid, 'test', 'it', $data));
self::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'));
self::assertEquals($data, $this->testedConfig->get($uid, 'test', 'it'));
self::assertEquals($data, $this->testedConfig->getCache()->get($uid, 'test', 'it'));
}
/**
@ -303,12 +303,12 @@ abstract class PConfigTest extends MockedTest
->once();
$this->testedConfig = $this->getInstance();
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
self::assertInstanceOf(Cache::class, $this->testedConfig->getCache());
$this->assertTrue($this->testedConfig->set($uid, 'test', 'it', $data));
self::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'));
self::assertEquals($data, $this->testedConfig->get($uid, 'test', 'it'));
self::assertEquals($data, $this->testedConfig->getCache()->get($uid, 'test', 'it'));
}
/**
@ -317,19 +317,19 @@ abstract class PConfigTest extends MockedTest
public function testGetWrongWithoutDB()
{
$this->testedConfig = $this->getInstance();
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
self::assertInstanceOf(Cache::class, $this->testedConfig->getCache());
// without refresh
$this->assertNull($this->testedConfig->get(0, 'test', 'it'));
self::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'));
self::assertNull($this->testedConfig->getCache()->get(0, 'test', 'it'));
// with default value
$this->assertEquals('default', $this->testedConfig->get(0, 'test', 'it', 'default'));
self::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));
self::assertEquals('default', $this->testedConfig->get(0, 'test', 'it', 'default', true));
}
/**
@ -342,19 +342,19 @@ abstract class PConfigTest extends MockedTest
$this->configCache->load($uid, ['test' => ['it' => 'now']]);
$this->testedConfig = $this->getInstance();
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
self::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'));
self::assertEquals('now', $this->testedConfig->get($uid, 'test', 'it'));
self::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'));
self::assertEquals($data, $this->testedConfig->get($uid, 'test', 'it', null, true));
self::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'));
self::assertEquals('default', $this->testedConfig->get($uid, 'test', 'not', 'default'));
self::assertNull($this->testedConfig->getCache()->get($uid, 'test', 'not'));
}
/**
@ -367,16 +367,16 @@ abstract class PConfigTest extends MockedTest
$this->configCache->load($uid, ['test' => ['it' => $data]]);
$this->testedConfig = $this->getInstance();
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
self::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'));
self::assertEquals($data, $this->testedConfig->get($uid, 'test', 'it'));
self::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'));
self::assertTrue($this->testedConfig->delete($uid, 'test', 'it'));
self::assertNull($this->testedConfig->get($uid, 'test', 'it'));
self::assertNull($this->testedConfig->getCache()->get($uid, 'test', 'it'));
$this->assertEmpty($this->testedConfig->getCache()->getAll());
self::assertEmpty($this->testedConfig->getCache()->getAll());
}
/**
@ -406,24 +406,24 @@ abstract class PConfigTest extends MockedTest
->once();
$this->testedConfig = $this->getInstance();
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
self::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'));
self::assertEquals('now', $this->testedConfig->get($uid, 'test', 'it'));
self::assertEquals('now', $this->testedConfig->getCache()->get($uid, 'test', 'it'));
// delete from cache only
$this->assertTrue($this->testedConfig->delete($uid, 'test', 'it'));
self::assertTrue($this->testedConfig->delete($uid, 'test', 'it'));
// delete from db only
$this->assertTrue($this->testedConfig->delete($uid, 'test', 'second'));
self::assertTrue($this->testedConfig->delete($uid, 'test', 'second'));
// no delete
$this->assertFalse($this->testedConfig->delete($uid, 'test', 'third'));
self::assertFalse($this->testedConfig->delete($uid, 'test', 'third'));
// delete both
$this->assertTrue($this->testedConfig->delete($uid, 'test', 'quarter'));
self::assertTrue($this->testedConfig->delete($uid, 'test', 'quarter'));
$this->assertEmpty($this->testedConfig->getCache()->getAll());
self::assertEmpty($this->testedConfig->getCache()->getAll());
}
public function dataMultiUid()
@ -466,12 +466,12 @@ abstract class PConfigTest extends MockedTest
$this->configCache->load($data2['uid'], $data2['data']);
$this->testedConfig = $this->getInstance();
$this->assertInstanceOf(Cache::class, $this->testedConfig->getCache());
self::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']);
self::assertConfig($data1['uid'], 'cat1', $data1['data']['cat1']);
self::assertConfig($data1['uid'], 'cat2', $data1['data']['cat2']);
self::assertConfig($data2['uid'], 'cat1', $data2['data']['cat1']);
self::assertConfig($data2['uid'], 'cat2', $data2['data']['cat2']);
}
/**
@ -485,10 +485,10 @@ abstract class PConfigTest extends MockedTest
$this->testedConfig = $this->getInstance();
$this->assertNull($this->testedConfig->get($uid, 'cat1', 'cat2'));
$this->assertEquals('fallback!', $this->testedConfig->get($uid, 'cat1', 'cat2', 'fallback!'));
self::assertNull($this->testedConfig->get($uid, 'cat1', 'cat2'));
self::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'));
self::assertFalse($this->testedConfig->set($uid, 'cat1', 'key1', 'doesn\'t matter!'));
self::assertFalse($this->testedConfig->delete($uid, 'cat1', 'key1'));
}
}

4
tests/src/Core/PConfig/PreloadPConfigTest.php
View file

@ -49,7 +49,7 @@ class PreloadPConfigTest extends PConfigTest
// Assert that every category is loaded everytime
foreach ($data as $cat => $values) {
$this->assertConfig($uid, $cat, $values);
self::assertConfig($uid, $cat, $values);
}
}
@ -71,7 +71,7 @@ class PreloadPConfigTest extends PConfigTest
// Assert that every category is loaded everytime and is NOT overwritten
foreach ($data1 as $cat => $values) {
$this->assertConfig($uid, $cat, $values);
self::assertConfig($uid, $cat, $values);
}
}

50
tests/src/Core/StorageManagerTest.php
View file

@ -87,7 +87,7 @@ class StorageManagerTest extends DatabaseTest
{
$storageManager = new StorageManager($this->dba, $this->config, $this->logger, $this->l10n);
$this->assertInstanceOf(StorageManager::class, $storageManager);
self::assertInstanceOf(StorageManager::class, $storageManager);
}
public function dataStorages()
@ -172,12 +172,12 @@ class StorageManagerTest extends DatabaseTest
$storage = $storageManager->getByName($name, $userBackend);
if (!empty($assert)) {
$this->assertInstanceOf(Storage\IStorage::class, $storage);
$this->assertInstanceOf($assert, $storage);
self::assertInstanceOf(Storage\IStorage::class, $storage);
self::assertInstanceOf($assert, $storage);
} else {
$this->assertNull($storage);
self::assertNull($storage);
}
$this->assertEquals($assertName, $storage);
self::assertEquals($assertName, $storage);
}
/**
@ -190,10 +190,10 @@ class StorageManagerTest extends DatabaseTest
$storageManager = new StorageManager($this->dba, $this->config, $this->logger, $this->l10n);
// true in every of the backends
$this->assertEquals(!empty($assertName), $storageManager->isValidBackend($name));
self::assertEquals(!empty($assertName), $storageManager->isValidBackend($name));
// if userBackend is set to true, filter out e.g. SystemRessource
$this->assertEquals($userBackend, $storageManager->isValidBackend($name, true));
self::assertEquals($userBackend, $storageManager->isValidBackend($name, true));
}
/**
@ -203,7 +203,7 @@ class StorageManagerTest extends DatabaseTest
{
$storageManager = new StorageManager($this->dba, $this->config, $this->logger, $this->l10n);
$this->assertEquals(StorageManager::DEFAULT_BACKENDS, $storageManager->listBackends());
self::assertEquals(StorageManager::DEFAULT_BACKENDS, $storageManager->listBackends());
}
/**
@ -215,12 +215,12 @@ class StorageManagerTest extends DatabaseTest
{
$storageManager = new StorageManager($this->dba, $this->config, $this->logger, $this->l10n);
$this->assertNull($storageManager->getBackend());
self::assertNull($storageManager->getBackend());
if ($userBackend) {
$storageManager->setBackend($name);
$this->assertInstanceOf($assert, $storageManager->getBackend());
self::assertInstanceOf($assert, $storageManager->getBackend());
}
}
@ -237,9 +237,9 @@ class StorageManagerTest extends DatabaseTest
$storageManager = new StorageManager($this->dba, $this->config, $this->logger, $this->l10n);
if ($userBackend) {
$this->assertInstanceOf($assert, $storageManager->getBackend());
self::assertInstanceOf($assert, $storageManager->getBackend());
} else {
$this->assertNull($storageManager->getBackend());
self::assertNull($storageManager->getBackend());
}
}
@ -261,12 +261,12 @@ class StorageManagerTest extends DatabaseTest
$storageManager = new StorageManager($this->dba, $this->config, $this->logger, $this->l10n);
$this->assertTrue($storageManager->register(SampleStorageBackend::class));
self::assertTrue($storageManager->register(SampleStorageBackend::class));
$this->assertEquals(array_merge(StorageManager::DEFAULT_BACKENDS, [
self::assertEquals(array_merge(StorageManager::DEFAULT_BACKENDS, [
SampleStorageBackend::getName() => SampleStorageBackend::class,
]), $storageManager->listBackends());
$this->assertEquals(array_merge(StorageManager::DEFAULT_BACKENDS, [
self::assertEquals(array_merge(StorageManager::DEFAULT_BACKENDS, [
SampleStorageBackend::getName() => SampleStorageBackend::class,
]), $this->config->get('storage', 'backends'));
@ -274,17 +274,17 @@ class StorageManagerTest extends DatabaseTest
SampleStorageBackend::registerHook();
Hook::loadHooks();
$this->assertTrue($storageManager->setBackend(SampleStorageBackend::NAME));
$this->assertEquals(SampleStorageBackend::NAME, $this->config->get('storage', 'name'));
self::assertTrue($storageManager->setBackend(SampleStorageBackend::NAME));
self::assertEquals(SampleStorageBackend::NAME, $this->config->get('storage', 'name'));
$this->assertInstanceOf(SampleStorageBackend::class, $storageManager->getBackend());
self::assertInstanceOf(SampleStorageBackend::class, $storageManager->getBackend());
$this->assertTrue($storageManager->unregister(SampleStorageBackend::class));
$this->assertEquals(StorageManager::DEFAULT_BACKENDS, $this->config->get('storage', 'backends'));
$this->assertEquals(StorageManager::DEFAULT_BACKENDS, $storageManager->listBackends());
self::assertTrue($storageManager->unregister(SampleStorageBackend::class));
self::assertEquals(StorageManager::DEFAULT_BACKENDS, $this->config->get('storage', 'backends'));
self::assertEquals(StorageManager::DEFAULT_BACKENDS, $storageManager->listBackends());
$this->assertNull($storageManager->getBackend());
$this->assertNull($this->config->get('storage', 'name'));
self::assertNull($storageManager->getBackend());
self::assertNull($this->config->get('storage', 'name'));
}
/**
@ -308,12 +308,12 @@ class StorageManagerTest extends DatabaseTest
while ($photo = $this->dba->fetch($photos)) {
$this->assertEmpty($photo['data']);
self::assertEmpty($photo['data']);
$storage = $storageManager->getByName($photo['backend-class']);
$data = $storage->get($photo['backend-ref']);
$this->assertNotEmpty($data);
self::assertNotEmpty($data);
}
}

10
tests/src/Core/SystemTest.php
View file

@ -42,33 +42,33 @@ class SystemTest extends TestCase
private function assertGuid($guid, $length, $prefix = '')
{
$length -= strlen($prefix);
$this->assertRegExp("/^" . $prefix . "[a-z0-9]{" . $length . "}?$/", $guid);
self::assertRegExp("/^" . $prefix . "[a-z0-9]{" . $length . "}?$/", $guid);
}
function testGuidWithoutParameter()
{
$this->useBaseUrl();
$guid = System::createGUID();
$this->assertGuid($guid, 16);
self::assertGuid($guid, 16);
}
function testGuidWithSize32()
{
$this->useBaseUrl();
$guid = System::createGUID(32);
$this->assertGuid($guid, 32);
self::assertGuid($guid, 32);
}
function testGuidWithSize64()
{
$this->useBaseUrl();
$guid = System::createGUID(64);
$this->assertGuid($guid, 64);
self::assertGuid($guid, 64);
}
function testGuidWithPrefix()
{
$guid = System::createGUID(23, 'test');
$this->assertGuid($guid, 23, 'test');
self::assertGuid($guid, 23, 'test');
}
}