aboutsummaryrefslogtreecommitdiffstats
path: root/tests/lib/Group/ManagerTest.php
diff options
context:
space:
mode:
Diffstat (limited to 'tests/lib/Group/ManagerTest.php')
-rw-r--r--tests/lib/Group/ManagerTest.php770
1 files changed, 426 insertions, 344 deletions
diff --git a/tests/lib/Group/ManagerTest.php b/tests/lib/Group/ManagerTest.php
index 1a7ced5f1ba..8515ef0e3e8 100644
--- a/tests/lib/Group/ManagerTest.php
+++ b/tests/lib/Group/ManagerTest.php
@@ -1,97 +1,121 @@
<?php
/**
- * @author Robin Appelman <icewind@owncloud.com>
- * @author Vincent Petry <pvince81@owncloud.com>
- *
- * @copyright Copyright (c) 2016, ownCloud GmbH.
- * @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/>
- *
+ * SPDX-FileCopyrightText: 2016-2024 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-FileCopyrightText: 2016 ownCloud, Inc.
+ * SPDX-License-Identifier: AGPL-3.0-only
*/
+
namespace Test\Group;
+use OC\Group\Database;
use OC\User\Manager;
-use OCP\IUser;
+use OC\User\User;
+use OCP\EventDispatcher\IEventDispatcher;
+use OCP\Group\Backend\ABackend;
+use OCP\Group\Backend\IAddToGroupBackend;
+use OCP\Group\Backend\ICreateGroupBackend;
+use OCP\Group\Backend\IGroupDetailsBackend;
+use OCP\Group\Backend\IRemoveFromGroupBackend;
+use OCP\Group\Backend\ISearchableGroupBackend;
use OCP\GroupInterface;
+use OCP\ICacheFactory;
+use OCP\IUser;
+use OCP\Security\Ip\IRemoteAddress;
+use PHPUnit\Framework\MockObject\MockObject;
+use Psr\Log\LoggerInterface;
+use Test\TestCase;
-class ManagerTest extends \Test\TestCase {
- /** @var Manager|\PHPUnit_Framework_MockObject_MockObject $userManager */
- protected $userManager;
+abstract class TestBackend extends ABackend implements ISearchableGroupBackend, IAddToGroupBackend, ICreateGroupBackend, IGroupDetailsBackend, IRemoveFromGroupBackend, GroupInterface {
- protected function setUp() {
+}
+
+class ManagerTest extends TestCase {
+ /** @var Manager|MockObject */
+ protected $userManager;
+ /** @var IEventDispatcher|MockObject */
+ protected $dispatcher;
+ /** @var LoggerInterface|MockObject */
+ protected $logger;
+ /** @var ICacheFactory|MockObject */
+ private $cache;
+ /** @var IRemoteAddress|MockObject */
+ private $remoteIpAddress;
+
+ protected function setUp(): void {
parent::setUp();
$this->userManager = $this->createMock(Manager::class);
+ $this->dispatcher = $this->createMock(IEventDispatcher::class);
+ $this->logger = $this->createMock(LoggerInterface::class);
+ $this->cache = $this->createMock(ICacheFactory::class);
+
+ $this->remoteIpAddress = $this->createMock(IRemoteAddress::class);
+ $this->remoteIpAddress->method('allowsAdminActions')->willReturn(true);
}
private function getTestUser($userId) {
$mockUser = $this->createMock(IUser::class);
$mockUser->expects($this->any())
->method('getUID')
- ->will($this->returnValue($userId));
+ ->willReturn($userId);
$mockUser->expects($this->any())
->method('getDisplayName')
- ->will($this->returnValue($userId));
+ ->willReturn($userId);
return $mockUser;
}
+ /**
+ * @param null|int $implementedActions
+ * @return \PHPUnit\Framework\MockObject\MockObject
+ */
private function getTestBackend($implementedActions = null) {
- if (is_null($implementedActions)) {
- $implementedActions =
- GroupInterface::ADD_TO_GROUP |
- GroupInterface::REMOVE_FROM_GOUP |
- GroupInterface::COUNT_USERS |
- GroupInterface::CREATE_GROUP |
- GroupInterface::DELETE_GROUP;
+ if ($implementedActions === null) {
+ $implementedActions
+ = GroupInterface::ADD_TO_GROUP
+ | GroupInterface::REMOVE_FROM_GOUP
+ | GroupInterface::COUNT_USERS
+ | GroupInterface::CREATE_GROUP
+ | GroupInterface::DELETE_GROUP;
}
// need to declare it this way due to optional methods
// thanks to the implementsActions logic
- $backend = $this->getMockBuilder(\OCP\GroupInterface::class)
+ $backend = $this->getMockBuilder(TestBackend::class)
->disableOriginalConstructor()
- ->setMethods([
+ ->onlyMethods([
'getGroupDetails',
'implementsActions',
'getUserGroups',
'inGroup',
'getGroups',
'groupExists',
+ 'groupsExists',
'usersInGroup',
'createGroup',
'addToGroup',
'removeFromGroup',
+ 'searchInGroup',
])
->getMock();
$backend->expects($this->any())
->method('implementsActions')
- ->will($this->returnCallback(function($actions) use ($implementedActions) {
+ ->willReturnCallback(function ($actions) use ($implementedActions) {
return (bool)($actions & $implementedActions);
- }));
+ });
return $backend;
}
- public function testGet() {
+ public function testGet(): void {
/**
- * @var \PHPUnit_Framework_MockObject_MockObject | \OC\Group\Backend $backend
+ * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
*/
$backend = $this->getTestBackend();
$backend->expects($this->any())
->method('groupExists')
->with('group1')
- ->will($this->returnValue(true));
+ ->willReturn(true);
- $manager = new \OC\Group\Manager($this->userManager);
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
$manager->addBackend($backend);
$group = $manager->get('group1');
@@ -99,33 +123,33 @@ class ManagerTest extends \Test\TestCase {
$this->assertEquals('group1', $group->getGID());
}
- public function testGetNoBackend() {
- $manager = new \OC\Group\Manager($this->userManager);
+ public function testGetNoBackend(): void {
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
$this->assertNull($manager->get('group1'));
}
- public function testGetNotExists() {
+ public function testGetNotExists(): void {
/**
- * @var \PHPUnit_Framework_MockObject_MockObject | \OC\Group\Backend $backend
+ * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
*/
$backend = $this->getTestBackend();
$backend->expects($this->once())
->method('groupExists')
->with('group1')
- ->will($this->returnValue(false));
+ ->willReturn(false);
- $manager = new \OC\Group\Manager($this->userManager);
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
$manager->addBackend($backend);
$this->assertNull($manager->get('group1'));
}
- public function testGetDeleted() {
+ public function testGetDeleted(): void {
$backend = new \Test\Util\Group\Dummy();
$backend->createGroup('group1');
- $manager = new \OC\Group\Manager($this->userManager);
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
$manager->addBackend($backend);
$group = $manager->get('group1');
@@ -133,26 +157,26 @@ class ManagerTest extends \Test\TestCase {
$this->assertNull($manager->get('group1'));
}
- public function testGetMultipleBackends() {
+ public function testGetMultipleBackends(): void {
/**
- * @var \PHPUnit_Framework_MockObject_MockObject | \OC\Group\Backend $backend1
+ * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend1
*/
$backend1 = $this->getTestBackend();
$backend1->expects($this->any())
->method('groupExists')
->with('group1')
- ->will($this->returnValue(false));
+ ->willReturn(false);
/**
- * @var \PHPUnit_Framework_MockObject_MockObject | \OC\Group\Backend $backend2
+ * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend2
*/
$backend2 = $this->getTestBackend();
$backend2->expects($this->any())
->method('groupExists')
->with('group1')
- ->will($this->returnValue(true));
+ ->willReturn(true);
- $manager = new \OC\Group\Manager($this->userManager);
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
$manager->addBackend($backend1);
$manager->addBackend($backend2);
@@ -161,410 +185,519 @@ class ManagerTest extends \Test\TestCase {
$this->assertEquals('group1', $group->getGID());
}
- public function testCreate() {
- /**
- * @var \PHPUnit_Framework_MockObject_MockObject | \OC\Group\Backend $backend
- */
+ public function testCreate(): void {
+ /** @var \PHPUnit\Framework\MockObject\MockObject|\OC\Group\Backend $backend */
$backendGroupCreated = false;
$backend = $this->getTestBackend();
$backend->expects($this->any())
->method('groupExists')
->with('group1')
- ->will($this->returnCallback(function () use (&$backendGroupCreated) {
+ ->willReturnCallback(function () use (&$backendGroupCreated) {
return $backendGroupCreated;
- }));
+ });
$backend->expects($this->once())
->method('createGroup')
- ->will($this->returnCallback(function () use (&$backendGroupCreated) {
+ ->willReturnCallback(function () use (&$backendGroupCreated) {
$backendGroupCreated = true;
- }));;
+ return true;
+ });
- $manager = new \OC\Group\Manager($this->userManager);
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
$manager->addBackend($backend);
$group = $manager->createGroup('group1');
$this->assertEquals('group1', $group->getGID());
}
- public function testCreateExists() {
- /**
- * @var \PHPUnit_Framework_MockObject_MockObject | \OC\Group\Backend $backend
- */
+ public function testCreateFailure(): void {
+ /** @var \PHPUnit\Framework\MockObject\MockObject|\OC\Group\Backend $backend */
+ $backendGroupCreated = false;
+ $backend = $this->getTestBackend(
+ GroupInterface::ADD_TO_GROUP
+ | GroupInterface::REMOVE_FROM_GOUP
+ | GroupInterface::COUNT_USERS
+ | GroupInterface::CREATE_GROUP
+ | GroupInterface::DELETE_GROUP
+ | GroupInterface::GROUP_DETAILS
+ );
+ $backend->expects($this->any())
+ ->method('groupExists')
+ ->with('group1')
+ ->willReturn(false);
+ $backend->expects($this->once())
+ ->method('createGroup')
+ ->willReturn(false);
+ $backend->expects($this->once())
+ ->method('getGroupDetails')
+ ->willReturn([]);
+
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
+ $manager->addBackend($backend);
+
+ $group = $manager->createGroup('group1');
+ $this->assertEquals(null, $group);
+ }
+
+ public function testCreateTooLong(): void {
+ /** @var \PHPUnit\Framework\MockObject\MockObject|\OC\Group\Backend $backend */
+ $backendGroupCreated = false;
+ $backend = $this->getTestBackend(
+ GroupInterface::ADD_TO_GROUP
+ | GroupInterface::REMOVE_FROM_GOUP
+ | GroupInterface::COUNT_USERS
+ | GroupInterface::CREATE_GROUP
+ | GroupInterface::DELETE_GROUP
+ | GroupInterface::GROUP_DETAILS
+ );
+ $groupName = str_repeat('x', 256);
+ $backend->expects($this->any())
+ ->method('groupExists')
+ ->with($groupName)
+ ->willReturn(false);
+
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
+ $manager->addBackend($backend);
+
+ $this->expectException(\Exception::class);
+ $group = $manager->createGroup($groupName);
+ }
+
+ public function testCreateExists(): void {
+ /** @var \PHPUnit\Framework\MockObject\MockObject|\OC\Group\Backend $backend */
$backend = $this->getTestBackend();
$backend->expects($this->any())
->method('groupExists')
->with('group1')
- ->will($this->returnValue(true));
+ ->willReturn(true);
$backend->expects($this->never())
->method('createGroup');
- $manager = new \OC\Group\Manager($this->userManager);
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
$manager->addBackend($backend);
$group = $manager->createGroup('group1');
$this->assertEquals('group1', $group->getGID());
}
- public function testSearch() {
+ public function testSearch(): void {
/**
- * @var \PHPUnit_Framework_MockObject_MockObject | \OC\Group\Backend $backend
+ * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
*/
$backend = $this->getTestBackend();
$backend->expects($this->once())
->method('getGroups')
->with('1')
- ->will($this->returnValue(array('group1')));
+ ->willReturn(['group1']);
$backend->expects($this->once())
- ->method('groupExists')
- ->with('group1')
- ->will($this->returnValue(true));
+ ->method('getGroupDetails')
+ ->willReturnMap([
+ ['group1', ['displayName' => 'group1']],
+ ]);
- $manager = new \OC\Group\Manager($this->userManager);
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
$manager->addBackend($backend);
$groups = $manager->search('1');
- $this->assertEquals(1, count($groups));
+ $this->assertCount(1, $groups);
$group1 = reset($groups);
$this->assertEquals('group1', $group1->getGID());
}
- public function testSearchMultipleBackends() {
+ public function testSearchMultipleBackends(): void {
/**
- * @var \PHPUnit_Framework_MockObject_MockObject | \OC\Group\Backend $backend1
+ * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend1
*/
$backend1 = $this->getTestBackend();
$backend1->expects($this->once())
->method('getGroups')
->with('1')
- ->will($this->returnValue(array('group1')));
+ ->willReturn(['group1']);
$backend1->expects($this->any())
- ->method('groupExists')
- ->will($this->returnValue(true));
+ ->method('getGroupDetails')
+ ->willReturnMap([
+ ['group1', ['displayName' => 'group1']],
+ ['group12', []],
+ ]);
/**
- * @var \PHPUnit_Framework_MockObject_MockObject | \OC\Group\Backend $backend2
+ * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend2
*/
$backend2 = $this->getTestBackend();
$backend2->expects($this->once())
->method('getGroups')
->with('1')
- ->will($this->returnValue(array('group12', 'group1')));
+ ->willReturn(['group12', 'group1']);
$backend2->expects($this->any())
- ->method('groupExists')
- ->will($this->returnValue(true));
+ ->method('getGroupDetails')
+ ->willReturnMap([
+ ['group12', ['displayName' => 'group12']],
+ ['group1', ['displayName' => 'group1']],
+ ]);
- $manager = new \OC\Group\Manager($this->userManager);
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
$manager->addBackend($backend1);
$manager->addBackend($backend2);
$groups = $manager->search('1');
- $this->assertEquals(2, count($groups));
+ $this->assertCount(2, $groups);
$group1 = reset($groups);
$group12 = next($groups);
$this->assertEquals('group1', $group1->getGID());
$this->assertEquals('group12', $group12->getGID());
}
- public function testSearchMultipleBackendsLimitAndOffset() {
+ public function testSearchMultipleBackendsLimitAndOffset(): void {
/**
- * @var \PHPUnit_Framework_MockObject_MockObject | \OC\Group\Backend $backend1
+ * @var \PHPUnit\Framework\MockObject\MockObject|\OC\Group\Backend $backend1
*/
$backend1 = $this->getTestBackend();
$backend1->expects($this->once())
->method('getGroups')
->with('1', 2, 1)
- ->will($this->returnValue(array('group1')));
+ ->willReturn(['group1']);
$backend1->expects($this->any())
- ->method('groupExists')
- ->will($this->returnValue(true));
+ ->method('getGroupDetails')
+ ->willReturnMap([
+ [1, []],
+ [2, []],
+ ['group1', ['displayName' => 'group1']],
+ ['group12', []],
+ ]);
/**
- * @var \PHPUnit_Framework_MockObject_MockObject | \OC\Group\Backend $backend2
+ * @var \PHPUnit\Framework\MockObject\MockObject|\OC\Group\Backend $backend2
*/
$backend2 = $this->getTestBackend();
$backend2->expects($this->once())
->method('getGroups')
->with('1', 2, 1)
- ->will($this->returnValue(array('group12')));
+ ->willReturn(['group12']);
$backend2->expects($this->any())
- ->method('groupExists')
- ->will($this->returnValue(true));
+ ->method('getGroupDetails')
+ ->willReturnMap([
+ [1, []],
+ [2, []],
+ ['group1', []],
+ ['group12', ['displayName' => 'group12']],
+ ]);
- $manager = new \OC\Group\Manager($this->userManager);
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
$manager->addBackend($backend1);
$manager->addBackend($backend2);
$groups = $manager->search('1', 2, 1);
- $this->assertEquals(2, count($groups));
+ $this->assertCount(2, $groups);
$group1 = reset($groups);
$group12 = next($groups);
$this->assertEquals('group1', $group1->getGID());
$this->assertEquals('group12', $group12->getGID());
}
- public function testGetUserGroups() {
+ public function testSearchResultExistsButGroupDoesNot(): void {
+ /** @var \PHPUnit\Framework\MockObject\MockObject|\OC\Group\Backend $backend */
+ $backend = $this->createMock(Database::class);
+ $backend->expects($this->once())
+ ->method('getGroups')
+ ->with('1')
+ ->willReturn(['group1']);
+ $backend->expects($this->never())
+ ->method('groupExists');
+ $backend->expects($this->once())
+ ->method('getGroupsDetails')
+ ->with(['group1'])
+ ->willReturn([]);
+
+ /** @var \OC\User\Manager $userManager */
+ $userManager = $this->createMock(Manager::class);
+
+ $manager = new \OC\Group\Manager($userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
+ $manager->addBackend($backend);
+
+ $groups = $manager->search('1');
+ $this->assertEmpty($groups);
+ }
+
+ public function testGetUserGroups(): void {
/**
- * @var \PHPUnit_Framework_MockObject_MockObject | \OC\Group\Backend $backend
+ * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
*/
$backend = $this->getTestBackend();
$backend->expects($this->once())
->method('getUserGroups')
->with('user1')
- ->will($this->returnValue(array('group1')));
+ ->willReturn(['group1']);
$backend->expects($this->any())
->method('groupExists')
->with('group1')
- ->will($this->returnValue(true));
+ ->willReturn(true);
- $manager = new \OC\Group\Manager($this->userManager);
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
$manager->addBackend($backend);
$groups = $manager->getUserGroups($this->getTestUser('user1'));
- $this->assertEquals(1, count($groups));
+ $this->assertCount(1, $groups);
$group1 = reset($groups);
$this->assertEquals('group1', $group1->getGID());
}
- public function testGetUserGroupIds() {
- /** @var \PHPUnit_Framework_MockObject_MockObject|\OC\Group\Manager $manager */
- $manager = $this->getMockBuilder('OC\Group\Manager')
- ->disableOriginalConstructor()
- ->setMethods(['getUserGroups'])
- ->getMock();
- $manager->expects($this->once())
- ->method('getUserGroups')
- ->willReturn([
- '123' => '123',
- 'abc' => 'abc',
- ]);
+ public function testGetUserGroupIds(): void {
+ /**
+ * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
+ */
+ $backend = $this->getTestBackend();
+ $backend->method('getUserGroups')
+ ->with('myUID')
+ ->willReturn(['123', 'abc']);
- /** @var \OC\User\User $user */
- $user = $this->getMockBuilder('OC\User\User')
- ->disableOriginalConstructor()
- ->getMock();
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
+ $manager->addBackend($backend);
+
+ /** @var User|\PHPUnit\Framework\MockObject\MockObject $user */
+ $user = $this->createMock(IUser::class);
+ $user->method('getUID')
+ ->willReturn('myUID');
$groups = $manager->getUserGroupIds($user);
- $this->assertEquals(2, count($groups));
+ $this->assertCount(2, $groups);
foreach ($groups as $group) {
- $this->assertInternalType('string', $group);
+ $this->assertIsString($group);
}
}
- public function testInGroup() {
+ public function testGetUserGroupsWithDeletedGroup(): void {
+ /**
+ * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
+ */
+ $backend = $this->createMock(Database::class);
+ $backend->expects($this->once())
+ ->method('getUserGroups')
+ ->with('user1')
+ ->willReturn(['group1']);
+ $backend->expects($this->any())
+ ->method('groupExists')
+ ->with('group1')
+ ->willReturn(false);
+
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
+ $manager->addBackend($backend);
+
+ /** @var User|\PHPUnit\Framework\MockObject\MockObject $user */
+ $user = $this->createMock(IUser::class);
+ $user->expects($this->atLeastOnce())
+ ->method('getUID')
+ ->willReturn('user1');
+
+ $groups = $manager->getUserGroups($user);
+ $this->assertEmpty($groups);
+ }
+
+ public function testInGroup(): void {
/**
- * @var \PHPUnit_Framework_MockObject_MockObject | \OC\Group\Backend $backend
+ * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
*/
$backend = $this->getTestBackend();
$backend->expects($this->once())
->method('getUserGroups')
->with('user1')
- ->will($this->returnValue(array('group1', 'admin', 'group2')));
+ ->willReturn(['group1', 'admin', 'group2']);
$backend->expects($this->any())
->method('groupExists')
- ->will($this->returnValue(true));
+ ->willReturn(true);
- $manager = new \OC\Group\Manager($this->userManager);
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
$manager->addBackend($backend);
$this->assertTrue($manager->isInGroup('user1', 'group1'));
}
- public function testIsAdmin() {
+ public function testIsAdmin(): void {
/**
- * @var \PHPUnit_Framework_MockObject_MockObject | \OC\Group\Backend $backend
+ * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
*/
$backend = $this->getTestBackend();
$backend->expects($this->once())
->method('getUserGroups')
->with('user1')
- ->will($this->returnValue(array('group1', 'admin', 'group2')));
+ ->willReturn(['group1', 'admin', 'group2']);
$backend->expects($this->any())
->method('groupExists')
- ->will($this->returnValue(true));
+ ->willReturn(true);
- $manager = new \OC\Group\Manager($this->userManager);
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
$manager->addBackend($backend);
$this->assertTrue($manager->isAdmin('user1'));
}
- public function testNotAdmin() {
+ public function testNotAdmin(): void {
/**
- * @var \PHPUnit_Framework_MockObject_MockObject | \OC\Group\Backend $backend
+ * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
*/
$backend = $this->getTestBackend();
$backend->expects($this->once())
->method('getUserGroups')
->with('user1')
- ->will($this->returnValue(array('group1', 'group2')));
+ ->willReturn(['group1', 'group2']);
$backend->expects($this->any())
->method('groupExists')
- ->will($this->returnValue(true));
+ ->willReturn(true);
- $manager = new \OC\Group\Manager($this->userManager);
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
$manager->addBackend($backend);
$this->assertFalse($manager->isAdmin('user1'));
}
- public function testGetUserGroupsMultipleBackends() {
+ public function testGetUserGroupsMultipleBackends(): void {
/**
- * @var \PHPUnit_Framework_MockObject_MockObject | \OC\Group\Backend $backend1
+ * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend1
*/
$backend1 = $this->getTestBackend();
$backend1->expects($this->once())
->method('getUserGroups')
->with('user1')
- ->will($this->returnValue(array('group1')));
+ ->willReturn(['group1']);
$backend1->expects($this->any())
->method('groupExists')
- ->will($this->returnValue(true));
+ ->willReturn(true);
/**
- * @var \PHPUnit_Framework_MockObject_MockObject | \OC\Group\Backend $backend2
+ * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend2
*/
$backend2 = $this->getTestBackend();
$backend2->expects($this->once())
->method('getUserGroups')
->with('user1')
- ->will($this->returnValue(array('group1', 'group2')));
+ ->willReturn(['group1', 'group2']);
$backend1->expects($this->any())
->method('groupExists')
- ->will($this->returnValue(true));
+ ->willReturn(true);
- $manager = new \OC\Group\Manager($this->userManager);
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
$manager->addBackend($backend1);
$manager->addBackend($backend2);
$groups = $manager->getUserGroups($this->getTestUser('user1'));
- $this->assertEquals(2, count($groups));
+ $this->assertCount(2, $groups);
$group1 = reset($groups);
$group2 = next($groups);
$this->assertEquals('group1', $group1->getGID());
$this->assertEquals('group2', $group2->getGID());
}
- public function testDisplayNamesInGroupWithOneUserBackend() {
+ public function testDisplayNamesInGroupWithOneUserBackend(): void {
/**
- * @var \PHPUnit_Framework_MockObject_MockObject | \OC\Group\Backend $backend
+ * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
*/
$backend = $this->getTestBackend();
$backend->expects($this->exactly(1))
->method('groupExists')
->with('testgroup')
- ->will($this->returnValue(true));
+ ->willReturn(true);
$backend->expects($this->any())
->method('inGroup')
- ->will($this->returnCallback(function($uid, $gid) {
- switch($uid) {
- case 'user1' : return false;
- case 'user2' : return true;
- case 'user3' : return false;
+ ->willReturnCallback(function ($uid, $gid) {
+ switch ($uid) {
+ case 'user1': return false;
+ case 'user2': return true;
+ case 'user3': return false;
case 'user33': return true;
default:
return null;
- }
- }));
-
- $userBackend = $this->getMockBuilder('\OC\User\Backend')
- ->disableOriginalConstructor()
- ->getMock();
+ }
+ });
$this->userManager->expects($this->any())
->method('searchDisplayName')
->with('user3')
- ->will($this->returnCallback(function($search, $limit, $offset) use ($userBackend) {
- switch($offset) {
- case 0 : return ['user3' => $this->getTestUser('user3'),
- 'user33' => $this->getTestUser('user33')];
- case 2 : return [];
+ ->willReturnCallback(function ($search, $limit, $offset) {
+ switch ($offset) {
+ case 0: return ['user3' => $this->getTestUser('user3'),
+ 'user33' => $this->getTestUser('user33')];
+ case 2: return [];
}
return null;
- }));
+ });
$this->userManager->expects($this->any())
->method('get')
- ->will($this->returnCallback(function($uid) use ($userBackend) {
- switch($uid) {
- case 'user1' : return $this->getTestUser('user1');
- case 'user2' : return $this->getTestUser('user2');
- case 'user3' : return $this->getTestUser('user3');
+ ->willReturnCallback(function ($uid) {
+ switch ($uid) {
+ case 'user1': return $this->getTestUser('user1');
+ case 'user2': return $this->getTestUser('user2');
+ case 'user3': return $this->getTestUser('user3');
case 'user33': return $this->getTestUser('user33');
default:
return null;
}
- }));
+ });
- $manager = new \OC\Group\Manager($this->userManager);
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
$manager->addBackend($backend);
$users = $manager->displayNamesInGroup('testgroup', 'user3');
- $this->assertEquals(1, count($users));
+ $this->assertCount(1, $users);
$this->assertFalse(isset($users['user1']));
$this->assertFalse(isset($users['user2']));
$this->assertFalse(isset($users['user3']));
$this->assertTrue(isset($users['user33']));
}
- public function testDisplayNamesInGroupWithOneUserBackendWithLimitSpecified() {
+ public function testDisplayNamesInGroupWithOneUserBackendWithLimitSpecified(): void {
/**
- * @var \PHPUnit_Framework_MockObject_MockObject | \OC\Group\Backend $backend
+ * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
*/
$backend = $this->getTestBackend();
$backend->expects($this->exactly(1))
->method('groupExists')
->with('testgroup')
- ->will($this->returnValue(true));
+ ->willReturn(true);
- $backend->expects($this->any())
+ $backend->expects($this->any())
->method('inGroup')
- ->will($this->returnCallback(function($uid, $gid) {
- switch($uid) {
- case 'user1' : return false;
- case 'user2' : return true;
- case 'user3' : return false;
- case 'user33': return true;
- case 'user333': return true;
- default:
- return null;
- }
- }));
-
- $userBackend = $this->getMockBuilder('\OC\User\Backend')
- ->disableOriginalConstructor()
- ->getMock();
+ ->willReturnCallback(function ($uid, $gid) {
+ switch ($uid) {
+ case 'user1': return false;
+ case 'user2': return true;
+ case 'user3': return false;
+ case 'user33': return true;
+ case 'user333': return true;
+ default:
+ return null;
+ }
+ });
$this->userManager->expects($this->any())
->method('searchDisplayName')
->with('user3')
- ->will($this->returnCallback(function($search, $limit, $offset) use ($userBackend) {
- switch($offset) {
- case 0 : return ['user3' => $this->getTestUser('user3'),
- 'user33' => $this->getTestUser('user33')];
- case 2 : return ['user333' => $this->getTestUser('user333')];
+ ->willReturnCallback(function ($search, $limit, $offset) {
+ switch ($offset) {
+ case 0: return ['user3' => $this->getTestUser('user3'),
+ 'user33' => $this->getTestUser('user33')];
+ case 2: return ['user333' => $this->getTestUser('user333')];
}
return null;
- }));
+ });
$this->userManager->expects($this->any())
->method('get')
- ->will($this->returnCallback(function($uid) use ($userBackend) {
- switch($uid) {
- case 'user1' : return $this->getTestUser('user1');
- case 'user2' : return $this->getTestUser('user2');
- case 'user3' : return $this->getTestUser('user3');
+ ->willReturnCallback(function ($uid) {
+ switch ($uid) {
+ case 'user1': return $this->getTestUser('user1');
+ case 'user2': return $this->getTestUser('user2');
+ case 'user3': return $this->getTestUser('user3');
case 'user33': return $this->getTestUser('user33');
case 'user333': return $this->getTestUser('user333');
default:
return null;
}
- }));
+ });
- $manager = new \OC\Group\Manager($this->userManager);
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
$manager->addBackend($backend);
$users = $manager->displayNamesInGroup('testgroup', 'user3', 1);
- $this->assertEquals(1, count($users));
+ $this->assertCount(1, $users);
$this->assertFalse(isset($users['user1']));
$this->assertFalse(isset($users['user2']));
$this->assertFalse(isset($users['user3']));
@@ -572,40 +705,36 @@ class ManagerTest extends \Test\TestCase {
$this->assertFalse(isset($users['user333']));
}
- public function testDisplayNamesInGroupWithOneUserBackendWithLimitAndOffsetSpecified() {
+ public function testDisplayNamesInGroupWithOneUserBackendWithLimitAndOffsetSpecified(): void {
/**
- * @var \PHPUnit_Framework_MockObject_MockObject | \OC\Group\Backend $backend
+ * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
*/
$backend = $this->getTestBackend();
$backend->expects($this->exactly(1))
->method('groupExists')
->with('testgroup')
- ->will($this->returnValue(true));
+ ->willReturn(true);
$backend->expects($this->any())
->method('inGroup')
- ->will($this->returnCallback(function($uid) {
- switch($uid) {
- case 'user1' : return false;
- case 'user2' : return true;
- case 'user3' : return false;
- case 'user33': return true;
- case 'user333': return true;
- default:
- return null;
- }
- }));
-
- $userBackend = $this->getMockBuilder('\OC\User\Backend')
- ->disableOriginalConstructor()
- ->getMock();
+ ->willReturnCallback(function ($uid) {
+ switch ($uid) {
+ case 'user1': return false;
+ case 'user2': return true;
+ case 'user3': return false;
+ case 'user33': return true;
+ case 'user333': return true;
+ default:
+ return null;
+ }
+ });
$this->userManager->expects($this->any())
->method('searchDisplayName')
->with('user3')
- ->will($this->returnCallback(function($search, $limit, $offset) use ($userBackend) {
- switch($offset) {
- case 0 :
+ ->willReturnCallback(function ($search, $limit, $offset) {
+ switch ($offset) {
+ case 0:
return [
'user3' => $this->getTestUser('user3'),
'user33' => $this->getTestUser('user33'),
@@ -613,26 +742,26 @@ class ManagerTest extends \Test\TestCase {
];
}
return null;
- }));
+ });
$this->userManager->expects($this->any())
->method('get')
- ->will($this->returnCallback(function($uid) use ($userBackend) {
- switch($uid) {
- case 'user1' : return $this->getTestUser('user1');
- case 'user2' : return $this->getTestUser('user2');
- case 'user3' : return $this->getTestUser('user3');
+ ->willReturnCallback(function ($uid) {
+ switch ($uid) {
+ case 'user1': return $this->getTestUser('user1');
+ case 'user2': return $this->getTestUser('user2');
+ case 'user3': return $this->getTestUser('user3');
case 'user33': return $this->getTestUser('user33');
case 'user333': return $this->getTestUser('user333');
default:
return null;
}
- }));
+ });
- $manager = new \OC\Group\Manager($this->userManager);
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
$manager->addBackend($backend);
$users = $manager->displayNamesInGroup('testgroup', 'user3', 1, 1);
- $this->assertEquals(1, count($users));
+ $this->assertCount(1, $users);
$this->assertFalse(isset($users['user1']));
$this->assertFalse(isset($users['user2']));
$this->assertFalse(isset($users['user3']));
@@ -640,252 +769,206 @@ class ManagerTest extends \Test\TestCase {
$this->assertTrue(isset($users['user333']));
}
- public function testDisplayNamesInGroupWithOneUserBackendAndSearchEmpty() {
+ public function testDisplayNamesInGroupWithOneUserBackendAndSearchEmpty(): void {
/**
- * @var \PHPUnit_Framework_MockObject_MockObject | \OC\Group\Backend $backend
+ * @var \PHPUnit\Framework\MockObject\MockObject|\OC\Group\Backend $backend
*/
$backend = $this->getTestBackend();
$backend->expects($this->exactly(1))
->method('groupExists')
->with('testgroup')
- ->will($this->returnValue(true));
+ ->willReturn(true);
- $backend->expects($this->once())
- ->method('usersInGroup')
+ $backend->expects($this->once())
+ ->method('searchInGroup')
->with('testgroup', '', -1, 0)
- ->will($this->returnValue(array('user2', 'user33')));
-
- $userBackend = $this->getMockBuilder('\OC\User\Backend')
- ->disableOriginalConstructor()
- ->getMock();
+ ->willReturn(['user2' => $this->getTestUser('user2'), 'user33' => $this->getTestUser('user33')]);
- $this->userManager->expects($this->any())
- ->method('get')
- ->will($this->returnCallback(function($uid) use ($userBackend) {
- switch($uid) {
- case 'user1' : return $this->getTestUser('user1');
- case 'user2' : return $this->getTestUser('user2');
- case 'user3' : return $this->getTestUser('user3');
- case 'user33': return $this->getTestUser('user33');
- default:
- return null;
- }
- }));
+ $this->userManager->expects($this->never())->method('get');
- $manager = new \OC\Group\Manager($this->userManager);
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
$manager->addBackend($backend);
$users = $manager->displayNamesInGroup('testgroup', '');
- $this->assertEquals(2, count($users));
+ $this->assertCount(2, $users);
$this->assertFalse(isset($users['user1']));
$this->assertTrue(isset($users['user2']));
$this->assertFalse(isset($users['user3']));
$this->assertTrue(isset($users['user33']));
}
- public function testDisplayNamesInGroupWithOneUserBackendAndSearchEmptyAndLimitSpecified() {
+ public function testDisplayNamesInGroupWithOneUserBackendAndSearchEmptyAndLimitSpecified(): void {
/**
- * @var \PHPUnit_Framework_MockObject_MockObject | \OC\Group\Backend $backend
+ * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
*/
$backend = $this->getTestBackend();
$backend->expects($this->exactly(1))
->method('groupExists')
->with('testgroup')
- ->will($this->returnValue(true));
+ ->willReturn(true);
$backend->expects($this->once())
- ->method('usersInGroup')
+ ->method('searchInGroup')
->with('testgroup', '', 1, 0)
- ->will($this->returnValue(array('user2')));
+ ->willReturn([new User('user2', null, $this->dispatcher)]);
- $userBackend = $this->getMockBuilder('\OC\User\Backend')
- ->disableOriginalConstructor()
- ->getMock();
+ $this->userManager->expects($this->never())->method('get');
- $this->userManager->expects($this->any())
- ->method('get')
- ->will($this->returnCallback(function($uid) use ($userBackend) {
- switch($uid) {
- case 'user1' : return $this->getTestUser('user1');
- case 'user2' : return $this->getTestUser('user2');
- case 'user3' : return $this->getTestUser('user3');
- case 'user33': return $this->getTestUser('user33');
- default:
- return null;
- }
- }));
-
- $manager = new \OC\Group\Manager($this->userManager);
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
$manager->addBackend($backend);
$users = $manager->displayNamesInGroup('testgroup', '', 1);
- $this->assertEquals(1, count($users));
+ $this->assertCount(1, $users);
$this->assertFalse(isset($users['user1']));
$this->assertTrue(isset($users['user2']));
$this->assertFalse(isset($users['user3']));
$this->assertFalse(isset($users['user33']));
}
- public function testDisplayNamesInGroupWithOneUserBackendAndSearchEmptyAndLimitAndOffsetSpecified() {
+ public function testDisplayNamesInGroupWithOneUserBackendAndSearchEmptyAndLimitAndOffsetSpecified(): void {
/**
- * @var \PHPUnit_Framework_MockObject_MockObject | \OC\Group\Backend $backend
+ * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
*/
$backend = $this->getTestBackend();
$backend->expects($this->exactly(1))
->method('groupExists')
->with('testgroup')
- ->will($this->returnValue(true));
+ ->willReturn(true);
$backend->expects($this->once())
- ->method('usersInGroup')
+ ->method('searchInGroup')
->with('testgroup', '', 1, 1)
- ->will($this->returnValue(array('user33')));
+ ->willReturn(['user33' => $this->getTestUser('user33')]);
- $userBackend = $this->getMockBuilder('\OC\User\Backend')
- ->disableOriginalConstructor()
- ->getMock();
+ $this->userManager->expects($this->never())->method('get');
- $this->userManager->expects($this->any())
- ->method('get')
- ->will($this->returnCallback(function($uid) use ($userBackend) {
- switch($uid) {
- case 'user1' : return $this->getTestUser('user1');
- case 'user2' : return $this->getTestUser('user2');
- case 'user3' : return $this->getTestUser('user3');
- case 'user33': return $this->getTestUser('user33');
- default:
- return null;
- }
- }));
-
- $manager = new \OC\Group\Manager($this->userManager);
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
$manager->addBackend($backend);
$users = $manager->displayNamesInGroup('testgroup', '', 1, 1);
- $this->assertEquals(1, count($users));
+ $this->assertCount(1, $users);
$this->assertFalse(isset($users['user1']));
$this->assertFalse(isset($users['user2']));
$this->assertFalse(isset($users['user3']));
$this->assertTrue(isset($users['user33']));
}
- public function testGetUserGroupsWithAddUser() {
+ public function testGetUserGroupsWithAddUser(): void {
/**
- * @var \PHPUnit_Framework_MockObject_MockObject | \OC\Group\Backend $backend
+ * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
*/
$backend = $this->getTestBackend();
$expectedGroups = [];
$backend->expects($this->any())
->method('getUserGroups')
->with('user1')
- ->will($this->returnCallback(function () use (&$expectedGroups) {
+ ->willReturnCallback(function () use (&$expectedGroups) {
return $expectedGroups;
- }));
+ });
$backend->expects($this->any())
->method('groupExists')
->with('group1')
- ->will($this->returnValue(true));
+ ->willReturn(true);
- $manager = new \OC\Group\Manager($this->userManager);
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
$manager->addBackend($backend);
// prime cache
$user1 = $this->getTestUser('user1');
$groups = $manager->getUserGroups($user1);
- $this->assertEquals(array(), $groups);
+ $this->assertEquals([], $groups);
// add user
$group = $manager->get('group1');
$group->addUser($user1);
- $expectedGroups = ['group1'];
+ $expectedGroups[] = 'group1';
// check result
$groups = $manager->getUserGroups($user1);
- $this->assertEquals(1, count($groups));
+ $this->assertCount(1, $groups);
$group1 = reset($groups);
$this->assertEquals('group1', $group1->getGID());
}
- public function testGetUserGroupsWithRemoveUser() {
+ public function testGetUserGroupsWithRemoveUser(): void {
/**
- * @var \PHPUnit_Framework_MockObject_MockObject | \OC\Group\Backend $backend
+ * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
*/
$backend = $this->getTestBackend();
$expectedGroups = ['group1'];
$backend->expects($this->any())
->method('getUserGroups')
->with('user1')
- ->will($this->returnCallback(function () use (&$expectedGroups) {
+ ->willReturnCallback(function () use (&$expectedGroups) {
return $expectedGroups;
- }));
+ });
$backend->expects($this->any())
->method('groupExists')
->with('group1')
- ->will($this->returnValue(true));
+ ->willReturn(true);
$backend->expects($this->once())
->method('inGroup')
- ->will($this->returnValue(true));
+ ->willReturn(true);
$backend->expects($this->once())
->method('removeFromGroup')
- ->will($this->returnValue(true));
+ ->willReturn(true);
- $manager = new \OC\Group\Manager($this->userManager);
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
$manager->addBackend($backend);
// prime cache
$user1 = $this->getTestUser('user1');
$groups = $manager->getUserGroups($user1);
- $this->assertEquals(1, count($groups));
+ $this->assertCount(1, $groups);
$group1 = reset($groups);
$this->assertEquals('group1', $group1->getGID());
// remove user
$group = $manager->get('group1');
$group->removeUser($user1);
- $expectedGroups = array();
+ $expectedGroups = [];
// check result
$groups = $manager->getUserGroups($user1);
$this->assertEquals($expectedGroups, $groups);
}
- public function testGetUserIdGroups() {
+ public function testGetUserIdGroups(): void {
/**
- * @var \PHPUnit_Framework_MockObject_MockObject | \OC\Group\Backend $backend
+ * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
*/
$backend = $this->getTestBackend();
$backend->expects($this->any())
->method('getUserGroups')
->with('user1')
- ->will($this->returnValue(null));
+ ->willReturn(null);
- $manager = new \OC\Group\Manager($this->userManager);
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
$manager->addBackend($backend);
$groups = $manager->getUserIdGroups('user1');
$this->assertEquals([], $groups);
}
- public function testGroupDisplayName() {
+ public function testGroupDisplayName(): void {
/**
- * @var \PHPUnit_Framework_MockObject_MockObject | \OC\Group\Backend $backend
+ * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
*/
$backend = $this->getTestBackend(
- GroupInterface::ADD_TO_GROUP |
- GroupInterface::REMOVE_FROM_GOUP |
- GroupInterface::COUNT_USERS |
- GroupInterface::CREATE_GROUP |
- GroupInterface::DELETE_GROUP |
- GroupInterface::GROUP_DETAILS
+ GroupInterface::ADD_TO_GROUP
+ | GroupInterface::REMOVE_FROM_GOUP
+ | GroupInterface::COUNT_USERS
+ | GroupInterface::CREATE_GROUP
+ | GroupInterface::DELETE_GROUP
+ | GroupInterface::GROUP_DETAILS
);
$backend->expects($this->any())
->method('getGroupDetails')
- ->will($this->returnValueMap([
+ ->willReturnMap([
['group1', ['gid' => 'group1', 'displayName' => 'Group One']],
['group2', ['gid' => 'group2']],
- ]));
-
- $manager = new \OC\Group\Manager($this->userManager);
+ ]);
+ $manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
$manager->addBackend($backend);
// group with display name
@@ -900,5 +983,4 @@ class ManagerTest extends \Test\TestCase {
$this->assertEquals('group2', $group->getGID());
$this->assertEquals('group2', $group->getDisplayName());
}
-
}
generated by cgit v1.2.3 (git 2.46.0) at 2025-08-16 19:29:13 +0000