Friendica/friendica-github
1
0
Fork 0
mirror of https://github.com/friendica/friendica synced 2025-04-23 23:50: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

4
tests/src/Model/FileTagTest.php
View file

@ -73,7 +73,7 @@ class FileTagTest extends TestCase
*/
public function testArrayToFile(array $array, string $type, string $file)
{
$this->assertEquals($file, FileTag::arrayToFile($array, $type));
self::assertEquals($file, FileTag::arrayToFile($array, $type));
}
public function dataFileToArray()
@ -133,6 +133,6 @@ class FileTagTest extends TestCase
*/
public function testFileToArray(string $file, string $type, array $array)
{
$this->assertEquals($array, FileTag::fileToArray($file, $type));
self::assertEquals($array, FileTag::fileToArray($file, $type));
}
}

12
tests/src/Model/ProcessTest.php
View file

@ -41,22 +41,22 @@ class ProcessTest extends DatabaseTest
{
$process = new Process($this->dba);
$this->assertEquals(0, $this->dba->count('process'));
self::assertEquals(0, $this->dba->count('process'));
$process->insert('test', 1);
$process->insert('test2', 2);
$process->insert('test3', 3);
$this->assertEquals(3, $this->dba->count('process'));
self::assertEquals(3, $this->dba->count('process'));
$this->assertEquals([
self::assertEquals([
['command' => 'test']
], $this->dba->selectToArray('process', ['command'], ['pid' => 1]));
$process->deleteByPid(1);
$this->assertEmpty($this->dba->selectToArray('process', ['command'], ['pid' => 1]));
self::assertEmpty($this->dba->selectToArray('process', ['command'], ['pid' => 1]));
$this->assertEquals(2, $this->dba->count('process'));
self::assertEquals(2, $this->dba->count('process'));
}
public function testDoubleInsert()
@ -68,7 +68,7 @@ class ProcessTest extends DatabaseTest
// double insert doesn't work
$process->insert('test23', 1);
$this->assertEquals([['command' => 'test']], $this->dba->selectToArray('process', ['command'], ['pid' => 1]));
self::assertEquals([['command' => 'test']], $this->dba->selectToArray('process', ['command'], ['pid' => 1]));
}
public function testWrongDelete()

2
tests/src/Model/Storage/DatabaseStorageTest.php
View file

@ -66,6 +66,6 @@ class DatabaseStorageTest extends StorageTest
protected function assertOption(IStorage $storage)
{
$this->assertEmpty($storage->getOptions());
self::assertEmpty($storage->getOptions());
}
}

12
tests/src/Model/Storage/FilesystemStorageTest.php
View file

@ -66,7 +66,7 @@ class FilesystemStorageTest extends StorageTest
protected function assertOption(IStorage $storage)
{
$this->assertEquals([
self::assertEquals([
'storagepath' => [
'input', 'Storage base path',
$this->root->getChild('storage')->url(),
@ -119,12 +119,12 @@ class FilesystemStorageTest extends StorageTest
$dir = $this->root->getChild('storage/f0/c0')->url();
$file = $this->root->getChild('storage/f0/c0/d0i0')->url();
$this->assertDirectoryExists($dir);
$this->assertFileExists($file);
self::assertDirectoryExists($dir);
self::assertFileExists($file);
$this->assertDirectoryIsWritable($dir);
$this->assertFileIsWritable($file);
self::assertDirectoryIsWritable($dir);
self::assertFileIsWritable($file);
$this->assertEquals('test', file_get_contents($file));
self::assertEquals('test', file_get_contents($file));
}
}

22
tests/src/Model/Storage/StorageTest.php
View file

@ -37,7 +37,7 @@ abstract class StorageTest extends MockedTest
public function testInstance()
{
$instance = $this->getInstance();
$this->assertInstanceOf(IStorage::class, $instance);
self::assertInstanceOf(IStorage::class, $instance);
}
/**
@ -58,11 +58,11 @@ abstract class StorageTest extends MockedTest
$instance = $this->getInstance();
$ref = $instance->put('data12345');
$this->assertNotEmpty($ref);
self::assertNotEmpty($ref);
$this->assertEquals('data12345', $instance->get($ref));
self::assertEquals('data12345', $instance->get($ref));
$this->assertTrue($instance->delete($ref));
self::assertTrue($instance->delete($ref));
}
/**
@ -73,7 +73,7 @@ abstract class StorageTest extends MockedTest
$instance = $this->getInstance();
// Even deleting not existing references should return "true"
$this->assertTrue($instance->delete(-1234456));
self::assertTrue($instance->delete(-1234456));
}
/**
@ -84,7 +84,7 @@ abstract class StorageTest extends MockedTest
$instance = $this->getInstance();
// Invalid references return an empty string
$this->assertEmpty($instance->get(-123456));
self::assertEmpty($instance->get(-123456));
}
/**
@ -95,12 +95,12 @@ abstract class StorageTest extends MockedTest
$instance = $this->getInstance();
$ref = $instance->put('data12345');
$this->assertNotEmpty($ref);
self::assertNotEmpty($ref);
$this->assertEquals('data12345', $instance->get($ref));
self::assertEquals('data12345', $instance->get($ref));
$this->assertEquals($ref, $instance->put('data5432', $ref));
$this->assertEquals('data5432', $instance->get($ref));
self::assertEquals($ref, $instance->put('data5432', $ref));
self::assertEquals('data5432', $instance->get($ref));
}
/**
@ -110,6 +110,6 @@ abstract class StorageTest extends MockedTest
{
$instance = $this->getInstance();
$this->assertEquals(-123, $instance->put('data12345', -123));
self::assertEquals(-123, $instance->put('data12345', -123));
}
}

66
tests/src/Model/User/CookieTest.php
View file

@ -60,7 +60,7 @@ class CookieTest extends MockedTest
$this->config->shouldReceive('get')->with('system', 'auth_cookie_lifetime', Cookie::DEFAULT_EXPIRE)->andReturn('7')->once();
$cookie = new Cookie($this->config, $this->baseUrl);
$this->assertInstanceOf(Cookie::class, $cookie);
self::assertInstanceOf(Cookie::class, $cookie);
}
public function dataGet()
@ -124,31 +124,31 @@ class CookieTest extends MockedTest
$this->config->shouldReceive('get')->with('system', 'auth_cookie_lifetime', Cookie::DEFAULT_EXPIRE)->andReturn('7')->once();
$cookie = new Cookie($this->config, $this->baseUrl, [], $cookieData);
$this->assertInstanceOf(Cookie::class, $cookie);
self::assertInstanceOf(Cookie::class, $cookie);
$assertData = $cookie->getData();
if (!$hasValues) {
$this->assertEmpty($assertData);
self::assertEmpty($assertData);
} else {
$this->assertNotEmpty($assertData);
self::assertNotEmpty($assertData);
if (isset($uid)) {
$this->assertObjectHasAttribute('uid', $assertData);
$this->assertEquals($uid, $assertData->uid);
self::assertObjectHasAttribute('uid', $assertData);
self::assertEquals($uid, $assertData->uid);
} else {
$this->assertObjectNotHasAttribute('uid', $assertData);
self::assertObjectNotHasAttribute('uid', $assertData);
}
if (isset($hash)) {
$this->assertObjectHasAttribute('hash', $assertData);
$this->assertEquals($hash, $assertData->hash);
self::assertObjectHasAttribute('hash', $assertData);
self::assertEquals($hash, $assertData->hash);
} else {
$this->assertObjectNotHasAttribute('hash', $assertData);
self::assertObjectNotHasAttribute('hash', $assertData);
}
if (isset($ip)) {
$this->assertObjectHasAttribute('ip', $assertData);
$this->assertEquals($ip, $assertData->ip);
self::assertObjectHasAttribute('ip', $assertData);
self::assertEquals($ip, $assertData->ip);
} else {
$this->assertObjectNotHasAttribute('ip', $assertData);
self::assertObjectNotHasAttribute('ip', $assertData);
}
}
}
@ -192,9 +192,9 @@ class CookieTest extends MockedTest
$this->config->shouldReceive('get')->with('system', 'auth_cookie_lifetime', Cookie::DEFAULT_EXPIRE)->andReturn('7')->once();
$cookie = new Cookie($this->config, $this->baseUrl);
$this->assertInstanceOf(Cookie::class, $cookie);
self::assertInstanceOf(Cookie::class, $cookie);
$this->assertEquals($assertTrue, $cookie->check($assertHash, $password, $userPrivateKey));
self::assertEquals($assertTrue, $cookie->check($assertHash, $password, $userPrivateKey));
}
public function dataSet()
@ -245,21 +245,21 @@ class CookieTest extends MockedTest
public function assertCookie($uid, $hash, $remoteIp, $lifetime)
{
$this->assertArrayHasKey(Cookie::NAME, StaticCookie::$_COOKIE);
self::assertArrayHasKey(Cookie::NAME, StaticCookie::$_COOKIE);
$data = json_decode(StaticCookie::$_COOKIE[Cookie::NAME]);
$this->assertObjectHasAttribute('uid', $data);
$this->assertEquals($uid, $data->uid);
$this->assertObjectHasAttribute('hash', $data);
$this->assertEquals($hash, $data->hash);
$this->assertObjectHasAttribute('ip', $data);
$this->assertEquals($remoteIp, $data->ip);
self::assertObjectHasAttribute('uid', $data);
self::assertEquals($uid, $data->uid);
self::assertObjectHasAttribute('hash', $data);
self::assertEquals($hash, $data->hash);
self::assertObjectHasAttribute('ip', $data);
self::assertEquals($remoteIp, $data->ip);
if (isset($lifetime) && $lifetime !== 0) {
$this->assertLessThanOrEqual(time() + $lifetime, StaticCookie::$_EXPIRE);
self::assertLessThanOrEqual(time() + $lifetime, StaticCookie::$_EXPIRE);
} else {
$this->assertLessThanOrEqual(time() + Cookie::DEFAULT_EXPIRE * 24 * 60 * 60, StaticCookie::$_EXPIRE);
self::assertLessThanOrEqual(time() + Cookie::DEFAULT_EXPIRE * 24 * 60 * 60, StaticCookie::$_EXPIRE);
}
}
@ -275,11 +275,11 @@ class CookieTest extends MockedTest
$this->config->shouldReceive('get')->with('system', 'auth_cookie_lifetime', Cookie::DEFAULT_EXPIRE)->andReturn(Cookie::DEFAULT_EXPIRE)->once();
$cookie = new StaticCookie($this->config, $this->baseUrl, $serverArray);
$this->assertInstanceOf(Cookie::class, $cookie);
self::assertInstanceOf(Cookie::class, $cookie);
$cookie->set($uid, $password, $privateKey, $lifetime);
$this->assertCookie($uid, $assertHash, $remoteIp, $lifetime);
self::assertCookie($uid, $assertHash, $remoteIp, $lifetime);
}
/**
@ -294,14 +294,14 @@ class CookieTest extends MockedTest
$this->config->shouldReceive('get')->with('system', 'auth_cookie_lifetime', Cookie::DEFAULT_EXPIRE)->andReturn(Cookie::DEFAULT_EXPIRE)->once();
$cookie = new StaticCookie($this->config, $this->baseUrl, $serverArray);
$this->assertInstanceOf(Cookie::class, $cookie);
self::assertInstanceOf(Cookie::class, $cookie);
// Invalid set, should get overwritten
$cookie->set(-1, 'invalid', 'nothing', -234);
$cookie->set($uid, $password, $privateKey, $lifetime);
$this->assertCookie($uid, $assertHash, $remoteIp, $lifetime);
self::assertCookie($uid, $assertHash, $remoteIp, $lifetime);
}
/**
@ -318,14 +318,14 @@ class CookieTest extends MockedTest
$this->config->shouldReceive('get')->with('system', 'auth_cookie_lifetime', Cookie::DEFAULT_EXPIRE)->andReturn(Cookie::DEFAULT_EXPIRE)->once();
$cookie = new StaticCookie($this->config, $this->baseUrl);
$this->assertInstanceOf(Cookie::class, $cookie);
self::assertInstanceOf(Cookie::class, $cookie);
$this->assertEquals('test', StaticCookie::$_COOKIE[Cookie::NAME]);
$this->assertEquals(null, StaticCookie::$_EXPIRE);
self::assertEquals('test', StaticCookie::$_COOKIE[Cookie::NAME]);
self::assertEquals(null, StaticCookie::$_EXPIRE);
$cookie->clear();
$this->assertEmpty(StaticCookie::$_COOKIE[Cookie::NAME]);
$this->assertEquals(-3600, StaticCookie::$_EXPIRE);
self::assertEmpty(StaticCookie::$_COOKIE[Cookie::NAME]);
self::assertEquals(-3600, StaticCookie::$_EXPIRE);
}
}

6
tests/src/Model/UserTest.php
View file

@ -72,7 +72,7 @@ class UserTest extends MockedTest
$record = User::identities($this->parent['uid']);
$this->assertEquals([], $record);
self::assertEquals([], $record);
}
public function testIdentitiesAsParent()
@ -109,7 +109,7 @@ class UserTest extends MockedTest
$record = User::identities($this->parent['uid']);
$this->assertEquals([
self::assertEquals([
$this->parent,
$this->child,
$this->manage
@ -162,7 +162,7 @@ class UserTest extends MockedTest
$record = User::identities($this->child['uid']);
$this->assertEquals([
self::assertEquals([
$this->parent,
$this->child,
$this->manage