Browse Source

Refactoring identities to Model\User::identities

pull/6097/head
Philipp Holzer 3 years ago
parent
commit
8ad721988b
No known key found for this signature in database GPG Key ID: 517BE60E2CE5C8A5
  1. 50
      src/Core/Authentication.php
  2. 70
      src/Model/User.php
  3. 113
      tests/Util/DBAMockTrait.php
  4. 148
      tests/src/Model/UserTest.php

50
src/Core/Authentication.php

@ -12,6 +12,7 @@ use Friendica\Core\L10n;
use Friendica\Core\Logger;
use Friendica\Core\PConfig;
use Friendica\Database\DBA;
use Friendica\Model\User;
use Friendica\Util\DateTimeFormat;
/**
@ -103,55 +104,16 @@ class Authentication extends BaseObject
$a->timezone = $a->user['timezone'];
}
$master_record = $a->user;
$masterUid = $user_record['uid'];
if ((x($_SESSION, 'submanage')) && intval($_SESSION['submanage'])) {
$user = DBA::selectFirst('user', [], ['uid' => $_SESSION['submanage']]);
$user = DBA::selectFirst('user', ['uid'], ['uid' => $_SESSION['submanage']]);
if (DBA::isResult($user)) {
$master_record = $user;
$masterUid = $user['uid'];
}
}
if ($master_record['parent-uid'] == 0) {
// First add our own entry
$a->identities = [['uid' => $master_record['uid'],
'username' => $master_record['username'],
'nickname' => $master_record['nickname']]];
// Then add all the children
$r = DBA::select('user', ['uid', 'username', 'nickname'],
['parent-uid' => $master_record['uid'], 'account_removed' => false]);
if (DBA::isResult($r)) {
$a->identities = array_merge($a->identities, DBA::toArray($r));
}
} else {
// Just ensure that the array is always defined
$a->identities = [];
// First entry is our parent
$r = DBA::select('user', ['uid', 'username', 'nickname'],
['uid' => $master_record['parent-uid'], 'account_removed' => false]);
if (DBA::isResult($r)) {
$a->identities = DBA::toArray($r);
}
// Then add all siblings
$r = DBA::select('user', ['uid', 'username', 'nickname'],
['parent-uid' => $master_record['parent-uid'], 'account_removed' => false]);
if (DBA::isResult($r)) {
$a->identities = array_merge($a->identities, DBA::toArray($r));
}
}
$r = DBA::p("SELECT `user`.`uid`, `user`.`username`, `user`.`nickname`
FROM `manage`
INNER JOIN `user` ON `manage`.`mid` = `user`.`uid`
WHERE `user`.`account_removed` = 0 AND `manage`.`uid` = ?",
$master_record['uid']
);
if (DBA::isResult($r)) {
$a->identities = array_merge($a->identities, DBA::toArray($r));
}
$a->identities = User::identities($masterUid);
if ($login_initial) {
Logger::log('auth_identities: ' . print_r($a->identities, true), Logger::DEBUG);
@ -174,7 +136,7 @@ class Authentication extends BaseObject
// Set the login date for all identities of the user
DBA::update('user', ['login_date' => DateTimeFormat::utcNow()],
['parent-uid' => $master_record['uid'], 'account_removed' => false]);
['parent-uid' => $masterUid, 'account_removed' => false]);
}
if ($login_initial) {

70
src/Model/User.php

@ -813,4 +813,74 @@ class User
$a->internalRedirect();
}
}
/**
* Return all identities to a user
*
* @param int $uid The user id
* @return array All identities for this user
*
* Example for a return:
* [
* [
* 'uid' => 1,
* 'username' => 'maxmuster',
* 'nickname' => 'Max Mustermann'
* ],
* [
* 'uid' => 2,
* 'username' => 'johndoe',
* 'nickname' => 'John Doe'
* ]
* ]
*/
public static function identities($uid)
{
$identities = [];
$user = DBA::selectFirst('user', ['uid', 'nickname', 'username', 'parent-uid'], ['uid' => $uid]);
if (!DBA::isResult($user)) {
return $identities;
}
if ($user['parent-uid'] == 0) {
// First add our own entry
$identities = [['uid' => $user['uid'],
'username' => $user['username'],
'nickname' => $user['nickname']]];
// Then add all the children
$r = DBA::select('user', ['uid', 'username', 'nickname'],
['parent-uid' => $user['uid'], 'account_removed' => false]);
if (DBA::isResult($r)) {
$identities = array_merge($identities, DBA::toArray($r));
}
} else {
// First entry is our parent
$r = DBA::select('user', ['uid', 'username', 'nickname'],
['uid' => $user['parent-uid'], 'account_removed' => false]);
if (DBA::isResult($r)) {
$identities = DBA::toArray($r);
}
// Then add all siblings
$r = DBA::select('user', ['uid', 'username', 'nickname'],
['parent-uid' => $user['parent-uid'], 'account_removed' => false]);
if (DBA::isResult($r)) {
$identities = array_merge($identities, DBA::toArray($r));
}
}
$r = DBA::p("SELECT `user`.`uid`, `user`.`username`, `user`.`nickname`
FROM `manage`
INNER JOIN `user` ON `manage`.`mid` = `user`.`uid`
WHERE `user`.`account_removed` = 0 AND `manage`.`uid` = ?",
$user['uid']
);
if (DBA::isResult($r)) {
$identities = array_merge($identities, DBA::toArray($r));
}
return $identities;
}
}

113
tests/Util/DBAMockTrait.php

@ -69,4 +69,117 @@ trait DBAMockTrait
->times($times)
->andReturn($return);
}
/**
* Mocking DBA::select()
*
* @param string $tableName The name of the table
* @param array $select The Select Array (Default is [])
* @param array $where The Where Array (Default is [])
* @param object $return The array to return (Default is [])
* @param null|int $times How often the method will get used
*/
public function mockSelect($tableName, $select = [], $where = [], $return = null, $times = null)
{
if (!isset($this->dbaMock)) {
$this->dbaMock = \Mockery::mock('alias:Friendica\Database\DBA');
}
$this->dbaMock
->shouldReceive('select')
->with($tableName, $select, $where)
->times($times)
->andReturn($return);
}
/**
* Mocking DBA::selectFirst()
*
* @param string $tableName The name of the table
* @param array $select The Select Array (Default is [])
* @param array $where The Where Array (Default is [])
* @param array $return The array to return (Default is [])
* @param null|int $times How often the method will get used
*/
public function mockSelectFirst($tableName, $select = [], $where = [], $return = [], $times = null)
{
if (!isset($this->dbaMock)) {
$this->dbaMock = \Mockery::mock('alias:Friendica\Database\DBA');
}
$this->dbaMock
->shouldReceive('selectFirst')
->with($tableName, $select, $where)
->times($times)
->andReturn($return);
}
/**
* Mocking DBA::isResult()
*
* @param object $record The record to test
* @param bool $return True, if the DB is connected, otherwise false
* @param null|int $times How often the method will get used
*/
public function mockIsResult($record, $return = true, $times = null)
{
if (!isset($this->dbaMock)) {
$this->dbaMock = \Mockery::mock('alias:Friendica\Database\DBA');
}
$this->dbaMock
->shouldReceive('isResult')
->with($record)
->times($times)
->andReturn($return);
}
/**
* Mocking DBA::isResult()
*
* @param object $record The record to test
* @param array $return The array to return
* @param null|int $times How often the method will get used
*/
public function mockToArray($record = null, $return = [], $times = null)
{
if (!isset($this->dbaMock)) {
$this->dbaMock = \Mockery::mock('alias:Friendica\Database\DBA');
}
$this->dbaMock
->shouldReceive('toArray')
->with($record)
->times($times)
->andReturn($return);
}
/**
* Mocking DBA::p()
*
* @param string $sql The SQL statement
* @param object $return The object to return
* @param null|int $times How often the method will get used
*/
public function mockP($sql = null, $return = null, $times = null)
{
if (!isset($this->dbaMock)) {
$this->dbaMock = \Mockery::mock('alias:Friendica\Database\DBA');
}
if (!isset($sql)) {
$this->dbaMock
->shouldReceive('p')
->times($times)
->andReturn($return);
} else {
$this->dbaMock
->shouldReceive('p')
->with($sql)
->times($times)
->andReturn($return);
}
}
}

148
tests/src/Model/UserTest.php

@ -0,0 +1,148 @@
<?php
namespace Friendica\Test\Object;
use Friendica\Model\User;
use Friendica\Test\MockedTest;
use Friendica\Test\Util\DBAMockTrait;
class UserTest extends MockedTest
{
use DBAMockTrait;
private $parent;
private $child;
private $manage;
protected function setUp()
{
parent::setUp();
$this->parent = [
'uid' => 1,
'username' => 'maxmuster',
'nickname' => 'Max Muster'
];
$this->child = [
'uid' => 2,
'username' => 'johndoe',
'nickname' => 'John Doe'
];
$this->manage = [
'uid' => 3,
'username' => 'janesmith',
'nickname' => 'Jane Smith'
];
}
public function testIdentitiesEmpty()
{
$this->mockSelectFirst('user',
['uid', 'nickname', 'username', 'parent-uid'],
['uid' => $this->parent['uid']],
$this->parent,
1
);
$this->mockIsResult($this->parent, false, 1);
$record = User::identities($this->parent['uid']);
$this->assertEquals([], $record);
}
public function testIdentitiesAsParent()
{
$parentSelect = $this->parent;
$parentSelect['parent-uid'] = 0;
// Select the user itself (=parent)
$this->mockSelectFirst('user',
['uid', 'nickname', 'username', 'parent-uid'],
['uid' => $this->parent['uid']],
$parentSelect,
1
);
$this->mockIsResult($parentSelect, true, 1);
// Select one child
$this->mockSelect('user',
['uid', 'username', 'nickname'],
[
'parent-uid' => $this->parent['uid'],
'account_removed' => false
],
'objectReturn',
1
);
$this->mockIsResult('objectReturn', true, 1);
$this->mockToArray('objectReturn', [ $this->child ], 1);
// Select the manage
$this->mockP(null, 'objectTwo', 1);
$this->mockIsResult('objectTwo', true, 1);
$this->mockToArray('objectTwo', [ $this->manage ], 1);
$record = User::identities($this->parent['uid']);
$this->assertEquals([
$this->parent,
$this->child,
$this->manage
], $record);
}
public function testIdentitiesAsChild()
{
$childSelect = $this->child;
$childSelect['parent-uid'] = $this->parent['uid'];
// Select the user itself (=child)
$this->mockSelectFirst('user',
['uid', 'nickname', 'username', 'parent-uid'],
['uid' => $this->child['uid']],
$childSelect,
1
);
$this->mockIsResult($childSelect, true, 1);
// Select the parent
$this->mockSelect('user',
['uid', 'username', 'nickname'],
[
'uid' => $this->parent['uid'],
'account_removed' => false
],
'objectReturn',
1
);
$this->mockIsResult('objectReturn', true, 1);
$this->mockToArray('objectReturn', [ $this->parent ], 1);
// Select the childs (user & manage)
$this->mockSelect('user',
['uid', 'username', 'nickname'],
[
'parent-uid' => $this->parent['uid'],
'account_removed' => false
],
'objectReturn',
1
);
$this->mockIsResult('objectReturn', true, 1);
$this->mockToArray('objectReturn', [ $this->child, $this->manage ], 1);
// Select the manage
$this->mockP(null, 'objectTwo', 1);
$this->mockIsResult('objectTwo', false, 1);
$record = User::identities($this->child['uid']);
$this->assertEquals([
$this->parent,
$this->child,
$this->manage
], $record);
}
}
Loading…
Cancel
Save