2016-11-16 21:01:57 +03:00
|
|
|
<?php
|
|
|
|
/**
|
|
|
|
* @author Björn Schießle <schiessle@owncloud.com>
|
|
|
|
*
|
|
|
|
* @copyright Copyright (c) 2016, ownCloud, Inc.
|
|
|
|
* @license AGPL-3.0
|
|
|
|
*
|
|
|
|
* This code is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU Affero General Public License, version 3,
|
|
|
|
* as published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU Affero General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Affero General Public License, version 3,
|
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
namespace Test\Accounts;
|
|
|
|
|
|
|
|
|
2018-10-12 10:30:44 +03:00
|
|
|
use OC\Accounts\Account;
|
2016-11-16 21:01:57 +03:00
|
|
|
use OC\Accounts\AccountManager;
|
2017-04-24 16:01:39 +03:00
|
|
|
use OCP\BackgroundJob\IJobList;
|
2016-11-16 21:01:57 +03:00
|
|
|
use OCP\IUser;
|
|
|
|
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
|
2017-04-10 11:22:57 +03:00
|
|
|
use Symfony\Component\EventDispatcher\GenericEvent;
|
2016-11-16 21:01:57 +03:00
|
|
|
use Test\TestCase;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Class AccountsManagerTest
|
|
|
|
*
|
|
|
|
* @group DB
|
|
|
|
* @package Test\Accounts
|
|
|
|
*/
|
|
|
|
class AccountsManagerTest extends TestCase {
|
|
|
|
|
|
|
|
/** @var \OCP\IDBConnection */
|
|
|
|
private $connection;
|
|
|
|
|
|
|
|
/** @var EventDispatcherInterface | \PHPUnit_Framework_MockObject_MockObject */
|
|
|
|
private $eventDispatcher;
|
|
|
|
|
2017-04-24 16:01:39 +03:00
|
|
|
/** @var IJobList | \PHPUnit_Framework_MockObject_MockObject */
|
|
|
|
private $jobList;
|
|
|
|
|
2016-11-16 21:01:57 +03:00
|
|
|
/** @var string accounts table name */
|
|
|
|
private $table = 'accounts';
|
|
|
|
|
|
|
|
public function setUp() {
|
|
|
|
parent::setUp();
|
|
|
|
$this->eventDispatcher = $this->getMockBuilder('Symfony\Component\EventDispatcher\EventDispatcherInterface')
|
|
|
|
->disableOriginalConstructor()->getMock();
|
|
|
|
$this->connection = \OC::$server->getDatabaseConnection();
|
2017-04-24 16:01:39 +03:00
|
|
|
$this->jobList = $this->getMockBuilder(IJobList::class)->getMock();
|
2016-11-16 21:01:57 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
public function tearDown() {
|
|
|
|
parent::tearDown();
|
|
|
|
$query = $this->connection->getQueryBuilder();
|
|
|
|
$query->delete($this->table)->execute();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* get a instance of the accountManager
|
|
|
|
*
|
|
|
|
* @param array $mockedMethods list of methods which should be mocked
|
|
|
|
* @return \PHPUnit_Framework_MockObject_MockObject | AccountManager
|
|
|
|
*/
|
|
|
|
public function getInstance($mockedMethods = null) {
|
2017-10-24 16:26:53 +03:00
|
|
|
return $this->getMockBuilder(AccountManager::class)
|
2017-04-24 16:01:39 +03:00
|
|
|
->setConstructorArgs([$this->connection, $this->eventDispatcher, $this->jobList])
|
2016-11-16 21:01:57 +03:00
|
|
|
->setMethods($mockedMethods)
|
|
|
|
->getMock();
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @dataProvider dataTrueFalse
|
2017-04-24 16:01:39 +03:00
|
|
|
*
|
|
|
|
* @param array $newData
|
|
|
|
* @param array $oldData
|
|
|
|
* @param bool $insertNew
|
|
|
|
* @param bool $updateExisting
|
2016-11-16 21:01:57 +03:00
|
|
|
*/
|
2017-04-24 16:01:39 +03:00
|
|
|
public function testUpdateUser($newData, $oldData, $insertNew, $updateExisting) {
|
|
|
|
$accountManager = $this->getInstance(['getUser', 'insertNewUser', 'updateExistingUser', 'updateVerifyStatus', 'checkEmailVerification']);
|
2017-04-10 11:22:57 +03:00
|
|
|
/** @var IUser $user */
|
|
|
|
$user = $this->createMock(IUser::class);
|
2016-11-16 21:01:57 +03:00
|
|
|
|
2016-11-23 23:19:06 +03:00
|
|
|
$accountManager->expects($this->once())->method('getUser')->with($user)->willReturn($oldData);
|
2016-11-16 21:01:57 +03:00
|
|
|
|
2017-04-24 16:01:39 +03:00
|
|
|
if ($updateExisting) {
|
|
|
|
$accountManager->expects($this->once())->method('checkEmailVerification')
|
2017-04-26 16:20:41 +03:00
|
|
|
->with($oldData, $newData, $user)->willReturn($newData);
|
2017-04-24 16:01:39 +03:00
|
|
|
$accountManager->expects($this->once())->method('updateVerifyStatus')
|
|
|
|
->with($oldData, $newData)->willReturn($newData);
|
2016-11-16 21:01:57 +03:00
|
|
|
$accountManager->expects($this->once())->method('updateExistingUser')
|
2016-11-23 23:19:06 +03:00
|
|
|
->with($user, $newData);
|
2016-11-16 21:01:57 +03:00
|
|
|
$accountManager->expects($this->never())->method('insertNewUser');
|
2016-11-23 23:19:06 +03:00
|
|
|
}
|
|
|
|
if ($insertNew) {
|
2016-11-16 21:01:57 +03:00
|
|
|
$accountManager->expects($this->once())->method('insertNewUser')
|
2016-11-23 23:19:06 +03:00
|
|
|
->with($user, $newData);
|
2016-11-16 21:01:57 +03:00
|
|
|
$accountManager->expects($this->never())->method('updateExistingUser');
|
|
|
|
}
|
|
|
|
|
2017-04-24 16:01:39 +03:00
|
|
|
if (!$insertNew && !$updateExisting) {
|
2016-11-23 23:19:06 +03:00
|
|
|
$accountManager->expects($this->never())->method('updateExistingUser');
|
2017-04-24 16:01:39 +03:00
|
|
|
$accountManager->expects($this->never())->method('checkEmailVerification');
|
|
|
|
$accountManager->expects($this->never())->method('updateVerifyStatus');
|
2016-11-23 23:19:06 +03:00
|
|
|
$accountManager->expects($this->never())->method('insertNewUser');
|
|
|
|
$this->eventDispatcher->expects($this->never())->method('dispatch');
|
|
|
|
} else {
|
|
|
|
$this->eventDispatcher->expects($this->once())->method('dispatch')
|
|
|
|
->willReturnCallback(
|
2017-04-10 11:22:57 +03:00
|
|
|
function ($eventName, $event) use ($user, $newData) {
|
2016-11-23 23:19:06 +03:00
|
|
|
$this->assertSame('OC\AccountManager::userUpdated', $eventName);
|
2017-04-10 11:22:57 +03:00
|
|
|
$this->assertInstanceOf(GenericEvent::class, $event);
|
|
|
|
/** @var GenericEvent $event */
|
|
|
|
$this->assertSame($user, $event->getSubject());
|
|
|
|
$this->assertSame($newData, $event->getArguments());
|
2016-11-23 23:19:06 +03:00
|
|
|
}
|
|
|
|
);
|
|
|
|
}
|
2016-11-16 21:01:57 +03:00
|
|
|
|
2016-11-23 23:19:06 +03:00
|
|
|
$accountManager->updateUser($user, $newData);
|
2016-11-16 21:01:57 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
public function dataTrueFalse() {
|
|
|
|
return [
|
2016-11-23 23:19:06 +03:00
|
|
|
[['newData'], ['oldData'], false, true],
|
|
|
|
[['newData'], [], true, false],
|
|
|
|
[['oldData'], ['oldData'], false, false]
|
2016-11-16 21:01:57 +03:00
|
|
|
];
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @dataProvider dataTestGetUser
|
|
|
|
*
|
|
|
|
* @param string $setUser
|
|
|
|
* @param array $setData
|
|
|
|
* @param IUser $askUser
|
|
|
|
* @param array $expectedData
|
2017-10-24 16:26:53 +03:00
|
|
|
* @param bool $userAlreadyExists
|
2016-11-16 21:01:57 +03:00
|
|
|
*/
|
|
|
|
public function testGetUser($setUser, $setData, $askUser, $expectedData, $userAlreadyExists) {
|
2017-04-24 16:01:39 +03:00
|
|
|
$accountManager = $this->getInstance(['buildDefaultUserRecord', 'insertNewUser', 'addMissingDefaultValues']);
|
2016-11-16 21:01:57 +03:00
|
|
|
if (!$userAlreadyExists) {
|
|
|
|
$accountManager->expects($this->once())->method('buildDefaultUserRecord')
|
|
|
|
->with($askUser)->willReturn($expectedData);
|
|
|
|
$accountManager->expects($this->once())->method('insertNewUser')
|
|
|
|
->with($askUser, $expectedData);
|
|
|
|
}
|
2017-04-24 16:01:39 +03:00
|
|
|
|
|
|
|
if(empty($expectedData)) {
|
|
|
|
$accountManager->expects($this->never())->method('addMissingDefaultValues');
|
|
|
|
|
|
|
|
} else {
|
|
|
|
$accountManager->expects($this->once())->method('addMissingDefaultValues')->with($expectedData)
|
|
|
|
->willReturn($expectedData);
|
|
|
|
}
|
|
|
|
|
2016-11-16 21:01:57 +03:00
|
|
|
$this->addDummyValuesToTable($setUser, $setData);
|
|
|
|
$this->assertEquals($expectedData,
|
|
|
|
$accountManager->getUser($askUser)
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
public function dataTestGetUser() {
|
2017-10-24 16:26:53 +03:00
|
|
|
$user1 = $this->getMockBuilder(IUser::class)->getMock();
|
2016-11-16 21:01:57 +03:00
|
|
|
$user1->expects($this->any())->method('getUID')->willReturn('user1');
|
2017-10-24 16:26:53 +03:00
|
|
|
$user2 = $this->getMockBuilder(IUser::class)->getMock();
|
2016-11-16 21:01:57 +03:00
|
|
|
$user2->expects($this->any())->method('getUID')->willReturn('user2');
|
|
|
|
return [
|
|
|
|
['user1', ['key' => 'value'], $user1, ['key' => 'value'], true],
|
|
|
|
['user1', ['key' => 'value'], $user2, [], false],
|
|
|
|
];
|
|
|
|
}
|
|
|
|
|
|
|
|
public function testUpdateExistingUser() {
|
2017-10-24 16:26:53 +03:00
|
|
|
$user = $this->getMockBuilder(IUser::class)->getMock();
|
2016-11-16 21:01:57 +03:00
|
|
|
$user->expects($this->once())->method('getUID')->willReturn('uid');
|
|
|
|
$oldData = ['key' => 'value'];
|
|
|
|
$newData = ['newKey' => 'newValue'];
|
|
|
|
|
|
|
|
$accountManager = $this->getInstance();
|
|
|
|
$this->addDummyValuesToTable('uid', $oldData);
|
|
|
|
$this->invokePrivate($accountManager, 'updateExistingUser', [$user, $newData]);
|
|
|
|
$newDataFromTable = $this->getDataFromTable('uid');
|
|
|
|
$this->assertEquals($newData, $newDataFromTable);
|
|
|
|
}
|
|
|
|
|
|
|
|
public function testInsertNewUser() {
|
2017-10-24 16:26:53 +03:00
|
|
|
$user = $this->getMockBuilder(IUser::class)->getMock();
|
2016-11-16 21:01:57 +03:00
|
|
|
$uid = 'uid';
|
|
|
|
$data = ['key' => 'value'];
|
|
|
|
|
|
|
|
$accountManager = $this->getInstance();
|
|
|
|
$user->expects($this->once())->method('getUID')->willReturn($uid);
|
|
|
|
$this->assertNull($this->getDataFromTable($uid));
|
|
|
|
$this->invokePrivate($accountManager, 'insertNewUser', [$user, $data]);
|
|
|
|
|
|
|
|
$dataFromDb = $this->getDataFromTable($uid);
|
|
|
|
$this->assertEquals($data, $dataFromDb);
|
|
|
|
}
|
|
|
|
|
2017-04-24 16:01:39 +03:00
|
|
|
public function testAddMissingDefaultValues() {
|
|
|
|
|
|
|
|
$accountManager = $this->getInstance();
|
|
|
|
|
|
|
|
$input = [
|
|
|
|
'key1' => ['value' => 'value1', 'verified' => '0'],
|
|
|
|
'key2' => ['value' => 'value1'],
|
|
|
|
];
|
|
|
|
|
|
|
|
$expected = [
|
|
|
|
'key1' => ['value' => 'value1', 'verified' => '0'],
|
|
|
|
'key2' => ['value' => 'value1', 'verified' => '0'],
|
|
|
|
];
|
|
|
|
|
|
|
|
$result = $this->invokePrivate($accountManager, 'addMissingDefaultValues', [$input]);
|
|
|
|
|
|
|
|
$this->assertSame($expected, $result);
|
|
|
|
}
|
|
|
|
|
2016-11-16 21:01:57 +03:00
|
|
|
private function addDummyValuesToTable($uid, $data) {
|
|
|
|
|
|
|
|
$query = $this->connection->getQueryBuilder();
|
|
|
|
$query->insert($this->table)
|
|
|
|
->values(
|
|
|
|
[
|
|
|
|
'uid' => $query->createNamedParameter($uid),
|
|
|
|
'data' => $query->createNamedParameter(json_encode($data)),
|
|
|
|
]
|
|
|
|
)
|
|
|
|
->execute();
|
|
|
|
}
|
|
|
|
|
|
|
|
private function getDataFromTable($uid) {
|
|
|
|
$query = $this->connection->getQueryBuilder();
|
|
|
|
$query->select('data')->from($this->table)
|
|
|
|
->where($query->expr()->eq('uid', $query->createParameter('uid')))
|
|
|
|
->setParameter('uid', $uid);
|
|
|
|
$query->execute();
|
|
|
|
$result = $query->execute()->fetchAll();
|
|
|
|
|
|
|
|
if (!empty($result)) {
|
|
|
|
return json_decode($result[0]['data'], true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-12 10:30:44 +03:00
|
|
|
public function testGetAccount() {
|
|
|
|
$accountManager = $this->getInstance(['getUser']);
|
|
|
|
/** @var IUser $user */
|
|
|
|
$user = $this->createMock(IUser::class);
|
|
|
|
|
|
|
|
$data = [
|
|
|
|
AccountManager::PROPERTY_TWITTER =>
|
|
|
|
[
|
|
|
|
'value' => '@twitterhandle',
|
|
|
|
'scope' => AccountManager::VISIBILITY_PRIVATE,
|
|
|
|
'verified' => AccountManager::NOT_VERIFIED,
|
|
|
|
],
|
|
|
|
AccountManager::PROPERTY_EMAIL =>
|
|
|
|
[
|
|
|
|
'value' => 'test@example.com',
|
|
|
|
'scope' => AccountManager::VISIBILITY_PUBLIC,
|
|
|
|
'verified' => AccountManager::VERIFICATION_IN_PROGRESS,
|
|
|
|
],
|
|
|
|
AccountManager::PROPERTY_WEBSITE =>
|
|
|
|
[
|
|
|
|
'value' => 'https://example.com',
|
|
|
|
'scope' => AccountManager::VISIBILITY_CONTACTS_ONLY,
|
|
|
|
'verified' => AccountManager::VERIFIED,
|
|
|
|
],
|
|
|
|
];
|
|
|
|
$expected = new Account($user);
|
|
|
|
$expected->setProperty(AccountManager::PROPERTY_TWITTER, '@twitterhandle', AccountManager::VISIBILITY_PRIVATE, AccountManager::NOT_VERIFIED);
|
|
|
|
$expected->setProperty(AccountManager::PROPERTY_EMAIL, 'test@example.com', AccountManager::VISIBILITY_PUBLIC, AccountManager::VERIFICATION_IN_PROGRESS);
|
|
|
|
$expected->setProperty(AccountManager::PROPERTY_WEBSITE, 'https://example.com', AccountManager::VISIBILITY_CONTACTS_ONLY, AccountManager::VERIFIED);
|
|
|
|
|
|
|
|
$accountManager->expects($this->once())
|
|
|
|
->method('getUser')
|
|
|
|
->willReturn($data);
|
|
|
|
$this->assertEquals($expected, $accountManager->getAccount($user));
|
|
|
|
}
|
|
|
|
|
2016-11-16 21:01:57 +03:00
|
|
|
}
|