11 files changed, 5759 insertions, 2935 deletions

diff --git a/apps/provisioning_api/tests/CapabilitiesTest.php b/apps/provisioning_api/tests/CapabilitiesTest.php
new file mode 100644
index 00000000000..86d2bb8c4fa
--- /dev/null
+++ b/apps/provisioning_api/tests/CapabilitiesTest.php
@@ -0,0 +1,77 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * SPDX-FileCopyrightText: 2021 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+namespace OCA\Provisioning_API\Tests;
+
+use OCA\FederatedFileSharing\FederatedShareProvider;
+use OCA\Provisioning_API\Capabilities;
+use OCP\App\IAppManager;
+use PHPUnit\Framework\MockObject\MockObject;
+use Test\TestCase;
+
+/**
+ * Capabilities test for provisioning API.
+ *
+ * Note: group DB needed because of usage of overwriteService()
+ *
+ * @package OCA\Provisioning_API\Tests
+ * @group DB
+ */
+class CapabilitiesTest extends TestCase {
+
+	protected IAppManager&MockObject $appManager;
+	protected Capabilities $capabilities;
+
+	public function setUp(): void {
+		parent::setUp();
+		$this->appManager = $this->createMock(IAppManager::class);
+		$this->capabilities = new Capabilities($this->appManager);
+
+		$this->appManager->expects($this->once())
+			->method('getAppVersion')
+			->with('provisioning_api')
+			->willReturn('1.12');
+	}
+
+	public static function getCapabilitiesProvider(): array {
+		return [
+			[true, false, false, true, false],
+			[true, true, false, true, false],
+			[true, true, true, true, true],
+			[false, false, false, false, false],
+			[false, true, false, false, false],
+			[false, true, true, false, true],
+		];
+	}
+
+	#[\PHPUnit\Framework\Attributes\DataProvider('getCapabilitiesProvider')]
+	public function testGetCapabilities(bool $federationAppEnabled, bool $federatedFileSharingAppEnabled, bool $lookupServerEnabled, bool $expectedFederatedScopeEnabled, bool $expectedPublishedScopeEnabled): void {
+		$this->appManager->expects($this->any())
+			->method('isEnabledForUser')
+			->willReturnMap([
+				['federation', null, $federationAppEnabled],
+				['federatedfilesharing', null, $federatedFileSharingAppEnabled],
+			]);
+
+		$federatedShareProvider = $this->createMock(FederatedShareProvider::class);
+		$this->overwriteService(FederatedShareProvider::class, $federatedShareProvider);
+
+		$federatedShareProvider->expects($this->any())
+			->method('isLookupServerUploadEnabled')
+			->willReturn($lookupServerEnabled);
+
+		$expected = [
+			'provisioning_api' => [
+				'version' => '1.12',
+				'AccountPropertyScopesVersion' => 2,
+				'AccountPropertyScopesFederatedEnabled' => $expectedFederatedScopeEnabled,
+				'AccountPropertyScopesPublishedEnabled' => $expectedPublishedScopeEnabled,
+			],
+		];
+		$this->assertSame($expected, $this->capabilities->getCapabilities());
+	}
+}
diff --git a/apps/provisioning_api/tests/Controller/AppConfigControllerTest.php b/apps/provisioning_api/tests/Controller/AppConfigControllerTest.php
new file mode 100644
index 00000000000..1b09838cbc3
--- /dev/null
+++ b/apps/provisioning_api/tests/Controller/AppConfigControllerTest.php
@@ -0,0 +1,396 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * SPDX-FileCopyrightText: 2016 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+namespace OCA\Provisioning_API\Tests\Controller;
+
+use OC\AppConfig;
+use OCA\Provisioning_API\Controller\AppConfigController;
+use OCP\App\IAppManager;
+use OCP\AppFramework\Http;
+use OCP\AppFramework\Http\DataResponse;
+use OCP\Exceptions\AppConfigUnknownKeyException;
+use OCP\IAppConfig;
+use OCP\IGroupManager;
+use OCP\IL10N;
+use OCP\IRequest;
+use OCP\IUser;
+use OCP\IUserSession;
+use OCP\Server;
+use OCP\Settings\IManager;
+use PHPUnit\Framework\MockObject\MockObject;
+use Test\TestCase;
+use function json_decode;
+use function json_encode;
+
+/**
+ * Class AppConfigControllerTest
+ *
+ * @package OCA\Provisioning_API\Tests
+ */
+class AppConfigControllerTest extends TestCase {
+	private IAppConfig&MockObject $appConfig;
+	private IUserSession&MockObject $userSession;
+	private IL10N&MockObject $l10n;
+	private IManager&MockObject $settingManager;
+	private IGroupManager&MockObject $groupManager;
+	private IAppManager $appManager;
+
+	protected function setUp(): void {
+		parent::setUp();
+
+		$this->appConfig = $this->createMock(AppConfig::class);
+		$this->userSession = $this->createMock(IUserSession::class);
+		$this->l10n = $this->createMock(IL10N::class);
+		$this->settingManager = $this->createMock(IManager::class);
+		$this->groupManager = $this->createMock(IGroupManager::class);
+		$this->appManager = Server::get(IAppManager::class);
+	}
+
+	/**
+	 * @param string[] $methods
+	 * @return AppConfigController|MockObject
+	 */
+	protected function getInstance(array $methods = []) {
+		$request = $this->createMock(IRequest::class);
+
+		if (empty($methods)) {
+			return new AppConfigController(
+				'provisioning_api',
+				$request,
+				$this->appConfig,
+				$this->userSession,
+				$this->l10n,
+				$this->groupManager,
+				$this->settingManager,
+				$this->appManager,
+			);
+		} else {
+			return $this->getMockBuilder(AppConfigController::class)
+				->setConstructorArgs([
+					'provisioning_api',
+					$request,
+					$this->appConfig,
+					$this->userSession,
+					$this->l10n,
+					$this->groupManager,
+					$this->settingManager,
+					$this->appManager,
+				])
+				->onlyMethods($methods)
+				->getMock();
+		}
+	}
+
+	public function testGetApps(): void {
+		$this->appConfig->expects($this->once())
+			->method('getApps')
+			->willReturn(['apps']);
+
+		$result = $this->getInstance()->getApps();
+		$this->assertInstanceOf(DataResponse::class, $result);
+		$this->assertSame(Http::STATUS_OK, $result->getStatus());
+		$this->assertEquals(['data' => ['apps']], $result->getData());
+	}
+
+	public static function dataGetKeys(): array {
+		return [
+			['app1 ', null, new \InvalidArgumentException('error'), Http::STATUS_FORBIDDEN],
+			['app2', ['keys'], null, Http::STATUS_OK],
+		];
+	}
+
+	#[\PHPUnit\Framework\Attributes\DataProvider('dataGetKeys')]
+	public function testGetKeys(string $app, ?array $keys, ?\Throwable $throws, int $status): void {
+		$api = $this->getInstance(['verifyAppId']);
+		if ($throws instanceof \Exception) {
+			$api->expects($this->once())
+				->method('verifyAppId')
+				->with($app)
+				->willThrowException($throws);
+
+			$this->appConfig->expects($this->never())
+				->method('getKeys');
+		} else {
+			$api->expects($this->once())
+				->method('verifyAppId')
+				->with($app);
+
+			$this->appConfig->expects($this->once())
+				->method('getKeys')
+				->with($app)
+				->willReturn($keys);
+		}
+
+		$result = $api->getKeys($app);
+		$this->assertInstanceOf(DataResponse::class, $result);
+		$this->assertSame($status, $result->getStatus());
+		if ($throws instanceof \Exception) {
+			$this->assertEquals(['data' => ['message' => $throws->getMessage()]], $result->getData());
+		} else {
+			$this->assertEquals(['data' => $keys], $result->getData());
+		}
+	}
+
+	public static function dataGetValue(): array {
+		return [
+			['app1', 'key', 'default', null, new \InvalidArgumentException('error'), Http::STATUS_FORBIDDEN],
+			['app2', 'key', 'default', 'return', null, Http::STATUS_OK],
+		];
+	}
+
+	#[\PHPUnit\Framework\Attributes\DataProvider('dataGetValue')]
+	public function testGetValue(string $app, string $key, string $default, ?string $return, ?\Throwable $throws, int $status): void {
+		$api = $this->getInstance(['verifyAppId']);
+		if ($throws instanceof \Exception) {
+			$api->expects($this->once())
+				->method('verifyAppId')
+				->with($app)
+				->willThrowException($throws);
+		} else {
+			$api->expects($this->once())
+				->method('verifyAppId')
+				->with($app);
+
+			$this->appConfig->expects($this->once())
+				->method('getValueMixed')
+				->with($app, $key, $default)
+				->willReturn($return);
+		}
+
+		$result = $api->getValue($app, $key, $default);
+		$this->assertInstanceOf(DataResponse::class, $result);
+		$this->assertSame($status, $result->getStatus());
+		if ($throws instanceof \Exception) {
+			$this->assertEquals(['data' => ['message' => $throws->getMessage()]], $result->getData());
+		} else {
+			$this->assertEquals(['data' => $return], $result->getData());
+		}
+	}
+
+	public static function dataSetValue(): array {
+		return [
+			['app1', 'key', 'default', new \InvalidArgumentException('error1'), null, Http::STATUS_FORBIDDEN],
+			['app2', 'key', 'default', null, new \InvalidArgumentException('error2'), Http::STATUS_FORBIDDEN],
+			['app2', 'key', 'default', null, null, Http::STATUS_OK],
+			['app2', 'key', '1', null, null, Http::STATUS_OK, IAppConfig::VALUE_BOOL],
+			['app2', 'key', '42', null, null, Http::STATUS_OK, IAppConfig::VALUE_INT],
+			['app2', 'key', '4.2', null, null, Http::STATUS_OK, IAppConfig::VALUE_FLOAT],
+			['app2', 'key', '42', null, null, Http::STATUS_OK, IAppConfig::VALUE_STRING],
+			['app2', 'key', 'secret', null, null, Http::STATUS_OK, IAppConfig::VALUE_STRING | IAppConfig::VALUE_SENSITIVE],
+			['app2', 'key', json_encode([4, 2]), null, null, Http::STATUS_OK, IAppConfig::VALUE_ARRAY],
+			['app2', 'key', json_encode([4, 2]), null, null, Http::STATUS_OK, new AppConfigUnknownKeyException()],
+		];
+	}
+
+	#[\PHPUnit\Framework\Attributes\DataProvider('dataSetValue')]
+	public function testSetValue(string $app, string $key, string $value, ?\Throwable $appThrows, ?\Throwable $keyThrows, int $status, int|\Throwable $type = IAppConfig::VALUE_MIXED): void {
+		$adminUser = $this->createMock(IUser::class);
+		$adminUser->expects($this->once())
+			->method('getUid')
+			->willReturn('admin');
+
+		$this->userSession->expects($this->once())
+			->method('getUser')
+			->willReturn($adminUser);
+		$this->groupManager->expects($this->once())
+			->method('isAdmin')
+			->with('admin')
+			->willReturn(true);
+		$api = $this->getInstance(['verifyAppId', 'verifyConfigKey']);
+		if ($appThrows instanceof \Exception) {
+			$api->expects($this->once())
+				->method('verifyAppId')
+				->with($app)
+				->willThrowException($appThrows);
+
+			$api->expects($this->never())
+				->method('verifyConfigKey');
+			$this->appConfig->expects($this->never())
+				->method('setValueMixed');
+		} elseif ($keyThrows instanceof  \Exception) {
+			$api->expects($this->once())
+				->method('verifyAppId')
+				->with($app);
+			$api->expects($this->once())
+				->method('verifyConfigKey')
+				->with($app, $key)
+				->willThrowException($keyThrows);
+
+			$this->appConfig->expects($this->never())
+				->method('setValueMixed');
+		} else {
+			$api->expects($this->once())
+				->method('verifyAppId')
+				->with($app);
+			$api->expects($this->once())
+				->method('verifyConfigKey')
+				->with($app, $key);
+
+			if ($type instanceof \Throwable) {
+				$this->appConfig->expects($this->once())
+					->method('getDetails')
+					->with($app, $key)
+					->willThrowException($type);
+			} else {
+				$this->appConfig->expects($this->once())
+					->method('getDetails')
+					->with($app, $key)
+					->willReturn([
+						'app' => $app,
+						'key' => $key,
+						'value' => '', // 🤷
+						'type' => $type,
+						'lazy' => false,
+						'typeString' => (string)$type, // this is not accurate, but acceptable
+						'sensitive' => ($type & IAppConfig::VALUE_SENSITIVE) !== 0,
+					]);
+			}
+
+			$configValueSetter = match ($type) {
+				IAppConfig::VALUE_BOOL => 'setValueBool',
+				IAppConfig::VALUE_FLOAT => 'setValueFloat',
+				IAppConfig::VALUE_INT => 'setValueInt',
+				IAppConfig::VALUE_STRING => 'setValueString',
+				IAppConfig::VALUE_ARRAY => 'setValueArray',
+				default => 'setValueMixed',
+			};
+
+			$this->appConfig->expects($this->once())
+				->method($configValueSetter)
+				->with($app, $key, $configValueSetter === 'setValueArray' ? json_decode($value, true) : $value);
+		}
+
+		$result = $api->setValue($app, $key, $value);
+		$this->assertInstanceOf(DataResponse::class, $result);
+		$this->assertSame($status, $result->getStatus());
+		if ($appThrows instanceof \Exception) {
+			$this->assertEquals(['data' => ['message' => $appThrows->getMessage()]], $result->getData());
+		} elseif ($keyThrows instanceof \Exception) {
+			$this->assertEquals(['data' => ['message' => $keyThrows->getMessage()]], $result->getData());
+		} else {
+			$this->assertEquals([], $result->getData());
+		}
+	}
+
+	public static function dataDeleteValue(): array {
+		return [
+			['app1', 'key', new \InvalidArgumentException('error1'), null, Http::STATUS_FORBIDDEN],
+			['app2', 'key', null, new \InvalidArgumentException('error2'), Http::STATUS_FORBIDDEN],
+			['app2', 'key', null, null, Http::STATUS_OK],
+		];
+	}
+
+	#[\PHPUnit\Framework\Attributes\DataProvider('dataDeleteValue')]
+	public function testDeleteValue(string $app, string $key, ?\Throwable $appThrows, ?\Throwable $keyThrows, int $status): void {
+		$api = $this->getInstance(['verifyAppId', 'verifyConfigKey']);
+		if ($appThrows instanceof \Exception) {
+			$api->expects($this->once())
+				->method('verifyAppId')
+				->with($app)
+				->willThrowException($appThrows);
+
+			$api->expects($this->never())
+				->method('verifyConfigKey');
+			$this->appConfig->expects($this->never())
+				->method('deleteKey');
+		} elseif ($keyThrows instanceof  \Exception) {
+			$api->expects($this->once())
+				->method('verifyAppId')
+				->with($app);
+			$api->expects($this->once())
+				->method('verifyConfigKey')
+				->with($app, $key)
+				->willThrowException($keyThrows);
+
+			$this->appConfig->expects($this->never())
+				->method('deleteKey');
+		} else {
+			$api->expects($this->once())
+				->method('verifyAppId')
+				->with($app);
+			$api->expects($this->once())
+				->method('verifyConfigKey')
+				->with($app, $key);
+
+			$this->appConfig->expects($this->once())
+				->method('deleteKey')
+				->with($app, $key);
+		}
+
+		$result = $api->deleteKey($app, $key);
+		$this->assertInstanceOf(DataResponse::class, $result);
+		$this->assertSame($status, $result->getStatus());
+		if ($appThrows instanceof \Exception) {
+			$this->assertEquals(['data' => ['message' => $appThrows->getMessage()]], $result->getData());
+		} elseif ($keyThrows instanceof \Exception) {
+			$this->assertEquals(['data' => ['message' => $keyThrows->getMessage()]], $result->getData());
+		} else {
+			$this->assertEquals([], $result->getData());
+		}
+	}
+
+	public function testVerifyAppId(): void {
+		$api = $this->getInstance();
+		$this->invokePrivate($api, 'verifyAppId', ['activity']);
+		$this->addToAssertionCount(1);
+	}
+
+	public static function dataVerifyAppIdThrows(): array {
+		return [
+			['activity..'],
+			['activity/'],
+			['activity\\'],
+			['activity\0'],
+		];
+	}
+
+	#[\PHPUnit\Framework\Attributes\DataProvider('dataVerifyAppIdThrows')]
+	public function testVerifyAppIdThrows(string $app): void {
+		$this->expectException(\InvalidArgumentException::class);
+
+		$api = $this->getInstance();
+		$this->invokePrivate($api, 'verifyAppId', [$app]);
+	}
+
+	public static function dataVerifyConfigKey(): array {
+		return [
+			['activity', 'abc', ''],
+			['dav', 'public_route', ''],
+			['files', 'remote_route', ''],
+			['core', 'encryption_enabled', 'yes'],
+		];
+	}
+
+	#[\PHPUnit\Framework\Attributes\DataProvider('dataVerifyConfigKey')]
+	public function testVerifyConfigKey(string $app, string $key, string $value): void {
+		$api = $this->getInstance();
+		$this->invokePrivate($api, 'verifyConfigKey', [$app, $key, $value]);
+		$this->addToAssertionCount(1);
+	}
+
+	public static function dataVerifyConfigKeyThrows(): array {
+		return [
+			['activity', 'installed_version', ''],
+			['calendar', 'enabled', ''],
+			['contacts', 'types', ''],
+			['core', 'encryption_enabled', 'no'],
+			['core', 'encryption_enabled', ''],
+			['core', 'public_files', ''],
+			['core', 'public_dav', ''],
+			['core', 'remote_files', ''],
+			['core', 'remote_dav', ''],
+		];
+	}
+
+	#[\PHPUnit\Framework\Attributes\DataProvider('dataVerifyConfigKeyThrows')]
+	public function testVerifyConfigKeyThrows(string $app, string $key, string $value): void {
+		$this->expectException(\InvalidArgumentException::class);
+
+		$api = $this->getInstance();
+		$this->invokePrivate($api, 'verifyConfigKey', [$app, $key, $value]);
+	}
+}
diff --git a/apps/provisioning_api/tests/Controller/AppsControllerTest.php b/apps/provisioning_api/tests/Controller/AppsControllerTest.php
new file mode 100644
index 00000000000..f95daeae7d3
--- /dev/null
+++ b/apps/provisioning_api/tests/Controller/AppsControllerTest.php
@@ -0,0 +1,110 @@
+<?php
+
+/**
+ * SPDX-FileCopyrightText: 2016-2024 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-FileCopyrightText: 2016 ownCloud, Inc.
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+namespace OCA\Provisioning_API\Tests\Controller;
+
+use OC\Installer;
+use OCA\Provisioning_API\Controller\AppsController;
+use OCA\Provisioning_API\Tests\TestCase;
+use OCP\App\IAppManager;
+use OCP\AppFramework\OCS\OCSException;
+use OCP\IAppConfig;
+use OCP\IGroupManager;
+use OCP\IRequest;
+use OCP\IUserSession;
+use OCP\Server;
+use PHPUnit\Framework\MockObject\MockObject;
+
+/**
+ * Class AppsTest
+ *
+ * @group DB
+ *
+ * @package OCA\Provisioning_API\Tests
+ */
+class AppsControllerTest extends TestCase {
+	private IAppManager $appManager;
+	private IAppConfig&MockObject $appConfig;
+	private Installer&MockObject $installer;
+	private AppsController $api;
+	private IUserSession $userSession;
+
+	protected function setUp(): void {
+		parent::setUp();
+
+		$this->appManager = Server::get(IAppManager::class);
+		$this->groupManager = Server::get(IGroupManager::class);
+		$this->userSession = Server::get(IUserSession::class);
+		$this->appConfig = $this->createMock(IAppConfig::class);
+		$this->installer = $this->createMock(Installer::class);
+
+		$request = $this->createMock(IRequest::class);
+
+		$this->api = new AppsController(
+			'provisioning_api',
+			$request,
+			$this->appManager,
+			$this->installer,
+			$this->appConfig,
+		);
+	}
+
+	protected function tearDown(): void {
+		$this->userSession->setUser(null);
+	}
+
+	public function testGetAppInfo(): void {
+		$result = $this->api->getAppInfo('provisioning_api');
+		$expected = $this->appManager->getAppInfo('provisioning_api');
+		$this->assertEquals($expected, $result->getData());
+	}
+
+
+	public function testGetAppInfoOnBadAppID(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(998);
+
+		$this->api->getAppInfo('not_provisioning_api');
+	}
+
+	public function testGetApps(): void {
+		$user = $this->generateUsers();
+		$this->groupManager->get('admin')->addUser($user);
+		$this->userSession->setUser($user);
+
+		$result = $this->api->getApps();
+
+		$data = $result->getData();
+		$this->assertEquals(count((new \OC_App())->listAllApps()), count($data['apps']));
+	}
+
+	public function testGetAppsEnabled(): void {
+		$result = $this->api->getApps('enabled');
+		$data = $result->getData();
+		$this->assertEquals(count(\OC_App::getEnabledApps()), count($data['apps']));
+	}
+
+	public function testGetAppsDisabled(): void {
+		$result = $this->api->getApps('disabled');
+		$data = $result->getData();
+		$apps = (new \OC_App)->listAllApps();
+		$list = [];
+		foreach ($apps as $app) {
+			$list[] = $app['id'];
+		}
+		$disabled = array_diff($list, \OC_App::getEnabledApps());
+		$this->assertEquals(count($disabled), count($data['apps']));
+	}
+
+
+	public function testGetAppsInvalidFilter(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(101);
+
+		$this->api->getApps('foo');
+	}
+}
diff --git a/apps/provisioning_api/tests/Controller/GroupsControllerTest.php b/apps/provisioning_api/tests/Controller/GroupsControllerTest.php
new file mode 100644
index 00000000000..85e5d733b1f
--- /dev/null
+++ b/apps/provisioning_api/tests/Controller/GroupsControllerTest.php
@@ -0,0 +1,548 @@
+<?php
+
+/**
+ * SPDX-FileCopyrightText: 2017-2024 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-FileCopyrightText: 2016 ownCloud, Inc.
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+namespace OCA\Provisioning_API\Tests\Controller;
+
+use OC\Group\Manager;
+use OC\User\NoUserException;
+use OCA\Provisioning_API\Controller\GroupsController;
+use OCP\Accounts\IAccountManager;
+use OCP\AppFramework\OCS\OCSException;
+use OCP\Files\IRootFolder;
+use OCP\Group\ISubAdmin;
+use OCP\IConfig;
+use OCP\IGroup;
+use OCP\IRequest;
+use OCP\IUser;
+use OCP\IUserManager;
+use OCP\IUserSession;
+use OCP\L10N\IFactory;
+use OCP\UserInterface;
+use PHPUnit\Framework\MockObject\MockObject;
+use Psr\Log\LoggerInterface;
+
+class GroupsControllerTest extends \Test\TestCase {
+	protected IRequest&MockObject $request;
+	protected IUserManager&MockObject $userManager;
+	protected IConfig&MockObject $config;
+	protected Manager&MockObject $groupManager;
+	protected IUserSession&MockObject $userSession;
+	protected IAccountManager&MockObject $accountManager;
+	protected ISubAdmin&MockObject $subAdminManager;
+	protected IFactory&MockObject $l10nFactory;
+	protected LoggerInterface&MockObject $logger;
+	protected GroupsController&MockObject $api;
+
+	private IRootFolder $rootFolder;
+
+
+	protected function setUp(): void {
+		parent::setUp();
+
+		$this->request = $this->createMock(IRequest::class);
+		$this->userManager = $this->createMock(IUserManager::class);
+		$this->config = $this->createMock(IConfig::class);
+		$this->groupManager = $this->createMock(Manager::class);
+		$this->userSession = $this->createMock(IUserSession::class);
+		$this->accountManager = $this->createMock(IAccountManager::class);
+		$this->subAdminManager = $this->createMock(ISubAdmin::class);
+		$this->l10nFactory = $this->createMock(IFactory::class);
+		$this->logger = $this->createMock(LoggerInterface::class);
+		$this->rootFolder = $this->createMock(IRootFolder::class);
+
+		$this->groupManager
+			->method('getSubAdmin')
+			->willReturn($this->subAdminManager);
+
+		$this->api = $this->getMockBuilder(GroupsController::class)
+			->setConstructorArgs([
+				'provisioning_api',
+				$this->request,
+				$this->userManager,
+				$this->config,
+				$this->groupManager,
+				$this->userSession,
+				$this->accountManager,
+				$this->subAdminManager,
+				$this->l10nFactory,
+				$this->rootFolder,
+				$this->logger
+			])
+			->onlyMethods(['fillStorageInfo'])
+			->getMock();
+	}
+
+	private function createGroup(string $gid): IGroup&MockObject {
+		$group = $this->createMock(IGroup::class);
+		$group
+			->method('getGID')
+			->willReturn($gid);
+		$group
+			->method('getDisplayName')
+			->willReturn($gid . '-name');
+		$group
+			->method('count')
+			->willReturn(123);
+		$group
+			->method('countDisabled')
+			->willReturn(11);
+		$group
+			->method('canAddUser')
+			->willReturn(true);
+		$group
+			->method('canRemoveUser')
+			->willReturn(true);
+
+		return $group;
+	}
+
+	/**
+	 * @param string $uid
+	 * @return IUser&MockObject
+	 */
+	private function createUser($uid) {
+		$user = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$user
+			->method('getUID')
+			->willReturn($uid);
+		$backendMock = $this->createMock(UserInterface::class);
+		$user
+			->method('getBackend')
+			->willReturn($backendMock);
+		return $user;
+	}
+
+	private function asUser() {
+		$user = $this->createUser('user');
+		$this->userSession
+			->method('getUser')
+			->willReturn($user);
+	}
+
+	private function asAdmin() {
+		$user = $this->createUser('admin');
+		$this->userSession
+			->method('getUser')
+			->willReturn($user);
+
+		$this->groupManager
+			->method('isAdmin')
+			->with('admin')
+			->willReturn(true);
+	}
+
+	private function asSubAdminOfGroup($group) {
+		$user = $this->createUser('subAdmin');
+		$this->userSession
+			->method('getUser')
+			->willReturn($user);
+
+		$this->subAdminManager
+			->method('isSubAdminOfGroup')
+			->willReturnCallback(function ($_user, $_group) use ($user, $group) {
+				if ($_user === $user && $_group === $group) {
+					return true;
+				}
+				return false;
+			});
+	}
+
+	public static function dataGetGroups(): array {
+		return [
+			[null, 0, 0],
+			['foo', 0, 0],
+			[null, 1, 0],
+			[null, 0, 2],
+			['foo', 1, 2],
+		];
+	}
+
+	#[\PHPUnit\Framework\Attributes\DataProvider('dataGetGroups')]
+	public function testGetGroups(?string $search, int $limit, int $offset): void {
+		$groups = [$this->createGroup('group1'), $this->createGroup('group2')];
+
+		$search = $search === null ? '' : $search;
+
+		$this->groupManager
+			->expects($this->once())
+			->method('search')
+			->with($search, $limit, $offset)
+			->willReturn($groups);
+
+		$result = $this->api->getGroups($search, $limit, $offset);
+		$this->assertEquals(['groups' => ['group1', 'group2']], $result->getData());
+	}
+
+	/**
+	 *
+	 * @param string|null $search
+	 * @param int|null $limit
+	 * @param int|null $offset
+	 */
+	#[\PHPUnit\Framework\Attributes\DataProvider('dataGetGroups')]
+	public function testGetGroupsDetails($search, $limit, $offset): void {
+		$groups = [$this->createGroup('group1'), $this->createGroup('group2')];
+
+		$search = $search === null ? '' : $search;
+
+		$this->groupManager
+			->expects($this->once())
+			->method('search')
+			->with($search, $limit, $offset)
+			->willReturn($groups);
+
+		$result = $this->api->getGroupsDetails($search, $limit, $offset);
+		$this->assertEquals(['groups' => [
+			[
+				'id' => 'group1',
+				'displayname' => 'group1-name',
+				'usercount' => 123,
+				'disabled' => 11,
+				'canAdd' => true,
+				'canRemove' => true
+			],
+			[
+				'id' => 'group2',
+				'displayname' => 'group2-name',
+				'usercount' => 123,
+				'disabled' => 11,
+				'canAdd' => true,
+				'canRemove' => true
+			]
+		]], $result->getData());
+	}
+
+	public function testGetGroupAsSubadmin(): void {
+		$group = $this->createGroup('group');
+		$this->asSubAdminOfGroup($group);
+
+		$this->groupManager
+			->method('get')
+			->with('group')
+			->willReturn($group);
+		$this->groupManager
+			->method('groupExists')
+			->with('group')
+			->willReturn(true);
+		$group
+			->method('getUsers')
+			->willReturn([
+				$this->createUser('user1'),
+				$this->createUser('user2')
+			]);
+
+		$result = $this->api->getGroup('group');
+
+		$this->assertEquals(['users' => ['user1', 'user2']], $result->getData());
+	}
+
+
+	public function testGetGroupAsIrrelevantSubadmin(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(403);
+
+		$group = $this->createGroup('group');
+		$otherGroup = $this->createGroup('otherGroup');
+		$this->asSubAdminOfGroup($otherGroup);
+
+		$this->groupManager
+			->method('get')
+			->with('group')
+			->willReturn($group);
+		$this->groupManager
+			->method('groupExists')
+			->with('group')
+			->willReturn(true);
+
+		$this->api->getGroup('group');
+	}
+
+	public function testGetGroupAsAdmin(): void {
+		$group = $this->createGroup('group');
+		$this->asAdmin();
+
+		$this->groupManager
+			->method('get')
+			->with('group')
+			->willReturn($group);
+		$this->groupManager
+			->method('groupExists')
+			->with('group')
+			->willReturn(true);
+		$group
+			->method('getUsers')
+			->willReturn([
+				$this->createUser('user1'),
+				$this->createUser('user2')
+			]);
+
+		$result = $this->api->getGroup('group');
+
+		$this->assertEquals(['users' => ['user1', 'user2']], $result->getData());
+	}
+
+
+	public function testGetGroupNonExisting(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionMessage('The requested group could not be found');
+		$this->expectExceptionCode(404);
+
+		$this->asUser();
+
+		$this->api->getGroup($this->getUniqueID());
+	}
+
+
+	public function testGetSubAdminsOfGroupsNotExists(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionMessage('Group does not exist');
+		$this->expectExceptionCode(101);
+
+		$this->api->getSubAdminsOfGroup('NonExistingGroup');
+	}
+
+	public function testGetSubAdminsOfGroup(): void {
+		$group = $this->createGroup('GroupWithSubAdmins');
+		$this->groupManager
+			->method('get')
+			->with('GroupWithSubAdmins')
+			->willReturn($group);
+
+		$this->subAdminManager
+			->expects($this->once())
+			->method('getGroupsSubAdmins')
+			->with($group)
+			->willReturn([
+				$this->createUser('SubAdmin1'),
+				$this->createUser('SubAdmin2'),
+			]);
+
+		$result = $this->api->getSubAdminsOfGroup('GroupWithSubAdmins');
+		$this->assertEquals(['SubAdmin1', 'SubAdmin2'], $result->getData());
+	}
+
+	public function testGetSubAdminsOfGroupEmptyList(): void {
+		$group = $this->createGroup('GroupWithOutSubAdmins');
+		$this->groupManager
+			->method('get')
+			->with('GroupWithOutSubAdmins')
+			->willReturn($group);
+
+		$this->subAdminManager
+			->expects($this->once())
+			->method('getGroupsSubAdmins')
+			->with($group)
+			->willReturn([
+			]);
+
+		$result = $this->api->getSubAdminsOfGroup('GroupWithOutSubAdmins');
+		$this->assertEquals([], $result->getData());
+	}
+
+
+	public function testAddGroupEmptyGroup(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionMessage('Invalid group name');
+		$this->expectExceptionCode(101);
+
+		$this->api->addGroup('');
+	}
+
+
+	public function testAddGroupExistingGroup(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(102);
+
+		$this->groupManager
+			->method('groupExists')
+			->with('ExistingGroup')
+			->willReturn(true);
+
+		$this->api->addGroup('ExistingGroup');
+	}
+
+	public function testAddGroup(): void {
+		$this->groupManager
+			->method('groupExists')
+			->with('NewGroup')
+			->willReturn(false);
+
+		$group = $this->createGroup('NewGroup');
+		$this->groupManager
+			->expects($this->once())
+			->method('createGroup')
+			->with('NewGroup')
+			->willReturn($group);
+
+		$this->api->addGroup('NewGroup');
+	}
+
+	public function testAddGroupWithSpecialChar(): void {
+		$this->groupManager
+			->method('groupExists')
+			->with('Iñtërnâtiônàlizætiøn')
+			->willReturn(false);
+
+		$group = $this->createGroup('Iñtërnâtiônàlizætiøn');
+		$this->groupManager
+			->expects($this->once())
+			->method('createGroup')
+			->with('Iñtërnâtiônàlizætiøn')
+			->willReturn($group);
+
+		$this->api->addGroup('Iñtërnâtiônàlizætiøn');
+	}
+
+
+	public function testDeleteGroupNonExisting(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(101);
+
+		$this->api->deleteGroup('NonExistingGroup');
+	}
+
+
+	public function testDeleteAdminGroup(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(102);
+
+		$this->groupManager
+			->method('groupExists')
+			->with('admin')
+			->willReturn('true');
+
+		$this->api->deleteGroup('admin');
+	}
+
+	public function testDeleteGroup(): void {
+		$this->groupManager
+			->method('groupExists')
+			->with('ExistingGroup')
+			->willReturn('true');
+
+		$group = $this->createGroup('ExistingGroup');
+		$this->groupManager
+			->method('get')
+			->with('ExistingGroup')
+			->willReturn($group);
+		$group
+			->expects($this->once())
+			->method('delete')
+			->willReturn(true);
+
+		$this->api->deleteGroup('ExistingGroup');
+	}
+
+	public function testDeleteGroupEncoding(): void {
+		$this->groupManager
+			->method('groupExists')
+			->with('ExistingGroup A/B')
+			->willReturn('true');
+
+		$group = $this->createGroup('ExistingGroup');
+		$this->groupManager
+			->method('get')
+			->with('ExistingGroup A/B')
+			->willReturn($group);
+		$group
+			->expects($this->once())
+			->method('delete')
+			->willReturn(true);
+
+		$this->api->deleteGroup(urlencode('ExistingGroup A/B'));
+	}
+
+	public function testGetGroupUsersDetails(): void {
+		$gid = 'ncg1';
+
+		$this->asAdmin();
+
+		$users = [
+			'ncu1' => $this->createUser('ncu1'), # regular
+			'ncu2' => $this->createUser('ncu2'), # the zombie
+		];
+		$users['ncu2']->expects($this->atLeastOnce())
+			->method('getHome')
+			->willThrowException(new NoUserException());
+
+		$this->userManager->expects($this->any())
+			->method('get')
+			->willReturnCallback(function (string $uid) use ($users) {
+				return $users[$uid] ?? null;
+			});
+
+		$group = $this->createGroup($gid);
+		$group->expects($this->once())
+			->method('searchUsers')
+			->with('', null, 0)
+			->willReturn(array_values($users));
+
+		$this->groupManager
+			->method('get')
+			->with($gid)
+			->willReturn($group);
+		$this->groupManager->expects($this->any())
+			->method('getUserGroups')
+			->willReturn([$group]);
+
+		/** @var MockObject */
+		$this->subAdminManager->expects($this->any())
+			->method('isSubAdminOfGroup')
+			->willReturn(false);
+		$this->subAdminManager->expects($this->any())
+			->method('getSubAdminsGroups')
+			->willReturn([]);
+
+
+		$this->api->getGroupUsersDetails($gid);
+	}
+
+	public function testGetGroupUsersDetailsEncoded(): void {
+		$gid = 'Department A/B C/D';
+
+		$this->asAdmin();
+
+		$users = [
+			'ncu1' => $this->createUser('ncu1'), # regular
+			'ncu2' => $this->createUser('ncu2'), # the zombie
+		];
+		$users['ncu2']->expects($this->atLeastOnce())
+			->method('getHome')
+			->willThrowException(new NoUserException());
+
+		$this->userManager->expects($this->any())
+			->method('get')
+			->willReturnCallback(function (string $uid) use ($users) {
+				return $users[$uid] ?? null;
+			});
+
+		$group = $this->createGroup($gid);
+		$group->expects($this->once())
+			->method('searchUsers')
+			->with('', null, 0)
+			->willReturn(array_values($users));
+
+		$this->groupManager
+			->method('get')
+			->with($gid)
+			->willReturn($group);
+		$this->groupManager->expects($this->any())
+			->method('getUserGroups')
+			->willReturn([$group]);
+
+		/** @var MockObject */
+		$this->subAdminManager->expects($this->any())
+			->method('isSubAdminOfGroup')
+			->willReturn(false);
+		$this->subAdminManager->expects($this->any())
+			->method('getSubAdminsGroups')
+			->willReturn([]);
+
+
+		$this->api->getGroupUsersDetails(urlencode($gid));
+	}
+}
diff --git a/apps/provisioning_api/tests/Controller/UsersControllerTest.php b/apps/provisioning_api/tests/Controller/UsersControllerTest.php
new file mode 100644
index 00000000000..0c0a0ae3d74
--- /dev/null
+++ b/apps/provisioning_api/tests/Controller/UsersControllerTest.php
@@ -0,0 +1,4463 @@
+<?php
+
+
+/**
+ * SPDX-FileCopyrightText: 2017-2024 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-FileCopyrightText: 2016 ownCloud, Inc.
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+namespace OCA\Provisioning_API\Tests\Controller;
+
+use Exception;
+use OC\Authentication\Token\RemoteWipe;
+use OC\Group\Manager;
+use OC\KnownUser\KnownUserService;
+use OC\PhoneNumberUtil;
+use OC\SubAdmin;
+use OCA\Provisioning_API\Controller\UsersController;
+use OCA\Settings\Mailer\NewUserMailHelper;
+use OCP\Accounts\IAccount;
+use OCP\Accounts\IAccountManager;
+use OCP\Accounts\IAccountProperty;
+use OCP\Accounts\IAccountPropertyCollection;
+use OCP\App\IAppManager;
+use OCP\AppFramework\Http\DataResponse;
+use OCP\AppFramework\OCS\OCSException;
+use OCP\EventDispatcher\IEventDispatcher;
+use OCP\Files\IRootFolder;
+use OCP\Group\ISubAdmin;
+use OCP\IConfig;
+use OCP\IGroup;
+use OCP\IL10N;
+use OCP\IPhoneNumberUtil;
+use OCP\IRequest;
+use OCP\IURLGenerator;
+use OCP\IUser;
+use OCP\IUserManager;
+use OCP\IUserSession;
+use OCP\L10N\IFactory;
+use OCP\Mail\IEMailTemplate;
+use OCP\Security\Events\GenerateSecurePasswordEvent;
+use OCP\Security\ISecureRandom;
+use OCP\User\Backend\ISetDisplayNameBackend;
+use OCP\UserInterface;
+use PHPUnit\Framework\MockObject\MockObject;
+use Psr\Log\LoggerInterface;
+use RuntimeException;
+use Test\TestCase;
+
+class UsersControllerTest extends TestCase {
+	protected IUserManager&MockObject $userManager;
+	protected IConfig&MockObject $config;
+	protected Manager&MockObject $groupManager;
+	protected IUserSession&MockObject $userSession;
+	protected LoggerInterface&MockObject $logger;
+	protected UsersController&MockObject $api;
+	protected IAccountManager&MockObject $accountManager;
+	protected ISubAdmin&MockObject $subAdminManager;
+	protected IURLGenerator&MockObject $urlGenerator;
+	protected IRequest&MockObject $request;
+	private IFactory&MockObject $l10nFactory;
+	private NewUserMailHelper&MockObject $newUserMailHelper;
+	private ISecureRandom&MockObject $secureRandom;
+	private RemoteWipe&MockObject $remoteWipe;
+	private KnownUserService&MockObject $knownUserService;
+	private IEventDispatcher&MockObject $eventDispatcher;
+	private IRootFolder $rootFolder;
+	private IPhoneNumberUtil $phoneNumberUtil;
+	private IAppManager $appManager;
+
+	protected function setUp(): void {
+		parent::setUp();
+
+		$this->userManager = $this->createMock(IUserManager::class);
+		$this->config = $this->createMock(IConfig::class);
+		$this->groupManager = $this->createMock(Manager::class);
+		$this->userSession = $this->createMock(IUserSession::class);
+		$this->logger = $this->createMock(LoggerInterface::class);
+		$this->request = $this->createMock(IRequest::class);
+		$this->accountManager = $this->createMock(IAccountManager::class);
+		$this->subAdminManager = $this->createMock(ISubAdmin::class);
+		$this->urlGenerator = $this->createMock(IURLGenerator::class);
+		$this->l10nFactory = $this->createMock(IFactory::class);
+		$this->newUserMailHelper = $this->createMock(NewUserMailHelper::class);
+		$this->secureRandom = $this->createMock(ISecureRandom::class);
+		$this->remoteWipe = $this->createMock(RemoteWipe::class);
+		$this->knownUserService = $this->createMock(KnownUserService::class);
+		$this->eventDispatcher = $this->createMock(IEventDispatcher::class);
+		$this->phoneNumberUtil = new PhoneNumberUtil();
+		$this->appManager = $this->createMock(IAppManager::class);
+		$this->rootFolder = $this->createMock(IRootFolder::class);
+
+		$l10n = $this->createMock(IL10N::class);
+		$l10n->method('t')->willReturnCallback(fn (string $txt, array $replacement = []) => sprintf($txt, ...$replacement));
+		$this->l10nFactory->method('get')->with('provisioning_api')->willReturn($l10n);
+
+		$this->api = $this->getMockBuilder(UsersController::class)
+			->setConstructorArgs([
+				'provisioning_api',
+				$this->request,
+				$this->userManager,
+				$this->config,
+				$this->groupManager,
+				$this->userSession,
+				$this->accountManager,
+				$this->subAdminManager,
+				$this->l10nFactory,
+				$this->rootFolder,
+				$this->urlGenerator,
+				$this->logger,
+				$this->newUserMailHelper,
+				$this->secureRandom,
+				$this->remoteWipe,
+				$this->knownUserService,
+				$this->eventDispatcher,
+				$this->phoneNumberUtil,
+				$this->appManager,
+			])
+			->onlyMethods(['fillStorageInfo'])
+			->getMock();
+	}
+
+	public function testGetUsersAsAdmin(): void {
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->once())
+			->method('getUID')
+			->willReturn('admin');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->willReturn(true);
+		$this->userManager
+			->expects($this->once())
+			->method('search')
+			->with('MyCustomSearch')
+			->willReturn(['Admin' => [], 'Foo' => [], 'Bar' => []]);
+
+		$expected = [
+			'users' => [
+				'Admin',
+				'Foo',
+				'Bar',
+			],
+		];
+		$this->assertEquals($expected, $this->api->getUsers('MyCustomSearch')->getData());
+	}
+
+	public function testGetUsersAsSubAdmin(): void {
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->once())
+			->method('getUID')
+			->willReturn('subadmin');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->willReturn(false);
+		$firstGroup = $this->getMockBuilder('OCP\IGroup')
+			->disableOriginalConstructor()
+			->getMock();
+		$firstGroup
+			->expects($this->once())
+			->method('getGID')
+			->willReturn('FirstGroup');
+		$secondGroup = $this->getMockBuilder('OCP\IGroup')
+			->disableOriginalConstructor()
+			->getMock();
+		$secondGroup
+			->expects($this->once())
+			->method('getGID')
+			->willReturn('SecondGroup');
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()->getMock();
+		$subAdminManager
+			->expects($this->once())
+			->method('isSubAdmin')
+			->with($loggedInUser)
+			->willReturn(true);
+		$subAdminManager
+			->expects($this->once())
+			->method('getSubAdminsGroups')
+			->with($loggedInUser)
+			->willReturn([$firstGroup, $secondGroup]);
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+		$this->groupManager
+			->expects($this->any())
+			->method('displayNamesInGroup')->willReturnOnConsecutiveCalls(['AnotherUserInTheFirstGroup' => []], ['UserInTheSecondGroup' => []]);
+
+		$expected = [
+			'users' => [
+				'AnotherUserInTheFirstGroup',
+				'UserInTheSecondGroup',
+			],
+		];
+		$this->assertEquals($expected, $this->api->getUsers('MyCustomSearch')->getData());
+	}
+
+	private function createUserMock(string $uid, bool $enabled): MockObject&IUser {
+		$mockUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$mockUser
+			->method('getUID')
+			->willReturn($uid);
+		$mockUser
+			->method('isEnabled')
+			->willReturn($enabled);
+		return $mockUser;
+	}
+
+	public function testGetDisabledUsersAsAdmin(): void {
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->once())
+			->method('getUID')
+			->willReturn('admin');
+		$this->userSession
+			->expects($this->atLeastOnce())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->willReturn(true);
+		$this->userManager
+			->expects($this->once())
+			->method('getDisabledUsers')
+			->with(3, 0, 'MyCustomSearch')
+			->willReturn([
+				$this->createUserMock('admin', false),
+				$this->createUserMock('foo', false),
+				$this->createUserMock('bar', false),
+			]);
+
+		$expected = [
+			'users' => [
+				'admin' => ['id' => 'admin'],
+				'foo' => ['id' => 'foo'],
+				'bar' => ['id' => 'bar'],
+			],
+		];
+		$this->assertEquals($expected, $this->api->getDisabledUsersDetails('MyCustomSearch', 3)->getData());
+	}
+
+	public function testGetDisabledUsersAsSubAdmin(): void {
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->once())
+			->method('getUID')
+			->willReturn('subadmin');
+		$this->userSession
+			->expects($this->atLeastOnce())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->willReturn(false);
+		$firstGroup = $this->getMockBuilder('OCP\IGroup')
+			->disableOriginalConstructor()
+			->getMock();
+		$secondGroup = $this->getMockBuilder('OCP\IGroup')
+			->disableOriginalConstructor()
+			->getMock();
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()->getMock();
+		$subAdminManager
+			->expects($this->once())
+			->method('isSubAdmin')
+			->with($loggedInUser)
+			->willReturn(true);
+		$subAdminManager
+			->expects($this->once())
+			->method('getSubAdminsGroups')
+			->with($loggedInUser)
+			->willReturn([$firstGroup, $secondGroup]);
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+		$this->groupManager
+			->expects($this->never())
+			->method('displayNamesInGroup');
+
+		$firstGroup
+			->expects($this->once())
+			->method('searchUsers')
+			->with('MyCustomSearch')
+			->willReturn([
+				$this->createUserMock('user1', false),
+				$this->createUserMock('bob', true),
+				$this->createUserMock('user2', false),
+				$this->createUserMock('alice', true),
+			]);
+
+		$secondGroup
+			->expects($this->once())
+			->method('searchUsers')
+			->with('MyCustomSearch')
+			->willReturn([
+				$this->createUserMock('user2', false),
+				$this->createUserMock('joe', true),
+				$this->createUserMock('user3', false),
+				$this->createUserMock('jim', true),
+				$this->createUserMock('john', true),
+			]);
+
+
+		$expected = [
+			'users' => [
+				'user1' => ['id' => 'user1'],
+				'user2' => ['id' => 'user2'],
+				'user3' => ['id' => 'user3'],
+			],
+		];
+		$this->assertEquals($expected, $this->api->getDisabledUsersDetails('MyCustomSearch', 3)->getData());
+	}
+
+
+	public function testAddUserAlreadyExisting(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(102);
+
+		$this->userManager
+			->expects($this->once())
+			->method('userExists')
+			->with('AlreadyExistingUser')
+			->willReturn(true);
+		$this->logger
+			->expects($this->once())
+			->method('error')
+			->with('Failed addUser attempt: User already exists.', ['app' => 'ocs_api']);
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->exactly(2))
+			->method('getUID')
+			->willReturn('adminUser');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('adminUser')
+			->willReturn(true);
+
+		$this->api->addUser('AlreadyExistingUser', 'password', '', '', []);
+	}
+
+
+	public function testAddUserNonExistingGroup(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionMessage('Group NonExistingGroup does not exist');
+		$this->expectExceptionCode(104);
+
+		$this->userManager
+			->expects($this->once())
+			->method('userExists')
+			->with('NewUser')
+			->willReturn(false);
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->exactly(2))
+			->method('getUID')
+			->willReturn('adminUser');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('adminUser')
+			->willReturn(true);
+		$this->groupManager
+			->expects($this->once())
+			->method('groupExists')
+			->with('NonExistingGroup')
+			->willReturn(false);
+
+		$this->api->addUser('NewUser', 'pass', '', '', ['NonExistingGroup']);
+	}
+
+
+	public function testAddUserExistingGroupNonExistingGroup(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionMessage('Group NonExistingGroup does not exist');
+		$this->expectExceptionCode(104);
+
+		$this->userManager
+			->expects($this->once())
+			->method('userExists')
+			->with('NewUser')
+			->willReturn(false);
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->exactly(2))
+			->method('getUID')
+			->willReturn('adminUser');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('adminUser')
+			->willReturn(true);
+		$this->groupManager
+			->expects($this->exactly(2))
+			->method('groupExists')
+			->willReturnMap([
+				['ExistingGroup', true],
+				['NonExistingGroup', false]
+			]);
+
+		$this->api->addUser('NewUser', 'pass', '', '', ['ExistingGroup', 'NonExistingGroup']);
+	}
+
+	public function testAddUserSuccessful(): void {
+		$this->userManager
+			->expects($this->once())
+			->method('userExists')
+			->with('NewUser')
+			->willReturn(false);
+		$this->userManager
+			->expects($this->once())
+			->method('createUser')
+			->with('NewUser', 'PasswordOfTheNewUser')
+			->willReturn($this->createMock(IUser::class));
+		$this->logger
+			->expects($this->once())
+			->method('info')
+			->with('Successful addUser call with userid: NewUser', ['app' => 'ocs_api']);
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->exactly(2))
+			->method('getUID')
+			->willReturn('adminUser');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('adminUser')
+			->willReturn(true);
+
+		$this->assertTrue(key_exists(
+			'id',
+			$this->api->addUser('NewUser', 'PasswordOfTheNewUser')->getData()
+		));
+	}
+
+	public function testAddUserSuccessfulWithDisplayName(): void {
+		/**
+		 * @var UserController
+		 */
+		$api = $this->getMockBuilder(UsersController::class)
+			->setConstructorArgs([
+				'provisioning_api',
+				$this->request,
+				$this->userManager,
+				$this->config,
+				$this->groupManager,
+				$this->userSession,
+				$this->accountManager,
+				$this->subAdminManager,
+				$this->l10nFactory,
+				$this->rootFolder,
+				$this->urlGenerator,
+				$this->logger,
+				$this->newUserMailHelper,
+				$this->secureRandom,
+				$this->remoteWipe,
+				$this->knownUserService,
+				$this->eventDispatcher,
+				$this->phoneNumberUtil,
+				$this->appManager,
+			])
+			->onlyMethods(['editUser'])
+			->getMock();
+
+		$this->userManager
+			->expects($this->once())
+			->method('userExists')
+			->with('NewUser')
+			->willReturn(false);
+		$this->userManager
+			->expects($this->once())
+			->method('createUser')
+			->with('NewUser', 'PasswordOfTheNewUser')
+			->willReturn($this->createMock(IUser::class));
+		$this->logger
+			->expects($this->once())
+			->method('info')
+			->with('Successful addUser call with userid: NewUser', ['app' => 'ocs_api']);
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('adminUser');
+		$this->userSession
+			->expects($this->any())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('adminUser')
+			->willReturn(true);
+		$api
+			->expects($this->once())
+			->method('editUser')
+			->with('NewUser', 'display', 'DisplayNameOfTheNewUser');
+
+		$this->assertTrue(key_exists(
+			'id',
+			$api->addUser('NewUser', 'PasswordOfTheNewUser', 'DisplayNameOfTheNewUser')->getData()
+		));
+	}
+
+	public function testAddUserSuccessfulGenerateUserID(): void {
+		$this->config
+			->expects($this->any())
+			->method('getAppValue')
+			->willReturnCallback(function ($appid, $key, $default) {
+				if ($key === 'newUser.generateUserID') {
+					return 'yes';
+				}
+				return null;
+			});
+		$this->userManager
+			->expects($this->any())
+			->method('userExists')
+			->with($this->anything())
+			->willReturn(false);
+		$this->userManager
+			->expects($this->once())
+			->method('createUser')
+			->with($this->anything(), 'PasswordOfTheNewUser')
+			->willReturn($this->createMock(IUser::class));
+		$this->logger
+			->expects($this->once())
+			->method('info')
+			->with($this->stringStartsWith('Successful addUser call with userid: '), ['app' => 'ocs_api']);
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->exactly(2))
+			->method('getUID')
+			->willReturn('adminUser');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('adminUser')
+			->willReturn(true);
+		$this->secureRandom->expects($this->any())
+			->method('generate')
+			->with(10)
+			->willReturnCallback(function () {
+				return (string)rand(100000000, 999999999);
+			});
+
+		$this->assertTrue(key_exists(
+			'id',
+			$this->api->addUser('', 'PasswordOfTheNewUser')->getData()
+		));
+	}
+
+	public function testAddUserSuccessfulGeneratePassword(): void {
+		$this->userManager
+			->expects($this->once())
+			->method('userExists')
+			->with('NewUser')
+			->willReturn(false);
+		$newUser = $this->createMock(IUser::class);
+		$newUser->expects($this->once())
+			->method('setSystemEMailAddress');
+		$this->userManager
+			->expects($this->once())
+			->method('createUser')
+			->willReturn($newUser);
+		$this->logger
+			->expects($this->once())
+			->method('info')
+			->with('Successful addUser call with userid: NewUser', ['app' => 'ocs_api']);
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->exactly(2))
+			->method('getUID')
+			->willReturn('adminUser');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('adminUser')
+			->willReturn(true);
+		$this->eventDispatcher
+			->expects($this->once())
+			->method('dispatchTyped')
+			->with(new GenerateSecurePasswordEvent());
+
+		$this->assertTrue(key_exists(
+			'id',
+			$this->api->addUser('NewUser', '', '', 'foo@bar')->getData()
+		));
+	}
+
+	public function testAddUserSuccessfulLowercaseEmail(): void {
+		$this->userManager
+			->expects($this->once())
+			->method('userExists')
+			->with('NewUser')
+			->willReturn(false);
+		$newUser = $this->createMock(IUser::class);
+		$newUser->expects($this->once())
+			->method('setSystemEMailAddress')
+			->with('foo@bar.com');
+		$this->userManager
+			->expects($this->once())
+			->method('createUser')
+			->willReturn($newUser);
+		$this->logger
+			->expects($this->once())
+			->method('info')
+			->with('Successful addUser call with userid: NewUser', ['app' => 'ocs_api']);
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->exactly(2))
+			->method('getUID')
+			->willReturn('adminUser');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('adminUser')
+			->willReturn(true);
+		$this->eventDispatcher
+			->expects($this->once())
+			->method('dispatchTyped')
+			->with(new GenerateSecurePasswordEvent());
+
+		$this->assertTrue(key_exists(
+			'id',
+			$this->api->addUser('NewUser', '', '', 'fOo@BaR.CoM')->getData()
+		));
+	}
+
+
+	public function testAddUserFailedToGenerateUserID(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionMessage('Could not create non-existing user ID');
+		$this->expectExceptionCode(111);
+
+		$this->config
+			->expects($this->any())
+			->method('getAppValue')
+			->willReturnCallback(function ($appid, $key, $default) {
+				if ($key === 'newUser.generateUserID') {
+					return 'yes';
+				}
+				return null;
+			});
+		$this->userManager
+			->expects($this->any())
+			->method('userExists')
+			->with($this->anything())
+			->willReturn(true);
+		$this->userManager
+			->expects($this->never())
+			->method('createUser');
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->exactly(2))
+			->method('getUID')
+			->willReturn('adminUser');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('adminUser')
+			->willReturn(true);
+
+		$this->api->addUser('', 'PasswordOfTheNewUser')->getData();
+	}
+
+
+	public function testAddUserEmailRequired(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionMessage('Required email address was not provided');
+		$this->expectExceptionCode(110);
+
+		$this->config
+			->expects($this->any())
+			->method('getAppValue')
+			->willReturnCallback(function ($appid, $key, $default) {
+				if ($key === 'newUser.requireEmail') {
+					return 'yes';
+				}
+				return null;
+			});
+		$this->userManager
+			->expects($this->once())
+			->method('userExists')
+			->with('NewUser')
+			->willReturn(false);
+		$this->userManager
+			->expects($this->never())
+			->method('createUser');
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->exactly(2))
+			->method('getUID')
+			->willReturn('adminUser');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('adminUser')
+			->willReturn(true);
+
+		$this->assertTrue(key_exists(
+			'id',
+			$this->api->addUser('NewUser', 'PasswordOfTheNewUser')->getData()
+		));
+	}
+
+	public function testAddUserExistingGroup(): void {
+		$this->userManager
+			->expects($this->once())
+			->method('userExists')
+			->with('NewUser')
+			->willReturn(false);
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->exactly(2))
+			->method('getUID')
+			->willReturn('adminUser');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('adminUser')
+			->willReturn(true);
+		$this->groupManager
+			->expects($this->once())
+			->method('groupExists')
+			->with('ExistingGroup')
+			->willReturn(true);
+		$user = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$this->userManager
+			->expects($this->once())
+			->method('createUser')
+			->with('NewUser', 'PasswordOfTheNewUser')
+			->willReturn($user);
+		$group = $this->getMockBuilder('OCP\IGroup')
+			->disableOriginalConstructor()
+			->getMock();
+		$group
+			->expects($this->once())
+			->method('addUser')
+			->with($user);
+		$this->groupManager
+			->expects($this->once())
+			->method('get')
+			->with('ExistingGroup')
+			->willReturn($group);
+
+		$calls = [
+			['Successful addUser call with userid: NewUser', ['app' => 'ocs_api']],
+			['Added userid NewUser to group ExistingGroup', ['app' => 'ocs_api']],
+		];
+		$this->logger
+			->expects($this->exactly(2))
+			->method('info')
+			->willReturnCallback(function () use (&$calls): void {
+				$expected = array_shift($calls);
+				$this->assertEquals($expected, func_get_args());
+			});
+
+		$this->assertArrayHasKey('id', $this->api->addUser('NewUser', 'PasswordOfTheNewUser', '', '', ['ExistingGroup'])->getData());
+	}
+
+
+	public function testAddUserUnsuccessful(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionMessage('Bad request');
+		$this->expectExceptionCode(101);
+
+		$exception = new Exception('User backend not found.');
+		$this->userManager
+			->expects($this->once())
+			->method('userExists')
+			->with('NewUser')
+			->willReturn(false);
+		$this->userManager
+			->expects($this->once())
+			->method('createUser')
+			->with('NewUser', 'PasswordOfTheNewUser')
+			->willThrowException($exception);
+		$this->logger
+			->expects($this->once())
+			->method('error')
+			->with(
+				'Failed addUser attempt with exception.',
+				[
+					'app' => 'ocs_api',
+					'exception' => $exception
+				]
+			);
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->exactly(2))
+			->method('getUID')
+			->willReturn('adminUser');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('adminUser')
+			->willReturn(true);
+
+		$this->api->addUser('NewUser', 'PasswordOfTheNewUser');
+	}
+
+
+	public function testAddUserAsSubAdminNoGroup(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionMessage('No group specified (required for sub-admins)');
+		$this->expectExceptionCode(106);
+
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->exactly(2))
+			->method('getUID')
+			->willReturn('regularUser');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('regularUser')
+			->willReturn(false);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()->getMock();
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->with()
+			->willReturn($subAdminManager);
+
+		$this->api->addUser('NewUser', 'PasswordOfTheNewUser', '', '', []);
+	}
+
+
+	public function testAddUserAsSubAdminValidGroupNotSubAdmin(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionMessage('Insufficient privileges for group ExistingGroup');
+		$this->expectExceptionCode(105);
+
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->exactly(2))
+			->method('getUID')
+			->willReturn('regularUser');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('regularUser')
+			->willReturn(false);
+		$existingGroup = $this->getMockBuilder('\OCP\IGroup')->disableOriginalConstructor()->getMock();
+		$this->groupManager
+			->expects($this->once())
+			->method('get')
+			->with('ExistingGroup')
+			->willReturn($existingGroup);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()->getMock();
+		$subAdminManager
+			->expects($this->once())
+			->method('isSubAdminOfGroup')
+			->with($loggedInUser, $existingGroup)
+			->willReturn(false);
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->with()
+			->willReturn($subAdminManager);
+		$this->groupManager
+			->expects($this->once())
+			->method('groupExists')
+			->with('ExistingGroup')
+			->willReturn(true);
+
+		$this->api->addUser('NewUser', 'PasswordOfTheNewUser', '', '', ['ExistingGroup'])->getData();
+	}
+
+	public function testAddUserAsSubAdminExistingGroups(): void {
+		$this->userManager
+			->expects($this->once())
+			->method('userExists')
+			->with('NewUser')
+			->willReturn(false);
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->exactly(2))
+			->method('getUID')
+			->willReturn('subAdminUser');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('subAdminUser')
+			->willReturn(false);
+		$this->groupManager
+			->expects($this->exactly(2))
+			->method('groupExists')
+			->willReturnMap([
+				['ExistingGroup1', true],
+				['ExistingGroup2', true]
+			]);
+		$user = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$this->userManager
+			->expects($this->once())
+			->method('createUser')
+			->with('NewUser', 'PasswordOfTheNewUser')
+			->willReturn($user);
+		$existingGroup1 = $this->getMockBuilder('OCP\IGroup')
+			->disableOriginalConstructor()
+			->getMock();
+		$existingGroup2 = $this->getMockBuilder('OCP\IGroup')
+			->disableOriginalConstructor()
+			->getMock();
+		$existingGroup1
+			->expects($this->once())
+			->method('addUser')
+			->with($user);
+		$existingGroup2
+			->expects($this->once())
+			->method('addUser')
+			->with($user);
+		$this->groupManager
+			->expects($this->exactly(4))
+			->method('get')
+			->willReturnMap([
+				['ExistingGroup1', $existingGroup1],
+				['ExistingGroup2', $existingGroup2]
+			]);
+
+		$calls = [
+			['Successful addUser call with userid: NewUser', ['app' => 'ocs_api']],
+			['Added userid NewUser to group ExistingGroup1', ['app' => 'ocs_api']],
+			['Added userid NewUser to group ExistingGroup2', ['app' => 'ocs_api']],
+		];
+		$this->logger
+			->expects($this->exactly(3))
+			->method('info')
+			->willReturnCallback(function () use (&$calls): void {
+				$expected = array_shift($calls);
+				$this->assertEquals($expected, func_get_args());
+			});
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()->getMock();
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+		$subAdminManager
+			->expects($this->exactly(2))
+			->method('isSubAdminOfGroup')
+			->willReturnMap([
+				[$loggedInUser, $existingGroup1, true],
+				[$loggedInUser, $existingGroup2, true],
+			]);
+
+		$this->assertArrayHasKey('id', $this->api->addUser('NewUser', 'PasswordOfTheNewUser', '', '', ['ExistingGroup1', 'ExistingGroup2'])->getData());
+	}
+
+
+	public function testGetUserTargetDoesNotExist(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionMessage('User does not exist');
+		$this->expectExceptionCode(404);
+
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$this->userSession
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToGet')
+			->willReturn(null);
+
+		$this->api->getUser('UserToGet');
+	}
+
+	public function testGetUserDataAsAdmin(): void {
+		$group0 = $this->createMock(IGroup::class);
+		$group1 = $this->createMock(IGroup::class);
+		$group2 = $this->createMock(IGroup::class);
+		$group3 = $this->createMock(IGroup::class);
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->method('getUID')
+			->willReturn('admin');
+		$targetUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$targetUser->expects($this->once())
+			->method('getSystemEMailAddress')
+			->willReturn('demo@nextcloud.com');
+		$this->userSession
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->method('get')
+			->with('UID')
+			->willReturn($targetUser);
+		$this->groupManager
+			->method('isAdmin')
+			->with('admin')
+			->willReturn(true);
+		$this->groupManager
+			->expects($this->any())
+			->method('getUserGroups')
+			->willReturn([$group0, $group1, $group2]);
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+		$subAdminManager
+			->expects($this->once())
+			->method('getSubAdminsGroups')
+			->willReturn([$group3]);
+		$group0->expects($this->once())
+			->method('getGID')
+			->willReturn('group0');
+		$group1->expects($this->once())
+			->method('getGID')
+			->willReturn('group1');
+		$group2->expects($this->once())
+			->method('getGID')
+			->willReturn('group2');
+		$group3->expects($this->once())
+			->method('getGID')
+			->willReturn('group3');
+
+		$this->mockAccount($targetUser, [
+			IAccountManager::PROPERTY_ADDRESS => ['value' => 'address'],
+			IAccountManager::PROPERTY_PHONE => ['value' => 'phone'],
+			IAccountManager::PROPERTY_TWITTER => ['value' => 'twitter'],
+			IAccountManager::PROPERTY_BLUESKY => ['value' => 'bluesky'],
+			IAccountManager::PROPERTY_FEDIVERSE => ['value' => 'fediverse'],
+			IAccountManager::PROPERTY_WEBSITE => ['value' => 'website'],
+			IAccountManager::PROPERTY_ORGANISATION => ['value' => 'organisation'],
+			IAccountManager::PROPERTY_ROLE => ['value' => 'role'],
+			IAccountManager::PROPERTY_HEADLINE => ['value' => 'headline'],
+			IAccountManager::PROPERTY_BIOGRAPHY => ['value' => 'biography'],
+			IAccountManager::PROPERTY_PROFILE_ENABLED => ['value' => '1'],
+			IAccountManager::PROPERTY_PRONOUNS => ['value' => 'they/them'],
+		]);
+		$this->config
+			->method('getUserValue')
+			->willReturnMap([
+				['UID', 'core', 'enabled', 'true', 'true'],
+			]);
+		$this->api
+			->expects($this->once())
+			->method('fillStorageInfo')
+			->with($targetUser)
+			->willReturn(['DummyValue']);
+
+		$backend = $this->createMock(UserInterface::class);
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->willReturn(true);
+
+		$targetUser
+			->expects($this->once())
+			->method('getDisplayName')
+			->willReturn('Demo User');
+		$targetUser
+			->expects($this->once())
+			->method('getHome')
+			->willReturn('/var/www/newtcloud/data/UID');
+		$targetUser
+			->expects($this->exactly(2))
+			->method('getLastLogin')
+			->willReturn(1521191471);
+		$targetUser
+			->expects($this->once())
+			->method('getFirstLogin')
+			->willReturn(1511191471);
+		$targetUser
+			->expects($this->once())
+			->method('getBackendClassName')
+			->willReturn('Database');
+		$targetUser
+			->expects($this->once())
+			->method('getBackend')
+			->willReturn($backend);
+		$targetUser
+			->method('getUID')
+			->willReturn('UID');
+
+		$this->l10nFactory
+			->expects($this->once())
+			->method('getUserLanguage')
+			->with($targetUser)
+			->willReturn('de');
+
+		$expected = [
+			'id' => 'UID',
+			'enabled' => true,
+			'storageLocation' => '/var/www/newtcloud/data/UID',
+			'firstLoginTimestamp' => 1511191471,
+			'lastLoginTimestamp' => 1521191471,
+			'lastLogin' => 1521191471000,
+			'backend' => 'Database',
+			'subadmin' => ['group3'],
+			'quota' => ['DummyValue'],
+			'email' => 'demo@nextcloud.com',
+			'displayname' => 'Demo User',
+			'display-name' => 'Demo User',
+			'phone' => 'phone',
+			'address' => 'address',
+			'website' => 'website',
+			'twitter' => 'twitter',
+			'bluesky' => 'bluesky',
+			'fediverse' => 'fediverse',
+			'groups' => ['group0', 'group1', 'group2'],
+			'language' => 'de',
+			'locale' => null,
+			'backendCapabilities' => [
+				'setDisplayName' => true,
+				'setPassword' => true,
+			],
+			'additional_mail' => [],
+			'organisation' => 'organisation',
+			'role' => 'role',
+			'headline' => 'headline',
+			'biography' => 'biography',
+			'profile_enabled' => '1',
+			'notify_email' => null,
+			'manager' => '',
+			'pronouns' => 'they/them',
+		];
+		$this->assertEquals($expected, $this->invokePrivate($this->api, 'getUserData', ['UID']));
+	}
+
+	public function testGetUserDataAsSubAdminAndUserIsAccessible(): void {
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->method('getUID')
+			->willReturn('subadmin');
+		$targetUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$targetUser
+			->expects($this->once())
+			->method('getSystemEMailAddress')
+			->willReturn('demo@nextcloud.com');
+		$this->userSession
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->method('get')
+			->with('UID')
+			->willReturn($targetUser);
+		$this->groupManager
+			->method('isAdmin')
+			->with('subadmin')
+			->willReturn(false);
+		$this->groupManager
+			->expects($this->any())
+			->method('getUserGroups')
+			->willReturn([]);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()
+			->getMock();
+		$subAdminManager
+			->expects($this->once())
+			->method('isUserAccessible')
+			->with($loggedInUser, $targetUser)
+			->willReturn(true);
+		$subAdminManager
+			->expects($this->once())
+			->method('getSubAdminsGroups')
+			->willReturn([]);
+		$this->groupManager
+			->expects($this->exactly(2))
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+		$this->config
+			->method('getUserValue')
+			->willReturnMap([
+				['UID', 'core', 'enabled', 'true', 'true'],
+			]);
+		$this->api
+			->expects($this->once())
+			->method('fillStorageInfo')
+			->with($targetUser)
+			->willReturn(['DummyValue']);
+
+		$backend = $this->createMock(UserInterface::class);
+		$backend->expects($this->any())
+			->method('implementsActions')
+			->willReturn(true);
+
+		$targetUser
+			->expects($this->once())
+			->method('getDisplayName')
+			->willReturn('Demo User');
+		$targetUser
+			->expects($this->never())
+			->method('getHome');
+		$targetUser
+			->expects($this->exactly(2))
+			->method('getLastLogin')
+			->willReturn(1521191471);
+		$targetUser
+			->expects($this->once())
+			->method('getFirstLogin')
+			->willReturn(1511191471);
+		$targetUser
+			->expects($this->once())
+			->method('getBackendClassName')
+			->willReturn('Database');
+		$targetUser
+			->expects($this->once())
+			->method('getBackend')
+			->willReturn($backend);
+		$targetUser
+			->method('getUID')
+			->willReturn('UID');
+
+		$this->mockAccount($targetUser, [
+			IAccountManager::PROPERTY_ADDRESS => ['value' => 'address'],
+			IAccountManager::PROPERTY_PHONE => ['value' => 'phone'],
+			IAccountManager::PROPERTY_TWITTER => ['value' => 'twitter'],
+			IAccountManager::PROPERTY_BLUESKY => ['value' => 'bluesky'],
+			IAccountManager::PROPERTY_FEDIVERSE => ['value' => 'fediverse'],
+			IAccountManager::PROPERTY_WEBSITE => ['value' => 'website'],
+			IAccountManager::PROPERTY_ORGANISATION => ['value' => 'organisation'],
+			IAccountManager::PROPERTY_ROLE => ['value' => 'role'],
+			IAccountManager::PROPERTY_HEADLINE => ['value' => 'headline'],
+			IAccountManager::PROPERTY_BIOGRAPHY => ['value' => 'biography'],
+			IAccountManager::PROPERTY_PROFILE_ENABLED => ['value' => '1'],
+			IAccountManager::PROPERTY_PRONOUNS => ['value' => 'they/them'],
+		]);
+
+		$this->l10nFactory
+			->expects($this->once())
+			->method('getUserLanguage')
+			->with($targetUser)
+			->willReturn('da');
+
+		$expected = [
+			'id' => 'UID',
+			'enabled' => true,
+			'firstLoginTimestamp' => 1511191471,
+			'lastLoginTimestamp' => 1521191471,
+			'lastLogin' => 1521191471000,
+			'backend' => 'Database',
+			'subadmin' => [],
+			'quota' => ['DummyValue'],
+			'email' => 'demo@nextcloud.com',
+			'displayname' => 'Demo User',
+			'display-name' => 'Demo User',
+			'phone' => 'phone',
+			'address' => 'address',
+			'website' => 'website',
+			'twitter' => 'twitter',
+			'bluesky' => 'bluesky',
+			'fediverse' => 'fediverse',
+			'groups' => [],
+			'language' => 'da',
+			'locale' => null,
+			'backendCapabilities' => [
+				'setDisplayName' => true,
+				'setPassword' => true,
+			],
+			'additional_mail' => [],
+			'organisation' => 'organisation',
+			'role' => 'role',
+			'headline' => 'headline',
+			'biography' => 'biography',
+			'profile_enabled' => '1',
+			'notify_email' => null,
+			'manager' => '',
+			'pronouns' => 'they/them',
+		];
+		$this->assertEquals($expected, $this->invokePrivate($this->api, 'getUserData', ['UID']));
+	}
+
+
+
+	public function testGetUserDataAsSubAdminAndUserIsNotAccessible(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(998);
+
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->exactly(4))
+			->method('getUID')
+			->willReturn('subadmin');
+		$targetUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$this->userSession
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToGet')
+			->willReturn($targetUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('subadmin')
+			->willReturn(false);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()
+			->getMock();
+		$subAdminManager
+			->expects($this->once())
+			->method('isUserAccessible')
+			->with($loggedInUser, $targetUser)
+			->willReturn(false);
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+
+		$this->invokePrivate($this->api, 'getUser', ['UserToGet']);
+	}
+
+	public function testGetUserDataAsSubAdminSelfLookup(): void {
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->method('getUID')
+			->willReturn('UID');
+		$targetUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$this->userSession
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->method('get')
+			->with('UID')
+			->willReturn($targetUser);
+		$this->groupManager
+			->method('isAdmin')
+			->with('UID')
+			->willReturn(false);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()
+			->getMock();
+		$subAdminManager
+			->expects($this->once())
+			->method('isUserAccessible')
+			->with($loggedInUser, $targetUser)
+			->willReturn(false);
+		$subAdminManager
+			->expects($this->once())
+			->method('getSubAdminsGroups')
+			->willReturn([]);
+		$this->groupManager
+			->expects($this->exactly(2))
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+		$this->groupManager
+			->expects($this->any())
+			->method('getUserGroups')
+			->willReturn([]);
+		$this->api
+			->expects($this->once())
+			->method('fillStorageInfo')
+			->with($targetUser)
+			->willReturn(['DummyValue']);
+
+		$backend = $this->createMock(UserInterface::class);
+		$backend->expects($this->atLeastOnce())
+			->method('implementsActions')
+			->willReturn(false);
+
+		$targetUser
+			->expects($this->once())
+			->method('getDisplayName')
+			->willReturn('Subadmin User');
+		$targetUser
+			->expects($this->once())
+			->method('getSystemEMailAddress')
+			->willReturn('subadmin@nextcloud.com');
+		$targetUser
+			->method('getUID')
+			->willReturn('UID');
+		$targetUser
+			->expects($this->never())
+			->method('getHome');
+		$targetUser
+			->expects($this->exactly(2))
+			->method('getLastLogin')
+			->willReturn(1521191471);
+		$targetUser
+			->expects($this->once())
+			->method('getFirstLogin')
+			->willReturn(1511191471);
+		$targetUser
+			->expects($this->once())
+			->method('getBackendClassName')
+			->willReturn('Database');
+		$targetUser
+			->expects($this->once())
+			->method('getBackend')
+			->willReturn($backend);
+		$this->mockAccount($targetUser, [
+			IAccountManager::PROPERTY_ADDRESS => ['value' => 'address'],
+			IAccountManager::PROPERTY_PHONE => ['value' => 'phone'],
+			IAccountManager::PROPERTY_TWITTER => ['value' => 'twitter'],
+			IAccountManager::PROPERTY_BLUESKY => ['value' => 'bluesky'],
+			IAccountManager::PROPERTY_FEDIVERSE => ['value' => 'fediverse'],
+			IAccountManager::PROPERTY_WEBSITE => ['value' => 'website'],
+			IAccountManager::PROPERTY_ORGANISATION => ['value' => 'organisation'],
+			IAccountManager::PROPERTY_ROLE => ['value' => 'role'],
+			IAccountManager::PROPERTY_HEADLINE => ['value' => 'headline'],
+			IAccountManager::PROPERTY_BIOGRAPHY => ['value' => 'biography'],
+			IAccountManager::PROPERTY_PROFILE_ENABLED => ['value' => '1'],
+			IAccountManager::PROPERTY_PRONOUNS => ['value' => 'they/them'],
+		]);
+
+		$this->l10nFactory
+			->expects($this->once())
+			->method('getUserLanguage')
+			->with($targetUser)
+			->willReturn('ru');
+
+		$expected = [
+			'id' => 'UID',
+			'firstLoginTimestamp' => 1511191471,
+			'lastLoginTimestamp' => 1521191471,
+			'lastLogin' => 1521191471000,
+			'backend' => 'Database',
+			'subadmin' => [],
+			'quota' => ['DummyValue'],
+			'email' => 'subadmin@nextcloud.com',
+			'displayname' => 'Subadmin User',
+			'display-name' => 'Subadmin User',
+			'phone' => 'phone',
+			'address' => 'address',
+			'website' => 'website',
+			'twitter' => 'twitter',
+			'bluesky' => 'bluesky',
+			'fediverse' => 'fediverse',
+			'groups' => [],
+			'language' => 'ru',
+			'locale' => null,
+			'backendCapabilities' => [
+				'setDisplayName' => false,
+				'setPassword' => false,
+			],
+			'additional_mail' => [],
+			'organisation' => 'organisation',
+			'role' => 'role',
+			'headline' => 'headline',
+			'biography' => 'biography',
+			'profile_enabled' => '1',
+			'notify_email' => null,
+			'manager' => '',
+			'pronouns' => 'they/them',
+		];
+		$this->assertEquals($expected, $this->invokePrivate($this->api, 'getUserData', ['UID']));
+	}
+
+	public static function dataSearchByPhoneNumbers(): array {
+		return [
+			'Invalid country' => ['Not a country code', ['12345' => ['NaN']], 400, null, null, []],
+			'No number to search' => ['DE', ['12345' => ['NaN']], 200, null, null, []],
+			'Valid number but no match' => ['DE', ['12345' => ['0711 / 25 24 28-90']], 200, ['+4971125242890'], [], []],
+			'Invalid number' => ['FR', ['12345' => ['0711 / 25 24 28-90']], 200, null, null, []],
+			'Invalid and valid number' => ['DE', ['12345' => ['NaN', '0711 / 25 24 28-90']], 200, ['+4971125242890'], [], []],
+			'Valid and invalid number' => ['DE', ['12345' => ['0711 / 25 24 28-90', 'NaN']], 200, ['+4971125242890'], [], []],
+			'Valid number and a match' => ['DE', ['12345' => ['0711 / 25 24 28-90']], 200, ['+4971125242890'], ['+4971125242890' => 'admin'], ['12345' => 'admin@localhost']],
+			'Same number twice, later hits' => ['DE', ['12345' => ['0711 / 25 24 28-90'], '23456' => ['0711 / 25 24 28-90']], 200, ['+4971125242890'], ['+4971125242890' => 'admin'], ['23456' => 'admin@localhost']],
+		];
+	}
+
+	#[\PHPUnit\Framework\Attributes\DataProvider('dataSearchByPhoneNumbers')]
+	public function testSearchByPhoneNumbers(string $location, array $search, int $status, ?array $searchUsers, ?array $userMatches, array $expected): void {
+		$knownTo = 'knownTo';
+		$user = $this->createMock(IUser::class);
+		$user->method('getUID')
+			->willReturn($knownTo);
+		$this->userSession->method('getUser')
+			->willReturn($user);
+
+		if ($searchUsers === null) {
+			$this->accountManager->expects($this->never())
+				->method('searchUsers');
+		} else {
+			$this->accountManager->expects($this->once())
+				->method('searchUsers')
+				->with(IAccountManager::PROPERTY_PHONE, $searchUsers)
+				->willReturn($userMatches);
+
+			$this->knownUserService->expects($this->once())
+				->method('deleteKnownTo')
+				->with($knownTo);
+
+			$this->knownUserService->expects($this->exactly(count($expected)))
+				->method('storeIsKnownToUser')
+				->with($knownTo, $this->anything());
+		}
+
+		$this->urlGenerator->method('getAbsoluteURL')
+			->with('/')
+			->willReturn('https://localhost/');
+
+		$response = $this->api->searchByPhoneNumbers($location, $search);
+
+		self::assertEquals($status, $response->getStatus());
+		self::assertEquals($expected, $response->getData());
+	}
+
+	public function testEditUserRegularUserSelfEditChangeDisplayName(): void {
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UID');
+		$targetUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToEdit')
+			->willReturn($targetUser);
+		$targetUser
+			->expects($this->once())
+			->method('getBackend')
+			->willReturn($this->createMock(ISetDisplayNameBackend::class));
+		$targetUser
+			->expects($this->once())
+			->method('setDisplayName')
+			->with('NewDisplayName')
+			->willReturn(true);
+		$targetUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UID');
+
+		$this->assertEquals([], $this->api->editUser('UserToEdit', 'display', 'NewDisplayName')->getData());
+	}
+
+	public function testEditUserRegularUserSelfEditChangeEmailValid(): void {
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UID');
+		$targetUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToEdit')
+			->willReturn($targetUser);
+		$targetUser
+			->expects($this->once())
+			->method('setSystemEMailAddress')
+			->with('demo@nextcloud.com');
+		$targetUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UID');
+
+		$backend = $this->createMock(UserInterface::class);
+		$targetUser
+			->expects($this->any())
+			->method('getBackend')
+			->willReturn($backend);
+
+		$this->config->method('getSystemValue')->willReturnCallback(fn (string $key, mixed $default) => $default);
+
+		$this->assertEquals([], $this->api->editUser('UserToEdit', 'email', 'demo@nextcloud.com')->getData());
+	}
+
+	public function testEditUserRegularUserSelfEditAddAdditionalEmailValid(): void {
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UID');
+		$targetUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToEdit')
+			->willReturn($targetUser);
+		$targetUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UID');
+
+		$backend = $this->createMock(UserInterface::class);
+		$targetUser
+			->expects($this->any())
+			->method('getBackend')
+			->willReturn($backend);
+
+		$userAccount = $this->createMock(IAccount::class);
+
+		$this->accountManager
+			->expects($this->once())
+			->method('getAccount')
+			->with($targetUser)
+			->willReturn($userAccount);
+		$this->accountManager
+			->expects($this->once())
+			->method('updateAccount')
+			->with($userAccount);
+
+		$this->assertEquals([], $this->api->editUser('UserToEdit', 'additional_mail', 'demo1@nextcloud.com')->getData());
+	}
+
+	public function testEditUserRegularUserSelfEditAddAdditionalEmailMainAddress(): void {
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UID');
+		$targetUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToEdit')
+			->willReturn($targetUser);
+		$targetUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UID');
+
+		$backend = $this->createMock(UserInterface::class);
+		$targetUser
+			->expects($this->any())
+			->method('getBackend')
+			->willReturn($backend);
+		$targetUser
+			->expects($this->any())
+			->method('getSystemEMailAddress')
+			->willReturn('demo@nextcloud.com');
+
+		$userAccount = $this->createMock(IAccount::class);
+
+		$this->accountManager
+			->expects($this->never())
+			->method('getAccount')
+			->with($targetUser)
+			->willReturn($userAccount);
+		$this->accountManager
+			->expects($this->never())
+			->method('updateAccount')
+			->with($userAccount);
+
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(101);
+		$this->api->editUser('UserToEdit', 'additional_mail', 'demo@nextcloud.com')->getData();
+	}
+
+	public function testEditUserRegularUserSelfEditAddAdditionalEmailDuplicate(): void {
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UID');
+		$targetUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToEdit')
+			->willReturn($targetUser);
+		$targetUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UID');
+
+		$backend = $this->createMock(UserInterface::class);
+		$targetUser
+			->expects($this->any())
+			->method('getBackend')
+			->willReturn($backend);
+
+		$property = $this->createMock(IAccountProperty::class);
+		$property->method('getValue')
+			->willReturn('demo1@nextcloud.com');
+		$collection = $this->createMock(IAccountPropertyCollection::class);
+		$collection->method('getPropertyByValue')
+			->with('demo1@nextcloud.com')
+			->willReturn($property);
+
+		$userAccount = $this->createMock(IAccount::class);
+		$userAccount->method('getPropertyCollection')
+			->with(IAccountManager::COLLECTION_EMAIL)
+			->willReturn($collection);
+
+		$this->accountManager
+			->expects($this->once())
+			->method('getAccount')
+			->with($targetUser)
+			->willReturn($userAccount);
+		$this->accountManager
+			->expects($this->never())
+			->method('updateAccount')
+			->with($userAccount);
+
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(101);
+		$this->api->editUser('UserToEdit', 'additional_mail', 'demo1@nextcloud.com')->getData();
+	}
+
+	public function testEditUserRegularUserSelfEditChangeEmailInvalid(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(101);
+
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UID');
+		$targetUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToEdit')
+			->willReturn($targetUser);
+		$targetUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UID');
+
+		$backend = $this->createMock(UserInterface::class);
+		$targetUser
+			->expects($this->any())
+			->method('getBackend')
+			->willReturn($backend);
+
+		$this->config->method('getSystemValue')->willReturnCallback(fn (string $key, mixed $default) => $default);
+
+		$this->api->editUser('UserToEdit', 'email', 'demo.org');
+	}
+
+	public static function selfEditChangePropertyProvider(): array {
+		return [
+			[IAccountManager::PROPERTY_TWITTER, '@oldtwitter', '@newtwitter'],
+			[IAccountManager::PROPERTY_BLUESKY, 'old.bluesky', 'new.bluesky'],
+			[IAccountManager::PROPERTY_FEDIVERSE, '@oldFediverse@floss.social', '@newFediverse@floss.social'],
+			[IAccountManager::PROPERTY_PHONE, '1234', '12345'],
+			[IAccountManager::PROPERTY_ADDRESS, 'Something street 2', 'Another street 3'],
+			[IAccountManager::PROPERTY_WEBSITE, 'https://examplesite1', 'https://examplesite2'],
+			[IAccountManager::PROPERTY_ORGANISATION, 'Organisation A', 'Organisation B'],
+			[IAccountManager::PROPERTY_ROLE, 'Human', 'Alien'],
+			[IAccountManager::PROPERTY_HEADLINE, 'Hi', 'Hello'],
+			[IAccountManager::PROPERTY_BIOGRAPHY, 'A biography', 'Another biography'],
+			[IAccountManager::PROPERTY_PROFILE_ENABLED, '1', '0'],
+			[IAccountManager::PROPERTY_PRONOUNS, 'they/them', 'he/him'],
+		];
+	}
+
+	#[\PHPUnit\Framework\Attributes\DataProvider('selfEditChangePropertyProvider')]
+	public function testEditUserRegularUserSelfEditChangeProperty($propertyName, $oldValue, $newValue): void {
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UID');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToEdit')
+			->willReturn($loggedInUser);
+
+		$backend = $this->createMock(UserInterface::class);
+		$loggedInUser
+			->expects($this->any())
+			->method('getBackend')
+			->willReturn($backend);
+
+		$propertyMock = $this->createMock(IAccountProperty::class);
+		$propertyMock->expects($this->any())
+			->method('getName')
+			->willReturn($propertyName);
+		$propertyMock->expects($this->any())
+			->method('getValue')
+			->willReturn($oldValue);
+		$propertyMock->expects($this->once())
+			->method('setValue')
+			->with($newValue)
+			->willReturnSelf();
+		$propertyMock->expects($this->any())
+			->method('getScope')
+			->willReturn(IAccountManager::SCOPE_LOCAL);
+
+		$accountMock = $this->createMock(IAccount::class);
+		$accountMock->expects($this->any())
+			->method('getProperty')
+			->with($propertyName)
+			->willReturn($propertyMock);
+
+		$this->accountManager->expects($this->atLeastOnce())
+			->method('getAccount')
+			->with($loggedInUser)
+			->willReturn($accountMock);
+		$this->accountManager->expects($this->once())
+			->method('updateAccount')
+			->with($accountMock);
+
+		$this->assertEquals([], $this->api->editUser('UserToEdit', $propertyName, $newValue)->getData());
+	}
+
+	public function selfEditChangePropertyScopeProvider() {
+		return [
+			[IAccountManager::PROPERTY_AVATAR, IAccountManager::SCOPE_LOCAL, IAccountManager::SCOPE_FEDERATED],
+			[IAccountManager::PROPERTY_DISPLAYNAME, IAccountManager::SCOPE_LOCAL, IAccountManager::SCOPE_FEDERATED],
+			[IAccountManager::PROPERTY_EMAIL, IAccountManager::SCOPE_LOCAL, IAccountManager::SCOPE_FEDERATED],
+			[IAccountManager::PROPERTY_TWITTER, IAccountManager::SCOPE_LOCAL, IAccountManager::SCOPE_FEDERATED],
+			[IAccountManager::PROPERTY_BLUESKY, IAccountManager::SCOPE_LOCAL, IAccountManager::SCOPE_FEDERATED],
+			[IAccountManager::PROPERTY_FEDIVERSE, IAccountManager::SCOPE_LOCAL, IAccountManager::SCOPE_FEDERATED],
+			[IAccountManager::PROPERTY_PHONE, IAccountManager::SCOPE_LOCAL, IAccountManager::SCOPE_FEDERATED],
+			[IAccountManager::PROPERTY_ADDRESS, IAccountManager::SCOPE_LOCAL, IAccountManager::SCOPE_FEDERATED],
+			[IAccountManager::PROPERTY_WEBSITE, IAccountManager::SCOPE_LOCAL, IAccountManager::SCOPE_FEDERATED],
+			[IAccountManager::PROPERTY_ORGANISATION, IAccountManager::SCOPE_LOCAL, IAccountManager::SCOPE_FEDERATED],
+			[IAccountManager::PROPERTY_ROLE, IAccountManager::SCOPE_LOCAL, IAccountManager::SCOPE_FEDERATED],
+			[IAccountManager::PROPERTY_HEADLINE, IAccountManager::SCOPE_LOCAL, IAccountManager::SCOPE_FEDERATED],
+			[IAccountManager::PROPERTY_BIOGRAPHY, IAccountManager::SCOPE_LOCAL, IAccountManager::SCOPE_FEDERATED],
+			[IAccountManager::PROPERTY_PROFILE_ENABLED, IAccountManager::SCOPE_LOCAL, IAccountManager::SCOPE_FEDERATED],
+			[IAccountManager::PROPERTY_PRONOUNS, IAccountManager::SCOPE_LOCAL, IAccountManager::SCOPE_FEDERATED],
+		];
+	}
+
+	#[\PHPUnit\Framework\Attributes\DataProvider('selfEditChangePropertyProvider')]
+	public function testEditUserRegularUserSelfEditChangePropertyScope($propertyName, $oldScope, $newScope): void {
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UID');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToEdit')
+			->willReturn($loggedInUser);
+
+		$backend = $this->createMock(UserInterface::class);
+		$loggedInUser
+			->expects($this->any())
+			->method('getBackend')
+			->willReturn($backend);
+
+		$propertyMock = $this->createMock(IAccountProperty::class);
+		$propertyMock->expects($this->any())
+			->method('getName')
+			->willReturn($propertyName);
+		$propertyMock->expects($this->any())
+			->method('getValue')
+			->willReturn('somevalue');
+		$propertyMock->expects($this->any())
+			->method('getScope')
+			->willReturn($oldScope);
+		$propertyMock->expects($this->atLeastOnce())
+			->method('setScope')
+			->with($newScope)
+			->willReturnSelf();
+
+		$accountMock = $this->createMock(IAccount::class);
+		$accountMock->expects($this->any())
+			->method('getProperty')
+			->with($propertyName)
+			->willReturn($propertyMock);
+
+		$this->accountManager->expects($this->atLeastOnce())
+			->method('getAccount')
+			->with($loggedInUser)
+			->willReturn($accountMock);
+		$this->accountManager->expects($this->once())
+			->method('updateAccount')
+			->with($accountMock);
+
+		$this->assertEquals([], $this->api->editUser('UserToEdit', $propertyName . 'Scope', $newScope)->getData());
+	}
+
+	public function testEditUserRegularUserSelfEditChangePassword(): void {
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UID');
+		$targetUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToEdit')
+			->willReturn($targetUser);
+		$targetUser
+			->expects($this->once())
+			->method('canChangePassword')
+			->willReturn(true);
+		$targetUser
+			->expects($this->once())
+			->method('setPassword')
+			->with('NewPassword');
+		$targetUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UID');
+
+		$backend = $this->createMock(UserInterface::class);
+		$targetUser
+			->expects($this->any())
+			->method('getBackend')
+			->willReturn($backend);
+
+		$this->assertEquals([], $this->api->editUser('UserToEdit', 'password', 'NewPassword')->getData());
+	}
+
+
+
+	public function testEditUserRegularUserSelfEditChangeQuota(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(113);
+
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UID');
+		$targetUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToEdit')
+			->willReturn($targetUser);
+		$targetUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UID');
+
+		$backend = $this->createMock(UserInterface::class);
+		$targetUser
+			->expects($this->any())
+			->method('getBackend')
+			->willReturn($backend);
+
+		$this->api->editUser('UserToEdit', 'quota', 'NewQuota');
+	}
+
+	public function testEditUserAdminUserSelfEditChangeValidQuota(): void {
+		$this->config
+			->expects($this->once())
+			->method('getAppValue')
+			->willReturnCallback(function ($appid, $key, $default) {
+				if ($key === 'max_quota') {
+					return '-1';
+				}
+				return null;
+			});
+		$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UID');
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$targetUser->expects($this->once())
+			->method('setQuota')
+			->with('2.9 MB');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToEdit')
+			->willReturn($targetUser);
+		$this->groupManager
+			->expects($this->exactly(3))
+			->method('isAdmin')
+			->with('UID')
+			->willReturn(true);
+		$targetUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UID');
+
+		$backend = $this->createMock(UserInterface::class);
+		$targetUser
+			->expects($this->any())
+			->method('getBackend')
+			->willReturn($backend);
+
+		$this->assertEquals([], $this->api->editUser('UserToEdit', 'quota', '3042824')->getData());
+	}
+
+
+
+	public function testEditUserAdminUserSelfEditChangeInvalidQuota(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionMessage('Invalid quota value: ABC');
+		$this->expectExceptionCode(101);
+
+		$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UID');
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToEdit')
+			->willReturn($targetUser);
+		$this->groupManager
+			->expects($this->exactly(3))
+			->method('isAdmin')
+			->with('UID')
+			->willReturn(true);
+		$targetUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UID');
+
+		$backend = $this->createMock(UserInterface::class);
+		$targetUser
+			->expects($this->any())
+			->method('getBackend')
+			->willReturn($backend);
+
+		$this->api->editUser('UserToEdit', 'quota', 'ABC');
+	}
+
+	public function testEditUserAdminUserEditChangeValidQuota(): void {
+		$this->config
+			->expects($this->once())
+			->method('getAppValue')
+			->willReturnCallback(function ($appid, $key, $default) {
+				if ($key === 'max_quota') {
+					return '-1';
+				}
+				return null;
+			});
+		$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('admin');
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$targetUser->expects($this->once())
+			->method('setQuota')
+			->with('2.9 MB');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToEdit')
+			->willReturn($targetUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('admin')
+			->willReturn(true);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()
+			->getMock();
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+		$targetUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UID');
+
+		$backend = $this->createMock(UserInterface::class);
+		$targetUser
+			->expects($this->any())
+			->method('getBackend')
+			->willReturn($backend);
+
+		$this->assertEquals([], $this->api->editUser('UserToEdit', 'quota', '3042824')->getData());
+	}
+
+	public function testEditUserSelfEditChangeLanguage(): void {
+		$this->l10nFactory->expects($this->once())
+			->method('findAvailableLanguages')
+			->willReturn(['en', 'de', 'sv']);
+		$this->config->expects($this->any())
+			->method('getSystemValue')
+			->willReturnMap([
+				['allow_user_to_change_display_name', true, true],
+				['force_language', false, false],
+			]);
+
+		$loggedInUser = $this->createMock(IUser::class);
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UserToEdit');
+		$targetUser = $this->createMock(IUser::class);
+		$this->config->expects($this->once())
+			->method('setUserValue')
+			->with('UserToEdit', 'core', 'lang', 'de');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToEdit')
+			->willReturn($targetUser);
+		$this->groupManager
+			->expects($this->atLeastOnce())
+			->method('isAdmin')
+			->with('UserToEdit')
+			->willReturn(false);
+		$targetUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UserToEdit');
+
+		$backend = $this->createMock(UserInterface::class);
+		$targetUser
+			->expects($this->any())
+			->method('getBackend')
+			->willReturn($backend);
+
+		$this->assertEquals([], $this->api->editUser('UserToEdit', 'language', 'de')->getData());
+	}
+
+	public static function dataEditUserSelfEditChangeLanguageButForced(): array {
+		return [
+			['de'],
+			[true],
+		];
+	}
+
+	#[\PHPUnit\Framework\Attributes\DataProvider('dataEditUserSelfEditChangeLanguageButForced')]
+	public function testEditUserSelfEditChangeLanguageButForced($forced): void {
+		$this->expectException(OCSException::class);
+
+		$this->config->expects($this->any())
+			->method('getSystemValue')
+			->willReturnMap([
+				['allow_user_to_change_display_name', true, true],
+				['force_language', false, $forced],
+			]);
+
+		$loggedInUser = $this->createMock(IUser::class);
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UserToEdit');
+		$targetUser = $this->createMock(IUser::class);
+		$this->config->expects($this->never())
+			->method('setUserValue');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToEdit')
+			->willReturn($targetUser);
+		$this->groupManager
+			->expects($this->atLeastOnce())
+			->method('isAdmin')
+			->with('UserToEdit')
+			->willReturn(false);
+		$targetUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UserToEdit');
+
+		$backend = $this->createMock(UserInterface::class);
+		$targetUser
+			->expects($this->any())
+			->method('getBackend')
+			->willReturn($backend);
+
+		$this->assertEquals([], $this->api->editUser('UserToEdit', 'language', 'de')->getData());
+	}
+
+	public function testEditUserAdminEditChangeLanguage(): void {
+		$this->l10nFactory->expects($this->once())
+			->method('findAvailableLanguages')
+			->willReturn(['en', 'de', 'sv']);
+
+		$loggedInUser = $this->createMock(IUser::class);
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('admin');
+		$targetUser = $this->createMock(IUser::class);
+		$this->config->expects($this->once())
+			->method('setUserValue')
+			->with('UserToEdit', 'core', 'lang', 'de');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToEdit')
+			->willReturn($targetUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('admin')
+			->willReturn(true);
+		$subAdminManager = $this->createMock(SubAdmin::class);
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+		$targetUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UserToEdit');
+
+		$backend = $this->createMock(UserInterface::class);
+		$targetUser
+			->expects($this->any())
+			->method('getBackend')
+			->willReturn($backend);
+
+		$this->assertEquals([], $this->api->editUser('UserToEdit', 'language', 'de')->getData());
+	}
+
+	#[\PHPUnit\Framework\Attributes\DataProvider('dataEditUserSelfEditChangeLanguageButForced')]
+	public function testEditUserAdminEditChangeLanguageInvalidLanguage(): void {
+		$this->expectException(OCSException::class);
+
+
+		$this->l10nFactory->expects($this->once())
+			->method('findAvailableLanguages')
+			->willReturn(['en', 'de', 'sv']);
+
+		$loggedInUser = $this->createMock(IUser::class);
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('admin');
+		$targetUser = $this->createMock(IUser::class);
+		$this->config->expects($this->never())
+			->method('setUserValue');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToEdit')
+			->willReturn($targetUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('admin')
+			->willReturn(true);
+		$subAdminManager = $this->createMock(SubAdmin::class);
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+		$targetUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UserToEdit');
+
+		$backend = $this->createMock(UserInterface::class);
+		$targetUser
+			->expects($this->any())
+			->method('getBackend')
+			->willReturn($backend);
+
+		$this->assertEquals([], $this->api->editUser('UserToEdit', 'language', 'ru')->getData());
+	}
+
+	public function testEditUserSubadminUserAccessible(): void {
+		$this->config
+			->expects($this->once())
+			->method('getAppValue')
+			->willReturnCallback(function ($appid, $key, $default) {
+				if ($key === 'max_quota') {
+					return '-1';
+				}
+				return null;
+			});
+		$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('subadmin');
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$targetUser->expects($this->once())
+			->method('setQuota')
+			->with('2.9 MB');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToEdit')
+			->willReturn($targetUser);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()
+			->getMock();
+		$subAdminManager
+			->expects($this->once())
+			->method('isUserAccessible')
+			->with($loggedInUser, $targetUser)
+			->willReturn(true);
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+		$targetUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UID');
+
+		$backend = $this->createMock(UserInterface::class);
+		$targetUser
+			->expects($this->any())
+			->method('getBackend')
+			->willReturn($backend);
+
+		$this->assertEquals([], $this->api->editUser('UserToEdit', 'quota', '3042824')->getData());
+	}
+
+
+	public function testEditUserSubadminUserInaccessible(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(998);
+
+		$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('subadmin');
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToEdit')
+			->willReturn($targetUser);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()
+			->getMock();
+		$subAdminManager
+			->expects($this->once())
+			->method('isUserAccessible')
+			->with($loggedInUser, $targetUser)
+			->willReturn(false);
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+		$targetUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UID');
+
+		$this->api->editUser('UserToEdit', 'quota', 'value');
+	}
+
+
+	public function testDeleteUserNotExistingUser(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(998);
+
+		$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UserToEdit');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToDelete')
+			->willReturn(null);
+
+		$this->api->deleteUser('UserToDelete');
+	}
+
+
+	public function testDeleteUserSelf(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(101);
+
+		$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('UID');
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$targetUser
+			->expects($this->once())
+			->method('getUID')
+			->willReturn('UID');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToDelete')
+			->willReturn($targetUser);
+
+		$this->api->deleteUser('UserToDelete');
+	}
+
+	public function testDeleteSuccessfulUserAsAdmin(): void {
+		$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('admin');
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$targetUser
+			->expects($this->once())
+			->method('getUID')
+			->willReturn('UID');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToDelete')
+			->willReturn($targetUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('admin')
+			->willReturn(true);
+		$targetUser
+			->expects($this->once())
+			->method('delete')
+			->willReturn(true);
+
+		$this->assertEquals([], $this->api->deleteUser('UserToDelete')->getData());
+	}
+
+
+	public function testDeleteUnsuccessfulUserAsAdmin(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(101);
+
+		$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('admin');
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$targetUser
+			->expects($this->once())
+			->method('getUID')
+			->willReturn('UID');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToDelete')
+			->willReturn($targetUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('admin')
+			->willReturn(true);
+		$targetUser
+			->expects($this->once())
+			->method('delete')
+			->willReturn(false);
+
+		$this->api->deleteUser('UserToDelete');
+	}
+
+	public function testDeleteSuccessfulUserAsSubadmin(): void {
+		$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('subadmin');
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$targetUser
+			->expects($this->once())
+			->method('getUID')
+			->willReturn('UID');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToDelete')
+			->willReturn($targetUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('subadmin')
+			->willReturn(false);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()->getMock();
+		$subAdminManager
+			->expects($this->once())
+			->method('isUserAccessible')
+			->with($loggedInUser, $targetUser)
+			->willReturn(true);
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+		$targetUser
+			->expects($this->once())
+			->method('delete')
+			->willReturn(true);
+
+		$this->assertEquals([], $this->api->deleteUser('UserToDelete')->getData());
+	}
+
+
+	public function testDeleteUnsuccessfulUserAsSubadmin(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(101);
+
+		$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('subadmin');
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$targetUser
+			->expects($this->once())
+			->method('getUID')
+			->willReturn('UID');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToDelete')
+			->willReturn($targetUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('subadmin')
+			->willReturn(false);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()->getMock();
+		$subAdminManager
+			->expects($this->once())
+			->method('isUserAccessible')
+			->with($loggedInUser, $targetUser)
+			->willReturn(true);
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+		$targetUser
+			->expects($this->once())
+			->method('delete')
+			->willReturn(false);
+
+		$this->api->deleteUser('UserToDelete');
+	}
+
+
+	public function testDeleteUserAsSubAdminAndUserIsNotAccessible(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(998);
+
+		$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('subadmin');
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$targetUser
+			->expects($this->once())
+			->method('getUID')
+			->willReturn('UID');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToDelete')
+			->willReturn($targetUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('subadmin')
+			->willReturn(false);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()->getMock();
+		$subAdminManager
+			->expects($this->once())
+			->method('isUserAccessible')
+			->with($loggedInUser, $targetUser)
+			->willReturn(false);
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+
+		$this->api->deleteUser('UserToDelete');
+	}
+
+
+	public function testGetUsersGroupsTargetUserNotExisting(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(998);
+
+		$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+
+		$this->api->getUsersGroups('UserToLookup');
+	}
+
+	public function testGetUsersGroupsSelfTargetted(): void {
+		$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$loggedInUser
+			->expects($this->exactly(3))
+			->method('getUID')
+			->willReturn('UserToLookup');
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$targetUser
+			->expects($this->once())
+			->method('getUID')
+			->willReturn('UserToLookup');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToLookup')
+			->willReturn($targetUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('getUserGroupIds')
+			->with($targetUser)
+			->willReturn(['DummyValue']);
+
+		$this->assertEquals(['groups' => ['DummyValue']], $this->api->getUsersGroups('UserToLookup')->getData());
+	}
+
+	public function testGetUsersGroupsForAdminUser(): void {
+		$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$loggedInUser
+			->expects($this->exactly(3))
+			->method('getUID')
+			->willReturn('admin');
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$targetUser
+			->expects($this->once())
+			->method('getUID')
+			->willReturn('UserToLookup');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToLookup')
+			->willReturn($targetUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('getUserGroupIds')
+			->with($targetUser)
+			->willReturn(['DummyValue']);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('admin')
+			->willReturn(true);
+
+		$this->assertEquals(['groups' => ['DummyValue']], $this->api->getUsersGroups('UserToLookup')->getData());
+	}
+
+	public function testGetUsersGroupsForSubAdminUserAndUserIsAccessible(): void {
+		$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$loggedInUser
+			->expects($this->exactly(3))
+			->method('getUID')
+			->willReturn('subadmin');
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$targetUser
+			->expects($this->once())
+			->method('getUID')
+			->willReturn('UserToLookup');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToLookup')
+			->willReturn($targetUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('subadmin')
+			->willReturn(false);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()->getMock();
+		$subAdminManager
+			->expects($this->once())
+			->method('isUserAccessible')
+			->with($loggedInUser, $targetUser)
+			->willReturn(true);
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+		$group1 = $this->getMockBuilder('\OCP\IGroup')->disableOriginalConstructor()->getMock();
+		$group1
+			->expects($this->any())
+			->method('getGID')
+			->willReturn('Group1');
+		$group2 = $this->getMockBuilder('\OCP\IGroup')->disableOriginalConstructor()->getMock();
+		$group2
+			->expects($this->any())
+			->method('getGID')
+			->willReturn('Group2');
+		$subAdminManager
+			->expects($this->once())
+			->method('getSubAdminsGroups')
+			->with($loggedInUser)
+			->willReturn([$group1, $group2]);
+		$this->groupManager
+			->expects($this->any())
+			->method('getUserGroupIds')
+			->with($targetUser)
+			->willReturn(['Group1']);
+
+		$this->assertEquals(['groups' => ['Group1']], $this->api->getUsersGroups('UserToLookup')->getData());
+	}
+
+
+	public function testGetUsersGroupsForSubAdminUserAndUserIsInaccessible(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(998);
+
+		$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$loggedInUser
+			->expects($this->exactly(3))
+			->method('getUID')
+			->willReturn('subadmin');
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$targetUser
+			->expects($this->once())
+			->method('getUID')
+			->willReturn('UserToLookup');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToLookup')
+			->willReturn($targetUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('subadmin')
+			->willReturn(false);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()->getMock();
+		$subAdminManager
+			->expects($this->once())
+			->method('isUserAccessible')
+			->with($loggedInUser, $targetUser)
+			->willReturn(false);
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+		$this->groupManager
+			->expects($this->any())
+			->method('getUserGroupIds')
+			->with($targetUser)
+			->willReturn(['Group1']);
+
+		$this->api->getUsersGroups('UserToLookup');
+	}
+
+
+	public function testAddToGroupWithTargetGroupNotExisting(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(102);
+
+		$this->groupManager->expects($this->once())
+			->method('get')
+			->with('GroupToAddTo')
+			->willReturn(null);
+
+		$this->api->addToGroup('TargetUser', 'GroupToAddTo');
+	}
+
+
+	public function testAddToGroupWithNoGroupSpecified(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(101);
+
+		$this->api->addToGroup('TargetUser');
+	}
+
+
+	public function testAddToGroupWithTargetUserNotExisting(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(103);
+
+		$targetGroup = $this->createMock(IGroup::class);
+		$this->groupManager->expects($this->once())
+			->method('get')
+			->with('GroupToAddTo')
+			->willReturn($targetGroup);
+
+		$this->api->addToGroup('TargetUser', 'GroupToAddTo');
+	}
+
+
+	public function testAddToGroupNoSubadmin(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(104);
+
+		$targetUser = $this->createMock(IUser::class);
+		$loggedInUser = $this->createMock(IUser::class);
+		$loggedInUser->expects($this->exactly(2))
+			->method('getUID')
+			->willReturn('subadmin');
+
+		$targetGroup = $this->createMock(IGroup::class);
+		$targetGroup->expects($this->never())
+			->method('addUser')
+			->with($targetUser);
+
+		$this->groupManager->expects($this->once())
+			->method('get')
+			->with('GroupToAddTo')
+			->willReturn($targetGroup);
+
+
+		$subAdminManager = $this->createMock(SubAdmin::class);
+		$subAdminManager->expects($this->once())
+			->method('isSubAdminOfGroup')
+			->with($loggedInUser, $targetGroup)
+			->willReturn(false);
+
+		$this->groupManager->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+		$this->groupManager->expects($this->once())
+			->method('isAdmin')
+			->with('subadmin')
+			->willReturn(false);
+
+		$this->userManager->expects($this->once())
+			->method('get')
+			->with('TargetUser')
+			->willReturn($targetUser);
+
+		$this->userSession->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+
+		$this->api->addToGroup('TargetUser', 'GroupToAddTo');
+	}
+
+	public function testAddToGroupSuccessAsSubadmin(): void {
+		$targetUser = $this->createMock(IUser::class);
+		$loggedInUser = $this->createMock(IUser::class);
+		$loggedInUser->expects($this->exactly(2))
+			->method('getUID')
+			->willReturn('subadmin');
+
+		$targetGroup = $this->createMock(IGroup::class);
+		$targetGroup->expects($this->once())
+			->method('addUser')
+			->with($targetUser);
+
+		$this->groupManager->expects($this->once())
+			->method('get')
+			->with('GroupToAddTo')
+			->willReturn($targetGroup);
+
+
+		$subAdminManager = $this->createMock(SubAdmin::class);
+		$subAdminManager->expects($this->once())
+			->method('isSubAdminOfGroup')
+			->with($loggedInUser, $targetGroup)
+			->willReturn(true);
+
+		$this->groupManager->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+		$this->groupManager->expects($this->once())
+			->method('isAdmin')
+			->with('subadmin')
+			->willReturn(false);
+
+		$this->userManager->expects($this->once())
+			->method('get')
+			->with('TargetUser')
+			->willReturn($targetUser);
+
+		$this->userSession->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+
+		$this->assertEquals(new DataResponse(), $this->api->addToGroup('TargetUser', 'GroupToAddTo'));
+	}
+
+	public function testAddToGroupSuccessAsAdmin(): void {
+		$targetUser = $this->createMock(IUser::class);
+		$loggedInUser = $this->createMock(IUser::class);
+		$loggedInUser->expects($this->exactly(2))
+			->method('getUID')
+			->willReturn('admin');
+
+		$targetGroup = $this->createMock(IGroup::class);
+		$targetGroup->expects($this->once())
+			->method('addUser')
+			->with($targetUser);
+
+		$this->groupManager->expects($this->once())
+			->method('get')
+			->with('GroupToAddTo')
+			->willReturn($targetGroup);
+
+
+		$subAdminManager = $this->createMock(SubAdmin::class);
+		$subAdminManager->expects($this->never())
+			->method('isSubAdminOfGroup');
+
+		$this->groupManager->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+		$this->groupManager->expects($this->once())
+			->method('isAdmin')
+			->with('admin')
+			->willReturn(true);
+
+		$this->userManager->expects($this->once())
+			->method('get')
+			->with('TargetUser')
+			->willReturn($targetUser);
+
+		$this->userSession->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+
+		$this->assertEquals(new DataResponse(), $this->api->addToGroup('TargetUser', 'GroupToAddTo'));
+	}
+
+
+	public function testRemoveFromGroupWithNoTargetGroup(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(101);
+
+		$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+
+		$this->api->removeFromGroup('TargetUser', '');
+	}
+
+
+	public function testRemoveFromGroupWithEmptyTargetGroup(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(101);
+
+		$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+
+		$this->api->removeFromGroup('TargetUser', '');
+	}
+
+
+	public function testRemoveFromGroupWithNotExistingTargetGroup(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(102);
+
+		$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('get')
+			->with('TargetGroup')
+			->willReturn(null);
+
+		$this->api->removeFromGroup('TargetUser', 'TargetGroup');
+	}
+
+
+	public function testRemoveFromGroupWithNotExistingTargetUser(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(103);
+
+		$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$targetGroup = $this->getMockBuilder('\OCP\IGroup')->disableOriginalConstructor()->getMock();
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('get')
+			->with('TargetGroup')
+			->willReturn($targetGroup);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('TargetUser')
+			->willReturn(null);
+
+		$this->api->removeFromGroup('TargetUser', 'TargetGroup');
+	}
+
+
+	public function testRemoveFromGroupWithoutPermission(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(104);
+
+		$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$loggedInUser
+			->expects($this->exactly(2))
+			->method('getUID')
+			->willReturn('unauthorizedUser');
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$targetGroup = $this->getMockBuilder('\OCP\IGroup')->disableOriginalConstructor()->getMock();
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('get')
+			->with('TargetGroup')
+			->willReturn($targetGroup);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('TargetUser')
+			->willReturn($targetUser);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()->getMock();
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('unauthorizedUser')
+			->willReturn(false);
+
+		$this->api->removeFromGroup('TargetUser', 'TargetGroup');
+	}
+
+
+	public function testRemoveFromGroupAsAdminFromAdmin(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionMessage('Cannot remove yourself from the admin group');
+		$this->expectExceptionCode(105);
+
+		$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('admin');
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$targetUser
+			->expects($this->once())
+			->method('getUID')
+			->willReturn('admin');
+		$targetGroup = $this->getMockBuilder('\OCP\IGroup')->disableOriginalConstructor()->getMock();
+		$targetGroup
+			->expects($this->once())
+			->method('getGID')
+			->willReturn('admin');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('get')
+			->with('admin')
+			->willReturn($targetGroup);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('Admin')
+			->willReturn($targetUser);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()->getMock();
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+		$this->groupManager
+			->expects($this->any())
+			->method('isAdmin')
+			->with('admin')
+			->willReturn(true);
+
+		$this->api->removeFromGroup('Admin', 'admin');
+	}
+
+
+	public function testRemoveFromGroupAsSubAdminFromSubAdmin(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionMessage('Cannot remove yourself from this group as you are a sub-admin');
+		$this->expectExceptionCode(105);
+
+		$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('subadmin');
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$targetUser
+			->expects($this->once())
+			->method('getUID')
+			->willReturn('subadmin');
+		$targetGroup = $this->getMockBuilder('\OCP\IGroup')->disableOriginalConstructor()->getMock();
+		$targetGroup
+			->expects($this->any())
+			->method('getGID')
+			->willReturn('subadmin');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('get')
+			->with('subadmin')
+			->willReturn($targetGroup);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('SubAdmin')
+			->willReturn($targetUser);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()->getMock();
+		$subAdminManager
+			->expects($this->once())
+			->method('isSubAdminOfGroup')
+			->with($loggedInUser, $targetGroup)
+			->willReturn(true);
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+		$this->groupManager
+			->expects($this->any())
+			->method('isAdmin')
+			->with('subadmin')
+			->willReturn(false);
+
+		$this->api->removeFromGroup('SubAdmin', 'subadmin');
+	}
+
+
+	public function testRemoveFromGroupAsSubAdminFromLastSubAdminGroup(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionMessage('Not viable to remove user from the last group you are sub-admin of');
+		$this->expectExceptionCode(105);
+
+		$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('subadmin');
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$targetGroup = $this->getMockBuilder('\OCP\IGroup')->disableOriginalConstructor()->getMock();
+		$targetGroup
+			->expects($this->any())
+			->method('getGID')
+			->willReturn('subadmin');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('get')
+			->with('subadmin')
+			->willReturn($targetGroup);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('AnotherUser')
+			->willReturn($targetUser);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()->getMock();
+		$subAdminManager
+			->expects($this->once())
+			->method('isSubAdminOfGroup')
+			->with($loggedInUser, $targetGroup)
+			->willReturn(true);
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+		$subAdminManager
+			->expects($this->once())
+			->method('getSubAdminsGroups')
+			->with($loggedInUser)
+			->willReturn([$targetGroup]);
+
+		$this->groupManager
+			->expects($this->any())
+			->method('isAdmin')
+			->with('subadmin')
+			->willReturn(false);
+		$this->groupManager
+			->expects($this->once())
+			->method('getUserGroupIds')
+			->with($targetUser)
+			->willReturn(['subadmin', 'other group']);
+
+		$this->api->removeFromGroup('AnotherUser', 'subadmin');
+	}
+
+	public function testRemoveFromGroupSuccessful(): void {
+		$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$loggedInUser
+			->expects($this->any())
+			->method('getUID')
+			->willReturn('admin');
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$targetGroup = $this->getMockBuilder('\OCP\IGroup')->disableOriginalConstructor()->getMock();
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('get')
+			->with('admin')
+			->willReturn($targetGroup);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('AnotherUser')
+			->willReturn($targetUser);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()->getMock();
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+		$this->groupManager
+			->expects($this->any())
+			->method('isAdmin')
+			->with('admin')
+			->willReturn(true);
+		$targetGroup
+			->expects($this->once())
+			->method('removeUser')
+			->with($targetUser);
+
+		$this->assertEquals([], $this->api->removeFromGroup('AnotherUser', 'admin')->getData());
+	}
+
+
+	public function testAddSubAdminWithNotExistingTargetUser(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionMessage('User does not exist');
+		$this->expectExceptionCode(101);
+
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('NotExistingUser')
+			->willReturn(null);
+
+		$this->api->addSubAdmin('NotExistingUser', '');
+	}
+
+
+	public function testAddSubAdminWithNotExistingTargetGroup(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionMessage('Group does not exist');
+		$this->expectExceptionCode(102);
+
+
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('ExistingUser')
+			->willReturn($targetUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('get')
+			->with('NotExistingGroup')
+			->willReturn(null);
+
+		$this->api->addSubAdmin('ExistingUser', 'NotExistingGroup');
+	}
+
+
+	public function testAddSubAdminToAdminGroup(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionMessage('Cannot create sub-admins for admin group');
+		$this->expectExceptionCode(103);
+
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$targetGroup = $this->getMockBuilder('\OCP\IGroup')->disableOriginalConstructor()->getMock();
+		$targetGroup
+			->expects($this->once())
+			->method('getGID')
+			->willReturn('admin');
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('ExistingUser')
+			->willReturn($targetUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('get')
+			->with('ADmiN')
+			->willReturn($targetGroup);
+
+		$this->api->addSubAdmin('ExistingUser', 'ADmiN');
+	}
+
+	public function testAddSubAdminTwice(): void {
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$targetGroup = $this->getMockBuilder('\OCP\IGroup')->disableOriginalConstructor()->getMock();
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('ExistingUser')
+			->willReturn($targetUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('get')
+			->with('TargetGroup')
+			->willReturn($targetGroup);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()->getMock();
+		$subAdminManager
+			->expects($this->once())
+			->method('isSubAdminOfGroup')
+			->with($targetUser, $targetGroup)
+			->willReturn(true);
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+
+		$this->assertEquals([], $this->api->addSubAdmin('ExistingUser', 'TargetGroup')->getData());
+	}
+
+	public function testAddSubAdminSuccessful(): void {
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$targetGroup = $this->getMockBuilder('\OCP\IGroup')->disableOriginalConstructor()->getMock();
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('ExistingUser')
+			->willReturn($targetUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('get')
+			->with('TargetGroup')
+			->willReturn($targetGroup);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()->getMock();
+		$subAdminManager
+			->expects($this->once())
+			->method('isSubAdminOfGroup')
+			->with($targetUser, $targetGroup)
+			->willReturn(false);
+		$subAdminManager
+			->expects($this->once())
+			->method('createSubAdmin')
+			->with($targetUser, $targetGroup);
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+
+		$this->assertEquals([], $this->api->addSubAdmin('ExistingUser', 'TargetGroup')->getData());
+	}
+
+
+	public function testRemoveSubAdminNotExistingTargetUser(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionMessage('User does not exist');
+		$this->expectExceptionCode(101);
+
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('NotExistingUser')
+			->willReturn(null);
+
+		$this->api->removeSubAdmin('NotExistingUser', 'GroupToDeleteFrom');
+	}
+
+
+	public function testRemoveSubAdminNotExistingTargetGroup(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionMessage('Group does not exist');
+		$this->expectExceptionCode(101);
+
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('ExistingUser')
+			->willReturn($targetUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('get')
+			->with('GroupToDeleteFrom')
+			->willReturn(null);
+
+		$this->api->removeSubAdmin('ExistingUser', 'GroupToDeleteFrom');
+	}
+
+
+
+	public function testRemoveSubAdminFromNotASubadmin(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionMessage('User is not a sub-admin of this group');
+		$this->expectExceptionCode(102);
+
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$targetGroup = $this->getMockBuilder('\OCP\IGroup')->disableOriginalConstructor()->getMock();
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('ExistingUser')
+			->willReturn($targetUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('get')
+			->with('GroupToDeleteFrom')
+			->willReturn($targetGroup);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()->getMock();
+		$subAdminManager
+			->expects($this->once())
+			->method('isSubAdminOfGroup')
+			->with($targetUser, $targetGroup)
+			->willReturn(false);
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+
+		$this->api->removeSubAdmin('ExistingUser', 'GroupToDeleteFrom');
+	}
+
+	public function testRemoveSubAdminSuccessful(): void {
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$targetGroup = $this->getMockBuilder('\OCP\IGroup')->disableOriginalConstructor()->getMock();
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('ExistingUser')
+			->willReturn($targetUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('get')
+			->with('GroupToDeleteFrom')
+			->willReturn($targetGroup);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()->getMock();
+		$subAdminManager
+			->expects($this->once())
+			->method('isSubAdminOfGroup')
+			->with($targetUser, $targetGroup)
+			->willReturn(true);
+		$subAdminManager
+			->expects($this->once())
+			->method('deleteSubAdmin')
+			->with($targetUser, $targetGroup);
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+
+		$this->assertEquals([], $this->api->removeSubAdmin('ExistingUser', 'GroupToDeleteFrom')->getData());
+	}
+
+
+	public function testGetUserSubAdminGroupsNotExistingTargetUser(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionMessage('User does not exist');
+		$this->expectExceptionCode(404);
+
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('RequestedUser')
+			->willReturn(null);
+
+		$this->api->getUserSubAdminGroups('RequestedUser');
+	}
+
+	public function testGetUserSubAdminGroupsWithGroups(): void {
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$targetGroup = $this->getMockBuilder('\OCP\IGroup')->disableOriginalConstructor()->getMock();
+		$targetGroup
+			->expects($this->once())
+			->method('getGID')
+			->willReturn('TargetGroup');
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('RequestedUser')
+			->willReturn($targetUser);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()->getMock();
+		$subAdminManager
+			->expects($this->once())
+			->method('getSubAdminsGroups')
+			->with($targetUser)
+			->willReturn([$targetGroup]);
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+
+		$this->assertEquals(['TargetGroup'], $this->api->getUserSubAdminGroups('RequestedUser')->getData());
+	}
+
+	public function testEnableUser(): void {
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$targetUser->expects($this->once())
+			->method('setEnabled')
+			->with(true);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('RequestedUser')
+			->willReturn($targetUser);
+		$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$loggedInUser
+			->expects($this->exactly(3))
+			->method('getUID')
+			->willReturn('admin');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->willReturn(true);
+
+		$this->assertEquals([], $this->api->enableUser('RequestedUser')->getData());
+	}
+
+	public function testDisableUser(): void {
+		$targetUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$targetUser->expects($this->once())
+			->method('setEnabled')
+			->with(false);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('RequestedUser')
+			->willReturn($targetUser);
+		$loggedInUser = $this->getMockBuilder(IUser::class)->disableOriginalConstructor()->getMock();
+		$loggedInUser
+			->expects($this->exactly(3))
+			->method('getUID')
+			->willReturn('admin');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->willReturn(true);
+
+		$this->assertEquals([], $this->api->disableUser('RequestedUser')->getData());
+	}
+
+	public function testGetCurrentUserLoggedIn(): void {
+		$user = $this->createMock(IUser::class);
+		$user->expects($this->once())->method('getUID')->willReturn('UID');
+
+		$this->userSession->expects($this->once())->method('getUser')
+			->willReturn($user);
+
+		/** @var UsersController | MockObject $api */
+		$api = $this->getMockBuilder(UsersController::class)
+			->setConstructorArgs([
+				'provisioning_api',
+				$this->request,
+				$this->userManager,
+				$this->config,
+				$this->groupManager,
+				$this->userSession,
+				$this->accountManager,
+				$this->subAdminManager,
+				$this->l10nFactory,
+				$this->rootFolder,
+				$this->urlGenerator,
+				$this->logger,
+				$this->newUserMailHelper,
+				$this->secureRandom,
+				$this->remoteWipe,
+				$this->knownUserService,
+				$this->eventDispatcher,
+				$this->phoneNumberUtil,
+				$this->appManager,
+			])
+			->onlyMethods(['getUserData'])
+			->getMock();
+
+		$api->expects($this->once())->method('getUserData')->with('UID', true)
+			->willReturn(
+				[
+					'id' => 'UID',
+					'enabled' => 'true',
+					'quota' => ['DummyValue'],
+					'email' => 'demo@nextcloud.com',
+					'displayname' => 'Demo User',
+					'display-name' => 'Demo User',
+					'phone' => 'phone',
+					'address' => 'address',
+					'website' => 'website',
+					'twitter' => 'twitter',
+					'bluesky' => 'bluesky',
+					'fediverse' => 'fediverse',
+					'organisation' => 'organisation',
+					'role' => 'role',
+					'headline' => 'headline',
+					'biography' => 'biography',
+					'profile_enabled' => '1',
+					'pronouns' => 'they/them',
+				]
+			);
+
+		$expected = [
+			'id' => 'UID',
+			'enabled' => 'true',
+			'quota' => ['DummyValue'],
+			'email' => 'demo@nextcloud.com',
+			'displayname' => 'Demo User',
+			'display-name' => 'Demo User',
+			'phone' => 'phone',
+			'address' => 'address',
+			'website' => 'website',
+			'twitter' => 'twitter',
+			'bluesky' => 'bluesky',
+			'fediverse' => 'fediverse',
+			'organisation' => 'organisation',
+			'role' => 'role',
+			'headline' => 'headline',
+			'biography' => 'biography',
+			'profile_enabled' => '1',
+			'pronouns' => 'they/them',
+		];
+
+		$this->assertSame($expected, $api->getCurrentUser()->getData());
+	}
+
+
+	public function testGetCurrentUserNotLoggedIn(): void {
+		$this->expectException(OCSException::class);
+
+
+		$this->userSession->expects($this->once())->method('getUser')
+			->willReturn(null);
+
+		$this->api->getCurrentUser();
+	}
+
+	public function testGetUser(): void {
+		$loggedInUser = $this->createMock(IUser::class);
+		$loggedInUser
+			->method('getUID')
+			->willReturn('currentuser');
+		$this->userSession
+			->method('getUser')
+			->willReturn($loggedInUser);
+
+		/** @var UsersController | MockObject $api */
+		$api = $this->getMockBuilder(UsersController::class)
+			->setConstructorArgs([
+				'provisioning_api',
+				$this->request,
+				$this->userManager,
+				$this->config,
+				$this->groupManager,
+				$this->userSession,
+				$this->accountManager,
+				$this->subAdminManager,
+				$this->l10nFactory,
+				$this->rootFolder,
+				$this->urlGenerator,
+				$this->logger,
+				$this->newUserMailHelper,
+				$this->secureRandom,
+				$this->remoteWipe,
+				$this->knownUserService,
+				$this->eventDispatcher,
+				$this->phoneNumberUtil,
+				$this->appManager,
+			])
+			->onlyMethods(['getUserData'])
+			->getMock();
+
+		$expected = [
+			'id' => 'UID',
+			'enabled' => 'true',
+			'quota' => ['DummyValue'],
+			'email' => 'demo@nextcloud.com',
+			'phone' => 'phone',
+			'address' => 'address',
+			'website' => 'website',
+			'twitter' => 'twitter',
+			'bluesky' => 'bluesky',
+			'fediverse' => 'fediverse',
+			'displayname' => 'Demo User',
+			'display-name' => 'Demo User',
+			'organisation' => 'organisation',
+			'role' => 'role',
+			'headline' => 'headline',
+			'biography' => 'biography',
+			'profile_enabled' => '1',
+			'pronouns' => 'they/them',
+		];
+
+		$api->expects($this->exactly(2))
+			->method('getUserData')
+			->willReturnMap([
+				['uid', false, $expected],
+				['currentuser', true, $expected],
+			]);
+
+		$this->assertSame($expected, $api->getUser('uid')->getData());
+
+		$this->assertSame($expected, $api->getUser('currentuser')->getData());
+	}
+
+
+	public function testResendWelcomeMessageWithNotExistingTargetUser(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(998);
+
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('NotExistingUser')
+			->willReturn(null);
+
+		$this->api->resendWelcomeMessage('NotExistingUser');
+	}
+
+
+	public function testResendWelcomeMessageAsSubAdminAndUserIsNotAccessible(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionCode(998);
+
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->exactly(2))
+			->method('getUID')
+			->willReturn('subadmin');
+		$targetUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToGet')
+			->willReturn($targetUser);
+		$this->groupManager
+			->expects($this->once())
+			->method('isAdmin')
+			->with('subadmin')
+			->willReturn(false);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()
+			->getMock();
+		$subAdminManager
+			->expects($this->once())
+			->method('isUserAccessible')
+			->with($loggedInUser, $targetUser)
+			->willReturn(false);
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+
+		$this->api->resendWelcomeMessage('UserToGet');
+	}
+
+
+	public function testResendWelcomeMessageNoEmail(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionMessage('Email address not available');
+		$this->expectExceptionCode(101);
+
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$targetUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToGet')
+			->willReturn($targetUser);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()
+			->getMock();
+		$subAdminManager
+			->expects($this->once())
+			->method('isUserAccessible')
+			->with($loggedInUser, $targetUser)
+			->willReturn(true);
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+		$loggedInUser
+			->expects($this->exactly(2))
+			->method('getUID')
+			->willReturn('logged-user-id');
+		$targetUser
+			->expects($this->once())
+			->method('getEmailAddress')
+			->willReturn('');
+
+		$this->api->resendWelcomeMessage('UserToGet');
+	}
+
+
+	public function testResendWelcomeMessageNullEmail(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionMessage('Email address not available');
+		$this->expectExceptionCode(101);
+
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$targetUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToGet')
+			->willReturn($targetUser);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()
+			->getMock();
+		$subAdminManager
+			->expects($this->once())
+			->method('isUserAccessible')
+			->with($loggedInUser, $targetUser)
+			->willReturn(true);
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+		$loggedInUser
+			->expects($this->exactly(2))
+			->method('getUID')
+			->willReturn('logged-user-id');
+		$targetUser
+			->expects($this->once())
+			->method('getEmailAddress')
+			->willReturn(null);
+
+		$this->api->resendWelcomeMessage('UserToGet');
+	}
+
+	public function testResendWelcomeMessageSuccess(): void {
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$targetUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->method('getUID')
+			->willReturn('logged-user-id');
+		$targetUser
+			->method('getUID')
+			->willReturn('user-id');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToGet')
+			->willReturn($targetUser);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()
+			->getMock();
+		$subAdminManager
+			->expects($this->once())
+			->method('isUserAccessible')
+			->with($loggedInUser, $targetUser)
+			->willReturn(true);
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+		$targetUser
+			->expects($this->once())
+			->method('getEmailAddress')
+			->willReturn('abc@example.org');
+		$emailTemplate = $this->createMock(IEMailTemplate::class);
+		$this->newUserMailHelper
+			->expects($this->once())
+			->method('generateTemplate')
+			->willReturn($emailTemplate);
+		$this->newUserMailHelper
+			->expects($this->once())
+			->method('sendMail')
+			->with($targetUser, $emailTemplate);
+
+		$this->api->resendWelcomeMessage('UserToGet');
+	}
+
+	public function testResendWelcomeMessageSuccessWithFallbackLanguage(): void {
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$targetUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->method('getUID')
+			->willReturn('logged-user-id');
+		$targetUser
+			->method('getUID')
+			->willReturn('user-id');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToGet')
+			->willReturn($targetUser);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()
+			->getMock();
+		$subAdminManager
+			->expects($this->once())
+			->method('isUserAccessible')
+			->with($loggedInUser, $targetUser)
+			->willReturn(true);
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+		$targetUser
+			->expects($this->once())
+			->method('getEmailAddress')
+			->willReturn('abc@example.org');
+		$emailTemplate = $this->createMock(IEMailTemplate::class);
+		$this->newUserMailHelper
+			->expects($this->once())
+			->method('generateTemplate')
+			->willReturn($emailTemplate);
+		$this->newUserMailHelper
+			->expects($this->once())
+			->method('sendMail')
+			->with($targetUser, $emailTemplate);
+
+		$this->api->resendWelcomeMessage('UserToGet');
+	}
+
+
+	public function testResendWelcomeMessageFailed(): void {
+		$this->expectException(OCSException::class);
+		$this->expectExceptionMessage('Sending email failed');
+		$this->expectExceptionCode(102);
+
+		$loggedInUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$targetUser = $this->getMockBuilder(IUser::class)
+			->disableOriginalConstructor()
+			->getMock();
+		$loggedInUser
+			->expects($this->exactly(2))
+			->method('getUID')
+			->willReturn('logged-user-id');
+		$targetUser
+			->method('getUID')
+			->willReturn('user-id');
+		$this->userSession
+			->expects($this->once())
+			->method('getUser')
+			->willReturn($loggedInUser);
+		$this->userManager
+			->expects($this->once())
+			->method('get')
+			->with('UserToGet')
+			->willReturn($targetUser);
+		$subAdminManager = $this->getMockBuilder('OC\SubAdmin')
+			->disableOriginalConstructor()
+			->getMock();
+		$subAdminManager
+			->expects($this->once())
+			->method('isUserAccessible')
+			->with($loggedInUser, $targetUser)
+			->willReturn(true);
+		$this->groupManager
+			->expects($this->once())
+			->method('getSubAdmin')
+			->willReturn($subAdminManager);
+		$targetUser
+			->expects($this->once())
+			->method('getEmailAddress')
+			->willReturn('abc@example.org');
+		$emailTemplate = $this->createMock(IEMailTemplate::class);
+		$this->newUserMailHelper
+			->expects($this->once())
+			->method('generateTemplate')
+			->willReturn($emailTemplate);
+		$this->newUserMailHelper
+			->expects($this->once())
+			->method('sendMail')
+			->with($targetUser, $emailTemplate)
+			->willThrowException(new \Exception());
+
+		$this->api->resendWelcomeMessage('UserToGet');
+	}
+
+
+	public static function dataGetEditableFields(): array {
+		return [
+			[false, true, ISetDisplayNameBackend::class, [
+				IAccountManager::PROPERTY_EMAIL,
+				IAccountManager::COLLECTION_EMAIL,
+				IAccountManager::PROPERTY_PHONE,
+				IAccountManager::PROPERTY_ADDRESS,
+				IAccountManager::PROPERTY_WEBSITE,
+				IAccountManager::PROPERTY_TWITTER,
+				IAccountManager::PROPERTY_BLUESKY,
+				IAccountManager::PROPERTY_FEDIVERSE,
+				IAccountManager::PROPERTY_ORGANISATION,
+				IAccountManager::PROPERTY_ROLE,
+				IAccountManager::PROPERTY_HEADLINE,
+				IAccountManager::PROPERTY_BIOGRAPHY,
+				IAccountManager::PROPERTY_PROFILE_ENABLED,
+				IAccountManager::PROPERTY_PRONOUNS,
+			]],
+			[true, false, ISetDisplayNameBackend::class, [
+				IAccountManager::PROPERTY_DISPLAYNAME,
+				IAccountManager::COLLECTION_EMAIL,
+				IAccountManager::PROPERTY_PHONE,
+				IAccountManager::PROPERTY_ADDRESS,
+				IAccountManager::PROPERTY_WEBSITE,
+				IAccountManager::PROPERTY_TWITTER,
+				IAccountManager::PROPERTY_BLUESKY,
+				IAccountManager::PROPERTY_FEDIVERSE,
+				IAccountManager::PROPERTY_ORGANISATION,
+				IAccountManager::PROPERTY_ROLE,
+				IAccountManager::PROPERTY_HEADLINE,
+				IAccountManager::PROPERTY_BIOGRAPHY,
+				IAccountManager::PROPERTY_PROFILE_ENABLED,
+				IAccountManager::PROPERTY_PRONOUNS,
+			]],
+			[true, true, ISetDisplayNameBackend::class, [
+				IAccountManager::PROPERTY_DISPLAYNAME,
+				IAccountManager::PROPERTY_EMAIL,
+				IAccountManager::COLLECTION_EMAIL,
+				IAccountManager::PROPERTY_PHONE,
+				IAccountManager::PROPERTY_ADDRESS,
+				IAccountManager::PROPERTY_WEBSITE,
+				IAccountManager::PROPERTY_TWITTER,
+				IAccountManager::PROPERTY_BLUESKY,
+				IAccountManager::PROPERTY_FEDIVERSE,
+				IAccountManager::PROPERTY_ORGANISATION,
+				IAccountManager::PROPERTY_ROLE,
+				IAccountManager::PROPERTY_HEADLINE,
+				IAccountManager::PROPERTY_BIOGRAPHY,
+				IAccountManager::PROPERTY_PROFILE_ENABLED,
+				IAccountManager::PROPERTY_PRONOUNS,
+			]],
+			[false, false, ISetDisplayNameBackend::class, [
+				IAccountManager::COLLECTION_EMAIL,
+				IAccountManager::PROPERTY_PHONE,
+				IAccountManager::PROPERTY_ADDRESS,
+				IAccountManager::PROPERTY_WEBSITE,
+				IAccountManager::PROPERTY_TWITTER,
+				IAccountManager::PROPERTY_BLUESKY,
+				IAccountManager::PROPERTY_FEDIVERSE,
+				IAccountManager::PROPERTY_ORGANISATION,
+				IAccountManager::PROPERTY_ROLE,
+				IAccountManager::PROPERTY_HEADLINE,
+				IAccountManager::PROPERTY_BIOGRAPHY,
+				IAccountManager::PROPERTY_PROFILE_ENABLED,
+				IAccountManager::PROPERTY_PRONOUNS,
+			]],
+			[false, true, UserInterface::class, [
+				IAccountManager::PROPERTY_EMAIL,
+				IAccountManager::COLLECTION_EMAIL,
+				IAccountManager::PROPERTY_PHONE,
+				IAccountManager::PROPERTY_ADDRESS,
+				IAccountManager::PROPERTY_WEBSITE,
+				IAccountManager::PROPERTY_TWITTER,
+				IAccountManager::PROPERTY_BLUESKY,
+				IAccountManager::PROPERTY_FEDIVERSE,
+				IAccountManager::PROPERTY_ORGANISATION,
+				IAccountManager::PROPERTY_ROLE,
+				IAccountManager::PROPERTY_HEADLINE,
+				IAccountManager::PROPERTY_BIOGRAPHY,
+				IAccountManager::PROPERTY_PROFILE_ENABLED,
+				IAccountManager::PROPERTY_PRONOUNS,
+			]],
+			[true, false, UserInterface::class, [
+				IAccountManager::COLLECTION_EMAIL,
+				IAccountManager::PROPERTY_PHONE,
+				IAccountManager::PROPERTY_ADDRESS,
+				IAccountManager::PROPERTY_WEBSITE,
+				IAccountManager::PROPERTY_TWITTER,
+				IAccountManager::PROPERTY_BLUESKY,
+				IAccountManager::PROPERTY_FEDIVERSE,
+				IAccountManager::PROPERTY_ORGANISATION,
+				IAccountManager::PROPERTY_ROLE,
+				IAccountManager::PROPERTY_HEADLINE,
+				IAccountManager::PROPERTY_BIOGRAPHY,
+				IAccountManager::PROPERTY_PROFILE_ENABLED,
+				IAccountManager::PROPERTY_PRONOUNS,
+			]],
+			[true, true, UserInterface::class, [
+				IAccountManager::PROPERTY_EMAIL,
+				IAccountManager::COLLECTION_EMAIL,
+				IAccountManager::PROPERTY_PHONE,
+				IAccountManager::PROPERTY_ADDRESS,
+				IAccountManager::PROPERTY_WEBSITE,
+				IAccountManager::PROPERTY_TWITTER,
+				IAccountManager::PROPERTY_BLUESKY,
+				IAccountManager::PROPERTY_FEDIVERSE,
+				IAccountManager::PROPERTY_ORGANISATION,
+				IAccountManager::PROPERTY_ROLE,
+				IAccountManager::PROPERTY_HEADLINE,
+				IAccountManager::PROPERTY_BIOGRAPHY,
+				IAccountManager::PROPERTY_PROFILE_ENABLED,
+				IAccountManager::PROPERTY_PRONOUNS,
+			]],
+			[false, false, UserInterface::class, [
+				IAccountManager::COLLECTION_EMAIL,
+				IAccountManager::PROPERTY_PHONE,
+				IAccountManager::PROPERTY_ADDRESS,
+				IAccountManager::PROPERTY_WEBSITE,
+				IAccountManager::PROPERTY_TWITTER,
+				IAccountManager::PROPERTY_BLUESKY,
+				IAccountManager::PROPERTY_FEDIVERSE,
+				IAccountManager::PROPERTY_ORGANISATION,
+				IAccountManager::PROPERTY_ROLE,
+				IAccountManager::PROPERTY_HEADLINE,
+				IAccountManager::PROPERTY_BIOGRAPHY,
+				IAccountManager::PROPERTY_PROFILE_ENABLED,
+				IAccountManager::PROPERTY_PRONOUNS,
+			]],
+		];
+	}
+
+	#[\PHPUnit\Framework\Attributes\DataProvider('dataGetEditableFields')]
+	public function testGetEditableFields(bool $allowedToChangeDisplayName, bool $allowedToChangeEmail, string $userBackend, array $expected): void {
+		$this->config->method('getSystemValue')->willReturnCallback(fn (string $key, mixed $default) => match ($key) {
+			'allow_user_to_change_display_name' => $allowedToChangeDisplayName,
+			'allow_user_to_change_email' => $allowedToChangeEmail,
+			default => throw new RuntimeException('Unexpected system config key: ' . $key),
+		});
+
+		$user = $this->createMock(IUser::class);
+		$this->userSession->method('getUser')
+			->willReturn($user);
+
+		$backend = $this->createMock($userBackend);
+
+		$user->method('getUID')
+			->willReturn('userId');
+		$user->method('getBackend')
+			->willReturn($backend);
+
+		$expectedResp = new DataResponse($expected);
+		$this->assertEquals($expectedResp, $this->api->getEditableFields('userId'));
+	}
+
+	private function mockAccount($targetUser, $accountProperties) {
+		$mockedProperties = [];
+
+		foreach ($accountProperties as $propertyName => $data) {
+			$mockedProperty = $this->createMock(IAccountProperty::class);
+			$mockedProperty->method('getValue')->willReturn($data['value'] ?? '');
+			$mockedProperty->method('getScope')->willReturn($data['scope'] ?? '');
+			$mockedProperties[] = [$propertyName, $mockedProperty];
+		}
+
+		$account = $this->createMock(IAccount::class);
+		$account->method('getProperty')
+			->willReturnMap($mockedProperties);
+
+		$this->accountManager->expects($this->any())->method('getAccount')
+			->with($targetUser)
+			->willReturn($account);
+	}
+}
diff --git a/apps/provisioning_api/tests/Middleware/ProvisioningApiMiddlewareTest.php b/apps/provisioning_api/tests/Middleware/ProvisioningApiMiddlewareTest.php
new file mode 100644
index 00000000000..c027e518a3d
--- /dev/null
+++ b/apps/provisioning_api/tests/Middleware/ProvisioningApiMiddlewareTest.php
@@ -0,0 +1,108 @@
+<?php
+
+/**
+ * SPDX-FileCopyrightText: 2016 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+namespace OCA\Provisioning_API\Tests\Middleware;
+
+use OCA\Provisioning_API\Middleware\Exceptions\NotSubAdminException;
+use OCA\Provisioning_API\Middleware\ProvisioningApiMiddleware;
+use OCP\AppFramework\Controller;
+use OCP\AppFramework\Http;
+use OCP\AppFramework\OCS\OCSException;
+use OCP\AppFramework\Utility\IControllerMethodReflector;
+use Test\TestCase;
+
+class ProvisioningApiMiddlewareTest extends TestCase {
+
+	/** @var IControllerMethodReflector|\PHPUnit\Framework\MockObject\MockObject */
+	private $reflector;
+
+	protected function setUp(): void {
+		parent::setUp();
+
+		$this->reflector = $this->createMock(IControllerMethodReflector::class);
+	}
+
+	public static function dataAnnotation(): array {
+		return [
+			[false, false, false, false, false],
+			[false, false, true, false, false],
+			[false, true, true, false, false],
+			[true, false, false, false, true],
+			[true, false, true, false, false],
+			[true, true, false, false, false],
+			[true, true, true, false, false],
+			[false, false, false, true, false],
+			[false, false, true, true, false],
+			[false, true, true, true, false],
+			[true, false, false, true, false],
+			[true, false, true, true, false],
+			[true, true, false, true, false],
+			[true, true, true, true, false],
+		];
+	}
+
+	#[\PHPUnit\Framework\Attributes\DataProvider('dataAnnotation')]
+	public function testBeforeController(bool $subadminRequired, bool $isAdmin, bool $isSubAdmin, bool $hasSettingAuthorizationAnnotation, bool $shouldThrowException): void {
+		$middleware = new ProvisioningApiMiddleware(
+			$this->reflector,
+			$isAdmin,
+			$isSubAdmin
+		);
+
+		$this->reflector->method('hasAnnotation')
+			->willReturnCallback(function ($annotation) use ($subadminRequired, $hasSettingAuthorizationAnnotation) {
+				if ($annotation === 'NoSubAdminRequired') {
+					return !$subadminRequired;
+				}
+				if ($annotation === 'AuthorizedAdminSetting') {
+					return $hasSettingAuthorizationAnnotation;
+				}
+				return false;
+			});
+
+		try {
+			$middleware->beforeController(
+				$this->createMock(Controller::class),
+				'myMethod'
+			);
+			$this->assertFalse($shouldThrowException);
+		} catch (NotSubAdminException $e) {
+			$this->assertTrue($shouldThrowException);
+		}
+	}
+
+	public static function dataAfterException(): array {
+		return [
+			[new NotSubAdminException(), false],
+			[new \Exception('test', 42), true],
+		];
+	}
+
+	#[\PHPUnit\Framework\Attributes\DataProvider('dataAfterException')]
+	public function testAfterException(\Exception $exception, bool $forwared): void {
+		$middleware = new ProvisioningApiMiddleware(
+			$this->reflector,
+			false,
+			false
+		);
+
+		try {
+			$middleware->afterException(
+				$this->createMock(Controller::class),
+				'myMethod',
+				$exception
+			);
+			$this->fail();
+		} catch (OCSException $e) {
+			$this->assertFalse($forwared);
+			$this->assertSame($exception->getMessage(), $e->getMessage());
+			$this->assertSame(Http::STATUS_FORBIDDEN, $e->getCode());
+		} catch (\Exception $e) {
+			$this->assertTrue($forwared);
+			$this->assertSame($exception, $e);
+		}
+	}
+}
diff --git a/apps/provisioning_api/tests/TestCase.php b/apps/provisioning_api/tests/TestCase.php
new file mode 100644
index 00000000000..30e7f3a4ecf
--- /dev/null
+++ b/apps/provisioning_api/tests/TestCase.php
@@ -0,0 +1,57 @@
+<?php
+
+/**
+ * SPDX-FileCopyrightText: 2019-2024 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-FileCopyrightText: 2016 ownCloud, Inc.
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+namespace OCA\Provisioning_API\Tests;
+
+use OCP\IGroupManager;
+use OCP\IUser;
+use OCP\IUserManager;
+use OCP\Server;
+
+abstract class TestCase extends \Test\TestCase {
+
+	/** @var IUser[] */
+	protected $users = [];
+
+	/** @var IUserManager */
+	protected $userManager;
+
+	/** @var IGroupManager */
+	protected $groupManager;
+
+	protected function setUp(): void {
+		parent::setUp();
+
+		$this->userManager = Server::get(IUserManager::class);
+		$this->groupManager = Server::get(IGroupManager::class);
+		$this->groupManager->createGroup('admin');
+	}
+
+	/**
+	 * Generates a temp user
+	 * @param int $num number of users to generate
+	 * @return IUser[]|IUser
+	 */
+	protected function generateUsers($num = 1) {
+		$users = [];
+		for ($i = 0; $i < $num; $i++) {
+			$user = $this->userManager->createUser($this->getUniqueID(), 'password');
+			$this->users[] = $user;
+			$users[] = $user;
+		}
+		return count($users) == 1 ? reset($users) : $users;
+	}
+
+	protected function tearDown(): void {
+		foreach ($this->users as $user) {
+			$user->delete();
+		}
+
+		$this->groupManager->get('admin')->delete();
+		parent::tearDown();
+	}
+}
diff --git a/apps/provisioning_api/tests/appstest.php b/apps/provisioning_api/tests/appstest.php
deleted file mode 100644
index 260bb4d527e..00000000000
--- a/apps/provisioning_api/tests/appstest.php
+++ /dev/null
@@ -1,122 +0,0 @@
-<?php
-/**
- * @author Joas Schilling <nickvergessen@owncloud.com>
- * @author Lukas Reschke <lukas@owncloud.com>
- * @author Morris Jobke <hey@morrisjobke.de>
- * @author Roeland Jago Douma <rullzer@owncloud.com>
- * @author Thomas Müller <thomas.mueller@tmit.eu>
- * @author Tom Needham <tom@owncloud.com>
- *
- * @copyright Copyright (c) 2016, ownCloud, Inc.
- * @license AGPL-3.0
- *
- * This code is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License, version 3,
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License, version 3,
- * along with this program.  If not, see <http://www.gnu.org/licenses/>
- *
- */
-
-namespace OCA\Provisioning_API\Tests;
-use OC\OCSClient;
-use OCA\Provisioning_API\Apps;
-use OCP\API;
-use OCP\App\IAppManager;
-use OCP\IUserSession;
-
-/**
- * Class AppsTest
- *
- * @group DB
- *
- * @package OCA\Provisioning_API\Tests
- */
-class AppsTest extends TestCase {
-	/** @var IAppManager */
-	private $appManager;
-	/** @var Apps */
-	private $api;
-	/** @var IUserSession */
-	private $userSession;
-	/** @var OCSClient */
-	private $ocsClient;
-
-	public function setup() {
-		parent::setup();
-		$this->appManager = \OC::$server->getAppManager();
-		$this->groupManager = \OC::$server->getGroupManager();
-		$this->userSession = \OC::$server->getUserSession();
-		$this->ocsClient = $this->getMockBuilder('\OC\OCSClient')
-				->disableOriginalConstructor()->getMock();
-		$this->api = new Apps($this->appManager, $this->ocsClient);
-	}
-
-	public function testGetAppInfo() {
-		$result = $this->api->getAppInfo(['appid' => 'provisioning_api']);
-		$this->assertInstanceOf('OC_OCS_Result', $result);
-		$this->assertTrue($result->succeeded());
-	}
-
-	public function testGetAppInfoOnBadAppID() {
-		$result = $this->api->getAppInfo(['appid' => 'not_provisioning_api']);
-		$this->assertInstanceOf('OC_OCS_Result', $result);
-		$this->assertFalse($result->succeeded());
-		$this->assertEquals(API::RESPOND_NOT_FOUND, $result->getStatusCode());
-	}
-
-	public function testGetApps() {
-		$this->ocsClient
-				->expects($this->any())
-				->method($this->anything())
-				->will($this->returnValue(null));
-		$user = $this->generateUsers();
-		$this->groupManager->get('admin')->addUser($user);
-		$this->userSession->setUser($user);
-
-		$result = $this->api->getApps([]);
-
-		$this->assertTrue($result->succeeded());
-		$data = $result->getData();
-		$this->assertEquals(count(\OC_App::listAllApps(false, true, $this->ocsClient)), count($data['apps']));
-	}
-
-	public function testGetAppsEnabled() {
-		$_GET['filter'] = 'enabled';
-		$result = $this->api->getApps(['filter' => 'enabled']);
-		$this->assertTrue($result->succeeded());
-		$data = $result->getData();
-		$this->assertEquals(count(\OC_App::getEnabledApps()), count($data['apps']));
-	}
-
-	public function testGetAppsDisabled() {
-		$this->ocsClient
-				->expects($this->any())
-				->method($this->anything())
-				->will($this->returnValue(null));
-		$_GET['filter'] = 'disabled';
-		$result = $this->api->getApps(['filter' => 'disabled']);
-		$this->assertTrue($result->succeeded());
-		$data = $result->getData();
-		$apps = \OC_App::listAllApps(false, true, $this->ocsClient);
-		$list =  array();
-		foreach($apps as $app) {
-			$list[] = $app['id'];
-		}
-		$disabled = array_diff($list, \OC_App::getEnabledApps());
-		$this->assertEquals(count($disabled), count($data['apps']));
-	}
-
-	public function testGetAppsInvalidFilter() {
-		$_GET['filter'] = 'foo';
-		$result = $this->api->getApps([]);
-		$this->assertFalse($result->succeeded());
-		$this->assertEquals(101, $result->getStatusCode());
-	}
-}
diff --git a/apps/provisioning_api/tests/groupstest.php b/apps/provisioning_api/tests/groupstest.php
deleted file mode 100644
index 1262f45cb3c..00000000000
--- a/apps/provisioning_api/tests/groupstest.php
+++ /dev/null
@@ -1,442 +0,0 @@
-<?php
-/**
- * @author Joas Schilling <nickvergessen@owncloud.com>
- * @author Lukas Reschke <lukas@owncloud.com>
- * @author Morris Jobke <hey@morrisjobke.de>
- * @author Roeland Jago Douma <rullzer@owncloud.com>
- * @author Tom Needham <tom@owncloud.com>
- *
- * @copyright Copyright (c) 2016, ownCloud, Inc.
- * @license AGPL-3.0
- *
- * This code is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License, version 3,
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License, version 3,
- * along with this program.  If not, see <http://www.gnu.org/licenses/>
- *
- */
-
-namespace OCA\Provisioning_API\Tests;
-
-use OCP\IGroupManager;
-use OCP\IUserSession;
-use OCP\IRequest;
-
-class GroupsTest extends \Test\TestCase {
-	/** @var IGroupManager|\PHPUnit_Framework_MockObject_MockObject */
-	protected $groupManager;
-	/** @var IUserSession|\PHPUnit_Framework_MockObject_MockObject */
-	protected $userSession;
-	/** @var IRequest|\PHPUnit_Framework_MockObject_MockObject */
-	protected $request;
-	/** @var \OC\SubAdmin|\PHPUnit_Framework_MockObject_MockObject */
-	protected $subAdminManager;
-	/** @var \OCA\Provisioning_API\Groups */
-	protected $api;
-
-	protected function setup() {
-		$this->subAdminManager = $this->getMockBuilder('OC\SubAdmin')->disableOriginalConstructor()->getMock();
-
-		$this->groupManager = $this->getMockBuilder('OC\Group\Manager')->disableOriginalConstructor()->getMock();
-		$this->groupManager
-			->method('getSubAdmin')
-			->willReturn($this->subAdminManager);
-
-		$this->userSession = $this->getMock('OCP\IUserSession');
-		$this->request = $this->getMock('OCP\IRequest');
-		$this->api = new \OCA\Provisioning_API\Groups(
-			$this->groupManager,
-			$this->userSession,
-			$this->request
-		);
-	}
-
-	/**
-	 * @param string $gid
-	 * @return \OCP\IGroup|\PHPUnit_Framework_MockObject_MockObject
-	 */
-	private function createGroup($gid) {
-		$group = $this->getMock('OCP\IGroup');
-		$group
-			->method('getGID')
-			->willReturn($gid);
-		return $group;
-	}
-
-	/**
-	 * @param string $uid
-	 * @return \OCP\IUser|\PHPUnit_Framework_MockObject_MockObject
-	 */
-	private function createUser($uid) {
-		$user = $this->getMock('OCP\IUser');
-		$user
-			->method('getUID')
-			->willReturn($uid);
-		return $user;
-	}
-
-	private function asUser() {
-		$user = $this->createUser('user');
-		$this->userSession
-			->method('getUser')
-			->willReturn($user);
-	}
-
-	private function asAdmin() {
-		$user = $this->createUser('admin');
-		$this->userSession
-			->method('getUser')
-			->willReturn($user);
-
-		$this->groupManager
-			->method('isAdmin')
-			->with('admin')
-			->willReturn(true);
-	}
-
-	private function asSubAdminOfGroup($group) {
-		$user = $this->createUser('subAdmin');
-		$this->userSession
-			->method('getUser')
-			->willReturn($user);
-
-		$this->subAdminManager
-			->method('isSubAdminOfGroup')
-			->will($this->returnCallback(function($_user, $_group) use ($user, $group) {
-				if ($_user === $user && $_group === $group) {
-					return true;
-				}
-				return false;
-			}));
-	}
-
-	public function dataGetGroups() {
-		return [
-			[null, null, null],
-			['foo', null, null],
-			[null, 1, null],
-			[null, null, 2],
-			['foo', 1, 2],
-		];
-	}
-
-	/**
-	 * @dataProvider dataGetGroups
-	 */
-	public function testGetGroups($search, $limit, $offset) {
-		$this->request
-			->expects($this->exactly(3))
-			->method('getParam')
-			->will($this->returnValueMap([
-				['search', '', $search],
-				['limit', null, $limit],
-				['offset', null, $offset],
-			]));
-
-		$groups = [$this->createGroup('group1'), $this->createGroup('group2')];
-
-		$search = $search === null ? '' : $search;
-
-		$this->groupManager
-			->expects($this->once())
-			->method('search')
-			->with($search, $limit, $offset)
-			->willReturn($groups);
-
-		$result = $this->api->getGroups([]);
-		$this->assertInstanceOf('OC_OCS_Result', $result);
-		$this->assertTrue($result->succeeded());
-		$this->assertEquals(['group1', 'group2'], $result->getData()['groups']);
-	}
-
-	public function testGetGroupAsUser() {
-		$result = $this->api->getGroup([]);
-
-		$this->assertInstanceOf('OC_OCS_Result', $result);
-		$this->assertFalse($result->succeeded());
-		$this->assertEquals(\OCP\API::RESPOND_UNAUTHORISED, $result->getStatusCode());
-
-	}
-
-	public function testGetGroupAsSubadmin() {
-		$group = $this->createGroup('group');
-		$this->asSubAdminOfGroup($group);
-
-		$this->groupManager
-			->method('get')
-			->with('group')
-			->willReturn($group);
-		$this->groupManager
-			->method('groupExists')
-			->with('group')
-			->willReturn(true);
-		$group
-			->method('getUsers')
-			->willReturn([
-				$this->createUser('user1'),
-				$this->createUser('user2')
-			]);
-
-		$result = $this->api->getGroup([
-			'groupid' => 'group',
-		]);
-
-		$this->assertInstanceOf('OC_OCS_Result', $result);
-		$this->assertTrue($result->succeeded());
-		$this->assertEquals(1, sizeof($result->getData()), 'Asserting the result data array only has the "users" key');
-		$this->assertArrayHasKey('users', $result->getData());
-		$this->assertEquals(['user1', 'user2'], $result->getData()['users']);
-	}
-
-	public function testGetGroupAsIrrelevantSubadmin() {
-		$group = $this->createGroup('group');
-		$otherGroup = $this->createGroup('otherGroup');
-		$this->asSubAdminOfGroup($otherGroup);
-
-		$this->groupManager
-			->method('get')
-			->with('group')
-			->willReturn($group);
-		$this->groupManager
-			->method('groupExists')
-			->with('group')
-			->willReturn(true);
-
-		$result = $this->api->getGroup([
-			'groupid' => 'group',
-		]);
-
-		$this->assertInstanceOf('OC_OCS_Result', $result);
-		$this->assertFalse($result->succeeded());
-		$this->assertEquals(\OCP\API::RESPOND_UNAUTHORISED, $result->getStatusCode());
-	}
-
-	public function testGetGroupAsAdmin() {
-		$group = $this->createGroup('group');
-		$this->asAdmin();
-
-		$this->groupManager
-			->method('get')
-			->with('group')
-			->willReturn($group);
-		$this->groupManager
-			->method('groupExists')
-			->with('group')
-			->willReturn(true);
-		$group
-			->method('getUsers')
-			->willReturn([
-				$this->createUser('user1'),
-				$this->createUser('user2')
-			]);
-
-		$result = $this->api->getGroup([
-			'groupid' => 'group',
-		]);
-
-		$this->assertInstanceOf('OC_OCS_Result', $result);
-		$this->assertTrue($result->succeeded());
-		$this->assertEquals(1, sizeof($result->getData()), 'Asserting the result data array only has the "users" key');
-		$this->assertArrayHasKey('users', $result->getData());
-		$this->assertEquals(['user1', 'user2'], $result->getData()['users']);
-	}
-
-	public function testGetGroupNonExisting() {
-		$this->asUser();
-
-		$result = $this->api->getGroup([
-			'groupid' => $this->getUniqueId()
-		]);
-
-		$this->assertInstanceOf('OC_OCS_Result', $result);
-		$this->assertFalse($result->succeeded());
-		$this->assertEquals(\OCP\API::RESPOND_NOT_FOUND, $result->getStatusCode());
-		$this->assertEquals('The requested group could not be found', $result->getMeta()['message']);
-	}
-
-	public function testGetSubAdminsOfGroupsNotExists() {
-		$result = $this->api->getSubAdminsOfGroup([
-			'groupid' => 'NonExistingGroup',
-		]);
-
-		$this->assertInstanceOf('OC_OCS_Result', $result);
-		$this->assertFalse($result->succeeded());
-		$this->assertEquals(101, $result->getStatusCode());
-		$this->assertEquals('Group does not exist', $result->getMeta()['message']);
-	}
-
-	public function testGetSubAdminsOfGroup() {
-		$group = $this->createGroup('GroupWithSubAdmins');
-		$this->groupManager
-			->method('get')
-			->with('GroupWithSubAdmins')
-			->willReturn($group);
-
-		$this->subAdminManager
-			->expects($this->once())
-			->method('getGroupsSubAdmins')
-			->with($group)
-			->willReturn([
-				$this->createUser('SubAdmin1'),
-				$this->createUser('SubAdmin2'),
-			]);
-
-		$result = $this->api->getSubAdminsOfGroup([
-			'groupid' => 'GroupWithSubAdmins',
-		]);
-
-		$this->assertInstanceOf('OC_OCS_Result', $result);
-		$this->assertTrue($result->succeeded());
-		$this->assertEquals(['SubAdmin1', 'SubAdmin2'], $result->getData());
-	}
-
-	public function testGetSubAdminsOfGroupEmptyList() {
-		$group = $this->createGroup('GroupWithOutSubAdmins');
-		$this->groupManager
-			->method('get')
-			->with('GroupWithOutSubAdmins')
-			->willReturn($group);
-
-		$this->subAdminManager
-			->expects($this->once())
-			->method('getGroupsSubAdmins')
-			->with($group)
-			->willReturn([
-			]);
-
-		$result = $this->api->getSubAdminsOfGroup([
-			'groupid' => 'GroupWithOutSubAdmins',
-		]);
-
-		$this->assertInstanceOf('OC_OCS_Result', $result);
-		$this->assertTrue($result->succeeded());
-		$this->assertEquals([], $result->getData());
-	}
-
-	public function testAddGroupEmptyGroup() {
-		$this->request
-			->method('getParam')
-			->with('groupid')
-			->willReturn('');
-
-		$result = $this->api->addGroup([]);
-
-		$this->assertInstanceOf('OC_OCS_Result', $result);
-		$this->assertFalse($result->succeeded());
-		$this->assertEquals(101, $result->getStatusCode());
-		$this->assertEquals('Invalid group name', $result->getMeta()['message']);
-	}
-
-	public function testAddGroupExistingGroup() {
-		$this->request
-			->method('getParam')
-			->with('groupid')
-			->willReturn('ExistingGroup');
-
-		$this->groupManager
-			->method('groupExists')
-			->with('ExistingGroup')
-			->willReturn(true);
-
-		$result = $this->api->addGroup([]);
-
-		$this->assertInstanceOf('OC_OCS_Result', $result);
-		$this->assertFalse($result->succeeded());
-		$this->assertEquals(102, $result->getStatusCode());
-	}
-
-	public function testAddGroup() {
-		$this->request
-			->method('getParam')
-			->with('groupid')
-			->willReturn('NewGroup');
-
-		$this->groupManager
-			->method('groupExists')
-			->with('NewGroup')
-			->willReturn(false);
-
-		$this->groupManager
-			->expects($this->once())
-			->method('createGroup')
-			->with('NewGroup');
-
-		$result = $this->api->addGroup([]);
-		$this->assertInstanceOf('OC_OCS_Result', $result);
-		$this->assertTrue($result->succeeded());
-	}
-
-	public function testAddGroupWithSpecialChar() {
-		$this->request
-			->method('getParam')
-			->with('groupid')
-			->willReturn('Iñtërnâtiônàlizætiøn');
-
-		$this->groupManager
-			->method('groupExists')
-			->with('Iñtërnâtiônàlizætiøn')
-			->willReturn(false);
-
-		$this->groupManager
-			->expects($this->once())
-			->method('createGroup')
-			->with('Iñtërnâtiônàlizætiøn');
-
-		$result = $this->api->addGroup([]);
-		$this->assertInstanceOf('OC_OCS_Result', $result);
-		$this->assertTrue($result->succeeded());
-	}
-
-	public function testDeleteGroupNonExisting() {
-		$result = $this->api->deleteGroup([
-			'groupid' => 'NonExistingGroup'
-		]);
-		$this->assertInstanceOf('OC_OCS_Result', $result);
-		$this->assertFalse($result->succeeded());
-		$this->assertEquals(101, $result->getStatusCode());
-	}
-
-	public function testDeleteAdminGroup() {
-		$this->groupManager
-			->method('groupExists')
-			->with('admin')
-			->willReturn('true');
-
-		$result = $this->api->deleteGroup([
-			'groupid' => 'admin'
-		]);
-		$this->assertInstanceOf('OC_OCS_Result', $result);
-		$this->assertFalse($result->succeeded());
-		$this->assertEquals(102, $result->getStatusCode());
-	}
-
-	public function testDeleteGroup() {
-		$this->groupManager
-			->method('groupExists')
-			->with('ExistingGroup')
-			->willReturn('true');
-
-		$group = $this->createGroup('ExistingGroup');
-		$this->groupManager
-			->method('get')
-			->with('ExistingGroup')
-			->willReturn($group);
-		$group
-			->expects($this->once())
-			->method('delete')
-			->willReturn(true);
-
-		$result = $this->api->deleteGroup([
-			'groupid' => 'ExistingGroup',
-		]);
-		$this->assertInstanceOf('OC_OCS_Result', $result);
-		$this->assertTrue($result->succeeded());
-	}
-}
diff --git a/apps/provisioning_api/tests/testcase.php b/apps/provisioning_api/tests/testcase.php
deleted file mode 100644
index 743c1c9c44b..00000000000
--- a/apps/provisioning_api/tests/testcase.php
+++ /dev/null
@@ -1,73 +0,0 @@
-<?php
-/**
- * @author Joas Schilling <nickvergessen@owncloud.com>
- * @author Morris Jobke <hey@morrisjobke.de>
- * @author Roeland Jago Douma <rullzer@owncloud.com>
- * @author Thomas Müller <thomas.mueller@tmit.eu>
- *
- * @copyright Copyright (c) 2016, ownCloud, Inc.
- * @license AGPL-3.0
- *
- * This code is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License, version 3,
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License, version 3,
- * along with this program.  If not, see <http://www.gnu.org/licenses/>
- *
- */
-
-namespace OCA\Provisioning_API\Tests;
-
-use OCP\IUser;
-use OCP\IUserManager;
-use OCP\IGroupManager;
-
-abstract class TestCase extends \Test\TestCase {
-
-	/** @var IUser[] */
-	protected $users = array();
-
-	/** @var IUserManager */
-	protected $userManager;
-
-	/** @var IGroupManager */
-	protected $groupManager;
-
-	protected function setUp() {
-		parent::setUp();
-
-		$this->userManager = \OC::$server->getUserManager();
-		$this->groupManager = \OC::$server->getGroupManager();
-		$this->groupManager->createGroup('admin');
-	}
-
-	/**
-	 * Generates a temp user
-	 * @param int $num number of users to generate
-	 * @return IUser[]|IUser
-	 */
-	protected function generateUsers($num = 1) {
-		$users = array();
-		for ($i = 0; $i < $num; $i++) {
-			$user = $this->userManager->createUser($this->getUniqueID(), 'password');
-			$this->users[] = $user;
-			$users[] = $user;
-		}
-		return count($users) == 1 ? reset($users) : $users;
-	}
-
-	protected function tearDown() {
-		foreach($this->users as $user) {
-			$user->delete();
-		}
-
-		$this->groupManager->get('admin')->delete();
-		parent::tearDown();
-	}
-}
diff --git a/apps/provisioning_api/tests/userstest.php b/apps/provisioning_api/tests/userstest.php
deleted file mode 100644
index 020071bcfa1..00000000000
--- a/apps/provisioning_api/tests/userstest.php
+++ /dev/null
@@ -1,2298 +0,0 @@
-<?php
-/**
- * @author Arthur Schiwon <blizzz@owncloud.com>
- * @author Joas Schilling <nickvergessen@owncloud.com>
- * @author Lukas Reschke <lukas@owncloud.com>
- * @author michag86 <micha_g@arcor.de>
- * @author Morris Jobke <hey@morrisjobke.de>
- * @author Roeland Jago Douma <rullzer@owncloud.com>
- * @author Thomas Müller <thomas.mueller@tmit.eu>
- * @author Tom Needham <tom@owncloud.com>
- *
- * @copyright Copyright (c) 2016, ownCloud, Inc.
- * @license AGPL-3.0
- *
- * This code is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License, version 3,
- * as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License, version 3,
- * along with this program.  If not, see <http://www.gnu.org/licenses/>
- *
- */
-
-namespace OCA\Provisioning_API\Tests;
-
-use OCA\Provisioning_API\Users;
-use OCP\API;
-use OCP\IUserManager;
-use OCP\IConfig;
-use OCP\IUserSession;
-use PHPUnit_Framework_MockObject_MockObject;
-use Test\TestCase as OriginalTest;
-use OCP\ILogger;
-
-class UsersTest extends OriginalTest {
-	
-	/** @var IUserManager | PHPUnit_Framework_MockObject_MockObject */
-	protected $userManager;
-	/** @var IConfig | PHPUnit_Framework_MockObject_MockObject */
-	protected $config;
-	/** @var \OC\Group\Manager | PHPUnit_Framework_MockObject_MockObject */
-	protected $groupManager;
-	/** @var IUserSession | PHPUnit_Framework_MockObject_MockObject */
-	protected $userSession;
-	/** @var ILogger | PHPUnit_Framework_MockObject_MockObject */
-	protected $logger;
-	/** @var Users | PHPUnit_Framework_MockObject_MockObject */
-	protected $api;
-
-	protected function tearDown() {
-		$_GET = null;
-		$_POST = null;
-		parent::tearDown();
-	}
-
-	protected function setup() {
-		parent::setup();
-
-		$this->userManager = $this->getMock('\OCP\IUserManager');
-		$this->config = $this->getMock('\OCP\IConfig');
-		$this->groupManager = $this->getMockBuilder('\OC\Group\Manager')
-		->disableOriginalConstructor()->getMock();
-		$this->userSession = $this->getMock('\OCP\IUserSession');
-		$this->logger = $this->getMock('\OCP\ILogger');
-		$this->api = $this->getMockBuilder('\OCA\Provisioning_API\Users')
-			->setConstructorArgs([
-					$this->userManager,
-					$this->config,
-					$this->groupManager,
-					$this->userSession,
-					$this->logger,
-				]
-			)
-			->setMethods(['fillStorageInfo'])
-			->getMock();
-	}
-
-	public function testGetUsersNotLoggedIn() {
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue(null));
-
-		$expected = new \OC_OCS_Result(null, API::RESPOND_UNAUTHORISED);
-		$this->assertEquals($expected, $this->api->getUsers());
-	}
-
-	public function testGetUsersAsAdmin() {
-		$_GET['search'] = 'MyCustomSearch';
-
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('admin'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->will($this->returnValue(true));
-		$this->userManager
-			->expects($this->once())
-			->method('search')
-			->with('MyCustomSearch', null, null)
-			->will($this->returnValue(['Admin' => [], 'Foo' => [], 'Bar' => []]));
-
-		$expected = new \OC_OCS_Result([
-			'users' => [
-				'Admin',
-				'Foo',
-				'Bar',
-			],
-		]);
-		$this->assertEquals($expected, $this->api->getUsers());
-	}
-
-	public function testGetUsersAsSubAdmin() {
-		$_GET['search'] = 'MyCustomSearch';
-
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('subadmin'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->will($this->returnValue(false));
-		$firstGroup = $this->getMock('\OCP\IGroup');
-		$firstGroup
-			->expects($this->once())
-			->method('getGID')
-			->will($this->returnValue('FirstGroup'));
-		$secondGroup = $this->getMock('\OCP\IGroup');
-		$secondGroup
-			->expects($this->once())
-			->method('getGID')
-			->will($this->returnValue('SecondGroup'));
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()->getMock();
-		$subAdminManager
-			->expects($this->once())
-			->method('isSubAdmin')
-			->with($loggedInUser)
-			->will($this->returnValue(true));
-		$subAdminManager
-			->expects($this->once())
-			->method('getSubAdminsGroups')
-			->with($loggedInUser)
-			->will($this->returnValue([$firstGroup, $secondGroup]));
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->will($this->returnValue($subAdminManager));
-		$this->groupManager
-			->expects($this->any())
-			->method('displayNamesInGroup')
-			->will($this->onConsecutiveCalls(['AnotherUserInTheFirstGroup' => []], ['UserInTheSecondGroup' => []]));
-
-		$expected = new \OC_OCS_Result([
-			'users' => [
-				'AnotherUserInTheFirstGroup',
-				'UserInTheSecondGroup',
-			],
-		]);
-		$this->assertEquals($expected, $this->api->getUsers());
-	}
-
-	public function testGetUsersAsRegularUser() {
-		$_GET['search'] = 'MyCustomSearch';
-
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('regularUser'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->will($this->returnValue(false));
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()->getMock();
-		$subAdminManager
-			->expects($this->once())
-			->method('isSubAdmin')
-			->with($loggedInUser)
-			->will($this->returnValue(false));
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->will($this->returnValue($subAdminManager));
-
-		$expected = new \OC_OCS_Result(null, API::RESPOND_UNAUTHORISED);
-		$this->assertEquals($expected, $this->api->getUsers());
-	}
-
-	public function testAddUserAlreadyExisting() {
-		$_POST['userid'] = 'AlreadyExistingUser';
-		$this->userManager
-			->expects($this->once())
-			->method('userExists')
-			->with('AlreadyExistingUser')
-			->will($this->returnValue(true));
-		$this->logger
-			->expects($this->once())
-			->method('error')
-			->with('Failed addUser attempt: User already exists.', ['app' => 'ocs_api']);
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('adminUser'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('adminUser')
-			->willReturn(true);
-
-		$expected = new \OC_OCS_Result(null, 102, 'User already exists');
-		$this->assertEquals($expected, $this->api->addUser());
-	}
-
-	public function testAddUserNonExistingGroup() {
-		$_POST['userid'] = 'NewUser';
-		$_POST['groups'] = ['NonExistingGroup'];
-		$this->userManager
-			->expects($this->once())
-			->method('userExists')
-			->with('NewUser')
-			->willReturn(false);
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('adminUser'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('adminUser')
-			->willReturn(true);
-		$this->groupManager
-			->expects($this->once())
-			->method('groupExists')
-			->with('NonExistingGroup')
-			->willReturn(false);
-
-		$expected = new \OC_OCS_Result(null, 104, 'group NonExistingGroup does not exist');
-		$this->assertEquals($expected, $this->api->addUser());
-	}
-
-	public function testAddUserExistingGroupNonExistingGroup() {
-		$_POST['userid'] = 'NewUser';
-		$_POST['groups'] = ['ExistingGroup', 'NonExistingGroup'];
-		$this->userManager
-			->expects($this->once())
-			->method('userExists')
-			->with('NewUser')
-			->willReturn(false);
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('adminUser'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('adminUser')
-			->willReturn(true);
-		$this->groupManager
-			->expects($this->exactly(2))
-			->method('groupExists')
-			->withConsecutive(
-				['ExistingGroup'],
-				['NonExistingGroup']
-			)
-			->will($this->returnValueMap([
-				['ExistingGroup', true],
-				['NonExistingGroup', false]
-			]));
-
-		$expected = new \OC_OCS_Result(null, 104, 'group NonExistingGroup does not exist');
-		$this->assertEquals($expected, $this->api->addUser());
-	}
-
-	public function testAddUserSuccessful() {
-		$_POST['userid'] = 'NewUser';
-		$_POST['password'] = 'PasswordOfTheNewUser';
-		$this->userManager
-			->expects($this->once())
-			->method('userExists')
-			->with('NewUser')
-			->will($this->returnValue(false));
-		$this->userManager
-			->expects($this->once())
-			->method('createUser')
-			->with('NewUser', 'PasswordOfTheNewUser');
-		$this->logger
-			->expects($this->once())
-			->method('info')
-			->with('Successful addUser call with userid: NewUser', ['app' => 'ocs_api']);
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('adminUser'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('adminUser')
-			->willReturn(true);
-
-		$expected = new \OC_OCS_Result(null, 100);
-		$this->assertEquals($expected, $this->api->addUser());
-	}
-
-	public function testAddUserExistingGroup() {
-		$_POST['userid'] = 'NewUser';
-		$_POST['password'] = 'PasswordOfTheNewUser';
-		$_POST['groups'] = ['ExistingGroup'];
-		$this->userManager
-			->expects($this->once())
-			->method('userExists')
-			->with('NewUser')
-			->willReturn(false);
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('adminUser'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('adminUser')
-			->willReturn(true);
-		$this->groupManager
-			->expects($this->once())
-			->method('groupExists')
-			->with('ExistingGroup')
-			->willReturn(true);
-		$user = $this->getMock('\OCP\IUser');
-		$this->userManager
-			->expects($this->once())
-			->method('createUser')
-			->with('NewUser', 'PasswordOfTheNewUser')
-			->willReturn($user);
-		$group = $this->getMock('\OCP\IGroup');
-		$group
-			->expects($this->once())
-			->method('addUser')
-			->with($user);
-		$this->groupManager
-			->expects($this->once())
-			->method('get')
-			->with('ExistingGroup')
-			->willReturn($group);
-		$this->logger
-			->expects($this->exactly(2))
-			->method('info')
-			->withConsecutive(
-				['Successful addUser call with userid: NewUser', ['app' => 'ocs_api']],
-				['Added userid NewUser to group ExistingGroup', ['app' => 'ocs_api']]
-			);
-
-		$expected = new \OC_OCS_Result(null, 100);
-		$this->assertEquals($expected, $this->api->addUser());
-	}
-
-	public function testAddUserUnsuccessful() {
-		$_POST['userid'] = 'NewUser';
-		$_POST['password'] = 'PasswordOfTheNewUser';
-		$this->userManager
-			->expects($this->once())
-			->method('userExists')
-			->with('NewUser')
-			->will($this->returnValue(false));
-		$this->userManager
-			->expects($this->once())
-			->method('createUser')
-			->with('NewUser', 'PasswordOfTheNewUser')
-			->will($this->throwException(new \Exception('User backend not found.')));
-		$this->logger
-			->expects($this->once())
-			->method('error')
-			->with('Failed addUser attempt with exception: User backend not found.', ['app' => 'ocs_api']);
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('adminUser'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('adminUser')
-			->willReturn(true);
-
-		$expected = new \OC_OCS_Result(null, 101, 'Bad request');
-		$this->assertEquals($expected, $this->api->addUser());
-	}
-
-	public function testAddUserAsRegularUser() {
-		$_POST['userid'] = 'NewUser';
-		$_POST['password'] = 'PasswordOfTheNewUser';
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('regularUser'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('regularUser')
-			->willReturn(false);
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()->getMock();
-		$subAdminManager
-			->expects($this->once())
-			->method('isSubAdmin')
-			->with($loggedInUser)
-			->willReturn(false);
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->with()
-			->willReturn($subAdminManager);
-
-		$expected = new \OC_OCS_Result(null, API::RESPOND_UNAUTHORISED);
-		$this->assertEquals($expected, $this->api->addUser());	
-	}
-
-	public function testAddUserAsSubAdminNoGroup() {
-		$_POST['userid'] = 'NewUser';
-		$_POST['password'] = 'PasswordOfTheNewUser';
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('regularUser'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('regularUser')
-			->willReturn(false);
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()->getMock();
-		$subAdminManager
-			->expects($this->once())
-			->method('isSubAdmin')
-			->with($loggedInUser)
-			->willReturn(true);
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->with()
-			->willReturn($subAdminManager);
-
-		$expected = new \OC_OCS_Result(null, 106, 'no group specified (required for subadmins)');
-		$this->assertEquals($expected, $this->api->addUser());	
-	}
-
-	public function testAddUserAsSubAdminValidGroupNotSubAdmin() {
-		$_POST['userid'] = 'NewUser';
-		$_POST['password'] = 'PasswordOfTheNewUser';
-		$_POST['groups'] = ['ExistingGroup'];
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('regularUser'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('regularUser')
-			->willReturn(false);
-		$existingGroup = $this->getMock('\OCP\IGroup');
-		$this->groupManager
-			->expects($this->once())
-			->method('get')
-			->with('ExistingGroup')
-			->willReturn($existingGroup);
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()->getMock();
-		$subAdminManager
-			->expects($this->once())
-			->method('isSubAdmin')
-			->with($loggedInUser)
-			->willReturn(true);
-		$subAdminManager
-			->expects($this->once())
-			->method('isSubAdminOfGroup')
-			->with($loggedInUser, $existingGroup)
-			->wilLReturn(false);
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->with()
-			->willReturn($subAdminManager);
-		$this->groupManager
-			->expects($this->once())
-			->method('groupExists')
-			->with('ExistingGroup')
-			->willReturn(true);
-
-		$expected = new \OC_OCS_Result(null, 105, 'insufficient privileges for group ExistingGroup');
-		$this->assertEquals($expected, $this->api->addUser());	
-	}
-
-	public function testAddUserAsSubAdminExistingGroups() {
-		$_POST['userid'] = 'NewUser';
-		$_POST['password'] = 'PasswordOfTheNewUser';
-		$_POST['groups'] = ['ExistingGroup1', 'ExistingGroup2'];
-		$this->userManager
-			->expects($this->once())
-			->method('userExists')
-			->with('NewUser')
-			->willReturn(false);
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('subAdminUser'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('subAdminUser')
-			->willReturn(false);
-		$this->groupManager
-			->expects($this->exactly(2))
-			->method('groupExists')
-			->withConsecutive(
-				['ExistingGroup1'],
-				['ExistingGroup2']
-			)
-			->willReturn(true);
-		$user = $this->getMock('\OCP\IUser');
-		$this->userManager
-			->expects($this->once())
-			->method('createUser')
-			->with('NewUser', 'PasswordOfTheNewUser')
-			->willReturn($user);
-		$existingGroup1 = $this->getMock('\OCP\IGroup');
-		$existingGroup2 = $this->getMock('\OCP\IGroup');
-		$existingGroup1
-			->expects($this->once())
-			->method('addUser')
-			->with($user);
-		$existingGroup2
-			->expects($this->once())
-			->method('addUser')
-			->with($user);
-		$this->groupManager
-			->expects($this->exactly(4))
-			->method('get')
-			->withConsecutive(
-				['ExistingGroup1'],
-				['ExistingGroup2'],
-				['ExistingGroup1'],
-				['ExistingGroup2']
-			)
-			->will($this->returnValueMap([
-				['ExistingGroup1', $existingGroup1],
-				['ExistingGroup2', $existingGroup2]
-			]));
-		$this->logger
-			->expects($this->exactly(3))
-			->method('info')
-			->withConsecutive(
-				['Successful addUser call with userid: NewUser', ['app' => 'ocs_api']],
-				['Added userid NewUser to group ExistingGroup1', ['app' => 'ocs_api']],
-				['Added userid NewUser to group ExistingGroup2', ['app' => 'ocs_api']]
-			);
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()->getMock();
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->willReturn($subAdminManager);
-		$subAdminManager
-			->expects($this->once())
-			->method('isSubAdmin')
-			->with($loggedInUser)
-			->willReturn(true);
-		$subAdminManager
-			->expects($this->exactly(2))
-			->method('isSubAdminOfGroup')
-			->withConsecutive(
-				[$loggedInUser, $existingGroup1],
-				[$loggedInUser, $existingGroup2]
-			)
-			->wilLReturn(true);
-
-
-		$expected = new \OC_OCS_Result(null, 100);
-		$this->assertEquals($expected, $this->api->addUser());
-	}
-
-
-	public function testGetUserNotLoggedIn() {
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue(null));
-
-		$expected = new \OC_OCS_Result(null, API::RESPOND_UNAUTHORISED);
-		$this->assertEquals($expected, $this->api->getUser(['userid' => 'UserToGet']));
-	}
-
-	public function testGetUserTargetDoesNotExist() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('UserToGet')
-			->will($this->returnValue(null));
-
-		$expected = new \OC_OCS_Result(null, API::RESPOND_NOT_FOUND, 'The requested user could not be found');
-		$this->assertEquals($expected, $this->api->getUser(['userid' => 'UserToGet']));
-	}
-
-	public function testGetUserAsAdmin() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('admin'));
-		$targetUser = $this->getMock('\OCP\IUser');
-		$targetUser->expects($this->once())
-			->method('getEMailAddress')
-			->willReturn('demo@owncloud.org');
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('UserToGet')
-			->will($this->returnValue($targetUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('admin')
-			->will($this->returnValue(true));
-		$this->config
-			->expects($this->at(0))
-			->method('getUserValue')
-			->with('UserToGet', 'core', 'enabled', 'true')
-			->will($this->returnValue('true'));
-		$this->api
-			->expects($this->once())
-			->method('fillStorageInfo')
-			->with('UserToGet')
-			->will($this->returnValue(['DummyValue']));
-		$targetUser
-			->expects($this->once())
-			->method('getDisplayName')
-			->will($this->returnValue('Demo User'));
-
-		$expected = new \OC_OCS_Result(
-			[
-				'enabled' => 'true',
-				'quota' => ['DummyValue'],
-				'email' => 'demo@owncloud.org',
-				'displayname' => 'Demo User',
-			]
-		);
-		$this->assertEquals($expected, $this->api->getUser(['userid' => 'UserToGet']));
-	}
-
-	public function testGetUserAsSubAdminAndUserIsAccessible() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('subadmin'));
-		$targetUser = $this->getMock('\OCP\IUser');
-		$targetUser
-				->expects($this->once())
-				->method('getEMailAddress')
-				->willReturn('demo@owncloud.org');
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('UserToGet')
-			->will($this->returnValue($targetUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('subadmin')
-			->will($this->returnValue(false));
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()
-			->getMock();
-		$subAdminManager
-			->expects($this->once())
-			->method('isUserAccessible')
-			->with($loggedInUser, $targetUser)
-			->will($this->returnValue(true));
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->will($this->returnValue($subAdminManager));
-		$this->config
-			->expects($this->at(0))
-			->method('getUserValue')
-			->with('UserToGet', 'core', 'enabled', 'true')
-			->will($this->returnValue('true'));
-		$this->api
-			->expects($this->once())
-			->method('fillStorageInfo')
-			->with('UserToGet')
-			->will($this->returnValue(['DummyValue']));
-		$targetUser
-			->expects($this->once())
-			->method('getDisplayName')
-			->will($this->returnValue('Demo User'));
-
-		$expected = new \OC_OCS_Result(
-			[
-				'enabled' => 'true',
-				'quota' => ['DummyValue'],
-				'email' => 'demo@owncloud.org',
-				'displayname' => 'Demo User',
-			]
-		);
-		$this->assertEquals($expected, $this->api->getUser(['userid' => 'UserToGet']));
-	}
-
-	public function testGetUserAsSubAdminAndUserIsNotAccessible() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->exactly(2))
-			->method('getUID')
-			->will($this->returnValue('subadmin'));
-		$targetUser = $this->getMock('\OCP\IUser');
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('UserToGet')
-			->will($this->returnValue($targetUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('subadmin')
-			->will($this->returnValue(false));
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()
-			->getMock();
-		$subAdminManager
-			->expects($this->once())
-			->method('isUserAccessible')
-			->with($loggedInUser, $targetUser)
-			->will($this->returnValue(false));
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->will($this->returnValue($subAdminManager));
-
-		$expected = new \OC_OCS_Result(null, API::RESPOND_UNAUTHORISED);
-		$this->assertEquals($expected, $this->api->getUser(['userid' => 'UserToGet']));
-	}
-
-	public function testGetUserAsSubAdminSelfLookup() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->exactly(2))
-			->method('getUID')
-			->will($this->returnValue('subadmin'));
-		$targetUser = $this->getMock('\OCP\IUser');
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('subadmin')
-			->will($this->returnValue($targetUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('subadmin')
-			->will($this->returnValue(false));
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()
-			->getMock();
-		$subAdminManager
-			->expects($this->once())
-			->method('isUserAccessible')
-			->with($loggedInUser, $targetUser)
-			->will($this->returnValue(false));
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->will($this->returnValue($subAdminManager));
-		$this->api
-			->expects($this->once())
-			->method('fillStorageInfo')
-			->with('subadmin')
-			->will($this->returnValue(['DummyValue']));
-		$targetUser
-			->expects($this->once())
-			->method('getDisplayName')
-			->will($this->returnValue('Subadmin User'));
-		$targetUser
-			->expects($this->once())
-			->method('getEMailAddress')
-			->will($this->returnValue('subadmin@owncloud.org'));
-
-		$expected = new \OC_OCS_Result([
-			'quota' => ['DummyValue'],
-			'email' => 'subadmin@owncloud.org',
-			'displayname' => 'Subadmin User',
-		]);
-		$this->assertEquals($expected, $this->api->getUser(['userid' => 'subadmin']));
-	}
-
-	public function testEditUserNotLoggedIn() {
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue(null));
-
-		$expected = new \OC_OCS_Result(null, API::RESPOND_UNAUTHORISED);
-		$this->assertEquals($expected, $this->api->editUser(['userid' => 'UserToEdit']));
-	}
-
-	public function testEditUserRegularUserSelfEditChangeDisplayName() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->any())
-			->method('getUID')
-			->will($this->returnValue('UserToEdit'));
-		$targetUser = $this->getMock('\OCP\IUser');
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('UserToEdit')
-			->will($this->returnValue($targetUser));
-		$targetUser
-			->expects($this->once())
-			->method('setDisplayName')
-			->with('NewDisplayName');
-
-		$expected = new \OC_OCS_Result(null, 100);
-		$this->assertEquals($expected, $this->api->editUser(['userid' => 'UserToEdit', '_put' => ['key' => 'display', 'value' => 'NewDisplayName']]));
-	}
-
-	public function testEditUserRegularUserSelfEditChangeEmailValid() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->any())
-			->method('getUID')
-			->will($this->returnValue('UserToEdit'));
-		$targetUser = $this->getMock('\OCP\IUser');
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('UserToEdit')
-			->will($this->returnValue($targetUser));
-		$targetUser
-			->expects($this->once())
-			->method('setEMailAddress')
-			->with('demo@owncloud.org');
-
-		$expected = new \OC_OCS_Result(null, 100);
-		$this->assertEquals($expected, $this->api->editUser(['userid' => 'UserToEdit', '_put' => ['key' => 'email', 'value' => 'demo@owncloud.org']]));
-	}
-
-	public function testEditUserRegularUserSelfEditChangeEmailInvalid() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->any())
-			->method('getUID')
-			->will($this->returnValue('UserToEdit'));
-		$targetUser = $this->getMock('\OCP\IUser');
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('UserToEdit')
-			->will($this->returnValue($targetUser));
-
-		$expected = new \OC_OCS_Result(null, 102);
-		$this->assertEquals($expected, $this->api->editUser(['userid' => 'UserToEdit', '_put' => ['key' => 'email', 'value' => 'demo.org']]));
-	}
-
-	public function testEditUserRegularUserSelfEditChangePassword() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->any())
-			->method('getUID')
-			->will($this->returnValue('UserToEdit'));
-		$targetUser = $this->getMock('\OCP\IUser');
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('UserToEdit')
-			->will($this->returnValue($targetUser));
-		$targetUser
-			->expects($this->once())
-			->method('setPassword')
-			->with('NewPassword');
-
-		$expected = new \OC_OCS_Result(null, 100);
-		$this->assertEquals($expected, $this->api->editUser(['userid' => 'UserToEdit', '_put' => ['key' => 'password', 'value' => 'NewPassword']]));
-	}
-
-	public function testEditUserRegularUserSelfEditChangeQuota() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->any())
-			->method('getUID')
-			->will($this->returnValue('UserToEdit'));
-		$targetUser = $this->getMock('\OCP\IUser');
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('UserToEdit')
-			->will($this->returnValue($targetUser));
-
-		$expected = new \OC_OCS_Result(null, 997);
-		$this->assertEquals($expected, $this->api->editUser(['userid' => 'UserToEdit', '_put' => ['key' => 'quota', 'value' => 'NewQuota']]));
-	}
-
-	public function testEditUserAdminUserSelfEditChangeValidQuota() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->any())
-			->method('getUID')
-			->will($this->returnValue('UserToEdit'));
-		$targetUser = $this->getMock('\OCP\IUser');
-		$targetUser->expects($this->once())
-			->method('setQuota')
-			->with('2.9 MB');
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('UserToEdit')
-			->will($this->returnValue($targetUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('UserToEdit')
-			->will($this->returnValue(true));
-
-		$expected = new \OC_OCS_Result(null, 100);
-		$this->assertEquals($expected, $this->api->editUser(['userid' => 'UserToEdit', '_put' => ['key' => 'quota', 'value' => '3042824']]));
-	}
-
-	public function testEditUserAdminUserSelfEditChangeInvalidQuota() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->any())
-			->method('getUID')
-			->will($this->returnValue('UserToEdit'));
-		$targetUser = $this->getMock('\OCP\IUser');
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('UserToEdit')
-			->will($this->returnValue($targetUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('UserToEdit')
-			->will($this->returnValue(true));
-
-		$expected = new \OC_OCS_Result(null, 103, 'Invalid quota value ABC');
-		$this->assertEquals($expected, $this->api->editUser(['userid' => 'UserToEdit', '_put' => ['key' => 'quota', 'value' => 'ABC']]));
-	}
-
-	public function testEditUserAdminUserEditChangeValidQuota() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->any())
-			->method('getUID')
-			->will($this->returnValue('admin'));
-		$targetUser = $this->getMock('\OCP\IUser');
-		$targetUser->expects($this->once())
-			->method('setQuota')
-			->with('2.9 MB');
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('UserToEdit')
-			->will($this->returnValue($targetUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('admin')
-			->will($this->returnValue(true));
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()
-			->getMock();
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->will($this->returnValue($subAdminManager));
-
-		$expected = new \OC_OCS_Result(null, 100);
-		$this->assertEquals($expected, $this->api->editUser(['userid' => 'UserToEdit', '_put' => ['key' => 'quota', 'value' => '3042824']]));
-	}
-
-	public function testEditUserSubadminUserAccessible() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->any())
-			->method('getUID')
-			->will($this->returnValue('subadmin'));
-		$targetUser = $this->getMock('\OCP\IUser');
-		$targetUser->expects($this->once())
-			->method('setQuota')
-			->with('2.9 MB');
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('UserToEdit')
-			->will($this->returnValue($targetUser));
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()
-			->getMock();
-		$subAdminManager
-			->expects($this->once())
-			->method('isUserAccessible')
-			->with($loggedInUser, $targetUser)
-			->will($this->returnValue(true));
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->will($this->returnValue($subAdminManager));
-
-		$expected = new \OC_OCS_Result(null, 100);
-		$this->assertEquals($expected, $this->api->editUser(['userid' => 'UserToEdit', '_put' => ['key' => 'quota', 'value' => '3042824']]));
-	}
-
-	public function testEditUserSubadminUserInaccessible() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->any())
-			->method('getUID')
-			->will($this->returnValue('subadmin'));
-		$targetUser = $this->getMock('\OCP\IUser');
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('UserToEdit')
-			->will($this->returnValue($targetUser));
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()
-			->getMock();
-		$subAdminManager
-			->expects($this->once())
-			->method('isUserAccessible')
-			->with($loggedInUser, $targetUser)
-			->will($this->returnValue(false));
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->will($this->returnValue($subAdminManager));
-
-		$expected = new \OC_OCS_Result(null, 997);
-		$this->assertEquals($expected, $this->api->editUser(['userid' => 'UserToEdit', '_put' => ['key' => 'quota', 'value' => '3042824']]));
-	}
-
-	public function testDeleteUserNotLoggedIn() {
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue(null));
-
-		$expected = new \OC_OCS_Result(null, 997);
-		$this->assertEquals($expected, $this->api->deleteUser(['userid' => 'UserToDelete']));
-	}
-
-	public function testDeleteUserNotExistingUser() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->any())
-			->method('getUID')
-			->will($this->returnValue('UserToEdit'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('UserToDelete')
-			->will($this->returnValue(null));
-
-		$expected = new \OC_OCS_Result(null, 101);
-		$this->assertEquals($expected, $this->api->deleteUser(['userid' => 'UserToDelete']));
-	}
-
-	public function testDeleteUserSelf() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->any())
-			->method('getUID')
-			->will($this->returnValue('UserToDelete'));
-		$targetUser = $this->getMock('\OCP\IUser');
-		$targetUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('UserToDelete'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('UserToDelete')
-			->will($this->returnValue($targetUser));
-
-		$expected = new \OC_OCS_Result(null, 101);
-		$this->assertEquals($expected, $this->api->deleteUser(['userid' => 'UserToDelete']));
-	}
-
-	public function testDeleteSuccessfulUserAsAdmin() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->any())
-			->method('getUID')
-			->will($this->returnValue('admin'));
-		$targetUser = $this->getMock('\OCP\IUser');
-		$targetUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('UserToDelete'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('UserToDelete')
-			->will($this->returnValue($targetUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('admin')
-			->will($this->returnValue(true));
-		$targetUser
-			->expects($this->once())
-			->method('delete')
-			->will($this->returnValue(true));
-
-		$expected = new \OC_OCS_Result(null, 100);
-		$this->assertEquals($expected, $this->api->deleteUser(['userid' => 'UserToDelete']));
-	}
-
-	public function testDeleteUnsuccessfulUserAsAdmin() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->any())
-			->method('getUID')
-			->will($this->returnValue('admin'));
-		$targetUser = $this->getMock('\OCP\IUser');
-		$targetUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('UserToDelete'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('UserToDelete')
-			->will($this->returnValue($targetUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('admin')
-			->will($this->returnValue(true));
-		$targetUser
-			->expects($this->once())
-			->method('delete')
-			->will($this->returnValue(false));
-
-		$expected = new \OC_OCS_Result(null, 101);
-		$this->assertEquals($expected, $this->api->deleteUser(['userid' => 'UserToDelete']));
-	}
-
-	public function testDeleteSuccessfulUserAsSubadmin() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->any())
-			->method('getUID')
-			->will($this->returnValue('subadmin'));
-		$targetUser = $this->getMock('\OCP\IUser');
-		$targetUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('UserToDelete'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('UserToDelete')
-			->will($this->returnValue($targetUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('subadmin')
-			->will($this->returnValue(false));
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()->getMock();
-		$subAdminManager
-			->expects($this->once())
-			->method('isUserAccessible')
-			->with($loggedInUser, $targetUser)
-			->will($this->returnValue(true));
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->will($this->returnValue($subAdminManager));
-		$targetUser
-			->expects($this->once())
-			->method('delete')
-			->will($this->returnValue(true));
-
-		$expected = new \OC_OCS_Result(null, 100);
-		$this->assertEquals($expected, $this->api->deleteUser(['userid' => 'UserToDelete']));
-	}
-
-	public function testDeleteUnsuccessfulUserAsSubadmin() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->any())
-			->method('getUID')
-			->will($this->returnValue('subadmin'));
-		$targetUser = $this->getMock('\OCP\IUser');
-		$targetUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('UserToDelete'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('UserToDelete')
-			->will($this->returnValue($targetUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('subadmin')
-			->will($this->returnValue(false));
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()->getMock();
-		$subAdminManager
-			->expects($this->once())
-			->method('isUserAccessible')
-			->with($loggedInUser, $targetUser)
-			->will($this->returnValue(true));
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->will($this->returnValue($subAdminManager));
-		$targetUser
-			->expects($this->once())
-			->method('delete')
-			->will($this->returnValue(false));
-
-		$expected = new \OC_OCS_Result(null, 101);
-		$this->assertEquals($expected, $this->api->deleteUser(['userid' => 'UserToDelete']));
-	}
-
-	public function testDeleteUserAsSubAdminAndUserIsNotAccessible() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->any())
-			->method('getUID')
-			->will($this->returnValue('subadmin'));
-		$targetUser = $this->getMock('\OCP\IUser');
-		$targetUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('UserToDelete'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('UserToDelete')
-			->will($this->returnValue($targetUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('subadmin')
-			->will($this->returnValue(false));
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()->getMock();
-		$subAdminManager
-			->expects($this->once())
-			->method('isUserAccessible')
-			->with($loggedInUser, $targetUser)
-			->will($this->returnValue(false));
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->will($this->returnValue($subAdminManager));
-
-		$expected = new \OC_OCS_Result(null, 997);
-		$this->assertEquals($expected, $this->api->deleteUser(['userid' => 'UserToDelete']));
-	}
-
-	public function testGetUsersGroupsNotLoggedIn() {
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue(null));
-
-		$expected = new \OC_OCS_Result(null, 997);
-		$this->assertEquals($expected, $this->api->getUsersGroups(['userid' => 'UserToLookup']));
-	}
-
-	public function testGetUsersGroupsTargetUserNotExisting() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-
-		$expected = new \OC_OCS_Result(null, 998);
-		$this->assertEquals($expected, $this->api->getUsersGroups(['userid' => 'UserToLookup']));
-	}
-
-	public function testGetUsersGroupsSelfTargetted() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('UserToLookup'));
-		$targetUser = $this->getMock('\OCP\IUser');
-		$targetUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('UserToLookup'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('UserToLookup')
-			->will($this->returnValue($targetUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('getUserGroupIds')
-			->with($targetUser)
-			->will($this->returnValue(['DummyValue']));
-
-		$expected = new \OC_OCS_Result(['groups' => ['DummyValue']]);
-		$this->assertEquals($expected, $this->api->getUsersGroups(['userid' => 'UserToLookup']));
-	}
-
-	public function testGetUsersGroupsForAdminUser() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->exactly(2))
-			->method('getUID')
-			->will($this->returnValue('admin'));
-		$targetUser = $this->getMock('\OCP\IUser');
-		$targetUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('UserToLookup'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('UserToLookup')
-			->will($this->returnValue($targetUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('getUserGroupIds')
-			->with($targetUser)
-			->will($this->returnValue(['DummyValue']));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('admin')
-			->will($this->returnValue(true));
-
-		$expected = new \OC_OCS_Result(['groups' => ['DummyValue']]);
-		$this->assertEquals($expected, $this->api->getUsersGroups(['userid' => 'UserToLookup']));
-	}
-
-	public function testGetUsersGroupsForSubAdminUserAndUserIsAccessible() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->exactly(2))
-			->method('getUID')
-			->will($this->returnValue('subadmin'));
-		$targetUser = $this->getMock('\OCP\IUser');
-		$targetUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('UserToLookup'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('UserToLookup')
-			->will($this->returnValue($targetUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('subadmin')
-			->will($this->returnValue(false));
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()->getMock();
-		$subAdminManager
-			->expects($this->once())
-			->method('isUserAccessible')
-			->with($loggedInUser, $targetUser)
-			->will($this->returnValue(true));
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->will($this->returnValue($subAdminManager));
-		$group1 = $this->getMock('\OCP\IGroup');
-		$group1
-			->expects($this->any())
-			->method('getGID')
-			->will($this->returnValue('Group1'));
-		$group2 = $this->getMock('\OCP\IGroup');
-		$group2
-			->expects($this->any())
-			->method('getGID')
-			->will($this->returnValue('Group2'));
-		$subAdminManager
-			->expects($this->once())
-			->method('getSubAdminsGroups')
-			->with($loggedInUser)
-			->will($this->returnValue([$group1, $group2]));
-		$this->groupManager
-			->expects($this->any())
-			->method('getUserGroupIds')
-			->with($targetUser)
-			->will($this->returnValue(['Group1']));
-
-		$expected = new \OC_OCS_Result(['groups' => ['Group1']]);
-		$this->assertEquals($expected, $this->api->getUsersGroups(['userid' => 'UserToLookup']));
-	}
-
-
-	public function testGetUsersGroupsForSubAdminUserAndUserIsInaccessible() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->exactly(2))
-			->method('getUID')
-			->will($this->returnValue('subadmin'));
-		$targetUser = $this->getMock('\OCP\IUser');
-		$targetUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('UserToLookup'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('UserToLookup')
-			->will($this->returnValue($targetUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('subadmin')
-			->will($this->returnValue(false));
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()->getMock();
-		$subAdminManager
-			->expects($this->once())
-			->method('isUserAccessible')
-			->with($loggedInUser, $targetUser)
-			->will($this->returnValue(false));
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->will($this->returnValue($subAdminManager));
-		$this->groupManager
-			->expects($this->any())
-			->method('getUserGroupIds')
-			->with($targetUser)
-			->will($this->returnValue(['Group1']));
-
-		$expected = new \OC_OCS_Result(null, 997);
-		$this->assertEquals($expected, $this->api->getUsersGroups(['userid' => 'UserToLookup']));
-	}
-
-	public function testAddToGroupNotLoggedIn() {
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue(null));
-
-		$expected = new \OC_OCS_Result(null, 997);
-		$this->assertEquals($expected, $this->api->addToGroup([]));
-	}
-
-	public function testAddToGroupWithTargetGroupNotExisting() {
-		$_POST['groupid'] = 'GroupToAddTo';
-
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('admin'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('get')
-			->with('GroupToAddTo')
-			->will($this->returnValue(null));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('admin')
-			->will($this->returnValue(true));
-
-		$expected = new \OC_OCS_Result(null, 102);
-		$this->assertEquals($expected, $this->api->addToGroup(['userid' => 'TargetUser']));
-	}
-
-	public function testAddToGroupWithNoGroupSpecified() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('admin'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('admin')
-			->will($this->returnValue(true));
-
-		$expected = new \OC_OCS_Result(null, 101);
-		$this->assertEquals($expected, $this->api->addToGroup(['userid' => 'TargetUser']));
-	}
-
-	public function testAddToGroupWithTargetUserNotExisting() {
-		$_POST['groupid'] = 'GroupToAddTo';
-
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('admin'));
-		$targetGroup = $this->getMock('\OCP\IGroup');
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('get')
-			->with('GroupToAddTo')
-			->will($this->returnValue($targetGroup));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('admin')
-			->will($this->returnValue(true));
-
-		$expected = new \OC_OCS_Result(null, 103);
-		$this->assertEquals($expected, $this->api->addToGroup(['userid' => 'TargetUser']));
-	}
-
-	public function testAddToGroupWithoutPermission() {
-		$_POST['groupid'] = 'GroupToAddTo';
-
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('admin'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('admin')
-			->will($this->returnValue(false));
-
-		$expected = new \OC_OCS_Result(null, 997);
-		$this->assertEquals($expected, $this->api->addToGroup(['userid' => 'TargetUser']));
-	}
-
-	public function testRemoveFromGroupWithoutLogIn() {
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue(null));
-
-		$expected = new \OC_OCS_Result(null, 997);
-		$this->assertEquals($expected, $this->api->removeFromGroup(['userid' => 'TargetUser', '_delete' => ['groupid' => 'TargetGroup']]));
-	}
-
-	public function testRemoveFromGroupWithNoTargetGroup() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$expected = new \OC_OCS_Result(null, 101);
-		$this->assertEquals($expected, $this->api->removeFromGroup(['userid' => 'TargetUser', '_delete' => []]));
-	}
-
-	public function testRemoveFromGroupWithNotExistingTargetGroup() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('get')
-			->with('TargetGroup')
-			->will($this->returnValue(null));
-
-		$expected = new \OC_OCS_Result(null, 102);
-		$this->assertEquals($expected, $this->api->removeFromGroup(['userid' => 'TargetUser', '_delete' => ['groupid' => 'TargetGroup']]));
-	}
-
-	public function testRemoveFromGroupWithNotExistingTargetUser() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$targetGroup = $this->getMock('\OCP\IGroup');
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('get')
-			->with('TargetGroup')
-			->will($this->returnValue($targetGroup));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('TargetUser')
-			->will($this->returnValue(null));
-
-		$expected = new \OC_OCS_Result(null, 103);
-		$this->assertEquals($expected, $this->api->removeFromGroup(['userid' => 'TargetUser', '_delete' => ['groupid' => 'TargetGroup']]));
-	}
-
-	public function testRemoveFromGroupWithoutPermission() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->once())
-			->method('getUID')
-			->will($this->returnValue('unauthorizedUser'));
-		$targetUser = $this->getMock('\OCP\IUser');
-		$targetGroup = $this->getMock('\OCP\IGroup');
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('get')
-			->with('TargetGroup')
-			->will($this->returnValue($targetGroup));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('TargetUser')
-			->will($this->returnValue($targetUser));
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()->getMock();
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->will($this->returnValue($subAdminManager));
-		$this->groupManager
-			->expects($this->once())
-			->method('isAdmin')
-			->with('unauthorizedUser')
-			->will($this->returnValue(false));
-
-		$expected = new \OC_OCS_Result(null, 104);
-		$this->assertEquals($expected, $this->api->removeFromGroup(['userid' => 'TargetUser', '_delete' => ['groupid' => 'TargetGroup']]));
-	}
-
-	public function testRemoveFromGroupAsAdminFromAdmin() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->any())
-			->method('getUID')
-			->will($this->returnValue('admin'));
-		$targetUser = $this->getMock('\OCP\IUser');
-		$targetGroup = $this->getMock('\OCP\IGroup');
-		$targetGroup
-			->expects($this->once())
-			->method('getGID')
-			->will($this->returnValue('admin'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('get')
-			->with('admin')
-			->will($this->returnValue($targetGroup));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('admin')
-			->will($this->returnValue($targetUser));
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()->getMock();
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->will($this->returnValue($subAdminManager));
-		$this->groupManager
-			->expects($this->any())
-			->method('isAdmin')
-			->with('admin')
-			->will($this->returnValue(true));
-
-		$expected = new \OC_OCS_Result(null, 105, 'Cannot remove yourself from the admin group');
-		$this->assertEquals($expected, $this->api->removeFromGroup(['userid' => 'admin', '_delete' => ['groupid' => 'admin']]));
-	}
-
-	public function testRemoveFromGroupAsSubAdminFromSubAdmin() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->any())
-			->method('getUID')
-			->will($this->returnValue('subadmin'));
-		$targetUser = $this->getMock('\OCP\IUser');
-		$targetGroup = $this->getMock('\OCP\IGroup');
-		$targetGroup
-			->expects($this->any())
-			->method('getGID')
-			->will($this->returnValue('subadmin'));
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('get')
-			->with('subadmin')
-			->will($this->returnValue($targetGroup));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('subadmin')
-			->will($this->returnValue($targetUser));
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()->getMock();
-		$subAdminManager
-			->expects($this->once())
-			->method('isSubAdminofGroup')
-			->with($loggedInUser, $targetGroup)
-			->will($this->returnValue(true));
-		$subAdminManager
-			->expects($this->once())
-			->method('getSubAdminsGroups')
-			->with($loggedInUser)
-			->will($this->returnValue([$targetGroup]));
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->will($this->returnValue($subAdminManager));
-		$this->groupManager
-			->expects($this->any())
-			->method('isAdmin')
-			->with('subadmin')
-			->will($this->returnValue(false));
-
-		$expected = new \OC_OCS_Result(null, 105, 'Cannot remove yourself from this group as you are a SubAdmin');
-		$this->assertEquals($expected, $this->api->removeFromGroup(['userid' => 'subadmin', '_delete' => ['groupid' => 'subadmin']]));
-	}
-
-	public function testRemoveFromGroupSuccessful() {
-		$loggedInUser = $this->getMock('\OCP\IUser');
-		$loggedInUser
-			->expects($this->any())
-			->method('getUID')
-			->will($this->returnValue('admin'));
-		$targetUser = $this->getMock('\OCP\IUser');
-		$targetGroup = $this->getMock('\OCP\IGroup');
-		$this->userSession
-			->expects($this->once())
-			->method('getUser')
-			->will($this->returnValue($loggedInUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('get')
-			->with('admin')
-			->will($this->returnValue($targetGroup));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('AnotherUser')
-			->will($this->returnValue($targetUser));
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()->getMock();
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->will($this->returnValue($subAdminManager));
-		$this->groupManager
-			->expects($this->any())
-			->method('isAdmin')
-			->with('admin')
-			->will($this->returnValue(true));
-		$targetGroup
-			->expects($this->once())
-			->method('removeUser')
-			->with($targetUser);
-
-		$expected = new \OC_OCS_Result(null, 100);
-		$this->assertEquals($expected, $this->api->removeFromGroup(['userid' => 'AnotherUser', '_delete' => ['groupid' => 'admin']]));
-	}
-
-	public function testAddSubAdminWithNotExistingTargetUser() {
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('NotExistingUser')
-			->will($this->returnValue(null));
-
-		$expected = new \OC_OCS_Result(null, 101, 'User does not exist');
-		$this->assertEquals($expected, $this->api->addSubAdmin(['userid' => 'NotExistingUser']));
-	}
-
-	public function testAddSubAdminWithNotExistingTargetGroup() {
-		$_POST['groupid'] = 'NotExistingGroup';
-
-		$targetUser = $this->getMock('\OCP\IUser');
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('ExistingUser')
-			->will($this->returnValue($targetUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('get')
-			->with('NotExistingGroup')
-			->will($this->returnValue(null));
-
-		$expected = new \OC_OCS_Result(null, 102, 'Group:NotExistingGroup does not exist');
-		$this->assertEquals($expected, $this->api->addSubAdmin(['userid' => 'ExistingUser']));
-	}
-
-	public function testAddSubAdminToAdminGroup() {
-		$_POST['groupid'] = 'ADmiN';
-
-		$targetUser = $this->getMock('\OCP\IUser');
-		$targetGroup = $this->getMock('\OCP\IGroup');
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('ExistingUser')
-			->will($this->returnValue($targetUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('get')
-			->with('ADmiN')
-			->will($this->returnValue($targetGroup));
-
-		$expected = new \OC_OCS_Result(null, 103, 'Cannot create subadmins for admin group');
-		$this->assertEquals($expected, $this->api->addSubAdmin(['userid' => 'ExistingUser']));
-	}
-
-	public function testAddSubAdminTwice() {
-		$_POST['groupid'] = 'TargetGroup';
-
-		$targetUser = $this->getMock('\OCP\IUser');
-		$targetGroup = $this->getMock('\OCP\IGroup');
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('ExistingUser')
-			->will($this->returnValue($targetUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('get')
-			->with('TargetGroup')
-			->will($this->returnValue($targetGroup));
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()->getMock();
-		$subAdminManager
-			->expects($this->once())
-			->method('isSubAdminOfGroup')
-			->with($targetUser, $targetGroup)
-			->will($this->returnValue(true));
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->will($this->returnValue($subAdminManager));
-
-		$expected = new \OC_OCS_Result(null, 100);
-		$this->assertEquals($expected, $this->api->addSubAdmin(['userid' => 'ExistingUser']));
-	}
-
-	public function testAddSubAdminSuccessful() {
-		$_POST['groupid'] = 'TargetGroup';
-
-		$targetUser = $this->getMock('\OCP\IUser');
-		$targetGroup = $this->getMock('\OCP\IGroup');
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('ExistingUser')
-			->will($this->returnValue($targetUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('get')
-			->with('TargetGroup')
-			->will($this->returnValue($targetGroup));
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()->getMock();
-		$subAdminManager
-			->expects($this->once())
-			->method('isSubAdminOfGroup')
-			->with($targetUser, $targetGroup)
-			->will($this->returnValue(false));
-		$subAdminManager
-			->expects($this->once())
-			->method('createSubAdmin')
-			->with($targetUser, $targetGroup)
-			->will($this->returnValue(true));
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->will($this->returnValue($subAdminManager));
-
-		$expected = new \OC_OCS_Result(null, 100);
-		$this->assertEquals($expected, $this->api->addSubAdmin(['userid' => 'ExistingUser']));
-	}
-
-	public function testAddSubAdminUnsuccessful() {
-		$_POST['groupid'] = 'TargetGroup';
-
-		$targetUser = $this->getMock('\OCP\IUser');
-		$targetGroup = $this->getMock('\OCP\IGroup');
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('ExistingUser')
-			->will($this->returnValue($targetUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('get')
-			->with('TargetGroup')
-			->will($this->returnValue($targetGroup));
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()->getMock();
-		$subAdminManager
-			->expects($this->once())
-			->method('isSubAdminOfGroup')
-			->with($targetUser, $targetGroup)
-			->will($this->returnValue(false));
-		$subAdminManager
-			->expects($this->once())
-			->method('createSubAdmin')
-			->with($targetUser, $targetGroup)
-			->will($this->returnValue(false));
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->will($this->returnValue($subAdminManager));
-
-		$expected = new \OC_OCS_Result(null, 103, 'Unknown error occurred');
-		$this->assertEquals($expected, $this->api->addSubAdmin(['userid' => 'ExistingUser']));
-	}
-
-	public function testRemoveSubAdminNotExistingTargetUser() {
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('NotExistingUser')
-			->will($this->returnValue(null));
-
-		$expected = new \OC_OCS_Result(null, 101, 'User does not exist');
-		$this->assertEquals($expected, $this->api->removeSubAdmin(['userid' => 'NotExistingUser', '_delete' => ['groupid' => 'GroupToDeleteFrom']]));
-	}
-
-	public function testRemoveSubAdminNotExistingTargetGroup() {
-		$targetUser = $this->getMock('\OCP\IUser');
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('ExistingUser')
-			->will($this->returnValue($targetUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('get')
-			->with('GroupToDeleteFrom')
-			->will($this->returnValue(null));
-
-		$expected = new \OC_OCS_Result(null, 101, 'Group does not exist');
-		$this->assertEquals($expected, $this->api->removeSubAdmin(['userid' => 'ExistingUser', '_delete' => ['groupid' => 'GroupToDeleteFrom']]));
-	}
-
-	public function testRemoveSubAdminFromNotASubadmin() {
-		$targetUser = $this->getMock('\OCP\IUser');
-		$targetGroup = $this->getMock('\OCP\IGroup');
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('ExistingUser')
-			->will($this->returnValue($targetUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('get')
-			->with('GroupToDeleteFrom')
-			->will($this->returnValue($targetGroup));
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()->getMock();
-		$subAdminManager
-			->expects($this->once())
-			->method('isSubAdminOfGroup')
-			->with($targetUser, $targetGroup)
-			->will($this->returnValue(false));
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->will($this->returnValue($subAdminManager));
-
-		$expected = new \OC_OCS_Result(null, 102, 'User is not a subadmin of this group');
-		$this->assertEquals($expected, $this->api->removeSubAdmin(['userid' => 'ExistingUser', '_delete' => ['groupid' => 'GroupToDeleteFrom']]));
-	}
-
-	public function testRemoveSubAdminSuccessful() {
-		$targetUser = $this->getMock('\OCP\IUser');
-		$targetGroup = $this->getMock('\OCP\IGroup');
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('ExistingUser')
-			->will($this->returnValue($targetUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('get')
-			->with('GroupToDeleteFrom')
-			->will($this->returnValue($targetGroup));
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()->getMock();
-		$subAdminManager
-			->expects($this->once())
-			->method('isSubAdminOfGroup')
-			->with($targetUser, $targetGroup)
-			->will($this->returnValue(true));
-		$subAdminManager
-			->expects($this->once())
-			->method('deleteSubAdmin')
-			->with($targetUser, $targetGroup)
-			->will($this->returnValue(true));
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->will($this->returnValue($subAdminManager));
-
-		$expected = new \OC_OCS_Result(null, 100);
-		$this->assertEquals($expected, $this->api->removeSubAdmin(['userid' => 'ExistingUser', '_delete' => ['groupid' => 'GroupToDeleteFrom']]));
-	}
-
-	public function testRemoveSubAdminUnsuccessful() {
-		$targetUser = $this->getMock('\OCP\IUser');
-		$targetGroup = $this->getMock('\OCP\IGroup');
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('ExistingUser')
-			->will($this->returnValue($targetUser));
-		$this->groupManager
-			->expects($this->once())
-			->method('get')
-			->with('GroupToDeleteFrom')
-			->will($this->returnValue($targetGroup));
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()->getMock();
-		$subAdminManager
-			->expects($this->once())
-			->method('isSubAdminOfGroup')
-			->with($targetUser, $targetGroup)
-			->will($this->returnValue(true));
-		$subAdminManager
-			->expects($this->once())
-			->method('deleteSubAdmin')
-			->with($targetUser, $targetGroup)
-			->will($this->returnValue(false));
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->will($this->returnValue($subAdminManager));
-
-		$expected = new \OC_OCS_Result(null, 103, 'Unknown error occurred');
-		$this->assertEquals($expected, $this->api->removeSubAdmin(['userid' => 'ExistingUser', '_delete' => ['groupid' => 'GroupToDeleteFrom']]));
-	}
-
-	public function testGetUserSubAdminGroupsNotExistingTargetUser() {
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('RequestedUser')
-			->will($this->returnValue(null));
-
-		$expected = new \OC_OCS_Result(null, 101, 'User does not exist');
-		$this->assertEquals($expected, $this->api->getUserSubAdminGroups(['userid' => 'RequestedUser']));
-	}
-
-	public function testGetUserSubAdminGroupsWithGroups() {
-		$targetUser = $this->getMock('\OCP\IUser');
-		$targetGroup = $this->getMock('\OCP\IGroup');
-		$targetGroup
-			->expects($this->once())
-			->method('getGID')
-			->will($this->returnValue('TargetGroup'));
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('RequestedUser')
-			->will($this->returnValue($targetUser));
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()->getMock();
-		$subAdminManager
-			->expects($this->once())
-			->method('getSubAdminsGroups')
-			->with($targetUser)
-			->will($this->returnValue([$targetGroup]));
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->will($this->returnValue($subAdminManager));
-
-		$expected = new \OC_OCS_Result(['TargetGroup'], 100);
-		$this->assertEquals($expected, $this->api->getUserSubAdminGroups(['userid' => 'RequestedUser']));
-	}
-
-	public function testGetUserSubAdminGroupsWithoutGroups() {
-		$targetUser = $this->getMock('\OCP\IUser');
-		$this->userManager
-			->expects($this->once())
-			->method('get')
-			->with('RequestedUser')
-			->will($this->returnValue($targetUser));
-		$subAdminManager = $this->getMockBuilder('\OC\Subadmin')
-			->disableOriginalConstructor()->getMock();
-		$subAdminManager
-			->expects($this->once())
-			->method('getSubAdminsGroups')
-			->with($targetUser)
-			->will($this->returnValue([]));
-		$this->groupManager
-			->expects($this->once())
-			->method('getSubAdmin')
-			->will($this->returnValue($subAdminManager));
-
-		$expected = new \OC_OCS_Result(null, 102, 'Unknown error occurred');
-		$this->assertEquals($expected, $this->api->getUserSubAdminGroups(['userid' => 'RequestedUser']));
-	}
-}