7 files changed, 1863 insertions, 0 deletions

diff --git a/tests/lib/Group/Backend.php b/tests/lib/Group/Backend.php
new file mode 100644
index 00000000000..3c068d8d64b
--- /dev/null
+++ b/tests/lib/Group/Backend.php
@@ -0,0 +1,145 @@
+<?php
+
+/**
+ * SPDX-FileCopyrightText: 2018-2024 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-FileCopyrightText: 2016 ownCloud, Inc.
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+namespace Test\Group;
+
+/**
+ * Class Backend
+ *
+ * @group DB
+ */
+abstract class Backend extends \Test\TestCase {
+	/**
+	 * @var \OC\Group\Backend $backend
+	 */
+	protected $backend;
+
+	/**
+	 * get a new unique group name
+	 * test cases can override this in order to clean up created groups
+	 *
+	 * @return string
+	 */
+	public function getGroupName($name = null) {
+		if (is_null($name)) {
+			return $this->getUniqueID('test_');
+		} else {
+			return $name;
+		}
+	}
+
+	/**
+	 * get a new unique user name
+	 * test cases can override this in order to clean up created user
+	 *
+	 * @return string
+	 */
+	public function getUserName() {
+		return $this->getUniqueID('test_');
+	}
+
+	public function testAddRemove(): void {
+		//get the number of groups we start with, in case there are exising groups
+		$startCount = count($this->backend->getGroups());
+
+		$name1 = $this->getGroupName();
+		$name2 = $this->getGroupName();
+		$this->backend->createGroup($name1);
+		$count = count($this->backend->getGroups()) - $startCount;
+		$this->assertEquals(1, $count);
+		$this->assertTrue((array_search($name1, $this->backend->getGroups()) !== false));
+		$this->assertFalse((array_search($name2, $this->backend->getGroups()) !== false));
+		$this->backend->createGroup($name2);
+		$count = count($this->backend->getGroups()) - $startCount;
+		$this->assertEquals(2, $count);
+		$this->assertTrue((array_search($name1, $this->backend->getGroups()) !== false));
+		$this->assertTrue((array_search($name2, $this->backend->getGroups()) !== false));
+
+		$this->backend->deleteGroup($name2);
+		$count = count($this->backend->getGroups()) - $startCount;
+		$this->assertEquals(1, $count);
+		$this->assertTrue((array_search($name1, $this->backend->getGroups()) !== false));
+		$this->assertFalse((array_search($name2, $this->backend->getGroups()) !== false));
+	}
+
+	public function testUser(): void {
+		$group1 = $this->getGroupName();
+		$group2 = $this->getGroupName();
+		$this->backend->createGroup($group1);
+		$this->backend->createGroup($group2);
+
+		$user1 = $this->getUserName();
+		$user2 = $this->getUserName();
+
+		$this->assertFalse($this->backend->inGroup($user1, $group1));
+		$this->assertFalse($this->backend->inGroup($user2, $group1));
+		$this->assertFalse($this->backend->inGroup($user1, $group2));
+		$this->assertFalse($this->backend->inGroup($user2, $group2));
+
+		$this->assertTrue($this->backend->addToGroup($user1, $group1));
+
+		$this->assertTrue($this->backend->inGroup($user1, $group1));
+		$this->assertFalse($this->backend->inGroup($user2, $group1));
+		$this->assertFalse($this->backend->inGroup($user1, $group2));
+		$this->assertFalse($this->backend->inGroup($user2, $group2));
+
+		$this->assertFalse($this->backend->addToGroup($user1, $group1));
+
+		$this->assertEquals([$user1], $this->backend->usersInGroup($group1));
+		$this->assertEquals([], $this->backend->usersInGroup($group2));
+
+		$this->assertEquals([$group1], $this->backend->getUserGroups($user1));
+		$this->assertEquals([], $this->backend->getUserGroups($user2));
+
+		$this->backend->deleteGroup($group1);
+		$this->assertEquals([], $this->backend->getUserGroups($user1));
+		$this->assertEquals([], $this->backend->usersInGroup($group1));
+		$this->assertFalse($this->backend->inGroup($user1, $group1));
+	}
+
+	public function testSearchGroups(): void {
+		$name1 = $this->getGroupName('foobarbaz');
+		$name2 = $this->getGroupName('bazfoobarfoo');
+		$name3 = $this->getGroupName('notme');
+
+		$this->backend->createGroup($name1);
+		$this->backend->createGroup($name2);
+		$this->backend->createGroup($name3);
+
+		$result = $this->backend->getGroups('foobar');
+		$this->assertSame(2, count($result));
+	}
+
+	public function testSearchUsers(): void {
+		$group = $this->getGroupName();
+		$this->backend->createGroup($group);
+
+		$name1 = 'foobarbaz';
+		$name2 = 'bazbarfoo';
+		$name3 = 'notme';
+
+		$this->backend->addToGroup($name1, $group);
+		$this->backend->addToGroup($name2, $group);
+		$this->backend->addToGroup($name3, $group);
+
+		$result = $this->backend->usersInGroup($group, 'bar');
+		$this->assertSame(2, count($result));
+
+		$result = $this->backend->countUsersInGroup($group, 'bar');
+		$this->assertSame(2, $result);
+	}
+
+	public function testAddDouble(): void {
+		$group = $this->getGroupName();
+
+		$this->backend->createGroup($group);
+		$this->backend->createGroup($group);
+
+		$this->addToAssertionCount(1);
+	}
+}
diff --git a/tests/lib/Group/DatabaseTest.php b/tests/lib/Group/DatabaseTest.php
new file mode 100644
index 00000000000..ee6b4156040
--- /dev/null
+++ b/tests/lib/Group/DatabaseTest.php
@@ -0,0 +1,61 @@
+<?php
+
+/**
+ * SPDX-FileCopyrightText: 2019-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;
+
+/**
+ * Class Database
+ *
+ * @group DB
+ */
+class DatabaseTest extends Backend {
+	private $groups = [];
+
+	/**
+	 * get a new unique group name
+	 * test cases can override this in order to clean up created groups
+	 */
+	public function getGroupName($name = null): string {
+		$name = parent::getGroupName($name);
+		$this->groups[] = $name;
+		return $name;
+	}
+
+	protected function setUp(): void {
+		parent::setUp();
+		$this->backend = new Database();
+	}
+
+	protected function tearDown(): void {
+		foreach ($this->groups as $group) {
+			$this->backend->deleteGroup($group);
+		}
+		parent::tearDown();
+	}
+
+	public function testAddDoubleNoCache(): void {
+		$group = $this->getGroupName();
+
+		$this->backend->createGroup($group);
+
+		$backend = new Database();
+		$this->assertNull($backend->createGroup($group));
+	}
+
+	public function testAddLongGroupName(): void {
+		$groupName = $this->getUniqueID('test_', 100);
+
+		$gidCreated = $this->backend->createGroup($groupName);
+		$this->assertEquals(64, strlen($gidCreated));
+
+		$group = $this->backend->getGroupDetails($gidCreated);
+		$this->assertEquals(['displayName' => $groupName], $group);
+	}
+}
diff --git a/tests/lib/Group/Dummy.php b/tests/lib/Group/Dummy.php
new file mode 100644
index 00000000000..5f2a81cf0aa
--- /dev/null
+++ b/tests/lib/Group/Dummy.php
@@ -0,0 +1,21 @@
+<?php
+
+/**
+ * SPDX-FileCopyrightText: 2019-2024 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-FileCopyrightText: 2016 ownCloud, Inc.
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+namespace Test\Group;
+
+/**
+ * Class Dummy
+ *
+ * @group DB
+ */
+class Dummy extends Backend {
+	protected function setUp(): void {
+		parent::setUp();
+		$this->backend = new \Test\Util\Group\Dummy();
+	}
+}
diff --git a/tests/lib/Group/GroupTest.php b/tests/lib/Group/GroupTest.php
new file mode 100644
index 00000000000..baae814675c
--- /dev/null
+++ b/tests/lib/Group/GroupTest.php
@@ -0,0 +1,476 @@
+<?php
+
+/**
+ * SPDX-FileCopyrightText: 2016-2024 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-FileCopyrightText: 2016 ownCloud, Inc.
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+namespace Test\Group;
+
+use OC\Group\Group;
+use OC\User\User;
+use OCP\EventDispatcher\IEventDispatcher;
+use OCP\IUser;
+use PHPUnit\Framework\MockObject\MockObject;
+
+class GroupTest extends \Test\TestCase {
+	/** @var IEventDispatcher|MockObject */
+	protected $dispatcher;
+
+	protected function setUp(): void {
+		parent::setUp();
+		$this->dispatcher = $this->createMock(IEventDispatcher::class);
+	}
+
+	/**
+	 * @param string $uid
+	 * @param \OC\User\Backend $backend
+	 * @return User
+	 */
+	private function newUser($uid, \OC\User\Backend $backend) {
+		$user = $this->createMock(IUser::class);
+		$user->method('getUID')
+			->willReturn($uid);
+		$user->method('getBackend')
+			->willReturn($backend);
+
+		return $user;
+	}
+
+	/**
+	 * @return \OC\User\Manager
+	 */
+	protected function getUserManager() {
+		$userManager = $this->getMockBuilder('\OC\User\Manager')
+			->disableOriginalConstructor()
+			->getMock();
+		$backend = $this->getMockBuilder('\OC\User\Backend')
+			->disableOriginalConstructor()
+			->getMock();
+		$user1 = $this->newUser('user1', $backend);
+		$user2 = $this->newUser('user2', $backend);
+		$user3 = $this->newUser('user3', $backend);
+		$userManager->expects($this->any())
+			->method('get')
+			->willReturnMap([
+				['user1', $user1],
+				['user2', $user2],
+				['user3', $user3]
+			]);
+		return $userManager;
+	}
+
+	public function testGetUsersSingleBackend(): void {
+		$backend = $this->getMockBuilder('OC\Group\Database')
+			->disableOriginalConstructor()
+			->getMock();
+		$userManager = $this->getUserManager();
+		$group = new Group('group1', [$backend], $this->dispatcher, $userManager);
+
+		$backend->expects($this->once())
+			->method('usersInGroup')
+			->with('group1')
+			->willReturn(['user1', 'user2']);
+
+		$users = $group->getUsers();
+
+		$this->assertEquals(2, count($users));
+		$user1 = $users['user1'];
+		$user2 = $users['user2'];
+		$this->assertEquals('user1', $user1->getUID());
+		$this->assertEquals('user2', $user2->getUID());
+	}
+
+	public function testGetUsersMultipleBackends(): void {
+		$backend1 = $this->getMockBuilder('OC\Group\Database')
+			->disableOriginalConstructor()
+			->getMock();
+		$backend2 = $this->getMockBuilder('OC\Group\Database')
+			->disableOriginalConstructor()
+			->getMock();
+		$userManager = $this->getUserManager();
+		$group = new Group('group1', [$backend1, $backend2], $this->dispatcher, $userManager);
+
+		$backend1->expects($this->once())
+			->method('usersInGroup')
+			->with('group1')
+			->willReturn(['user1', 'user2']);
+
+		$backend2->expects($this->once())
+			->method('usersInGroup')
+			->with('group1')
+			->willReturn(['user2', 'user3']);
+
+		$users = $group->getUsers();
+
+		$this->assertEquals(3, count($users));
+		$user1 = $users['user1'];
+		$user2 = $users['user2'];
+		$user3 = $users['user3'];
+		$this->assertEquals('user1', $user1->getUID());
+		$this->assertEquals('user2', $user2->getUID());
+		$this->assertEquals('user3', $user3->getUID());
+	}
+
+	public function testInGroupSingleBackend(): void {
+		$backend = $this->getMockBuilder('OC\Group\Database')
+			->disableOriginalConstructor()
+			->getMock();
+		$userManager = $this->getUserManager();
+		$userBackend = $this->getMockBuilder('\OC\User\Backend')
+			->disableOriginalConstructor()
+			->getMock();
+		$group = new Group('group1', [$backend], $this->dispatcher, $userManager);
+
+		$backend->expects($this->once())
+			->method('inGroup')
+			->with('user1', 'group1')
+			->willReturn(true);
+
+		$this->assertTrue($group->inGroup($this->newUser('user1', $userBackend)));
+	}
+
+	public function testInGroupMultipleBackends(): void {
+		$backend1 = $this->getMockBuilder('OC\Group\Database')
+			->disableOriginalConstructor()
+			->getMock();
+		$backend2 = $this->getMockBuilder('OC\Group\Database')
+			->disableOriginalConstructor()
+			->getMock();
+		$userManager = $this->getUserManager();
+		$userBackend = $this->getMockBuilder(\OC\User\Backend::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$group = new Group('group1', [$backend1, $backend2], $this->dispatcher, $userManager);
+
+		$backend1->expects($this->once())
+			->method('inGroup')
+			->with('user1', 'group1')
+			->willReturn(false);
+
+		$backend2->expects($this->once())
+			->method('inGroup')
+			->with('user1', 'group1')
+			->willReturn(true);
+
+		$this->assertTrue($group->inGroup($this->newUser('user1', $userBackend)));
+	}
+
+	public function testAddUser(): void {
+		$backend = $this->getMockBuilder('OC\Group\Database')
+			->disableOriginalConstructor()
+			->getMock();
+		$userManager = $this->getUserManager();
+		$userBackend = $this->getMockBuilder('\OC\User\Backend')
+			->disableOriginalConstructor()
+			->getMock();
+		$group = new Group('group1', [$backend], $this->dispatcher, $userManager);
+
+		$backend->expects($this->once())
+			->method('inGroup')
+			->with('user1', 'group1')
+			->willReturn(false);
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->willReturn(true);
+
+		$backend->expects($this->once())
+			->method('addToGroup')
+			->with('user1', 'group1');
+
+		$group->addUser($this->newUser('user1', $userBackend));
+	}
+
+	public function testAddUserAlreadyInGroup(): void {
+		$backend = $this->getMockBuilder('OC\Group\Database')
+			->disableOriginalConstructor()
+			->getMock();
+		$userManager = $this->getUserManager();
+		$userBackend = $this->getMockBuilder('\OC\User\Backend')
+			->disableOriginalConstructor()
+			->getMock();
+		$group = new Group('group1', [$backend], $this->dispatcher, $userManager);
+
+		$backend->expects($this->once())
+			->method('inGroup')
+			->with('user1', 'group1')
+			->willReturn(true);
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->willReturn(true);
+
+		$backend->expects($this->never())
+			->method('addToGroup');
+
+		$group->addUser($this->newUser('user1', $userBackend));
+	}
+
+	public function testRemoveUser(): void {
+		$backend = $this->getMockBuilder('OC\Group\Database')
+			->disableOriginalConstructor()
+			->getMock();
+		$userManager = $this->getUserManager();
+		$userBackend = $this->getMockBuilder('\OC\User\Backend')
+			->disableOriginalConstructor()
+			->getMock();
+		$group = new Group('group1', [$backend], $this->dispatcher, $userManager);
+
+		$backend->expects($this->once())
+			->method('inGroup')
+			->with('user1', 'group1')
+			->willReturn(true);
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->willReturn(true);
+
+		$backend->expects($this->once())
+			->method('removeFromGroup')
+			->with('user1', 'group1');
+
+		$group->removeUser($this->newUser('user1', $userBackend));
+	}
+
+	public function testRemoveUserNotInGroup(): void {
+		$backend = $this->getMockBuilder('OC\Group\Database')
+			->disableOriginalConstructor()
+			->getMock();
+		$userManager = $this->getUserManager();
+		$userBackend = $this->getMockBuilder(\OC\User\Backend::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$group = new Group('group1', [$backend], $this->dispatcher, $userManager);
+
+		$backend->expects($this->once())
+			->method('inGroup')
+			->with('user1', 'group1')
+			->willReturn(false);
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->willReturn(true);
+
+		$backend->expects($this->never())
+			->method('removeFromGroup');
+
+		$group->removeUser($this->newUser('user1', $userBackend));
+	}
+
+	public function testRemoveUserMultipleBackends(): void {
+		$backend1 = $this->getMockBuilder('OC\Group\Database')
+			->disableOriginalConstructor()
+			->getMock();
+		$backend2 = $this->getMockBuilder('OC\Group\Database')
+			->disableOriginalConstructor()
+			->getMock();
+		$userManager = $this->getUserManager();
+		$userBackend = $this->getMockBuilder('\OC\User\Backend')
+			->disableOriginalConstructor()
+			->getMock();
+		$group = new Group('group1', [$backend1, $backend2], $this->dispatcher, $userManager);
+
+		$backend1->expects($this->once())
+			->method('inGroup')
+			->with('user1', 'group1')
+			->willReturn(true);
+		$backend1->expects($this->any())
+			->method('implementsActions')
+			->willReturn(true);
+
+		$backend1->expects($this->once())
+			->method('removeFromGroup')
+			->with('user1', 'group1');
+
+		$backend2->expects($this->once())
+			->method('inGroup')
+			->with('user1', 'group1')
+			->willReturn(true);
+		$backend2->expects($this->any())
+			->method('implementsActions')
+			->willReturn(true);
+
+		$backend2->expects($this->once())
+			->method('removeFromGroup')
+			->with('user1', 'group1');
+
+		$group->removeUser($this->newUser('user1', $userBackend));
+	}
+
+	public function testSearchUsers(): void {
+		$backend = $this->getMockBuilder('OC\Group\Database')
+			->disableOriginalConstructor()
+			->getMock();
+		$userManager = $this->getUserManager();
+		$group = new Group('group1', [$backend], $this->dispatcher, $userManager);
+
+		$backend->expects($this->once())
+			->method('searchInGroup')
+			->with('group1', '2')
+			->willReturn(['user2' => new User('user2', null, $this->dispatcher)]);
+
+		$users = $group->searchUsers('2');
+
+		$this->assertEquals(1, count($users));
+		$user2 = reset($users);
+		$this->assertEquals('user2', $user2->getUID());
+	}
+
+	public function testSearchUsersMultipleBackends(): void {
+		$backend1 = $this->getMockBuilder('OC\Group\Database')
+			->disableOriginalConstructor()
+			->getMock();
+		$backend2 = $this->getMockBuilder('OC\Group\Database')
+			->disableOriginalConstructor()
+			->getMock();
+		$userManager = $this->getUserManager();
+		$group = new Group('group1', [$backend1, $backend2], $this->dispatcher, $userManager);
+
+		$backend1->expects($this->once())
+			->method('searchInGroup')
+			->with('group1', '2')
+			->willReturn(['user2' => new User('user2', null, $this->dispatcher)]);
+		$backend2->expects($this->once())
+			->method('searchInGroup')
+			->with('group1', '2')
+			->willReturn(['user2' => new User('user2', null, $this->dispatcher)]);
+
+		$users = $group->searchUsers('2');
+
+		$this->assertEquals(1, count($users));
+		$user2 = reset($users);
+		$this->assertEquals('user2', $user2->getUID());
+	}
+
+	public function testSearchUsersLimitAndOffset(): void {
+		$backend = $this->getMockBuilder('OC\Group\Database')
+			->disableOriginalConstructor()
+			->getMock();
+		$userManager = $this->getUserManager();
+		$group = new Group('group1', [$backend], $this->dispatcher, $userManager);
+
+		$backend->expects($this->once())
+			->method('searchInGroup')
+			->with('group1', 'user', 1, 1)
+			->willReturn(['user2' => new User('user2', null, $this->dispatcher)]);
+
+		$users = $group->searchUsers('user', 1, 1);
+
+		$this->assertEquals(1, count($users));
+		$user2 = reset($users);
+		$this->assertEquals('user2', $user2->getUID());
+	}
+
+	public function testSearchUsersMultipleBackendsLimitAndOffset(): void {
+		$backend1 = $this->getMockBuilder('OC\Group\Database')
+			->disableOriginalConstructor()
+			->getMock();
+		$backend2 = $this->getMockBuilder('OC\Group\Database')
+			->disableOriginalConstructor()
+			->getMock();
+		$userManager = $this->getUserManager();
+		$group = new Group('group1', [$backend1, $backend2], $this->dispatcher, $userManager);
+
+		$backend1->expects($this->once())
+			->method('searchInGroup')
+			->with('group1', 'user', 2, 1)
+			->willReturn(['user2' => new User('user2', null, $this->dispatcher)]);
+		$backend2->expects($this->once())
+			->method('searchInGroup')
+			->with('group1', 'user', 2, 1)
+			->willReturn(['user1' => new User('user1', null, $this->dispatcher)]);
+
+		$users = $group->searchUsers('user', 2, 1);
+
+		$this->assertEquals(2, count($users));
+		$user2 = reset($users);
+		$user1 = next($users);
+		$this->assertEquals('user2', $user2->getUID());
+		$this->assertEquals('user1', $user1->getUID());
+	}
+
+	public function testCountUsers(): void {
+		$backend1 = $this->getMockBuilder('OC\Group\Database')
+			->disableOriginalConstructor()
+			->getMock();
+		$userManager = $this->getUserManager();
+		$group = new Group('group1', [$backend1], $this->dispatcher, $userManager);
+
+		$backend1->expects($this->once())
+			->method('countUsersInGroup')
+			->with('group1', '2')
+			->willReturn(3);
+
+		$backend1->expects($this->any())
+			->method('implementsActions')
+			->willReturn(true);
+
+		$users = $group->count('2');
+
+		$this->assertSame(3, $users);
+	}
+
+	public function testCountUsersMultipleBackends(): void {
+		$backend1 = $this->getMockBuilder('OC\Group\Database')
+			->disableOriginalConstructor()
+			->getMock();
+		$backend2 = $this->getMockBuilder('OC\Group\Database')
+			->disableOriginalConstructor()
+			->getMock();
+		$userManager = $this->getUserManager();
+		$group = new Group('group1', [$backend1, $backend2], $this->dispatcher, $userManager);
+
+		$backend1->expects($this->once())
+			->method('countUsersInGroup')
+			->with('group1', '2')
+			->willReturn(3);
+		$backend1->expects($this->any())
+			->method('implementsActions')
+			->willReturn(true);
+
+		$backend2->expects($this->once())
+			->method('countUsersInGroup')
+			->with('group1', '2')
+			->willReturn(4);
+		$backend2->expects($this->any())
+			->method('implementsActions')
+			->willReturn(true);
+
+		$users = $group->count('2');
+
+		$this->assertSame(7, $users);
+	}
+
+	public function testCountUsersNoMethod(): void {
+		$backend1 = $this->getMockBuilder('OC\Group\Database')
+			->disableOriginalConstructor()
+			->getMock();
+		$userManager = $this->getUserManager();
+		$group = new Group('group1', [$backend1], $this->dispatcher, $userManager);
+
+		$backend1->expects($this->never())
+			->method('countUsersInGroup');
+		$backend1->expects($this->any())
+			->method('implementsActions')
+			->willReturn(false);
+
+		$users = $group->count('2');
+
+		$this->assertSame(false, $users);
+	}
+
+	public function testDelete(): void {
+		$backend = $this->getMockBuilder('OC\Group\Database')
+			->disableOriginalConstructor()
+			->getMock();
+		$userManager = $this->getUserManager();
+		$group = new Group('group1', [$backend], $this->dispatcher, $userManager);
+
+		$backend->expects($this->once())
+			->method('deleteGroup')
+			->with('group1');
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->willReturn(true);
+
+		$group->delete();
+	}
+}
diff --git a/tests/lib/Group/HideFromCollaborationTest.php b/tests/lib/Group/HideFromCollaborationTest.php
new file mode 100644
index 00000000000..5ff7c797508
--- /dev/null
+++ b/tests/lib/Group/HideFromCollaborationTest.php
@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+namespace Test\Group;
+
+use OC\Group\Group;
+use OCP\EventDispatcher\IEventDispatcher;
+use OCP\Group\Backend\ABackend;
+use OCP\Group\Backend\IHideFromCollaborationBackend;
+use OCP\IUserManager;
+use PHPUnit\Framework\MockObject\MockObject;
+use Test\TestCase;
+
+abstract class HideFromCollaborationBackendTest extends ABackend implements IHideFromCollaborationBackend {
+
+}
+
+class HideFromCollaborationTest extends TestCase {
+
+	private IUserManager&MockObject $userManager;
+	private IEventDispatcher&MockObject $dispatcher;
+
+	protected function setUp(): void {
+		parent::setUp();
+
+		$this->userManager = $this->createMock(IUserManager::class);
+		$this->dispatcher = $this->createMock(IEventDispatcher::class);
+	}
+
+
+	public function testHideFromCollaboration(): void {
+		// Arrange
+		$backend1 = $this->createMock(HideFromCollaborationBackendTest::class);
+		$backend1->method('hideGroup')
+			->willReturn(false);
+		$backend2 = $this->createMock(HideFromCollaborationBackendTest::class);
+		$backend2->method('hideGroup')
+			->willReturn(true);
+		$group = new Group('group1', [$backend1, $backend2], $this->dispatcher, $this->userManager);
+
+		// Act
+		$result = $group->hideFromCollaboration();
+
+		// Assert
+		$this->assertTrue($result);
+	}
+}
diff --git a/tests/lib/Group/ManagerTest.php b/tests/lib/Group/ManagerTest.php
new file mode 100644
index 00000000000..8515ef0e3e8
--- /dev/null
+++ b/tests/lib/Group/ManagerTest.php
@@ -0,0 +1,986 @@
+<?php
+
+/**
+ * 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 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;
+
+abstract class TestBackend extends ABackend implements ISearchableGroupBackend, IAddToGroupBackend, ICreateGroupBackend, IGroupDetailsBackend, IRemoveFromGroupBackend, GroupInterface {
+
+}
+
+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')
+			->willReturn($userId);
+		$mockUser->expects($this->any())
+			->method('getDisplayName')
+			->willReturn($userId);
+		return $mockUser;
+	}
+
+	/**
+	 * @param null|int $implementedActions
+	 * @return \PHPUnit\Framework\MockObject\MockObject
+	 */
+	private function getTestBackend($implementedActions = null) {
+		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(TestBackend::class)
+			->disableOriginalConstructor()
+			->onlyMethods([
+				'getGroupDetails',
+				'implementsActions',
+				'getUserGroups',
+				'inGroup',
+				'getGroups',
+				'groupExists',
+				'groupsExists',
+				'usersInGroup',
+				'createGroup',
+				'addToGroup',
+				'removeFromGroup',
+				'searchInGroup',
+			])
+			->getMock();
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->willReturnCallback(function ($actions) use ($implementedActions) {
+				return (bool)($actions & $implementedActions);
+			});
+		return $backend;
+	}
+
+	public function testGet(): void {
+		/**
+		 * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
+		 */
+		$backend = $this->getTestBackend();
+		$backend->expects($this->any())
+			->method('groupExists')
+			->with('group1')
+			->willReturn(true);
+
+		$manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
+		$manager->addBackend($backend);
+
+		$group = $manager->get('group1');
+		$this->assertNotNull($group);
+		$this->assertEquals('group1', $group->getGID());
+	}
+
+	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(): void {
+		/**
+		 * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
+		 */
+		$backend = $this->getTestBackend();
+		$backend->expects($this->once())
+			->method('groupExists')
+			->with('group1')
+			->willReturn(false);
+
+		$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(): void {
+		$backend = new \Test\Util\Group\Dummy();
+		$backend->createGroup('group1');
+
+		$manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
+		$manager->addBackend($backend);
+
+		$group = $manager->get('group1');
+		$group->delete();
+		$this->assertNull($manager->get('group1'));
+	}
+
+	public function testGetMultipleBackends(): void {
+		/**
+		 * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend1
+		 */
+		$backend1 = $this->getTestBackend();
+		$backend1->expects($this->any())
+			->method('groupExists')
+			->with('group1')
+			->willReturn(false);
+
+		/**
+		 * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend2
+		 */
+		$backend2 = $this->getTestBackend();
+		$backend2->expects($this->any())
+			->method('groupExists')
+			->with('group1')
+			->willReturn(true);
+
+		$manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
+		$manager->addBackend($backend1);
+		$manager->addBackend($backend2);
+
+		$group = $manager->get('group1');
+		$this->assertNotNull($group);
+		$this->assertEquals('group1', $group->getGID());
+	}
+
+	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')
+			->willReturnCallback(function () use (&$backendGroupCreated) {
+				return $backendGroupCreated;
+			});
+		$backend->expects($this->once())
+			->method('createGroup')
+			->willReturnCallback(function () use (&$backendGroupCreated) {
+				$backendGroupCreated = true;
+				return true;
+			});
+
+		$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 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')
+			->willReturn(true);
+		$backend->expects($this->never())
+			->method('createGroup');
+
+		$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(): void {
+		/**
+		 * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
+		 */
+		$backend = $this->getTestBackend();
+		$backend->expects($this->once())
+			->method('getGroups')
+			->with('1')
+			->willReturn(['group1']);
+		$backend->expects($this->once())
+			->method('getGroupDetails')
+			->willReturnMap([
+				['group1', ['displayName' => 'group1']],
+			]);
+
+		$manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
+		$manager->addBackend($backend);
+
+		$groups = $manager->search('1');
+		$this->assertCount(1, $groups);
+		$group1 = reset($groups);
+		$this->assertEquals('group1', $group1->getGID());
+	}
+
+	public function testSearchMultipleBackends(): void {
+		/**
+		 * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend1
+		 */
+		$backend1 = $this->getTestBackend();
+		$backend1->expects($this->once())
+			->method('getGroups')
+			->with('1')
+			->willReturn(['group1']);
+		$backend1->expects($this->any())
+			->method('getGroupDetails')
+			->willReturnMap([
+				['group1', ['displayName' => 'group1']],
+				['group12', []],
+			]);
+
+		/**
+		 * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend2
+		 */
+		$backend2 = $this->getTestBackend();
+		$backend2->expects($this->once())
+			->method('getGroups')
+			->with('1')
+			->willReturn(['group12', 'group1']);
+		$backend2->expects($this->any())
+			->method('getGroupDetails')
+			->willReturnMap([
+				['group12', ['displayName' => 'group12']],
+				['group1', ['displayName' => 'group1']],
+			]);
+
+		$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->assertCount(2, $groups);
+		$group1 = reset($groups);
+		$group12 = next($groups);
+		$this->assertEquals('group1', $group1->getGID());
+		$this->assertEquals('group12', $group12->getGID());
+	}
+
+	public function testSearchMultipleBackendsLimitAndOffset(): void {
+		/**
+		 * @var \PHPUnit\Framework\MockObject\MockObject|\OC\Group\Backend $backend1
+		 */
+		$backend1 = $this->getTestBackend();
+		$backend1->expects($this->once())
+			->method('getGroups')
+			->with('1', 2, 1)
+			->willReturn(['group1']);
+		$backend1->expects($this->any())
+			->method('getGroupDetails')
+			->willReturnMap([
+				[1, []],
+				[2, []],
+				['group1', ['displayName' => 'group1']],
+				['group12', []],
+			]);
+
+		/**
+		 * @var \PHPUnit\Framework\MockObject\MockObject|\OC\Group\Backend $backend2
+		 */
+		$backend2 = $this->getTestBackend();
+		$backend2->expects($this->once())
+			->method('getGroups')
+			->with('1', 2, 1)
+			->willReturn(['group12']);
+		$backend2->expects($this->any())
+			->method('getGroupDetails')
+			->willReturnMap([
+				[1, []],
+				[2, []],
+				['group1', []],
+				['group12', ['displayName' => 'group12']],
+			]);
+
+		$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->assertCount(2, $groups);
+		$group1 = reset($groups);
+		$group12 = next($groups);
+		$this->assertEquals('group1', $group1->getGID());
+		$this->assertEquals('group12', $group12->getGID());
+	}
+
+	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
+		 */
+		$backend = $this->getTestBackend();
+		$backend->expects($this->once())
+			->method('getUserGroups')
+			->with('user1')
+			->willReturn(['group1']);
+		$backend->expects($this->any())
+			->method('groupExists')
+			->with('group1')
+			->willReturn(true);
+
+		$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->assertCount(1, $groups);
+		$group1 = reset($groups);
+		$this->assertEquals('group1', $group1->getGID());
+	}
+
+	public function testGetUserGroupIds(): void {
+		/**
+		 * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
+		 */
+		$backend = $this->getTestBackend();
+		$backend->method('getUserGroups')
+			->with('myUID')
+			->willReturn(['123', 'abc']);
+
+		$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->assertCount(2, $groups);
+
+		foreach ($groups as $group) {
+			$this->assertIsString($group);
+		}
+	}
+
+	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
+		 */
+		$backend = $this->getTestBackend();
+		$backend->expects($this->once())
+			->method('getUserGroups')
+			->with('user1')
+			->willReturn(['group1', 'admin', 'group2']);
+		$backend->expects($this->any())
+			->method('groupExists')
+			->willReturn(true);
+
+		$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(): void {
+		/**
+		 * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
+		 */
+		$backend = $this->getTestBackend();
+		$backend->expects($this->once())
+			->method('getUserGroups')
+			->with('user1')
+			->willReturn(['group1', 'admin', 'group2']);
+		$backend->expects($this->any())
+			->method('groupExists')
+			->willReturn(true);
+
+		$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(): void {
+		/**
+		 * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
+		 */
+		$backend = $this->getTestBackend();
+		$backend->expects($this->once())
+			->method('getUserGroups')
+			->with('user1')
+			->willReturn(['group1', 'group2']);
+		$backend->expects($this->any())
+			->method('groupExists')
+			->willReturn(true);
+
+		$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(): void {
+		/**
+		 * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend1
+		 */
+		$backend1 = $this->getTestBackend();
+		$backend1->expects($this->once())
+			->method('getUserGroups')
+			->with('user1')
+			->willReturn(['group1']);
+		$backend1->expects($this->any())
+			->method('groupExists')
+			->willReturn(true);
+
+		/**
+		 * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend2
+		 */
+		$backend2 = $this->getTestBackend();
+		$backend2->expects($this->once())
+			->method('getUserGroups')
+			->with('user1')
+			->willReturn(['group1', 'group2']);
+		$backend1->expects($this->any())
+			->method('groupExists')
+			->willReturn(true);
+
+		$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->assertCount(2, $groups);
+		$group1 = reset($groups);
+		$group2 = next($groups);
+		$this->assertEquals('group1', $group1->getGID());
+		$this->assertEquals('group2', $group2->getGID());
+	}
+
+	public function testDisplayNamesInGroupWithOneUserBackend(): void {
+		/**
+		 * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
+		 */
+		$backend = $this->getTestBackend();
+		$backend->expects($this->exactly(1))
+			->method('groupExists')
+			->with('testgroup')
+			->willReturn(true);
+
+		$backend->expects($this->any())
+			->method('inGroup')
+			->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;
+				}
+			});
+
+		$this->userManager->expects($this->any())
+			->method('searchDisplayName')
+			->with('user3')
+			->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')
+			->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, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
+		$manager->addBackend($backend);
+
+		$users = $manager->displayNamesInGroup('testgroup', 'user3');
+		$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(): void {
+		/**
+		 * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
+		 */
+		$backend = $this->getTestBackend();
+		$backend->expects($this->exactly(1))
+			->method('groupExists')
+			->with('testgroup')
+			->willReturn(true);
+
+		$backend->expects($this->any())
+			->method('inGroup')
+			->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')
+			->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')
+			->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, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
+		$manager->addBackend($backend);
+
+		$users = $manager->displayNamesInGroup('testgroup', 'user3', 1);
+		$this->assertCount(1, $users);
+		$this->assertFalse(isset($users['user1']));
+		$this->assertFalse(isset($users['user2']));
+		$this->assertFalse(isset($users['user3']));
+		$this->assertTrue(isset($users['user33']));
+		$this->assertFalse(isset($users['user333']));
+	}
+
+	public function testDisplayNamesInGroupWithOneUserBackendWithLimitAndOffsetSpecified(): void {
+		/**
+		 * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
+		 */
+		$backend = $this->getTestBackend();
+		$backend->expects($this->exactly(1))
+			->method('groupExists')
+			->with('testgroup')
+			->willReturn(true);
+
+		$backend->expects($this->any())
+			->method('inGroup')
+			->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')
+			->willReturnCallback(function ($search, $limit, $offset) {
+				switch ($offset) {
+					case 0:
+						return [
+							'user3' => $this->getTestUser('user3'),
+							'user33' => $this->getTestUser('user33'),
+							'user333' => $this->getTestUser('user333')
+						];
+				}
+				return null;
+			});
+		$this->userManager->expects($this->any())
+			->method('get')
+			->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, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
+		$manager->addBackend($backend);
+
+		$users = $manager->displayNamesInGroup('testgroup', 'user3', 1, 1);
+		$this->assertCount(1, $users);
+		$this->assertFalse(isset($users['user1']));
+		$this->assertFalse(isset($users['user2']));
+		$this->assertFalse(isset($users['user3']));
+		$this->assertFalse(isset($users['user33']));
+		$this->assertTrue(isset($users['user333']));
+	}
+
+	public function testDisplayNamesInGroupWithOneUserBackendAndSearchEmpty(): void {
+		/**
+		 * @var \PHPUnit\Framework\MockObject\MockObject|\OC\Group\Backend $backend
+		 */
+		$backend = $this->getTestBackend();
+		$backend->expects($this->exactly(1))
+			->method('groupExists')
+			->with('testgroup')
+			->willReturn(true);
+
+		$backend->expects($this->once())
+			->method('searchInGroup')
+			->with('testgroup', '', -1, 0)
+			->willReturn(['user2' => $this->getTestUser('user2'), 'user33' => $this->getTestUser('user33')]);
+
+		$this->userManager->expects($this->never())->method('get');
+
+		$manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
+		$manager->addBackend($backend);
+
+		$users = $manager->displayNamesInGroup('testgroup', '');
+		$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(): void {
+		/**
+		 * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
+		 */
+		$backend = $this->getTestBackend();
+		$backend->expects($this->exactly(1))
+			->method('groupExists')
+			->with('testgroup')
+			->willReturn(true);
+
+		$backend->expects($this->once())
+			->method('searchInGroup')
+			->with('testgroup', '', 1, 0)
+			->willReturn([new User('user2', null, $this->dispatcher)]);
+
+		$this->userManager->expects($this->never())->method('get');
+
+		$manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
+		$manager->addBackend($backend);
+
+		$users = $manager->displayNamesInGroup('testgroup', '', 1);
+		$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(): void {
+		/**
+		 * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
+		 */
+		$backend = $this->getTestBackend();
+		$backend->expects($this->exactly(1))
+			->method('groupExists')
+			->with('testgroup')
+			->willReturn(true);
+
+		$backend->expects($this->once())
+			->method('searchInGroup')
+			->with('testgroup', '', 1, 1)
+			->willReturn(['user33' => $this->getTestUser('user33')]);
+
+		$this->userManager->expects($this->never())->method('get');
+
+		$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->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(): void {
+		/**
+		 * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
+		 */
+		$backend = $this->getTestBackend();
+		$expectedGroups = [];
+		$backend->expects($this->any())
+			->method('getUserGroups')
+			->with('user1')
+			->willReturnCallback(function () use (&$expectedGroups) {
+				return $expectedGroups;
+			});
+		$backend->expects($this->any())
+			->method('groupExists')
+			->with('group1')
+			->willReturn(true);
+
+		$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([], $groups);
+
+		// add user
+		$group = $manager->get('group1');
+		$group->addUser($user1);
+		$expectedGroups[] = 'group1';
+
+		// check result
+		$groups = $manager->getUserGroups($user1);
+		$this->assertCount(1, $groups);
+		$group1 = reset($groups);
+		$this->assertEquals('group1', $group1->getGID());
+	}
+
+	public function testGetUserGroupsWithRemoveUser(): void {
+		/**
+		 * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
+		 */
+		$backend = $this->getTestBackend();
+		$expectedGroups = ['group1'];
+		$backend->expects($this->any())
+			->method('getUserGroups')
+			->with('user1')
+			->willReturnCallback(function () use (&$expectedGroups) {
+				return $expectedGroups;
+			});
+		$backend->expects($this->any())
+			->method('groupExists')
+			->with('group1')
+			->willReturn(true);
+		$backend->expects($this->once())
+			->method('inGroup')
+			->willReturn(true);
+		$backend->expects($this->once())
+			->method('removeFromGroup')
+			->willReturn(true);
+
+		$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->assertCount(1, $groups);
+		$group1 = reset($groups);
+		$this->assertEquals('group1', $group1->getGID());
+
+		// remove user
+		$group = $manager->get('group1');
+		$group->removeUser($user1);
+		$expectedGroups = [];
+
+		// check result
+		$groups = $manager->getUserGroups($user1);
+		$this->assertEquals($expectedGroups, $groups);
+	}
+
+	public function testGetUserIdGroups(): void {
+		/**
+		 * @var \PHPUnit\Framework\MockObject\MockObject | \OC\Group\Backend $backend
+		 */
+		$backend = $this->getTestBackend();
+		$backend->expects($this->any())
+			->method('getUserGroups')
+			->with('user1')
+			->willReturn(null);
+
+		$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(): void {
+		/**
+		 * @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
+		);
+		$backend->expects($this->any())
+			->method('getGroupDetails')
+			->willReturnMap([
+				['group1', ['gid' => 'group1', 'displayName' => 'Group One']],
+				['group2', ['gid' => 'group2']],
+			]);
+		$manager = new \OC\Group\Manager($this->userManager, $this->dispatcher, $this->logger, $this->cache, $this->remoteIpAddress);
+		$manager->addBackend($backend);
+
+		// group with display name
+		$group = $manager->get('group1');
+		$this->assertNotNull($group);
+		$this->assertEquals('group1', $group->getGID());
+		$this->assertEquals('Group One', $group->getDisplayName());
+
+		// group without display name
+		$group = $manager->get('group2');
+		$this->assertNotNull($group);
+		$this->assertEquals('group2', $group->getGID());
+		$this->assertEquals('group2', $group->getDisplayName());
+	}
+}
diff --git a/tests/lib/Group/MetaDataTest.php b/tests/lib/Group/MetaDataTest.php
new file mode 100644
index 00000000000..dee59eab8da
--- /dev/null
+++ b/tests/lib/Group/MetaDataTest.php
@@ -0,0 +1,121 @@
+<?php
+
+/**
+ * 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\MetaData;
+use OCP\IUserSession;
+
+class MetaDataTest extends \Test\TestCase {
+	private \OC\Group\Manager $groupManager;
+	private IUserSession $userSession;
+	private MetaData $groupMetadata;
+	private bool $isAdmin = true;
+	private bool $isDelegatedAdmin = true;
+
+	protected function setUp(): void {
+		parent::setUp();
+		$this->groupManager = $this->getMockBuilder('\OC\Group\Manager')
+			->disableOriginalConstructor()
+			->getMock();
+		$this->userSession = $this->createMock(IUserSession::class);
+		$this->groupMetadata = new MetaData(
+			'foo',
+			$this->isAdmin,
+			$this->isDelegatedAdmin,
+			$this->groupManager,
+			$this->userSession
+		);
+	}
+
+	private function getGroupMock($countCallCount = 0) {
+		$group = $this->getMockBuilder('\OC\Group\Group')
+			->disableOriginalConstructor()
+			->getMock();
+
+		$group->expects($this->exactly(6))
+			->method('getGID')->willReturnOnConsecutiveCalls('admin', 'admin', 'g2', 'g2', 'g3', 'g3');
+
+		$group->expects($this->exactly(3))
+			->method('getDisplayName')->willReturnOnConsecutiveCalls('admin', 'g2', 'g3');
+
+		$group->expects($this->exactly($countCallCount))
+			->method('count')
+			->with('')->willReturnOnConsecutiveCalls(2, 3, 5);
+
+		return $group;
+	}
+
+
+	public function testGet(): void {
+		$group = $this->getGroupMock();
+		$groups = array_fill(0, 3, $group);
+
+		$this->groupManager->expects($this->once())
+			->method('search')
+			->with('')
+			->willReturn($groups);
+
+		[$adminGroups, $ordinaryGroups] = $this->groupMetadata->get();
+
+		$this->assertSame(1, count($adminGroups));
+		$this->assertSame(2, count($ordinaryGroups));
+
+		$this->assertSame('g2', $ordinaryGroups[0]['name']);
+		// user count is not loaded
+		$this->assertSame(0, $ordinaryGroups[0]['usercount']);
+	}
+
+	public function testGetWithSorting(): void {
+		$this->groupMetadata->setSorting(1);
+		$group = $this->getGroupMock(3);
+		$groups = array_fill(0, 3, $group);
+
+		$this->groupManager->expects($this->once())
+			->method('search')
+			->with('')
+			->willReturn($groups);
+
+		[$adminGroups, $ordinaryGroups] = $this->groupMetadata->get();
+
+		$this->assertSame(1, count($adminGroups));
+		$this->assertSame(2, count($ordinaryGroups));
+
+		$this->assertSame('g3', $ordinaryGroups[0]['name']);
+		$this->assertSame(5, $ordinaryGroups[0]['usercount']);
+	}
+
+	public function testGetWithCache(): void {
+		$group = $this->getGroupMock();
+		$groups = array_fill(0, 3, $group);
+
+		$this->groupManager->expects($this->once())
+			->method('search')
+			->with('')
+			->willReturn($groups);
+
+		//two calls, if caching fails call counts for group and groupmanager
+		//are exceeded
+		$this->groupMetadata->get();
+		$this->groupMetadata->get();
+	}
+
+	//get() does not need to be tested with search parameters, because they are
+	//solely and only passed to GroupManager and Group.
+
+	public function testGetGroupsAsAdmin(): void {
+		$this->groupManager
+			->expects($this->once())
+			->method('search')
+			->with('Foo')
+			->willReturn(['DummyValue']);
+
+		$expected = ['DummyValue'];
+		$this->assertSame($expected, $this->invokePrivate($this->groupMetadata, 'getGroups', ['Foo']));
+	}
+}