nextcloud / server

apps/encryption/tests/Settings/AdminTest.php

Indentation +51 added lines, -51 removed lines

@@ -21,62 +21,62 @@
 
 class AdminTest extends TestCase {
 
-	protected Admin $admin;
+    protected Admin $admin;
 
-	protected IL10N&MockObject $l;
-	protected LoggerInterface&MockObject $logger;
-	protected IUserSession&MockObject $userSession;
-	protected IConfig&MockObject $config;
-	protected IUserManager&MockObject $userManager;
-	protected ISession&MockObject $session;
+    protected IL10N&MockObject $l;
+    protected LoggerInterface&MockObject $logger;
+    protected IUserSession&MockObject $userSession;
+    protected IConfig&MockObject $config;
+    protected IUserManager&MockObject $userManager;
+    protected ISession&MockObject $session;
 
-	protected function setUp(): void {
-		parent::setUp();
+    protected function setUp(): void {
+        parent::setUp();
 
-		$this->l = $this->getMockBuilder(IL10N::class)->getMock();
-		$this->logger = $this->getMockBuilder(LoggerInterface::class)->getMock();
-		$this->userSession = $this->getMockBuilder(IUserSession::class)->getMock();
-		$this->config = $this->getMockBuilder(IConfig::class)->getMock();
-		$this->userManager = $this->getMockBuilder(IUserManager::class)->getMock();
-		$this->session = $this->getMockBuilder(ISession::class)->getMock();
+        $this->l = $this->getMockBuilder(IL10N::class)->getMock();
+        $this->logger = $this->getMockBuilder(LoggerInterface::class)->getMock();
+        $this->userSession = $this->getMockBuilder(IUserSession::class)->getMock();
+        $this->config = $this->getMockBuilder(IConfig::class)->getMock();
+        $this->userManager = $this->getMockBuilder(IUserManager::class)->getMock();
+        $this->session = $this->getMockBuilder(ISession::class)->getMock();
 
-		$this->admin = new Admin(
-			$this->l,
-			$this->logger,
-			$this->userSession,
-			$this->config,
-			$this->userManager,
-			$this->session
-		);
-	}
+        $this->admin = new Admin(
+            $this->l,
+            $this->logger,
+            $this->userSession,
+            $this->config,
+            $this->userManager,
+            $this->session
+        );
+    }
 
-	public function testGetForm(): void {
-		$this->config
-			->method('getAppValue')
-			->will($this->returnCallback(function ($app, $key, $default) {
-				if ($app === 'encryption' && $key === 'recoveryAdminEnabled' && $default === '0') {
-					return '1';
-				}
-				if ($app === 'encryption' && $key === 'encryptHomeStorage' && $default === '1') {
-					return '1';
-				}
-				return $default;
-			}));
-		$params = [
-			'recoveryEnabled' => '1',
-			'initStatus' => '0',
-			'encryptHomeStorage' => true,
-			'masterKeyEnabled' => true
-		];
-		$expected = new TemplateResponse('encryption', 'settings-admin', $params, '');
-		$this->assertEquals($expected, $this->admin->getForm());
-	}
+    public function testGetForm(): void {
+        $this->config
+            ->method('getAppValue')
+            ->will($this->returnCallback(function ($app, $key, $default) {
+                if ($app === 'encryption' && $key === 'recoveryAdminEnabled' && $default === '0') {
+                    return '1';
+                }
+                if ($app === 'encryption' && $key === 'encryptHomeStorage' && $default === '1') {
+                    return '1';
+                }
+                return $default;
+            }));
+        $params = [
+            'recoveryEnabled' => '1',
+            'initStatus' => '0',
+            'encryptHomeStorage' => true,
+            'masterKeyEnabled' => true
+        ];
+        $expected = new TemplateResponse('encryption', 'settings-admin', $params, '');
+        $this->assertEquals($expected, $this->admin->getForm());
+    }
 
-	public function testGetSection(): void {
-		$this->assertSame('security', $this->admin->getSection());
-	}
+    public function testGetSection(): void {
+        $this->assertSame('security', $this->admin->getSection());
+    }
 
-	public function testGetPriority(): void {
-		$this->assertSame(11, $this->admin->getPriority());
-	}
+    public function testGetPriority(): void {
+        $this->assertSame(11, $this->admin->getPriority());
+    }
 }

apps/encryption/tests/Users/SetupTest.php

Indentation +57 added lines, -57 removed lines

@@ -17,61 +17,61 @@
 
 class SetupTest extends TestCase {
 
-	protected Setup $instance;
-
-	protected KeyManager&MockObject $keyManagerMock;
-	protected Crypt&MockObject $cryptMock;
-
-	protected function setUp(): void {
-		parent::setUp();
-		$this->cryptMock = $this->getMockBuilder(Crypt::class)
-			->disableOriginalConstructor()
-			->getMock();
-
-		$this->keyManagerMock = $this->getMockBuilder(KeyManager::class)
-			->disableOriginalConstructor()
-			->getMock();
-
-		$this->instance = new Setup(
-			$this->cryptMock,
-			$this->keyManagerMock);
-	}
-
-
-	public function testSetupSystem(): void {
-		$this->keyManagerMock->expects($this->once())->method('validateShareKey');
-		$this->keyManagerMock->expects($this->once())->method('validateMasterKey');
-
-		$this->instance->setupSystem();
-	}
-
-	/**
-	 * @dataProvider dataTestSetupUser
-	 *
-	 * @param bool $hasKeys
-	 * @param bool $expected
-	 */
-	public function testSetupUser($hasKeys, $expected): void {
-		$this->keyManagerMock->expects($this->once())->method('userHasKeys')
-			->with('uid')->willReturn($hasKeys);
-
-		if ($hasKeys) {
-			$this->keyManagerMock->expects($this->never())->method('storeKeyPair');
-		} else {
-			$this->cryptMock->expects($this->once())->method('createKeyPair')->willReturn(['publicKey' => 'publicKey', 'privateKey' => 'privateKey']);
-			$this->keyManagerMock->expects($this->once())->method('storeKeyPair')
-				->with('uid', 'password', ['publicKey' => 'publicKey', 'privateKey' => 'privateKey'])->willReturn(true);
-		}
-
-		$this->assertSame($expected,
-			$this->instance->setupUser('uid', 'password')
-		);
-	}
-
-	public static function dataTestSetupUser(): array {
-		return [
-			[true, true],
-			[false, true]
-		];
-	}
+    protected Setup $instance;
+
+    protected KeyManager&MockObject $keyManagerMock;
+    protected Crypt&MockObject $cryptMock;
+
+    protected function setUp(): void {
+        parent::setUp();
+        $this->cryptMock = $this->getMockBuilder(Crypt::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $this->keyManagerMock = $this->getMockBuilder(KeyManager::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $this->instance = new Setup(
+            $this->cryptMock,
+            $this->keyManagerMock);
+    }
+
+
+    public function testSetupSystem(): void {
+        $this->keyManagerMock->expects($this->once())->method('validateShareKey');
+        $this->keyManagerMock->expects($this->once())->method('validateMasterKey');
+
+        $this->instance->setupSystem();
+    }
+
+    /**
+     * @dataProvider dataTestSetupUser
+     *
+     * @param bool $hasKeys
+     * @param bool $expected
+     */
+    public function testSetupUser($hasKeys, $expected): void {
+        $this->keyManagerMock->expects($this->once())->method('userHasKeys')
+            ->with('uid')->willReturn($hasKeys);
+
+        if ($hasKeys) {
+            $this->keyManagerMock->expects($this->never())->method('storeKeyPair');
+        } else {
+            $this->cryptMock->expects($this->once())->method('createKeyPair')->willReturn(['publicKey' => 'publicKey', 'privateKey' => 'privateKey']);
+            $this->keyManagerMock->expects($this->once())->method('storeKeyPair')
+                ->with('uid', 'password', ['publicKey' => 'publicKey', 'privateKey' => 'privateKey'])->willReturn(true);
+        }
+
+        $this->assertSame($expected,
+            $this->instance->setupUser('uid', 'password')
+        );
+    }
+
+    public static function dataTestSetupUser(): array {
+        return [
+            [true, true],
+            [false, true]
+        ];
+    }
 }

apps/encryption/tests/KeyManagerTest.php

Indentation +678 added lines, -678 removed lines

@@ -31,682 +31,682 @@
 
 class KeyManagerTest extends TestCase {
 
-	protected KeyManager $instance;
-
-	protected string $userId;
-	protected string $systemKeyId;
-	protected IStorage&MockObject $keyStorageMock;
-	protected Crypt&MockObject $cryptMock;
-	protected IUserSession&MockObject $userMock;
-	protected Session&MockObject $sessionMock;
-	protected LoggerInterface&MockObject $logMock;
-	protected Util&MockObject $utilMock;
-	protected IConfig&MockObject $configMock;
-	protected ILockingProvider&MockObject $lockingProviderMock;
-
-	protected function setUp(): void {
-		parent::setUp();
-		$this->userId = 'user1';
-		$this->systemKeyId = 'systemKeyId';
-		$this->keyStorageMock = $this->createMock(IStorage::class);
-		$this->cryptMock = $this->getMockBuilder(Crypt::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$this->configMock = $this->createMock(IConfig::class);
-		$this->configMock->expects($this->any())
-			->method('getAppValue')
-			->willReturn($this->systemKeyId);
-		$this->userMock = $this->createMock(IUserSession::class);
-		$this->sessionMock = $this->getMockBuilder(Session::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$this->logMock = $this->createMock(LoggerInterface::class);
-		$this->utilMock = $this->getMockBuilder(Util::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$this->lockingProviderMock = $this->createMock(ILockingProvider::class);
-
-		$this->instance = new KeyManager(
-			$this->keyStorageMock,
-			$this->cryptMock,
-			$this->configMock,
-			$this->userMock,
-			$this->sessionMock,
-			$this->logMock,
-			$this->utilMock,
-			$this->lockingProviderMock
-		);
-	}
-
-	public function testDeleteShareKey(): void {
-		$this->keyStorageMock->expects($this->any())
-			->method('deleteFileKey')
-			->with($this->equalTo('/path'), $this->equalTo('keyId.shareKey'))
-			->willReturn(true);
-
-		$this->assertTrue(
-			$this->instance->deleteShareKey('/path', 'keyId')
-		);
-	}
-
-	public function testGetPrivateKey(): void {
-		$this->keyStorageMock->expects($this->any())
-			->method('getUserKey')
-			->with($this->equalTo($this->userId), $this->equalTo('privateKey'))
-			->willReturn('privateKey');
-
-
-		$this->assertSame('privateKey',
-			$this->instance->getPrivateKey($this->userId)
-		);
-	}
-
-	public function testGetPublicKey(): void {
-		$this->keyStorageMock->expects($this->any())
-			->method('getUserKey')
-			->with($this->equalTo($this->userId), $this->equalTo('publicKey'))
-			->willReturn('publicKey');
-
-
-		$this->assertSame('publicKey',
-			$this->instance->getPublicKey($this->userId)
-		);
-	}
-
-	public function testRecoveryKeyExists(): void {
-		$this->keyStorageMock->expects($this->any())
-			->method('getSystemUserKey')
-			->with($this->equalTo($this->systemKeyId . '.publicKey'))
-			->willReturn('recoveryKey');
-
-
-		$this->assertTrue($this->instance->recoveryKeyExists());
-	}
-
-	public function testCheckRecoveryKeyPassword(): void {
-		$this->keyStorageMock->expects($this->any())
-			->method('getSystemUserKey')
-			->with($this->equalTo($this->systemKeyId . '.privateKey'))
-			->willReturn('recoveryKey');
-		$this->cryptMock->expects($this->any())
-			->method('decryptPrivateKey')
-			->with($this->equalTo('recoveryKey'), $this->equalTo('pass'))
-			->willReturn('decryptedRecoveryKey');
-
-		$this->assertTrue($this->instance->checkRecoveryPassword('pass'));
-	}
-
-	public function testSetPublicKey(): void {
-		$this->keyStorageMock->expects($this->any())
-			->method('setUserKey')
-			->with(
-				$this->equalTo($this->userId),
-				$this->equalTo('publicKey'),
-				$this->equalTo('key'))
-			->willReturn(true);
-
-
-		$this->assertTrue(
-			$this->instance->setPublicKey($this->userId, 'key')
-		);
-	}
-
-	public function testSetPrivateKey(): void {
-		$this->keyStorageMock->expects($this->any())
-			->method('setUserKey')
-			->with(
-				$this->equalTo($this->userId),
-				$this->equalTo('privateKey'),
-				$this->equalTo('key'))
-			->willReturn(true);
-
-
-		$this->assertTrue(
-			$this->instance->setPrivateKey($this->userId, 'key')
-		);
-	}
-
-	/**
-	 * @dataProvider dataTestUserHasKeys
-	 */
-	public function testUserHasKeys($key, $expected): void {
-		$this->keyStorageMock->expects($this->exactly(2))
-			->method('getUserKey')
-			->with($this->equalTo($this->userId), $this->anything())
-			->willReturn($key);
-
-
-		$this->assertSame($expected,
-			$this->instance->userHasKeys($this->userId)
-		);
-	}
-
-	public static function dataTestUserHasKeys(): array {
-		return [
-			['key', true],
-			['', false]
-		];
-	}
-
-
-	public function testUserHasKeysMissingPrivateKey(): void {
-		$this->expectException(PrivateKeyMissingException::class);
-
-		$this->keyStorageMock->expects($this->exactly(2))
-			->method('getUserKey')
-			->willReturnCallback(function ($uid, $keyID, $encryptionModuleId) {
-				if ($keyID === 'privateKey') {
-					return '';
-				}
-				return 'key';
-			});
-
-		$this->instance->userHasKeys($this->userId);
-	}
-
-
-	public function testUserHasKeysMissingPublicKey(): void {
-		$this->expectException(PublicKeyMissingException::class);
-
-		$this->keyStorageMock->expects($this->exactly(2))
-			->method('getUserKey')
-			->willReturnCallback(function ($uid, $keyID, $encryptionModuleId) {
-				if ($keyID === 'publicKey') {
-					return '';
-				}
-				return 'key';
-			});
-
-		$this->instance->userHasKeys($this->userId);
-	}
-
-	/**
-	 * @dataProvider dataTestInit
-	 *
-	 * @param bool $useMasterKey
-	 */
-	public function testInit($useMasterKey): void {
-		/** @var KeyManager&MockObject $instance */
-		$instance = $this->getMockBuilder(KeyManager::class)
-			->setConstructorArgs(
-				[
-					$this->keyStorageMock,
-					$this->cryptMock,
-					$this->configMock,
-					$this->userMock,
-					$this->sessionMock,
-					$this->logMock,
-					$this->utilMock,
-					$this->lockingProviderMock
-				]
-			)->onlyMethods(['getMasterKeyId', 'getMasterKeyPassword', 'getSystemPrivateKey', 'getPrivateKey'])
-			->getMock();
-
-		$this->utilMock->expects($this->once())->method('isMasterKeyEnabled')
-			->willReturn($useMasterKey);
-
-		$sessionSetStatusCalls = [];
-		$this->sessionMock->expects($this->exactly(2))
-			->method('setStatus')
-			->willReturnCallback(function (string $status) use (&$sessionSetStatusCalls) {
-				$sessionSetStatusCalls[] = $status;
-			});
-
-		$instance->expects($this->any())->method('getMasterKeyId')->willReturn('masterKeyId');
-		$instance->expects($this->any())->method('getMasterKeyPassword')->willReturn('masterKeyPassword');
-		$instance->expects($this->any())->method('getSystemPrivateKey')->with('masterKeyId')->willReturn('privateMasterKey');
-		$instance->expects($this->any())->method('getPrivateKey')->with($this->userId)->willReturn('privateUserKey');
-
-		if ($useMasterKey) {
-			$this->cryptMock->expects($this->once())->method('decryptPrivateKey')
-				->with('privateMasterKey', 'masterKeyPassword', 'masterKeyId')
-				->willReturn('key');
-		} else {
-			$this->cryptMock->expects($this->once())->method('decryptPrivateKey')
-				->with('privateUserKey', 'pass', $this->userId)
-				->willReturn('key');
-		}
-
-		$this->sessionMock->expects($this->once())->method('setPrivateKey')
-			->with('key');
-
-		$this->assertTrue($instance->init($this->userId, 'pass'));
-		self::assertEquals([
-			Session::INIT_EXECUTED,
-			Session::INIT_SUCCESSFUL,
-		], $sessionSetStatusCalls);
-	}
-
-	public static function dataTestInit(): array {
-		return [
-			[true],
-			[false]
-		];
-	}
-
-
-	public function testSetRecoveryKey(): void {
-		$this->keyStorageMock->expects($this->exactly(2))
-			->method('setSystemUserKey')
-			->willReturn(true);
-		$this->cryptMock->expects($this->any())
-			->method('encryptPrivateKey')
-			->with($this->equalTo('privateKey'), $this->equalTo('pass'))
-			->willReturn('decryptedPrivateKey');
-
-
-		$this->assertTrue(
-			$this->instance->setRecoveryKey('pass',
-				['publicKey' => 'publicKey', 'privateKey' => 'privateKey'])
-		);
-	}
-
-	public function testSetSystemPrivateKey(): void {
-		$this->keyStorageMock->expects($this->exactly(1))
-			->method('setSystemUserKey')
-			->with($this->equalTo('keyId.privateKey'), $this->equalTo('key'))
-			->willReturn(true);
-
-
-		$this->assertTrue(
-			$this->instance->setSystemPrivateKey('keyId', 'key')
-		);
-	}
-
-	public function testGetSystemPrivateKey(): void {
-		$this->keyStorageMock->expects($this->exactly(1))
-			->method('getSystemUserKey')
-			->with($this->equalTo('keyId.privateKey'))
-			->willReturn('systemPrivateKey');
-
-
-		$this->assertSame('systemPrivateKey',
-			$this->instance->getSystemPrivateKey('keyId')
-		);
-	}
-
-	public function testGetEncryptedFileKey(): void {
-		$this->keyStorageMock->expects($this->once())
-			->method('getFileKey')
-			->with('/', 'fileKey')
-			->willReturn(true);
-
-		$this->assertTrue($this->instance->getEncryptedFileKey('/'));
-	}
-
-	public static function dataTestGetFileKey(): array {
-		return [
-			['user1', false, 'privateKey', 'legacyKey', 'multiKeyDecryptResult'],
-			['user1', false, 'privateKey', '', 'multiKeyDecryptResult'],
-			['user1', false, false, 'legacyKey', ''],
-			['user1', false, false, '', ''],
-			['user1', true, 'privateKey', 'legacyKey', 'multiKeyDecryptResult'],
-			['user1', true, 'privateKey', '', 'multiKeyDecryptResult'],
-			['user1', true, false, 'legacyKey', ''],
-			['user1', true, false, '', ''],
-			[null, false, 'privateKey', 'legacyKey', 'multiKeyDecryptResult'],
-			[null, false, 'privateKey', '', 'multiKeyDecryptResult'],
-			[null, false, false, 'legacyKey', ''],
-			[null, false, false, '', ''],
-			[null, true, 'privateKey', 'legacyKey', 'multiKeyDecryptResult'],
-			[null, true, 'privateKey', '', 'multiKeyDecryptResult'],
-			[null, true, false, 'legacyKey', ''],
-			[null, true, false, '', ''],
-		];
-	}
-
-	/**
-	 * @dataProvider dataTestGetFileKey
-	 *
-	 * @param $uid
-	 * @param $isMasterKeyEnabled
-	 * @param $privateKey
-	 * @param $expected
-	 */
-	public function testGetFileKey($uid, $isMasterKeyEnabled, $privateKey, $encryptedFileKey, $expected): void {
-		$path = '/foo.txt';
-
-		if ($isMasterKeyEnabled) {
-			$expectedUid = 'masterKeyId';
-			$this->configMock->expects($this->any())->method('getSystemValue')->with('secret')
-				->willReturn('password');
-		} elseif (!$uid) {
-			$expectedUid = 'systemKeyId';
-		} else {
-			$expectedUid = $uid;
-		}
-
-		$this->invokePrivate($this->instance, 'masterKeyId', ['masterKeyId']);
-
-		$this->keyStorageMock->expects($this->exactly(2))
-			->method('getFileKey')
-			->willReturnMap([
-				[$path, 'fileKey', 'OC_DEFAULT_MODULE', $encryptedFileKey],
-				[$path, $expectedUid . '.shareKey', 'OC_DEFAULT_MODULE', 'fileKey'],
-			]);
-
-		$this->utilMock->expects($this->any())->method('isMasterKeyEnabled')
-			->willReturn($isMasterKeyEnabled);
-
-		if (is_null($uid)) {
-			$this->keyStorageMock->expects($this->once())
-				->method('getSystemUserKey')
-				->willReturn(true);
-			$this->cryptMock->expects($this->once())
-				->method('decryptPrivateKey')
-				->willReturn($privateKey);
-		} else {
-			$this->keyStorageMock->expects($this->never())
-				->method('getSystemUserKey');
-			$this->sessionMock->expects($this->once())->method('getPrivateKey')->willReturn($privateKey);
-		}
-
-		if (!empty($encryptedFileKey)) {
-			$this->cryptMock->expects($this->never())
-				->method('multiKeyDecrypt');
-			if ($privateKey) {
-				$this->cryptMock->expects($this->once())
-					->method('multiKeyDecryptLegacy')
-					->willReturn('multiKeyDecryptResult');
-			} else {
-				$this->cryptMock->expects($this->never())
-					->method('multiKeyDecryptLegacy');
-			}
-		} else {
-			$this->cryptMock->expects($this->never())
-				->method('multiKeyDecryptLegacy');
-			if ($privateKey) {
-				$this->cryptMock->expects($this->once())
-					->method('multiKeyDecrypt')
-					->willReturn('multiKeyDecryptResult');
-			} else {
-				$this->cryptMock->expects($this->never())
-					->method('multiKeyDecrypt');
-			}
-		}
-
-		$this->assertSame($expected,
-			$this->instance->getFileKey($path, $uid, null)
-		);
-	}
-
-	public function testDeletePrivateKey(): void {
-		$this->keyStorageMock->expects($this->once())
-			->method('deleteUserKey')
-			->with('user1', 'privateKey')
-			->willReturn(true);
-
-		$this->assertTrue(self::invokePrivate($this->instance,
-			'deletePrivateKey',
-			[$this->userId]));
-	}
-
-	public function testDeleteAllFileKeys(): void {
-		$this->keyStorageMock->expects($this->once())
-			->method('deleteAllFileKeys')
-			->willReturn(true);
-
-		$this->assertTrue($this->instance->deleteAllFileKeys('/'));
-	}
-
-	/**
-	 * test add public share key and or recovery key to the list of public keys
-	 *
-	 * @dataProvider dataTestAddSystemKeys
-	 *
-	 * @param array $accessList
-	 * @param array $publicKeys
-	 * @param string $uid
-	 * @param array $expectedKeys
-	 */
-	public function testAddSystemKeys($accessList, $publicKeys, $uid, $expectedKeys): void {
-		$publicShareKeyId = 'publicShareKey';
-		$recoveryKeyId = 'recoveryKey';
-
-		$this->keyStorageMock->expects($this->any())
-			->method('getSystemUserKey')
-			->willReturnCallback(function ($keyId, $encryptionModuleId) {
-				return $keyId;
-			});
-
-		$this->utilMock->expects($this->any())
-			->method('isRecoveryEnabledForUser')
-			->willReturnCallback(function ($uid) {
-				if ($uid === 'user1') {
-					return true;
-				}
-				return false;
-			});
-
-		// set key IDs
-		self::invokePrivate($this->instance, 'publicShareKeyId', [$publicShareKeyId]);
-		self::invokePrivate($this->instance, 'recoveryKeyId', [$recoveryKeyId]);
-
-		$result = $this->instance->addSystemKeys($accessList, $publicKeys, $uid);
-
-		foreach ($expectedKeys as $expected) {
-			$this->assertArrayHasKey($expected, $result);
-		}
-
-		$this->assertSameSize($expectedKeys, $result);
-	}
-
-	/**
-	 * data provider for testAddSystemKeys()
-	 *
-	 * @return array
-	 */
-	public static function dataTestAddSystemKeys(): array {
-		return [
-			[['public' => true],[], 'user1', ['publicShareKey', 'recoveryKey']],
-			[['public' => false], [], 'user1', ['recoveryKey']],
-			[['public' => true],[], 'user2', ['publicShareKey']],
-			[['public' => false], [], 'user2', []],
-		];
-	}
-
-	public function testGetMasterKeyId(): void {
-		$this->assertSame('systemKeyId', $this->instance->getMasterKeyId());
-	}
-
-	public function testGetPublicMasterKey(): void {
-		$this->keyStorageMock->expects($this->once())->method('getSystemUserKey')
-			->with('systemKeyId.publicKey', Encryption::ID)
-			->willReturn(true);
-
-		$this->assertTrue(
-			$this->instance->getPublicMasterKey()
-		);
-	}
-
-	public function testGetMasterKeyPassword(): void {
-		$this->configMock->expects($this->once())->method('getSystemValue')->with('secret')
-			->willReturn('password');
-
-		$this->assertSame('password',
-			$this->invokePrivate($this->instance, 'getMasterKeyPassword', [])
-		);
-	}
-
-
-	public function testGetMasterKeyPasswordException(): void {
-		$this->expectException(\Exception::class);
-
-		$this->configMock->expects($this->once())->method('getSystemValue')->with('secret')
-			->willReturn('');
-
-		$this->invokePrivate($this->instance, 'getMasterKeyPassword', []);
-	}
-
-	/**
-	 * @dataProvider dataTestValidateMasterKey
-	 *
-	 * @param $masterKey
-	 */
-	public function testValidateMasterKey($masterKey): void {
-		/** @var KeyManager&MockObject $instance */
-		$instance = $this->getMockBuilder(KeyManager::class)
-			->setConstructorArgs(
-				[
-					$this->keyStorageMock,
-					$this->cryptMock,
-					$this->configMock,
-					$this->userMock,
-					$this->sessionMock,
-					$this->logMock,
-					$this->utilMock,
-					$this->lockingProviderMock
-				]
-			)->onlyMethods(['getPublicMasterKey', 'setSystemPrivateKey', 'getMasterKeyPassword'])
-			->getMock();
-
-		$this->utilMock->expects($this->once())->method('isMasterKeyEnabled')
-			->willReturn(true);
-
-		$instance->expects($this->once())->method('getPublicMasterKey')
-			->willReturn($masterKey);
-
-		$instance->expects($this->any())->method('getMasterKeyPassword')->willReturn('masterKeyPassword');
-		$this->cryptMock->expects($this->any())->method('generateHeader')->willReturn('header');
-
-		if (empty($masterKey)) {
-			$this->cryptMock->expects($this->once())->method('createKeyPair')
-				->willReturn(['publicKey' => 'public', 'privateKey' => 'private']);
-			$this->keyStorageMock->expects($this->once())->method('setSystemUserKey')
-				->with('systemKeyId.publicKey', 'public', Encryption::ID);
-			$this->cryptMock->expects($this->once())->method('encryptPrivateKey')
-				->with('private', 'masterKeyPassword', 'systemKeyId')
-				->willReturn('EncryptedKey');
-			$this->lockingProviderMock->expects($this->once())
-				->method('acquireLock');
-			$instance->expects($this->once())->method('setSystemPrivateKey')
-				->with('systemKeyId', 'headerEncryptedKey');
-		} else {
-			$this->cryptMock->expects($this->never())->method('createKeyPair');
-			$this->keyStorageMock->expects($this->never())->method('setSystemUserKey');
-			$this->cryptMock->expects($this->never())->method('encryptPrivateKey');
-			$instance->expects($this->never())->method('setSystemPrivateKey');
-		}
-
-		$instance->validateMasterKey();
-	}
-
-	public function testValidateMasterKeyLocked(): void {
-		/** @var KeyManager&MockObject $instance */
-		$instance = $this->getMockBuilder(KeyManager::class)
-			->setConstructorArgs([
-				$this->keyStorageMock,
-				$this->cryptMock,
-				$this->configMock,
-				$this->userMock,
-				$this->sessionMock,
-				$this->logMock,
-				$this->utilMock,
-				$this->lockingProviderMock
-			])
-			->onlyMethods(['getPublicMasterKey', 'getPrivateMasterKey', 'setSystemPrivateKey', 'getMasterKeyPassword'])
-			->getMock();
-
-		$this->utilMock->expects($this->once())->method('isMasterKeyEnabled')
-			->willReturn(true);
-
-		$instance->expects($this->once())->method('getPublicMasterKey')
-			->willReturn('');
-		$instance->expects($this->once())->method('getPrivateMasterKey')
-			->willReturn('');
-
-		$instance->expects($this->any())->method('getMasterKeyPassword')->willReturn('masterKeyPassword');
-		$this->cryptMock->expects($this->any())->method('generateHeader')->willReturn('header');
-
-		$this->lockingProviderMock->expects($this->once())
-			->method('acquireLock')
-			->willThrowException(new LockedException('encryption-generateMasterKey'));
-
-		$this->expectException(LockedException::class);
-		$instance->validateMasterKey();
-	}
-
-	public static function dataTestValidateMasterKey(): array {
-		return [
-			['masterKey'],
-			['']
-		];
-	}
-
-	public function testGetVersionWithoutFileInfo(): void {
-		$view = $this->getMockBuilder(View::class)
-			->disableOriginalConstructor()->getMock();
-		$view->expects($this->once())
-			->method('getFileInfo')
-			->with('/admin/files/myfile.txt')
-			->willReturn(false);
-
-		/** @var View $view */
-		$this->assertSame(0, $this->instance->getVersion('/admin/files/myfile.txt', $view));
-	}
-
-	public function testGetVersionWithFileInfo(): void {
-		$view = $this->getMockBuilder(View::class)
-			->disableOriginalConstructor()->getMock();
-		$fileInfo = $this->getMockBuilder(FileInfo::class)
-			->disableOriginalConstructor()->getMock();
-		$fileInfo->expects($this->once())
-			->method('getEncryptedVersion')
-			->willReturn(1337);
-		$view->expects($this->once())
-			->method('getFileInfo')
-			->with('/admin/files/myfile.txt')
-			->willReturn($fileInfo);
-
-		/** @var View $view */
-		$this->assertSame(1337, $this->instance->getVersion('/admin/files/myfile.txt', $view));
-	}
-
-	public function testSetVersionWithFileInfo(): void {
-		$view = $this->getMockBuilder(View::class)
-			->disableOriginalConstructor()->getMock();
-		$cache = $this->getMockBuilder(ICache::class)
-			->disableOriginalConstructor()->getMock();
-		$cache->expects($this->once())
-			->method('update')
-			->with(123, ['encrypted' => 5, 'encryptedVersion' => 5]);
-		$storage = $this->getMockBuilder(FilesIStorage::class)
-			->disableOriginalConstructor()->getMock();
-		$storage->expects($this->once())
-			->method('getCache')
-			->willReturn($cache);
-		$fileInfo = $this->getMockBuilder(FileInfo::class)
-			->disableOriginalConstructor()->getMock();
-		$fileInfo->expects($this->once())
-			->method('getStorage')
-			->willReturn($storage);
-		$fileInfo->expects($this->once())
-			->method('getId')
-			->willReturn(123);
-		$view->expects($this->once())
-			->method('getFileInfo')
-			->with('/admin/files/myfile.txt')
-			->willReturn($fileInfo);
-
-		/** @var View $view */
-		$this->instance->setVersion('/admin/files/myfile.txt', 5, $view);
-	}
-
-	public function testSetVersionWithoutFileInfo(): void {
-		$view = $this->getMockBuilder(View::class)
-			->disableOriginalConstructor()->getMock();
-		$view->expects($this->once())
-			->method('getFileInfo')
-			->with('/admin/files/myfile.txt')
-			->willReturn(false);
-
-		/** @var View $view */
-		$this->instance->setVersion('/admin/files/myfile.txt', 5, $view);
-	}
-
-	public function testBackupUserKeys(): void {
-		$this->keyStorageMock->expects($this->once())->method('backupUserKeys')
-			->with('OC_DEFAULT_MODULE', 'test', 'user1');
-		$this->instance->backupUserKeys('test', 'user1');
-	}
+    protected KeyManager $instance;
+
+    protected string $userId;
+    protected string $systemKeyId;
+    protected IStorage&MockObject $keyStorageMock;
+    protected Crypt&MockObject $cryptMock;
+    protected IUserSession&MockObject $userMock;
+    protected Session&MockObject $sessionMock;
+    protected LoggerInterface&MockObject $logMock;
+    protected Util&MockObject $utilMock;
+    protected IConfig&MockObject $configMock;
+    protected ILockingProvider&MockObject $lockingProviderMock;
+
+    protected function setUp(): void {
+        parent::setUp();
+        $this->userId = 'user1';
+        $this->systemKeyId = 'systemKeyId';
+        $this->keyStorageMock = $this->createMock(IStorage::class);
+        $this->cryptMock = $this->getMockBuilder(Crypt::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $this->configMock = $this->createMock(IConfig::class);
+        $this->configMock->expects($this->any())
+            ->method('getAppValue')
+            ->willReturn($this->systemKeyId);
+        $this->userMock = $this->createMock(IUserSession::class);
+        $this->sessionMock = $this->getMockBuilder(Session::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $this->logMock = $this->createMock(LoggerInterface::class);
+        $this->utilMock = $this->getMockBuilder(Util::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $this->lockingProviderMock = $this->createMock(ILockingProvider::class);
+
+        $this->instance = new KeyManager(
+            $this->keyStorageMock,
+            $this->cryptMock,
+            $this->configMock,
+            $this->userMock,
+            $this->sessionMock,
+            $this->logMock,
+            $this->utilMock,
+            $this->lockingProviderMock
+        );
+    }
+
+    public function testDeleteShareKey(): void {
+        $this->keyStorageMock->expects($this->any())
+            ->method('deleteFileKey')
+            ->with($this->equalTo('/path'), $this->equalTo('keyId.shareKey'))
+            ->willReturn(true);
+
+        $this->assertTrue(
+            $this->instance->deleteShareKey('/path', 'keyId')
+        );
+    }
+
+    public function testGetPrivateKey(): void {
+        $this->keyStorageMock->expects($this->any())
+            ->method('getUserKey')
+            ->with($this->equalTo($this->userId), $this->equalTo('privateKey'))
+            ->willReturn('privateKey');
+
+
+        $this->assertSame('privateKey',
+            $this->instance->getPrivateKey($this->userId)
+        );
+    }
+
+    public function testGetPublicKey(): void {
+        $this->keyStorageMock->expects($this->any())
+            ->method('getUserKey')
+            ->with($this->equalTo($this->userId), $this->equalTo('publicKey'))
+            ->willReturn('publicKey');
+
+
+        $this->assertSame('publicKey',
+            $this->instance->getPublicKey($this->userId)
+        );
+    }
+
+    public function testRecoveryKeyExists(): void {
+        $this->keyStorageMock->expects($this->any())
+            ->method('getSystemUserKey')
+            ->with($this->equalTo($this->systemKeyId . '.publicKey'))
+            ->willReturn('recoveryKey');
+
+
+        $this->assertTrue($this->instance->recoveryKeyExists());
+    }
+
+    public function testCheckRecoveryKeyPassword(): void {
+        $this->keyStorageMock->expects($this->any())
+            ->method('getSystemUserKey')
+            ->with($this->equalTo($this->systemKeyId . '.privateKey'))
+            ->willReturn('recoveryKey');
+        $this->cryptMock->expects($this->any())
+            ->method('decryptPrivateKey')
+            ->with($this->equalTo('recoveryKey'), $this->equalTo('pass'))
+            ->willReturn('decryptedRecoveryKey');
+
+        $this->assertTrue($this->instance->checkRecoveryPassword('pass'));
+    }
+
+    public function testSetPublicKey(): void {
+        $this->keyStorageMock->expects($this->any())
+            ->method('setUserKey')
+            ->with(
+                $this->equalTo($this->userId),
+                $this->equalTo('publicKey'),
+                $this->equalTo('key'))
+            ->willReturn(true);
+
+
+        $this->assertTrue(
+            $this->instance->setPublicKey($this->userId, 'key')
+        );
+    }
+
+    public function testSetPrivateKey(): void {
+        $this->keyStorageMock->expects($this->any())
+            ->method('setUserKey')
+            ->with(
+                $this->equalTo($this->userId),
+                $this->equalTo('privateKey'),
+                $this->equalTo('key'))
+            ->willReturn(true);
+
+
+        $this->assertTrue(
+            $this->instance->setPrivateKey($this->userId, 'key')
+        );
+    }
+
+    /**
+     * @dataProvider dataTestUserHasKeys
+     */
+    public function testUserHasKeys($key, $expected): void {
+        $this->keyStorageMock->expects($this->exactly(2))
+            ->method('getUserKey')
+            ->with($this->equalTo($this->userId), $this->anything())
+            ->willReturn($key);
+
+
+        $this->assertSame($expected,
+            $this->instance->userHasKeys($this->userId)
+        );
+    }
+
+    public static function dataTestUserHasKeys(): array {
+        return [
+            ['key', true],
+            ['', false]
+        ];
+    }
+
+
+    public function testUserHasKeysMissingPrivateKey(): void {
+        $this->expectException(PrivateKeyMissingException::class);
+
+        $this->keyStorageMock->expects($this->exactly(2))
+            ->method('getUserKey')
+            ->willReturnCallback(function ($uid, $keyID, $encryptionModuleId) {
+                if ($keyID === 'privateKey') {
+                    return '';
+                }
+                return 'key';
+            });
+
+        $this->instance->userHasKeys($this->userId);
+    }
+
+
+    public function testUserHasKeysMissingPublicKey(): void {
+        $this->expectException(PublicKeyMissingException::class);
+
+        $this->keyStorageMock->expects($this->exactly(2))
+            ->method('getUserKey')
+            ->willReturnCallback(function ($uid, $keyID, $encryptionModuleId) {
+                if ($keyID === 'publicKey') {
+                    return '';
+                }
+                return 'key';
+            });
+
+        $this->instance->userHasKeys($this->userId);
+    }
+
+    /**
+     * @dataProvider dataTestInit
+     *
+     * @param bool $useMasterKey
+     */
+    public function testInit($useMasterKey): void {
+        /** @var KeyManager&MockObject $instance */
+        $instance = $this->getMockBuilder(KeyManager::class)
+            ->setConstructorArgs(
+                [
+                    $this->keyStorageMock,
+                    $this->cryptMock,
+                    $this->configMock,
+                    $this->userMock,
+                    $this->sessionMock,
+                    $this->logMock,
+                    $this->utilMock,
+                    $this->lockingProviderMock
+                ]
+            )->onlyMethods(['getMasterKeyId', 'getMasterKeyPassword', 'getSystemPrivateKey', 'getPrivateKey'])
+            ->getMock();
+
+        $this->utilMock->expects($this->once())->method('isMasterKeyEnabled')
+            ->willReturn($useMasterKey);
+
+        $sessionSetStatusCalls = [];
+        $this->sessionMock->expects($this->exactly(2))
+            ->method('setStatus')
+            ->willReturnCallback(function (string $status) use (&$sessionSetStatusCalls) {
+                $sessionSetStatusCalls[] = $status;
+            });
+
+        $instance->expects($this->any())->method('getMasterKeyId')->willReturn('masterKeyId');
+        $instance->expects($this->any())->method('getMasterKeyPassword')->willReturn('masterKeyPassword');
+        $instance->expects($this->any())->method('getSystemPrivateKey')->with('masterKeyId')->willReturn('privateMasterKey');
+        $instance->expects($this->any())->method('getPrivateKey')->with($this->userId)->willReturn('privateUserKey');
+
+        if ($useMasterKey) {
+            $this->cryptMock->expects($this->once())->method('decryptPrivateKey')
+                ->with('privateMasterKey', 'masterKeyPassword', 'masterKeyId')
+                ->willReturn('key');
+        } else {
+            $this->cryptMock->expects($this->once())->method('decryptPrivateKey')
+                ->with('privateUserKey', 'pass', $this->userId)
+                ->willReturn('key');
+        }
+
+        $this->sessionMock->expects($this->once())->method('setPrivateKey')
+            ->with('key');
+
+        $this->assertTrue($instance->init($this->userId, 'pass'));
+        self::assertEquals([
+            Session::INIT_EXECUTED,
+            Session::INIT_SUCCESSFUL,
+        ], $sessionSetStatusCalls);
+    }
+
+    public static function dataTestInit(): array {
+        return [
+            [true],
+            [false]
+        ];
+    }
+
+
+    public function testSetRecoveryKey(): void {
+        $this->keyStorageMock->expects($this->exactly(2))
+            ->method('setSystemUserKey')
+            ->willReturn(true);
+        $this->cryptMock->expects($this->any())
+            ->method('encryptPrivateKey')
+            ->with($this->equalTo('privateKey'), $this->equalTo('pass'))
+            ->willReturn('decryptedPrivateKey');
+
+
+        $this->assertTrue(
+            $this->instance->setRecoveryKey('pass',
+                ['publicKey' => 'publicKey', 'privateKey' => 'privateKey'])
+        );
+    }
+
+    public function testSetSystemPrivateKey(): void {
+        $this->keyStorageMock->expects($this->exactly(1))
+            ->method('setSystemUserKey')
+            ->with($this->equalTo('keyId.privateKey'), $this->equalTo('key'))
+            ->willReturn(true);
+
+
+        $this->assertTrue(
+            $this->instance->setSystemPrivateKey('keyId', 'key')
+        );
+    }
+
+    public function testGetSystemPrivateKey(): void {
+        $this->keyStorageMock->expects($this->exactly(1))
+            ->method('getSystemUserKey')
+            ->with($this->equalTo('keyId.privateKey'))
+            ->willReturn('systemPrivateKey');
+
+
+        $this->assertSame('systemPrivateKey',
+            $this->instance->getSystemPrivateKey('keyId')
+        );
+    }
+
+    public function testGetEncryptedFileKey(): void {
+        $this->keyStorageMock->expects($this->once())
+            ->method('getFileKey')
+            ->with('/', 'fileKey')
+            ->willReturn(true);
+
+        $this->assertTrue($this->instance->getEncryptedFileKey('/'));
+    }
+
+    public static function dataTestGetFileKey(): array {
+        return [
+            ['user1', false, 'privateKey', 'legacyKey', 'multiKeyDecryptResult'],
+            ['user1', false, 'privateKey', '', 'multiKeyDecryptResult'],
+            ['user1', false, false, 'legacyKey', ''],
+            ['user1', false, false, '', ''],
+            ['user1', true, 'privateKey', 'legacyKey', 'multiKeyDecryptResult'],
+            ['user1', true, 'privateKey', '', 'multiKeyDecryptResult'],
+            ['user1', true, false, 'legacyKey', ''],
+            ['user1', true, false, '', ''],
+            [null, false, 'privateKey', 'legacyKey', 'multiKeyDecryptResult'],
+            [null, false, 'privateKey', '', 'multiKeyDecryptResult'],
+            [null, false, false, 'legacyKey', ''],
+            [null, false, false, '', ''],
+            [null, true, 'privateKey', 'legacyKey', 'multiKeyDecryptResult'],
+            [null, true, 'privateKey', '', 'multiKeyDecryptResult'],
+            [null, true, false, 'legacyKey', ''],
+            [null, true, false, '', ''],
+        ];
+    }
+
+    /**
+     * @dataProvider dataTestGetFileKey
+     *
+     * @param $uid
+     * @param $isMasterKeyEnabled
+     * @param $privateKey
+     * @param $expected
+     */
+    public function testGetFileKey($uid, $isMasterKeyEnabled, $privateKey, $encryptedFileKey, $expected): void {
+        $path = '/foo.txt';
+
+        if ($isMasterKeyEnabled) {
+            $expectedUid = 'masterKeyId';
+            $this->configMock->expects($this->any())->method('getSystemValue')->with('secret')
+                ->willReturn('password');
+        } elseif (!$uid) {
+            $expectedUid = 'systemKeyId';
+        } else {
+            $expectedUid = $uid;
+        }
+
+        $this->invokePrivate($this->instance, 'masterKeyId', ['masterKeyId']);
+
+        $this->keyStorageMock->expects($this->exactly(2))
+            ->method('getFileKey')
+            ->willReturnMap([
+                [$path, 'fileKey', 'OC_DEFAULT_MODULE', $encryptedFileKey],
+                [$path, $expectedUid . '.shareKey', 'OC_DEFAULT_MODULE', 'fileKey'],
+            ]);
+
+        $this->utilMock->expects($this->any())->method('isMasterKeyEnabled')
+            ->willReturn($isMasterKeyEnabled);
+
+        if (is_null($uid)) {
+            $this->keyStorageMock->expects($this->once())
+                ->method('getSystemUserKey')
+                ->willReturn(true);
+            $this->cryptMock->expects($this->once())
+                ->method('decryptPrivateKey')
+                ->willReturn($privateKey);
+        } else {
+            $this->keyStorageMock->expects($this->never())
+                ->method('getSystemUserKey');
+            $this->sessionMock->expects($this->once())->method('getPrivateKey')->willReturn($privateKey);
+        }
+
+        if (!empty($encryptedFileKey)) {
+            $this->cryptMock->expects($this->never())
+                ->method('multiKeyDecrypt');
+            if ($privateKey) {
+                $this->cryptMock->expects($this->once())
+                    ->method('multiKeyDecryptLegacy')
+                    ->willReturn('multiKeyDecryptResult');
+            } else {
+                $this->cryptMock->expects($this->never())
+                    ->method('multiKeyDecryptLegacy');
+            }
+        } else {
+            $this->cryptMock->expects($this->never())
+                ->method('multiKeyDecryptLegacy');
+            if ($privateKey) {
+                $this->cryptMock->expects($this->once())
+                    ->method('multiKeyDecrypt')
+                    ->willReturn('multiKeyDecryptResult');
+            } else {
+                $this->cryptMock->expects($this->never())
+                    ->method('multiKeyDecrypt');
+            }
+        }
+
+        $this->assertSame($expected,
+            $this->instance->getFileKey($path, $uid, null)
+        );
+    }
+
+    public function testDeletePrivateKey(): void {
+        $this->keyStorageMock->expects($this->once())
+            ->method('deleteUserKey')
+            ->with('user1', 'privateKey')
+            ->willReturn(true);
+
+        $this->assertTrue(self::invokePrivate($this->instance,
+            'deletePrivateKey',
+            [$this->userId]));
+    }
+
+    public function testDeleteAllFileKeys(): void {
+        $this->keyStorageMock->expects($this->once())
+            ->method('deleteAllFileKeys')
+            ->willReturn(true);
+
+        $this->assertTrue($this->instance->deleteAllFileKeys('/'));
+    }
+
+    /**
+     * test add public share key and or recovery key to the list of public keys
+     *
+     * @dataProvider dataTestAddSystemKeys
+     *
+     * @param array $accessList
+     * @param array $publicKeys
+     * @param string $uid
+     * @param array $expectedKeys
+     */
+    public function testAddSystemKeys($accessList, $publicKeys, $uid, $expectedKeys): void {
+        $publicShareKeyId = 'publicShareKey';
+        $recoveryKeyId = 'recoveryKey';
+
+        $this->keyStorageMock->expects($this->any())
+            ->method('getSystemUserKey')
+            ->willReturnCallback(function ($keyId, $encryptionModuleId) {
+                return $keyId;
+            });
+
+        $this->utilMock->expects($this->any())
+            ->method('isRecoveryEnabledForUser')
+            ->willReturnCallback(function ($uid) {
+                if ($uid === 'user1') {
+                    return true;
+                }
+                return false;
+            });
+
+        // set key IDs
+        self::invokePrivate($this->instance, 'publicShareKeyId', [$publicShareKeyId]);
+        self::invokePrivate($this->instance, 'recoveryKeyId', [$recoveryKeyId]);
+
+        $result = $this->instance->addSystemKeys($accessList, $publicKeys, $uid);
+
+        foreach ($expectedKeys as $expected) {
+            $this->assertArrayHasKey($expected, $result);
+        }
+
+        $this->assertSameSize($expectedKeys, $result);
+    }
+
+    /**
+     * data provider for testAddSystemKeys()
+     *
+     * @return array
+     */
+    public static function dataTestAddSystemKeys(): array {
+        return [
+            [['public' => true],[], 'user1', ['publicShareKey', 'recoveryKey']],
+            [['public' => false], [], 'user1', ['recoveryKey']],
+            [['public' => true],[], 'user2', ['publicShareKey']],
+            [['public' => false], [], 'user2', []],
+        ];
+    }
+
+    public function testGetMasterKeyId(): void {
+        $this->assertSame('systemKeyId', $this->instance->getMasterKeyId());
+    }
+
+    public function testGetPublicMasterKey(): void {
+        $this->keyStorageMock->expects($this->once())->method('getSystemUserKey')
+            ->with('systemKeyId.publicKey', Encryption::ID)
+            ->willReturn(true);
+
+        $this->assertTrue(
+            $this->instance->getPublicMasterKey()
+        );
+    }
+
+    public function testGetMasterKeyPassword(): void {
+        $this->configMock->expects($this->once())->method('getSystemValue')->with('secret')
+            ->willReturn('password');
+
+        $this->assertSame('password',
+            $this->invokePrivate($this->instance, 'getMasterKeyPassword', [])
+        );
+    }
+
+
+    public function testGetMasterKeyPasswordException(): void {
+        $this->expectException(\Exception::class);
+
+        $this->configMock->expects($this->once())->method('getSystemValue')->with('secret')
+            ->willReturn('');
+
+        $this->invokePrivate($this->instance, 'getMasterKeyPassword', []);
+    }
+
+    /**
+     * @dataProvider dataTestValidateMasterKey
+     *
+     * @param $masterKey
+     */
+    public function testValidateMasterKey($masterKey): void {
+        /** @var KeyManager&MockObject $instance */
+        $instance = $this->getMockBuilder(KeyManager::class)
+            ->setConstructorArgs(
+                [
+                    $this->keyStorageMock,
+                    $this->cryptMock,
+                    $this->configMock,
+                    $this->userMock,
+                    $this->sessionMock,
+                    $this->logMock,
+                    $this->utilMock,
+                    $this->lockingProviderMock
+                ]
+            )->onlyMethods(['getPublicMasterKey', 'setSystemPrivateKey', 'getMasterKeyPassword'])
+            ->getMock();
+
+        $this->utilMock->expects($this->once())->method('isMasterKeyEnabled')
+            ->willReturn(true);
+
+        $instance->expects($this->once())->method('getPublicMasterKey')
+            ->willReturn($masterKey);
+
+        $instance->expects($this->any())->method('getMasterKeyPassword')->willReturn('masterKeyPassword');
+        $this->cryptMock->expects($this->any())->method('generateHeader')->willReturn('header');
+
+        if (empty($masterKey)) {
+            $this->cryptMock->expects($this->once())->method('createKeyPair')
+                ->willReturn(['publicKey' => 'public', 'privateKey' => 'private']);
+            $this->keyStorageMock->expects($this->once())->method('setSystemUserKey')
+                ->with('systemKeyId.publicKey', 'public', Encryption::ID);
+            $this->cryptMock->expects($this->once())->method('encryptPrivateKey')
+                ->with('private', 'masterKeyPassword', 'systemKeyId')
+                ->willReturn('EncryptedKey');
+            $this->lockingProviderMock->expects($this->once())
+                ->method('acquireLock');
+            $instance->expects($this->once())->method('setSystemPrivateKey')
+                ->with('systemKeyId', 'headerEncryptedKey');
+        } else {
+            $this->cryptMock->expects($this->never())->method('createKeyPair');
+            $this->keyStorageMock->expects($this->never())->method('setSystemUserKey');
+            $this->cryptMock->expects($this->never())->method('encryptPrivateKey');
+            $instance->expects($this->never())->method('setSystemPrivateKey');
+        }
+
+        $instance->validateMasterKey();
+    }
+
+    public function testValidateMasterKeyLocked(): void {
+        /** @var KeyManager&MockObject $instance */
+        $instance = $this->getMockBuilder(KeyManager::class)
+            ->setConstructorArgs([
+                $this->keyStorageMock,
+                $this->cryptMock,
+                $this->configMock,
+                $this->userMock,
+                $this->sessionMock,
+                $this->logMock,
+                $this->utilMock,
+                $this->lockingProviderMock
+            ])
+            ->onlyMethods(['getPublicMasterKey', 'getPrivateMasterKey', 'setSystemPrivateKey', 'getMasterKeyPassword'])
+            ->getMock();
+
+        $this->utilMock->expects($this->once())->method('isMasterKeyEnabled')
+            ->willReturn(true);
+
+        $instance->expects($this->once())->method('getPublicMasterKey')
+            ->willReturn('');
+        $instance->expects($this->once())->method('getPrivateMasterKey')
+            ->willReturn('');
+
+        $instance->expects($this->any())->method('getMasterKeyPassword')->willReturn('masterKeyPassword');
+        $this->cryptMock->expects($this->any())->method('generateHeader')->willReturn('header');
+
+        $this->lockingProviderMock->expects($this->once())
+            ->method('acquireLock')
+            ->willThrowException(new LockedException('encryption-generateMasterKey'));
+
+        $this->expectException(LockedException::class);
+        $instance->validateMasterKey();
+    }
+
+    public static function dataTestValidateMasterKey(): array {
+        return [
+            ['masterKey'],
+            ['']
+        ];
+    }
+
+    public function testGetVersionWithoutFileInfo(): void {
+        $view = $this->getMockBuilder(View::class)
+            ->disableOriginalConstructor()->getMock();
+        $view->expects($this->once())
+            ->method('getFileInfo')
+            ->with('/admin/files/myfile.txt')
+            ->willReturn(false);
+
+        /** @var View $view */
+        $this->assertSame(0, $this->instance->getVersion('/admin/files/myfile.txt', $view));
+    }
+
+    public function testGetVersionWithFileInfo(): void {
+        $view = $this->getMockBuilder(View::class)
+            ->disableOriginalConstructor()->getMock();
+        $fileInfo = $this->getMockBuilder(FileInfo::class)
+            ->disableOriginalConstructor()->getMock();
+        $fileInfo->expects($this->once())
+            ->method('getEncryptedVersion')
+            ->willReturn(1337);
+        $view->expects($this->once())
+            ->method('getFileInfo')
+            ->with('/admin/files/myfile.txt')
+            ->willReturn($fileInfo);
+
+        /** @var View $view */
+        $this->assertSame(1337, $this->instance->getVersion('/admin/files/myfile.txt', $view));
+    }
+
+    public function testSetVersionWithFileInfo(): void {
+        $view = $this->getMockBuilder(View::class)
+            ->disableOriginalConstructor()->getMock();
+        $cache = $this->getMockBuilder(ICache::class)
+            ->disableOriginalConstructor()->getMock();
+        $cache->expects($this->once())
+            ->method('update')
+            ->with(123, ['encrypted' => 5, 'encryptedVersion' => 5]);
+        $storage = $this->getMockBuilder(FilesIStorage::class)
+            ->disableOriginalConstructor()->getMock();
+        $storage->expects($this->once())
+            ->method('getCache')
+            ->willReturn($cache);
+        $fileInfo = $this->getMockBuilder(FileInfo::class)
+            ->disableOriginalConstructor()->getMock();
+        $fileInfo->expects($this->once())
+            ->method('getStorage')
+            ->willReturn($storage);
+        $fileInfo->expects($this->once())
+            ->method('getId')
+            ->willReturn(123);
+        $view->expects($this->once())
+            ->method('getFileInfo')
+            ->with('/admin/files/myfile.txt')
+            ->willReturn($fileInfo);
+
+        /** @var View $view */
+        $this->instance->setVersion('/admin/files/myfile.txt', 5, $view);
+    }
+
+    public function testSetVersionWithoutFileInfo(): void {
+        $view = $this->getMockBuilder(View::class)
+            ->disableOriginalConstructor()->getMock();
+        $view->expects($this->once())
+            ->method('getFileInfo')
+            ->with('/admin/files/myfile.txt')
+            ->willReturn(false);
+
+        /** @var View $view */
+        $this->instance->setVersion('/admin/files/myfile.txt', 5, $view);
+    }
+
+    public function testBackupUserKeys(): void {
+        $this->keyStorageMock->expects($this->once())->method('backupUserKeys')
+            ->with('OC_DEFAULT_MODULE', 'test', 'user1');
+        $this->instance->backupUserKeys('test', 'user1');
+    }
 }

tests/lib/Files/FilenameValidatorTest.php

Indentation +482 added lines, -482 removed lines

@@ -26,486 +26,486 @@
 
 class FilenameValidatorTest extends TestCase {
 
-	protected IFactory&MockObject $l10n;
-	protected IConfig&MockObject $config;
-	protected IDBConnection&MockObject $database;
-	protected LoggerInterface&MockObject $logger;
-
-	protected function setUp(): void {
-		parent::setUp();
-		$l10n = $this->createMock(IL10N::class);
-		$l10n->method('t')
-			->willReturnCallback(fn ($string, $params) => sprintf($string, ...$params));
-		$this->l10n = $this->createMock(IFactory::class);
-		$this->l10n
-			->method('get')
-			->with('core')
-			->willReturn($l10n);
-
-		$this->config = $this->createMock(IConfig::class);
-		$this->logger = $this->createMock(LoggerInterface::class);
-		$this->database = $this->createMock(IDBConnection::class);
-		$this->database->method('supports4ByteText')->willReturn(true);
-	}
-
-	/**
-	 * @dataProvider dataValidateFilename
-	 */
-	public function testValidateFilename(
-		string $filename,
-		array $forbiddenNames,
-		array $forbiddenBasenames,
-		array $forbiddenExtensions,
-		array $forbiddenCharacters,
-		?string $exception,
-	): void {
-		/** @var FilenameValidator&MockObject */
-		$validator = $this->getMockBuilder(FilenameValidator::class)
-			->onlyMethods([
-				'getForbiddenBasenames',
-				'getForbiddenCharacters',
-				'getForbiddenExtensions',
-				'getForbiddenFilenames',
-			])
-			->setConstructorArgs([$this->l10n, $this->database, $this->config, $this->logger])
-			->getMock();
-
-		$validator->method('getForbiddenBasenames')
-			->willReturn($forbiddenBasenames);
-		$validator->method('getForbiddenCharacters')
-			->willReturn($forbiddenCharacters);
-		$validator->method('getForbiddenExtensions')
-			->willReturn($forbiddenExtensions);
-		$validator->method('getForbiddenFilenames')
-			->willReturn($forbiddenNames);
-
-		if ($exception !== null) {
-			$this->expectException($exception);
-		} else {
-			$this->expectNotToPerformAssertions();
-		}
-		$validator->validateFilename($filename);
-	}
-
-	/**
-	 * @dataProvider dataValidateFilename
-	 */
-	public function testIsFilenameValid(
-		string $filename,
-		array $forbiddenNames,
-		array $forbiddenBasenames,
-		array $forbiddenExtensions,
-		array $forbiddenCharacters,
-		?string $exception,
-	): void {
-		/** @var FilenameValidator&MockObject */
-		$validator = $this->getMockBuilder(FilenameValidator::class)
-			->onlyMethods([
-				'getForbiddenBasenames',
-				'getForbiddenExtensions',
-				'getForbiddenFilenames',
-				'getForbiddenCharacters',
-			])
-			->setConstructorArgs([$this->l10n, $this->database, $this->config, $this->logger])
-			->getMock();
-
-		$validator->method('getForbiddenBasenames')
-			->willReturn($forbiddenBasenames);
-		$validator->method('getForbiddenCharacters')
-			->willReturn($forbiddenCharacters);
-		$validator->method('getForbiddenExtensions')
-			->willReturn($forbiddenExtensions);
-		$validator->method('getForbiddenFilenames')
-			->willReturn($forbiddenNames);
-
-
-		$this->assertEquals($exception === null, $validator->isFilenameValid($filename));
-	}
-
-	public static function dataValidateFilename(): array {
-		return [
-			'valid name' => [
-				'a: b.txt', ['.htaccess'], [], [], [], null
-			],
-			'forbidden name in the middle is ok' => [
-				'a.htaccess.txt', ['.htaccess'], [], [], [], null
-			],
-			'valid name with some more parameters' => [
-				'a: b.txt', ['.htaccess'], [], ['exe'], ['~'], null
-			],
-			'valid name checks only the full name' => [
-				'.htaccess.sample', ['.htaccess'], [], [], [], null
-			],
-			'forbidden name' => [
-				'.htaccess', ['.htaccess'], [], [], [], ReservedWordException::class
-			],
-			'forbidden name - name is case insensitive' => [
-				'COM1', ['.htaccess', 'com1'], [], [], [], ReservedWordException::class
-			],
-			'forbidden basename' => [
-				// needed for Windows namespaces
-				'com1.suffix', ['.htaccess'], ['com1'], [], [], ReservedWordException::class
-			],
-			'forbidden basename case insensitive' => [
-				// needed for Windows namespaces
-				'COM1.suffix', ['.htaccess'], ['com1'], [], [], ReservedWordException::class
-			],
-			'forbidden basename for hidden files' => [
-				// needed for Windows namespaces
-				'.thumbs.db', ['.htaccess'], ['.thumbs'], [], [], ReservedWordException::class
-			],
-			'invalid character' => [
-				'a: b.txt', ['.htaccess'], [], [], [':'], InvalidCharacterInPathException::class
-			],
-			'invalid path' => [
-				'../../foo.bar', ['.htaccess'], [], [], ['/', '\\'], InvalidCharacterInPathException::class,
-			],
-			'invalid extension' => [
-				'a: b.txt', ['.htaccess'], [], ['.txt'], [], InvalidPathException::class
-			],
-			'invalid extension case insensitive' => [
-				'a: b.TXT', ['.htaccess'], [], ['.txt'], [], InvalidPathException::class
-			],
-			'empty filename' => [
-				'', [], [], [], [], EmptyFileNameException::class
-			],
-			'reserved unix name "."' => [
-				'.', [], [], [], [], InvalidDirectoryException::class
-			],
-			'reserved unix name ".."' => [
-				'..', [], [], [], [], InvalidDirectoryException::class
-			],
-			'weird but valid tripple dot name' => [
-				'...', [], [], [], [], null // is valid
-			],
-			'too long filename "."' => [
-				str_repeat('a', 251), [], [], [], [], FileNameTooLongException::class
-			],
-			// make sure to not split the list entries as they migh contain Unicode sequences
-			// in this example the "face in clouds" emoji contains the clouds emoji so only having clouds is ok
-			['

tests/lib/App/AppManagerTest.php

Indentation +851 added lines, -851 removed lines

@@ -36,856 +36,856 @@
  * @package Test\App
  */
 class AppManagerTest extends TestCase {
-	/**
-	 * @return AppConfig|MockObject
-	 */
-	protected function getAppConfig() {
-		$appConfig = [];
-		$config = $this->createMock(AppConfig::class);
-
-		$config->expects($this->any())
-			->method('getValue')
-			->willReturnCallback(function ($app, $key, $default) use (&$appConfig) {
-				return (isset($appConfig[$app]) and isset($appConfig[$app][$key])) ? $appConfig[$app][$key] : $default;
-			});
-		$config->expects($this->any())
-			->method('setValue')
-			->willReturnCallback(function ($app, $key, $value) use (&$appConfig) {
-				if (!isset($appConfig[$app])) {
-					$appConfig[$app] = [];
-				}
-				$appConfig[$app][$key] = $value;
-			});
-		$config->expects($this->any())
-			->method('getValues')
-			->willReturnCallback(function ($app, $key) use (&$appConfig) {
-				if ($app) {
-					return $appConfig[$app];
-				} else {
-					$values = [];
-					foreach ($appConfig as $appid => $appData) {
-						if (isset($appData[$key])) {
-							$values[$appid] = $appData[$key];
-						}
-					}
-					return $values;
-				}
-			});
-
-		return $config;
-	}
-
-	/** @var IUserSession|MockObject */
-	protected $userSession;
-
-	/** @var IConfig|MockObject */
-	private $config;
-
-	/** @var IGroupManager|MockObject */
-	protected $groupManager;
-
-	/** @var AppConfig|MockObject */
-	protected $appConfig;
-
-	/** @var ICache|MockObject */
-	protected $cache;
-
-	/** @var ICacheFactory|MockObject */
-	protected $cacheFactory;
-
-	/** @var IEventDispatcher|MockObject */
-	protected $eventDispatcher;
-
-	/** @var LoggerInterface|MockObject */
-	protected $logger;
-
-	protected IURLGenerator&MockObject $urlGenerator;
-
-	protected ServerVersion&MockObject $serverVersion;
-
-	/** @var IAppManager */
-	protected $manager;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->userSession = $this->createMock(IUserSession::class);
-		$this->groupManager = $this->createMock(IGroupManager::class);
-		$this->config = $this->createMock(IConfig::class);
-		$this->appConfig = $this->getAppConfig();
-		$this->cacheFactory = $this->createMock(ICacheFactory::class);
-		$this->cache = $this->createMock(ICache::class);
-		$this->eventDispatcher = $this->createMock(IEventDispatcher::class);
-		$this->logger = $this->createMock(LoggerInterface::class);
-		$this->urlGenerator = $this->createMock(IURLGenerator::class);
-		$this->serverVersion = $this->createMock(ServerVersion::class);
-
-		$this->overwriteService(AppConfig::class, $this->appConfig);
-		$this->overwriteService(IURLGenerator::class, $this->urlGenerator);
-
-		$this->cacheFactory->expects($this->any())
-			->method('createDistributed')
-			->with('settings')
-			->willReturn($this->cache);
-
-		$this->config
-			->method('getSystemValueBool')
-			->with('installed', false)
-			->willReturn(true);
-
-		$this->manager = new AppManager(
-			$this->userSession,
-			$this->config,
-			$this->groupManager,
-			$this->cacheFactory,
-			$this->eventDispatcher,
-			$this->logger,
-			$this->serverVersion,
-		);
-	}
-
-	/**
-	 * @dataProvider dataGetAppIcon
-	 */
-	public function testGetAppIcon($callback, ?bool $dark, ?string $expected): void {
-		$this->urlGenerator->expects($this->atLeastOnce())
-			->method('imagePath')
-			->willReturnCallback($callback);
-
-		if ($dark !== null) {
-			$this->assertEquals($expected, $this->manager->getAppIcon('test', $dark));
-		} else {
-			$this->assertEquals($expected, $this->manager->getAppIcon('test'));
-		}
-	}
-
-	public static function dataGetAppIcon(): array {
-		$nothing = function ($appId) {
-			self::assertEquals('test', $appId);
-			throw new \RuntimeException();
-		};
-
-		$createCallback = function ($workingIcons) {
-			return function ($appId, $icon) use ($workingIcons) {
-				self::assertEquals('test', $appId);
-				if (in_array($icon, $workingIcons)) {
-					return '/path/' . $icon;
-				}
-				throw new \RuntimeException();
-			};
-		};
-
-		return [
-			'does not find anything' => [
-				$nothing,
-				false,
-				null,
-			],
-			'nothing if request dark but only bright available' => [
-				$createCallback(['app.svg']),
-				true,
-				null,
-			],
-			'nothing if request bright but only dark available' => [
-				$createCallback(['app-dark.svg']),
-				false,
-				null,
-			],
-			'bright and only app.svg' => [
-				$createCallback(['app.svg']),
-				false,
-				'/path/app.svg',
-			],
-			'dark and only app-dark.svg' => [
-				$createCallback(['app-dark.svg']),
-				true,
-				'/path/app-dark.svg',
-			],
-			'dark only appname -dark.svg' => [
-				$createCallback(['test-dark.svg']),
-				true,
-				'/path/test-dark.svg',
-			],
-			'bright and only appname.svg' => [
-				$createCallback(['test.svg']),
-				false,
-				'/path/test.svg',
-			],
-			'priotize custom over default' => [
-				$createCallback(['app.svg', 'test.svg']),
-				false,
-				'/path/test.svg',
-			],
-			'defaults to bright' => [
-				$createCallback(['test-dark.svg', 'test.svg']),
-				null,
-				'/path/test.svg',
-			],
-			'no dark icon on default' => [
-				$createCallback(['test-dark.svg', 'test.svg', 'app-dark.svg', 'app.svg']),
-				false,
-				'/path/test.svg',
-			],
-			'no bright icon on dark' => [
-				$createCallback(['test-dark.svg', 'test.svg', 'app-dark.svg', 'app.svg']),
-				true,
-				'/path/test-dark.svg',
-			],
-		];
-	}
-
-	public function testEnableApp(): void {
-		// making sure "files_trashbin" is disabled
-		if ($this->manager->isEnabledForUser('files_trashbin')) {
-			$this->manager->disableApp('files_trashbin');
-		}
-		$this->eventDispatcher->expects($this->once())->method('dispatchTyped')->with(new AppEnableEvent('files_trashbin'));
-		$this->manager->enableApp('files_trashbin');
-		$this->assertEquals('yes', $this->appConfig->getValue('files_trashbin', 'enabled', 'no'));
-	}
-
-	public function testDisableApp(): void {
-		$this->eventDispatcher->expects($this->once())->method('dispatchTyped')->with(new AppDisableEvent('files_trashbin'));
-		$this->manager->disableApp('files_trashbin');
-		$this->assertEquals('no', $this->appConfig->getValue('files_trashbin', 'enabled', 'no'));
-	}
-
-	public function testNotEnableIfNotInstalled(): void {
-		try {
-			$this->manager->enableApp('some_random_name_which_i_hope_is_not_an_app');
-			$this->assertFalse(true, 'If this line is reached the expected exception is not thrown.');
-		} catch (AppPathNotFoundException $e) {
-			// Exception is expected
-			$this->assertEquals('Could not find path for some_random_name_which_i_hope_is_not_an_app', $e->getMessage());
-		}
-
-		$this->assertEquals('no', $this->appConfig->getValue(
-			'some_random_name_which_i_hope_is_not_an_app', 'enabled', 'no'
-		));
-	}
-
-	public function testEnableAppForGroups(): void {
-		$group1 = $this->createMock(IGroup::class);
-		$group1->method('getGID')
-			->willReturn('group1');
-		$group2 = $this->createMock(IGroup::class);
-		$group2->method('getGID')
-			->willReturn('group2');
-
-		$groups = [$group1, $group2];
-
-		/** @var AppManager|MockObject $manager */
-		$manager = $this->getMockBuilder(AppManager::class)
-			->setConstructorArgs([
-				$this->userSession,
-				$this->config,
-				$this->groupManager,
-				$this->cacheFactory,
-				$this->eventDispatcher,
-				$this->logger,
-				$this->serverVersion,
-			])
-			->onlyMethods([
-				'getAppPath',
-			])
-			->getMock();
-
-		$manager->expects($this->exactly(2))
-			->method('getAppPath')
-			->with('test')
-			->willReturn('apps/test');
-
-		$this->eventDispatcher->expects($this->once())->method('dispatchTyped')->with(new AppEnableEvent('test', ['group1', 'group2']));
-
-		$manager->enableAppForGroups('test', $groups);
-		$this->assertEquals('["group1","group2"]', $this->appConfig->getValue('test', 'enabled', 'no'));
-	}
-
-	public static function dataEnableAppForGroupsAllowedTypes(): array {
-		return [
-			[[]],
-			[[
-				'types' => [],
-			]],
-			[[
-				'types' => ['nickvergessen'],
-			]],
-		];
-	}
-
-	/**
-	 * @dataProvider dataEnableAppForGroupsAllowedTypes
-	 *
-	 * @param array $appInfo
-	 */
-	public function testEnableAppForGroupsAllowedTypes(array $appInfo): void {
-		$group1 = $this->createMock(IGroup::class);
-		$group1->method('getGID')
-			->willReturn('group1');
-		$group2 = $this->createMock(IGroup::class);
-		$group2->method('getGID')
-			->willReturn('group2');
-
-		$groups = [$group1, $group2];
-
-		/** @var AppManager|MockObject $manager */
-		$manager = $this->getMockBuilder(AppManager::class)
-			->setConstructorArgs([
-				$this->userSession,
-				$this->config,
-				$this->groupManager,
-				$this->cacheFactory,
-				$this->eventDispatcher,
-				$this->logger,
-				$this->serverVersion,
-			])
-			->onlyMethods([
-				'getAppPath',
-				'getAppInfo',
-			])
-			->getMock();
-
-		$manager->expects($this->once())
-			->method('getAppPath')
-			->with('test')
-			->willReturn('');
-
-		$manager->expects($this->once())
-			->method('getAppInfo')
-			->with('test')
-			->willReturn($appInfo);
-
-		$this->eventDispatcher->expects($this->once())->method('dispatchTyped')->with(new AppEnableEvent('test', ['group1', 'group2']));
-
-		$manager->enableAppForGroups('test', $groups);
-		$this->assertEquals('["group1","group2"]', $this->appConfig->getValue('test', 'enabled', 'no'));
-	}
-
-	public static function dataEnableAppForGroupsForbiddenTypes(): array {
-		return [
-			['filesystem'],
-			['prelogin'],
-			['authentication'],
-			['logging'],
-			['prevent_group_restriction'],
-		];
-	}
-
-	/**
-	 * @dataProvider dataEnableAppForGroupsForbiddenTypes
-	 *
-	 * @param string $type
-	 *
-	 */
-	public function testEnableAppForGroupsForbiddenTypes($type): void {
-		$this->expectException(\Exception::class);
-		$this->expectExceptionMessage('test can\'t be enabled for groups.');
-
-		$group1 = $this->createMock(IGroup::class);
-		$group1->method('getGID')
-			->willReturn('group1');
-		$group2 = $this->createMock(IGroup::class);
-		$group2->method('getGID')
-			->willReturn('group2');
-
-		$groups = [$group1, $group2];
-
-		/** @var AppManager|MockObject $manager */
-		$manager = $this->getMockBuilder(AppManager::class)
-			->setConstructorArgs([
-				$this->userSession,
-				$this->config,
-				$this->groupManager,
-				$this->cacheFactory,
-				$this->eventDispatcher,
-				$this->logger,
-				$this->serverVersion,
-			])
-			->onlyMethods([
-				'getAppPath',
-				'getAppInfo',
-			])
-			->getMock();
-
-		$manager->expects($this->once())
-			->method('getAppPath')
-			->with('test')
-			->willReturn('');
-
-		$manager->expects($this->once())
-			->method('getAppInfo')
-			->with('test')
-			->willReturn([
-				'types' => [$type],
-			]);
-
-		$this->eventDispatcher->expects($this->never())->method('dispatchTyped')->with(new AppEnableEvent('test', ['group1', 'group2']));
-
-		$manager->enableAppForGroups('test', $groups);
-	}
-
-	public function testIsInstalledEnabled(): void {
-		$this->appConfig->setValue('test', 'enabled', 'yes');
-		$this->assertTrue($this->manager->isEnabledForAnyone('test'));
-	}
-
-	public function testIsInstalledDisabled(): void {
-		$this->appConfig->setValue('test', 'enabled', 'no');
-		$this->assertFalse($this->manager->isEnabledForAnyone('test'));
-	}
-
-	public function testIsInstalledEnabledForGroups(): void {
-		$this->appConfig->setValue('test', 'enabled', '["foo"]');
-		$this->assertTrue($this->manager->isEnabledForAnyone('test'));
-	}
-
-	private function newUser($uid) {
-		$user = $this->createMock(IUser::class);
-		$user->method('getUID')
-			->willReturn($uid);
-
-		return $user;
-	}
-
-	public function testIsEnabledForUserEnabled(): void {
-		$this->appConfig->setValue('test', 'enabled', 'yes');
-		$user = $this->newUser('user1');
-		$this->assertTrue($this->manager->isEnabledForUser('test', $user));
-	}
-
-	public function testIsEnabledForUserDisabled(): void {
-		$this->appConfig->setValue('test', 'enabled', 'no');
-		$user = $this->newUser('user1');
-		$this->assertFalse($this->manager->isEnabledForUser('test', $user));
-	}
-
-	public function testGetAppPath(): void {
-		$this->assertEquals(\OC::$SERVERROOT . '/apps/files', $this->manager->getAppPath('files'));
-	}
-
-	public function testGetAppPathSymlink(): void {
-		$fakeAppDirname = sha1(uniqid('test', true));
-		$fakeAppPath = sys_get_temp_dir() . '/' . $fakeAppDirname;
-		$fakeAppLink = \OC::$SERVERROOT . '/' . $fakeAppDirname;
-
-		mkdir($fakeAppPath);
-		if (symlink($fakeAppPath, $fakeAppLink) === false) {
-			$this->markTestSkipped('Failed to create symlink');
-		}
-
-		// Use the symlink as the app path
-		\OC::$APPSROOTS[] = [
-			'path' => $fakeAppLink,
-			'url' => \OC::$WEBROOT . '/' . $fakeAppDirname,
-			'writable' => false,
-		];
-
-		$fakeTestAppPath = $fakeAppPath . '/' . 'test-test-app';
-		mkdir($fakeTestAppPath);
-
-		$generatedAppPath = $this->manager->getAppPath('test-test-app');
-
-		rmdir($fakeTestAppPath);
-		unlink($fakeAppLink);
-		rmdir($fakeAppPath);
-
-		$this->assertEquals($fakeAppLink . '/test-test-app', $generatedAppPath);
-	}
-
-	public function testGetAppPathFail(): void {
-		$this->expectException(AppPathNotFoundException::class);
-		$this->manager->getAppPath('testnotexisting');
-	}
-
-	public function testIsEnabledForUserEnabledForGroup(): void {
-		$user = $this->newUser('user1');
-		$this->groupManager->expects($this->once())
-			->method('getUserGroupIds')
-			->with($user)
-			->willReturn(['foo', 'bar']);
-
-		$this->appConfig->setValue('test', 'enabled', '["foo"]');
-		$this->assertTrue($this->manager->isEnabledForUser('test', $user));
-	}
-
-	public function testIsEnabledForUserDisabledForGroup(): void {
-		$user = $this->newUser('user1');
-		$this->groupManager->expects($this->once())
-			->method('getUserGroupIds')
-			->with($user)
-			->willReturn(['bar']);
-
-		$this->appConfig->setValue('test', 'enabled', '["foo"]');
-		$this->assertFalse($this->manager->isEnabledForUser('test', $user));
-	}
-
-	public function testIsEnabledForUserLoggedOut(): void {
-		$this->appConfig->setValue('test', 'enabled', '["foo"]');
-		$this->assertFalse($this->manager->isEnabledForUser('test'));
-	}
-
-	public function testIsEnabledForUserLoggedIn(): void {
-		$user = $this->newUser('user1');
-
-		$this->userSession->expects($this->once())
-			->method('getUser')
-			->willReturn($user);
-		$this->groupManager->expects($this->once())
-			->method('getUserGroupIds')
-			->with($user)
-			->willReturn(['foo', 'bar']);
-
-		$this->appConfig->setValue('test', 'enabled', '["foo"]');
-		$this->assertTrue($this->manager->isEnabledForUser('test'));
-	}
-
-	public function testGetEnabledApps(): void {
-		$this->appConfig->setValue('test1', 'enabled', 'yes');
-		$this->appConfig->setValue('test2', 'enabled', 'no');
-		$this->appConfig->setValue('test3', 'enabled', '["foo"]');
-		$apps = [
-			'cloud_federation_api',
-			'dav',
-			'federatedfilesharing',
-			'files',
-			'lookup_server_connector',
-			'oauth2',
-			'profile',
-			'provisioning_api',
-			'settings',
-			'test1',
-			'test3',
-			'theming',
-			'twofactor_backupcodes',
-			'viewer',
-			'workflowengine',
-		];
-		$this->assertEquals($apps, $this->manager->getEnabledApps());
-	}
-
-	public function testGetAppsForUser(): void {
-		$user = $this->newUser('user1');
-		$this->groupManager->expects($this->any())
-			->method('getUserGroupIds')
-			->with($user)
-			->willReturn(['foo', 'bar']);
-
-		$this->appConfig->setValue('test1', 'enabled', 'yes');
-		$this->appConfig->setValue('test2', 'enabled', 'no');
-		$this->appConfig->setValue('test3', 'enabled', '["foo"]');
-		$this->appConfig->setValue('test4', 'enabled', '["asd"]');
-		$enabled = [
-			'cloud_federation_api',
-			'dav',
-			'federatedfilesharing',
-			'files',
-			'lookup_server_connector',
-			'oauth2',
-			'profile',
-			'provisioning_api',
-			'settings',
-			'test1',
-			'test3',
-			'theming',
-			'twofactor_backupcodes',
-			'viewer',
-			'workflowengine',
-		];
-		$this->assertEquals($enabled, $this->manager->getEnabledAppsForUser($user));
-	}
-
-	public function testGetAppsNeedingUpgrade(): void {
-		/** @var AppManager|MockObject $manager */
-		$manager = $this->getMockBuilder(AppManager::class)
-			->setConstructorArgs([
-				$this->userSession,
-				$this->config,
-				$this->groupManager,
-				$this->cacheFactory,
-				$this->eventDispatcher,
-				$this->logger,
-				$this->serverVersion,
-			])
-			->onlyMethods(['getAppInfo'])
-			->getMock();
-
-		$appInfos = [
-			'cloud_federation_api' => ['id' => 'cloud_federation_api'],
-			'dav' => ['id' => 'dav'],
-			'files' => ['id' => 'files'],
-			'federatedfilesharing' => ['id' => 'federatedfilesharing'],
-			'profile' => ['id' => 'profile'],
-			'provisioning_api' => ['id' => 'provisioning_api'],
-			'lookup_server_connector' => ['id' => 'lookup_server_connector'],
-			'test1' => ['id' => 'test1', 'version' => '1.0.1', 'requiremax' => '9.0.0'],
-			'test2' => ['id' => 'test2', 'version' => '1.0.0', 'requiremin' => '8.2.0'],
-			'test3' => ['id' => 'test3', 'version' => '1.2.4', 'requiremin' => '9.0.0'],
-			'test4' => ['id' => 'test4', 'version' => '3.0.0', 'requiremin' => '8.1.0'],
-			'testnoversion' => ['id' => 'testnoversion', 'requiremin' => '8.2.0'],
-			'settings' => ['id' => 'settings'],
-			'theming' => ['id' => 'theming'],
-			'twofactor_backupcodes' => ['id' => 'twofactor_backupcodes'],
-			'viewer' => ['id' => 'viewer'],
-			'workflowengine' => ['id' => 'workflowengine'],
-			'oauth2' => ['id' => 'oauth2'],
-		];
-
-		$manager->expects($this->any())
-			->method('getAppInfo')
-			->willReturnCallback(
-				function ($appId) use ($appInfos) {
-					return $appInfos[$appId];
-				}
-			);
-
-		$this->appConfig->setValue('test1', 'enabled', 'yes');
-		$this->appConfig->setValue('test1', 'installed_version', '1.0.0');
-		$this->appConfig->setValue('test2', 'enabled', 'yes');
-		$this->appConfig->setValue('test2', 'installed_version', '1.0.0');
-		$this->appConfig->setValue('test3', 'enabled', 'yes');
-		$this->appConfig->setValue('test3', 'installed_version', '1.0.0');
-		$this->appConfig->setValue('test4', 'enabled', 'yes');
-		$this->appConfig->setValue('test4', 'installed_version', '2.4.0');
-
-		$apps = $manager->getAppsNeedingUpgrade('8.2.0');
-
-		$this->assertCount(2, $apps);
-		$this->assertEquals('test1', $apps[0]['id']);
-		$this->assertEquals('test4', $apps[1]['id']);
-	}
-
-	public function testGetIncompatibleApps(): void {
-		/** @var AppManager|MockObject $manager */
-		$manager = $this->getMockBuilder(AppManager::class)
-			->setConstructorArgs([
-				$this->userSession,
-				$this->config,
-				$this->groupManager,
-				$this->cacheFactory,
-				$this->eventDispatcher,
-				$this->logger,
-				$this->serverVersion,
-			])
-			->onlyMethods(['getAppInfo'])
-			->getMock();
-
-		$appInfos = [
-			'cloud_federation_api' => ['id' => 'cloud_federation_api'],
-			'dav' => ['id' => 'dav'],
-			'files' => ['id' => 'files'],
-			'federatedfilesharing' => ['id' => 'federatedfilesharing'],
-			'profile' => ['id' => 'profile'],
-			'provisioning_api' => ['id' => 'provisioning_api'],
-			'lookup_server_connector' => ['id' => 'lookup_server_connector'],
-			'test1' => ['id' => 'test1', 'version' => '1.0.1', 'requiremax' => '8.0.0'],
-			'test2' => ['id' => 'test2', 'version' => '1.0.0', 'requiremin' => '8.2.0'],
-			'test3' => ['id' => 'test3', 'version' => '1.2.4', 'requiremin' => '9.0.0'],
-			'settings' => ['id' => 'settings'],
-			'testnoversion' => ['id' => 'testnoversion', 'requiremin' => '8.2.0'],
-			'theming' => ['id' => 'theming'],
-			'twofactor_backupcodes' => ['id' => 'twofactor_backupcodes'],
-			'workflowengine' => ['id' => 'workflowengine'],
-			'oauth2' => ['id' => 'oauth2'],
-			'viewer' => ['id' => 'viewer'],
-		];
-
-		$manager->expects($this->any())
-			->method('getAppInfo')
-			->willReturnCallback(
-				function ($appId) use ($appInfos) {
-					return $appInfos[$appId];
-				}
-			);
-
-		$this->appConfig->setValue('test1', 'enabled', 'yes');
-		$this->appConfig->setValue('test2', 'enabled', 'yes');
-		$this->appConfig->setValue('test3', 'enabled', 'yes');
-
-		$apps = $manager->getIncompatibleApps('8.2.0');
-
-		$this->assertCount(2, $apps);
-		$this->assertEquals('test1', $apps[0]['id']);
-		$this->assertEquals('test3', $apps[1]['id']);
-	}
-
-	public function testGetEnabledAppsForGroup(): void {
-		$group = $this->createMock(IGroup::class);
-		$group->expects($this->any())
-			->method('getGID')
-			->willReturn('foo');
-
-		$this->appConfig->setValue('test1', 'enabled', 'yes');
-		$this->appConfig->setValue('test2', 'enabled', 'no');
-		$this->appConfig->setValue('test3', 'enabled', '["foo"]');
-		$this->appConfig->setValue('test4', 'enabled', '["asd"]');
-		$enabled = [
-			'cloud_federation_api',
-			'dav',
-			'federatedfilesharing',
-			'files',
-			'lookup_server_connector',
-			'oauth2',
-			'profile',
-			'provisioning_api',
-			'settings',
-			'test1',
-			'test3',
-			'theming',
-			'twofactor_backupcodes',
-			'viewer',
-			'workflowengine',
-		];
-		$this->assertEquals($enabled, $this->manager->getEnabledAppsForGroup($group));
-	}
-
-	public function testGetAppRestriction(): void {
-		$this->appConfig->setValue('test1', 'enabled', 'yes');
-		$this->appConfig->setValue('test2', 'enabled', 'no');
-		$this->appConfig->setValue('test3', 'enabled', '["foo"]');
-
-		$this->assertEquals([], $this->manager->getAppRestriction('test1'));
-		$this->assertEquals([], $this->manager->getAppRestriction('test2'));
-		$this->assertEquals(['foo'], $this->manager->getAppRestriction('test3'));
-	}
-
-	public static function isBackendRequiredDataProvider(): array {
-		return [
-			// backend available
-			[
-				'caldav',
-				['app1' => ['caldav']],
-				true,
-			],
-			[
-				'caldav',
-				['app1' => [], 'app2' => ['foo'], 'app3' => ['caldav']],
-				true,
-			],
-			// backend not available
-			[
-				'caldav',
-				['app3' => [], 'app1' => ['foo'], 'app2' => ['bar', 'baz']],
-				false,
-			],
-			// no app available
-			[
-				'caldav',
-				[],
-				false,
-			],
-		];
-	}
-
-	/**
-	 * @dataProvider isBackendRequiredDataProvider
-	 */
-	public function testIsBackendRequired(
-		string $backend,
-		array $appBackends,
-		bool $expected,
-	): void {
-		$appInfoData = array_map(
-			static fn (array $backends) => ['dependencies' => ['backend' => $backends]],
-			$appBackends,
-		);
-
-		$reflection = new \ReflectionClass($this->manager);
-		$property = $reflection->getProperty('appInfos');
-		$property->setValue($this->manager, $appInfoData);
-
-		$this->assertEquals($expected, $this->manager->isBackendRequired($backend));
-	}
-
-	public function testGetAppVersion() {
-		$manager = $this->getMockBuilder(AppManager::class)
-			->setConstructorArgs([
-				$this->userSession,
-				$this->config,
-				$this->groupManager,
-				$this->cacheFactory,
-				$this->eventDispatcher,
-				$this->logger,
-				$this->serverVersion,
-			])
-			->onlyMethods([
-				'getAppInfo',
-			])
-			->getMock();
-
-		$manager->expects(self::once())
-			->method('getAppInfo')
-			->with('myapp')
-			->willReturn(['version' => '99.99.99-rc.99']);
-
-		$this->serverVersion
-			->expects(self::never())
-			->method('getVersionString');
-
-		$this->assertEquals(
-			'99.99.99-rc.99',
-			$manager->getAppVersion('myapp'),
-		);
-	}
-
-	public function testGetAppVersionCore() {
-		$manager = $this->getMockBuilder(AppManager::class)
-			->setConstructorArgs([
-				$this->userSession,
-				$this->config,
-				$this->groupManager,
-				$this->cacheFactory,
-				$this->eventDispatcher,
-				$this->logger,
-				$this->serverVersion,
-			])
-			->onlyMethods([
-				'getAppInfo',
-			])
-			->getMock();
-
-		$manager->expects(self::never())
-			->method('getAppInfo');
-
-		$this->serverVersion
-			->expects(self::once())
-			->method('getVersionString')
-			->willReturn('1.2.3-beta.4');
-
-		$this->assertEquals(
-			'1.2.3-beta.4',
-			$manager->getAppVersion('core'),
-		);
-	}
-
-	public function testGetAppVersionUnknown() {
-		$manager = $this->getMockBuilder(AppManager::class)
-			->setConstructorArgs([
-				$this->userSession,
-				$this->config,
-				$this->groupManager,
-				$this->cacheFactory,
-				$this->eventDispatcher,
-				$this->logger,
-				$this->serverVersion,
-			])
-			->onlyMethods([
-				'getAppInfo',
-			])
-			->getMock();
-
-		$manager->expects(self::once())
-			->method('getAppInfo')
-			->with('unknown')
-			->willReturn(null);
-
-		$this->serverVersion
-			->expects(self::never())
-			->method('getVersionString');
-
-		$this->assertEquals(
-			'0',
-			$manager->getAppVersion('unknown'),
-		);
-	}
+    /**
+     * @return AppConfig|MockObject
+     */
+    protected function getAppConfig() {
+        $appConfig = [];
+        $config = $this->createMock(AppConfig::class);
+
+        $config->expects($this->any())
+            ->method('getValue')
+            ->willReturnCallback(function ($app, $key, $default) use (&$appConfig) {
+                return (isset($appConfig[$app]) and isset($appConfig[$app][$key])) ? $appConfig[$app][$key] : $default;
+            });
+        $config->expects($this->any())
+            ->method('setValue')
+            ->willReturnCallback(function ($app, $key, $value) use (&$appConfig) {
+                if (!isset($appConfig[$app])) {
+                    $appConfig[$app] = [];
+                }
+                $appConfig[$app][$key] = $value;
+            });
+        $config->expects($this->any())
+            ->method('getValues')
+            ->willReturnCallback(function ($app, $key) use (&$appConfig) {
+                if ($app) {
+                    return $appConfig[$app];
+                } else {
+                    $values = [];
+                    foreach ($appConfig as $appid => $appData) {
+                        if (isset($appData[$key])) {
+                            $values[$appid] = $appData[$key];
+                        }
+                    }
+                    return $values;
+                }
+            });
+
+        return $config;
+    }
+
+    /** @var IUserSession|MockObject */
+    protected $userSession;
+
+    /** @var IConfig|MockObject */
+    private $config;
+
+    /** @var IGroupManager|MockObject */
+    protected $groupManager;
+
+    /** @var AppConfig|MockObject */
+    protected $appConfig;
+
+    /** @var ICache|MockObject */
+    protected $cache;
+
+    /** @var ICacheFactory|MockObject */
+    protected $cacheFactory;
+
+    /** @var IEventDispatcher|MockObject */
+    protected $eventDispatcher;
+
+    /** @var LoggerInterface|MockObject */
+    protected $logger;
+
+    protected IURLGenerator&MockObject $urlGenerator;
+
+    protected ServerVersion&MockObject $serverVersion;
+
+    /** @var IAppManager */
+    protected $manager;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->userSession = $this->createMock(IUserSession::class);
+        $this->groupManager = $this->createMock(IGroupManager::class);
+        $this->config = $this->createMock(IConfig::class);
+        $this->appConfig = $this->getAppConfig();
+        $this->cacheFactory = $this->createMock(ICacheFactory::class);
+        $this->cache = $this->createMock(ICache::class);
+        $this->eventDispatcher = $this->createMock(IEventDispatcher::class);
+        $this->logger = $this->createMock(LoggerInterface::class);
+        $this->urlGenerator = $this->createMock(IURLGenerator::class);
+        $this->serverVersion = $this->createMock(ServerVersion::class);
+
+        $this->overwriteService(AppConfig::class, $this->appConfig);
+        $this->overwriteService(IURLGenerator::class, $this->urlGenerator);
+
+        $this->cacheFactory->expects($this->any())
+            ->method('createDistributed')
+            ->with('settings')
+            ->willReturn($this->cache);
+
+        $this->config
+            ->method('getSystemValueBool')
+            ->with('installed', false)
+            ->willReturn(true);
+
+        $this->manager = new AppManager(
+            $this->userSession,
+            $this->config,
+            $this->groupManager,
+            $this->cacheFactory,
+            $this->eventDispatcher,
+            $this->logger,
+            $this->serverVersion,
+        );
+    }
+
+    /**
+     * @dataProvider dataGetAppIcon
+     */
+    public function testGetAppIcon($callback, ?bool $dark, ?string $expected): void {
+        $this->urlGenerator->expects($this->atLeastOnce())
+            ->method('imagePath')
+            ->willReturnCallback($callback);
+
+        if ($dark !== null) {
+            $this->assertEquals($expected, $this->manager->getAppIcon('test', $dark));
+        } else {
+            $this->assertEquals($expected, $this->manager->getAppIcon('test'));
+        }
+    }
+
+    public static function dataGetAppIcon(): array {
+        $nothing = function ($appId) {
+            self::assertEquals('test', $appId);
+            throw new \RuntimeException();
+        };
+
+        $createCallback = function ($workingIcons) {
+            return function ($appId, $icon) use ($workingIcons) {
+                self::assertEquals('test', $appId);
+                if (in_array($icon, $workingIcons)) {
+                    return '/path/' . $icon;
+                }
+                throw new \RuntimeException();
+            };
+        };
+
+        return [
+            'does not find anything' => [
+                $nothing,
+                false,
+                null,
+            ],
+            'nothing if request dark but only bright available' => [
+                $createCallback(['app.svg']),
+                true,
+                null,
+            ],
+            'nothing if request bright but only dark available' => [
+                $createCallback(['app-dark.svg']),
+                false,
+                null,
+            ],
+            'bright and only app.svg' => [
+                $createCallback(['app.svg']),
+                false,
+                '/path/app.svg',
+            ],
+            'dark and only app-dark.svg' => [
+                $createCallback(['app-dark.svg']),
+                true,
+                '/path/app-dark.svg',
+            ],
+            'dark only appname -dark.svg' => [
+                $createCallback(['test-dark.svg']),
+                true,
+                '/path/test-dark.svg',
+            ],
+            'bright and only appname.svg' => [
+                $createCallback(['test.svg']),
+                false,
+                '/path/test.svg',
+            ],
+            'priotize custom over default' => [
+                $createCallback(['app.svg', 'test.svg']),
+                false,
+                '/path/test.svg',
+            ],
+            'defaults to bright' => [
+                $createCallback(['test-dark.svg', 'test.svg']),
+                null,
+                '/path/test.svg',
+            ],
+            'no dark icon on default' => [
+                $createCallback(['test-dark.svg', 'test.svg', 'app-dark.svg', 'app.svg']),
+                false,
+                '/path/test.svg',
+            ],
+            'no bright icon on dark' => [
+                $createCallback(['test-dark.svg', 'test.svg', 'app-dark.svg', 'app.svg']),
+                true,
+                '/path/test-dark.svg',
+            ],
+        ];
+    }
+
+    public function testEnableApp(): void {
+        // making sure "files_trashbin" is disabled
+        if ($this->manager->isEnabledForUser('files_trashbin')) {
+            $this->manager->disableApp('files_trashbin');
+        }
+        $this->eventDispatcher->expects($this->once())->method('dispatchTyped')->with(new AppEnableEvent('files_trashbin'));
+        $this->manager->enableApp('files_trashbin');
+        $this->assertEquals('yes', $this->appConfig->getValue('files_trashbin', 'enabled', 'no'));
+    }
+
+    public function testDisableApp(): void {
+        $this->eventDispatcher->expects($this->once())->method('dispatchTyped')->with(new AppDisableEvent('files_trashbin'));
+        $this->manager->disableApp('files_trashbin');
+        $this->assertEquals('no', $this->appConfig->getValue('files_trashbin', 'enabled', 'no'));
+    }
+
+    public function testNotEnableIfNotInstalled(): void {
+        try {
+            $this->manager->enableApp('some_random_name_which_i_hope_is_not_an_app');
+            $this->assertFalse(true, 'If this line is reached the expected exception is not thrown.');
+        } catch (AppPathNotFoundException $e) {
+            // Exception is expected
+            $this->assertEquals('Could not find path for some_random_name_which_i_hope_is_not_an_app', $e->getMessage());
+        }
+
+        $this->assertEquals('no', $this->appConfig->getValue(
+            'some_random_name_which_i_hope_is_not_an_app', 'enabled', 'no'
+        ));
+    }
+
+    public function testEnableAppForGroups(): void {
+        $group1 = $this->createMock(IGroup::class);
+        $group1->method('getGID')
+            ->willReturn('group1');
+        $group2 = $this->createMock(IGroup::class);
+        $group2->method('getGID')
+            ->willReturn('group2');
+
+        $groups = [$group1, $group2];
+
+        /** @var AppManager|MockObject $manager */
+        $manager = $this->getMockBuilder(AppManager::class)
+            ->setConstructorArgs([
+                $this->userSession,
+                $this->config,
+                $this->groupManager,
+                $this->cacheFactory,
+                $this->eventDispatcher,
+                $this->logger,
+                $this->serverVersion,
+            ])
+            ->onlyMethods([
+                'getAppPath',
+            ])
+            ->getMock();
+
+        $manager->expects($this->exactly(2))
+            ->method('getAppPath')
+            ->with('test')
+            ->willReturn('apps/test');
+
+        $this->eventDispatcher->expects($this->once())->method('dispatchTyped')->with(new AppEnableEvent('test', ['group1', 'group2']));
+
+        $manager->enableAppForGroups('test', $groups);
+        $this->assertEquals('["group1","group2"]', $this->appConfig->getValue('test', 'enabled', 'no'));
+    }
+
+    public static function dataEnableAppForGroupsAllowedTypes(): array {
+        return [
+            [[]],
+            [[
+                'types' => [],
+            ]],
+            [[
+                'types' => ['nickvergessen'],
+            ]],
+        ];
+    }
+
+    /**
+     * @dataProvider dataEnableAppForGroupsAllowedTypes
+     *
+     * @param array $appInfo
+     */
+    public function testEnableAppForGroupsAllowedTypes(array $appInfo): void {
+        $group1 = $this->createMock(IGroup::class);
+        $group1->method('getGID')
+            ->willReturn('group1');
+        $group2 = $this->createMock(IGroup::class);
+        $group2->method('getGID')
+            ->willReturn('group2');
+
+        $groups = [$group1, $group2];
+
+        /** @var AppManager|MockObject $manager */
+        $manager = $this->getMockBuilder(AppManager::class)
+            ->setConstructorArgs([
+                $this->userSession,
+                $this->config,
+                $this->groupManager,
+                $this->cacheFactory,
+                $this->eventDispatcher,
+                $this->logger,
+                $this->serverVersion,
+            ])
+            ->onlyMethods([
+                'getAppPath',
+                'getAppInfo',
+            ])
+            ->getMock();
+
+        $manager->expects($this->once())
+            ->method('getAppPath')
+            ->with('test')
+            ->willReturn('');
+
+        $manager->expects($this->once())
+            ->method('getAppInfo')
+            ->with('test')
+            ->willReturn($appInfo);
+
+        $this->eventDispatcher->expects($this->once())->method('dispatchTyped')->with(new AppEnableEvent('test', ['group1', 'group2']));
+
+        $manager->enableAppForGroups('test', $groups);
+        $this->assertEquals('["group1","group2"]', $this->appConfig->getValue('test', 'enabled', 'no'));
+    }
+
+    public static function dataEnableAppForGroupsForbiddenTypes(): array {
+        return [
+            ['filesystem'],
+            ['prelogin'],
+            ['authentication'],
+            ['logging'],
+            ['prevent_group_restriction'],
+        ];
+    }
+
+    /**
+     * @dataProvider dataEnableAppForGroupsForbiddenTypes
+     *
+     * @param string $type
+     *
+     */
+    public function testEnableAppForGroupsForbiddenTypes($type): void {
+        $this->expectException(\Exception::class);
+        $this->expectExceptionMessage('test can\'t be enabled for groups.');
+
+        $group1 = $this->createMock(IGroup::class);
+        $group1->method('getGID')
+            ->willReturn('group1');
+        $group2 = $this->createMock(IGroup::class);
+        $group2->method('getGID')
+            ->willReturn('group2');
+
+        $groups = [$group1, $group2];
+
+        /** @var AppManager|MockObject $manager */
+        $manager = $this->getMockBuilder(AppManager::class)
+            ->setConstructorArgs([
+                $this->userSession,
+                $this->config,
+                $this->groupManager,
+                $this->cacheFactory,
+                $this->eventDispatcher,
+                $this->logger,
+                $this->serverVersion,
+            ])
+            ->onlyMethods([
+                'getAppPath',
+                'getAppInfo',
+            ])
+            ->getMock();
+
+        $manager->expects($this->once())
+            ->method('getAppPath')
+            ->with('test')
+            ->willReturn('');
+
+        $manager->expects($this->once())
+            ->method('getAppInfo')
+            ->with('test')
+            ->willReturn([
+                'types' => [$type],
+            ]);
+
+        $this->eventDispatcher->expects($this->never())->method('dispatchTyped')->with(new AppEnableEvent('test', ['group1', 'group2']));
+
+        $manager->enableAppForGroups('test', $groups);
+    }
+
+    public function testIsInstalledEnabled(): void {
+        $this->appConfig->setValue('test', 'enabled', 'yes');
+        $this->assertTrue($this->manager->isEnabledForAnyone('test'));
+    }
+
+    public function testIsInstalledDisabled(): void {
+        $this->appConfig->setValue('test', 'enabled', 'no');
+        $this->assertFalse($this->manager->isEnabledForAnyone('test'));
+    }
+
+    public function testIsInstalledEnabledForGroups(): void {
+        $this->appConfig->setValue('test', 'enabled', '["foo"]');
+        $this->assertTrue($this->manager->isEnabledForAnyone('test'));
+    }
+
+    private function newUser($uid) {
+        $user = $this->createMock(IUser::class);
+        $user->method('getUID')
+            ->willReturn($uid);
+
+        return $user;
+    }
+
+    public function testIsEnabledForUserEnabled(): void {
+        $this->appConfig->setValue('test', 'enabled', 'yes');
+        $user = $this->newUser('user1');
+        $this->assertTrue($this->manager->isEnabledForUser('test', $user));
+    }
+
+    public function testIsEnabledForUserDisabled(): void {
+        $this->appConfig->setValue('test', 'enabled', 'no');
+        $user = $this->newUser('user1');
+        $this->assertFalse($this->manager->isEnabledForUser('test', $user));
+    }
+
+    public function testGetAppPath(): void {
+        $this->assertEquals(\OC::$SERVERROOT . '/apps/files', $this->manager->getAppPath('files'));
+    }
+
+    public function testGetAppPathSymlink(): void {
+        $fakeAppDirname = sha1(uniqid('test', true));
+        $fakeAppPath = sys_get_temp_dir() . '/' . $fakeAppDirname;
+        $fakeAppLink = \OC::$SERVERROOT . '/' . $fakeAppDirname;
+
+        mkdir($fakeAppPath);
+        if (symlink($fakeAppPath, $fakeAppLink) === false) {
+            $this->markTestSkipped('Failed to create symlink');
+        }
+
+        // Use the symlink as the app path
+        \OC::$APPSROOTS[] = [
+            'path' => $fakeAppLink,
+            'url' => \OC::$WEBROOT . '/' . $fakeAppDirname,
+            'writable' => false,
+        ];
+
+        $fakeTestAppPath = $fakeAppPath . '/' . 'test-test-app';
+        mkdir($fakeTestAppPath);
+
+        $generatedAppPath = $this->manager->getAppPath('test-test-app');
+
+        rmdir($fakeTestAppPath);
+        unlink($fakeAppLink);
+        rmdir($fakeAppPath);
+
+        $this->assertEquals($fakeAppLink . '/test-test-app', $generatedAppPath);
+    }
+
+    public function testGetAppPathFail(): void {
+        $this->expectException(AppPathNotFoundException::class);
+        $this->manager->getAppPath('testnotexisting');
+    }
+
+    public function testIsEnabledForUserEnabledForGroup(): void {
+        $user = $this->newUser('user1');
+        $this->groupManager->expects($this->once())
+            ->method('getUserGroupIds')
+            ->with($user)
+            ->willReturn(['foo', 'bar']);
+
+        $this->appConfig->setValue('test', 'enabled', '["foo"]');
+        $this->assertTrue($this->manager->isEnabledForUser('test', $user));
+    }
+
+    public function testIsEnabledForUserDisabledForGroup(): void {
+        $user = $this->newUser('user1');
+        $this->groupManager->expects($this->once())
+            ->method('getUserGroupIds')
+            ->with($user)
+            ->willReturn(['bar']);
+
+        $this->appConfig->setValue('test', 'enabled', '["foo"]');
+        $this->assertFalse($this->manager->isEnabledForUser('test', $user));
+    }
+
+    public function testIsEnabledForUserLoggedOut(): void {
+        $this->appConfig->setValue('test', 'enabled', '["foo"]');
+        $this->assertFalse($this->manager->isEnabledForUser('test'));
+    }
+
+    public function testIsEnabledForUserLoggedIn(): void {
+        $user = $this->newUser('user1');
+
+        $this->userSession->expects($this->once())
+            ->method('getUser')
+            ->willReturn($user);
+        $this->groupManager->expects($this->once())
+            ->method('getUserGroupIds')
+            ->with($user)
+            ->willReturn(['foo', 'bar']);
+
+        $this->appConfig->setValue('test', 'enabled', '["foo"]');
+        $this->assertTrue($this->manager->isEnabledForUser('test'));
+    }
+
+    public function testGetEnabledApps(): void {
+        $this->appConfig->setValue('test1', 'enabled', 'yes');
+        $this->appConfig->setValue('test2', 'enabled', 'no');
+        $this->appConfig->setValue('test3', 'enabled', '["foo"]');
+        $apps = [
+            'cloud_federation_api',
+            'dav',
+            'federatedfilesharing',
+            'files',
+            'lookup_server_connector',
+            'oauth2',
+            'profile',
+            'provisioning_api',
+            'settings',
+            'test1',
+            'test3',
+            'theming',
+            'twofactor_backupcodes',
+            'viewer',
+            'workflowengine',
+        ];
+        $this->assertEquals($apps, $this->manager->getEnabledApps());
+    }
+
+    public function testGetAppsForUser(): void {
+        $user = $this->newUser('user1');
+        $this->groupManager->expects($this->any())
+            ->method('getUserGroupIds')
+            ->with($user)
+            ->willReturn(['foo', 'bar']);
+
+        $this->appConfig->setValue('test1', 'enabled', 'yes');
+        $this->appConfig->setValue('test2', 'enabled', 'no');
+        $this->appConfig->setValue('test3', 'enabled', '["foo"]');
+        $this->appConfig->setValue('test4', 'enabled', '["asd"]');
+        $enabled = [
+            'cloud_federation_api',
+            'dav',
+            'federatedfilesharing',
+            'files',
+            'lookup_server_connector',
+            'oauth2',
+            'profile',
+            'provisioning_api',
+            'settings',
+            'test1',
+            'test3',
+            'theming',
+            'twofactor_backupcodes',
+            'viewer',
+            'workflowengine',
+        ];
+        $this->assertEquals($enabled, $this->manager->getEnabledAppsForUser($user));
+    }
+
+    public function testGetAppsNeedingUpgrade(): void {
+        /** @var AppManager|MockObject $manager */
+        $manager = $this->getMockBuilder(AppManager::class)
+            ->setConstructorArgs([
+                $this->userSession,
+                $this->config,
+                $this->groupManager,
+                $this->cacheFactory,
+                $this->eventDispatcher,
+                $this->logger,
+                $this->serverVersion,
+            ])
+            ->onlyMethods(['getAppInfo'])
+            ->getMock();
+
+        $appInfos = [
+            'cloud_federation_api' => ['id' => 'cloud_federation_api'],
+            'dav' => ['id' => 'dav'],
+            'files' => ['id' => 'files'],
+            'federatedfilesharing' => ['id' => 'federatedfilesharing'],
+            'profile' => ['id' => 'profile'],
+            'provisioning_api' => ['id' => 'provisioning_api'],
+            'lookup_server_connector' => ['id' => 'lookup_server_connector'],
+            'test1' => ['id' => 'test1', 'version' => '1.0.1', 'requiremax' => '9.0.0'],
+            'test2' => ['id' => 'test2', 'version' => '1.0.0', 'requiremin' => '8.2.0'],
+            'test3' => ['id' => 'test3', 'version' => '1.2.4', 'requiremin' => '9.0.0'],
+            'test4' => ['id' => 'test4', 'version' => '3.0.0', 'requiremin' => '8.1.0'],
+            'testnoversion' => ['id' => 'testnoversion', 'requiremin' => '8.2.0'],
+            'settings' => ['id' => 'settings'],
+            'theming' => ['id' => 'theming'],
+            'twofactor_backupcodes' => ['id' => 'twofactor_backupcodes'],
+            'viewer' => ['id' => 'viewer'],
+            'workflowengine' => ['id' => 'workflowengine'],
+            'oauth2' => ['id' => 'oauth2'],
+        ];
+
+        $manager->expects($this->any())
+            ->method('getAppInfo')
+            ->willReturnCallback(
+                function ($appId) use ($appInfos) {
+                    return $appInfos[$appId];
+                }
+            );
+
+        $this->appConfig->setValue('test1', 'enabled', 'yes');
+        $this->appConfig->setValue('test1', 'installed_version', '1.0.0');
+        $this->appConfig->setValue('test2', 'enabled', 'yes');
+        $this->appConfig->setValue('test2', 'installed_version', '1.0.0');
+        $this->appConfig->setValue('test3', 'enabled', 'yes');
+        $this->appConfig->setValue('test3', 'installed_version', '1.0.0');
+        $this->appConfig->setValue('test4', 'enabled', 'yes');
+        $this->appConfig->setValue('test4', 'installed_version', '2.4.0');
+
+        $apps = $manager->getAppsNeedingUpgrade('8.2.0');
+
+        $this->assertCount(2, $apps);
+        $this->assertEquals('test1', $apps[0]['id']);
+        $this->assertEquals('test4', $apps[1]['id']);
+    }
+
+    public function testGetIncompatibleApps(): void {
+        /** @var AppManager|MockObject $manager */
+        $manager = $this->getMockBuilder(AppManager::class)
+            ->setConstructorArgs([
+                $this->userSession,
+                $this->config,
+                $this->groupManager,
+                $this->cacheFactory,
+                $this->eventDispatcher,
+                $this->logger,
+                $this->serverVersion,
+            ])
+            ->onlyMethods(['getAppInfo'])
+            ->getMock();
+
+        $appInfos = [
+            'cloud_federation_api' => ['id' => 'cloud_federation_api'],
+            'dav' => ['id' => 'dav'],
+            'files' => ['id' => 'files'],
+            'federatedfilesharing' => ['id' => 'federatedfilesharing'],
+            'profile' => ['id' => 'profile'],
+            'provisioning_api' => ['id' => 'provisioning_api'],
+            'lookup_server_connector' => ['id' => 'lookup_server_connector'],
+            'test1' => ['id' => 'test1', 'version' => '1.0.1', 'requiremax' => '8.0.0'],
+            'test2' => ['id' => 'test2', 'version' => '1.0.0', 'requiremin' => '8.2.0'],
+            'test3' => ['id' => 'test3', 'version' => '1.2.4', 'requiremin' => '9.0.0'],
+            'settings' => ['id' => 'settings'],
+            'testnoversion' => ['id' => 'testnoversion', 'requiremin' => '8.2.0'],
+            'theming' => ['id' => 'theming'],
+            'twofactor_backupcodes' => ['id' => 'twofactor_backupcodes'],
+            'workflowengine' => ['id' => 'workflowengine'],
+            'oauth2' => ['id' => 'oauth2'],
+            'viewer' => ['id' => 'viewer'],
+        ];
+
+        $manager->expects($this->any())
+            ->method('getAppInfo')
+            ->willReturnCallback(
+                function ($appId) use ($appInfos) {
+                    return $appInfos[$appId];
+                }
+            );
+
+        $this->appConfig->setValue('test1', 'enabled', 'yes');
+        $this->appConfig->setValue('test2', 'enabled', 'yes');
+        $this->appConfig->setValue('test3', 'enabled', 'yes');
+
+        $apps = $manager->getIncompatibleApps('8.2.0');
+
+        $this->assertCount(2, $apps);
+        $this->assertEquals('test1', $apps[0]['id']);
+        $this->assertEquals('test3', $apps[1]['id']);
+    }
+
+    public function testGetEnabledAppsForGroup(): void {
+        $group = $this->createMock(IGroup::class);
+        $group->expects($this->any())
+            ->method('getGID')
+            ->willReturn('foo');
+
+        $this->appConfig->setValue('test1', 'enabled', 'yes');
+        $this->appConfig->setValue('test2', 'enabled', 'no');
+        $this->appConfig->setValue('test3', 'enabled', '["foo"]');
+        $this->appConfig->setValue('test4', 'enabled', '["asd"]');
+        $enabled = [
+            'cloud_federation_api',
+            'dav',
+            'federatedfilesharing',
+            'files',
+            'lookup_server_connector',
+            'oauth2',
+            'profile',
+            'provisioning_api',
+            'settings',
+            'test1',
+            'test3',
+            'theming',
+            'twofactor_backupcodes',
+            'viewer',
+            'workflowengine',
+        ];
+        $this->assertEquals($enabled, $this->manager->getEnabledAppsForGroup($group));
+    }
+
+    public function testGetAppRestriction(): void {
+        $this->appConfig->setValue('test1', 'enabled', 'yes');
+        $this->appConfig->setValue('test2', 'enabled', 'no');
+        $this->appConfig->setValue('test3', 'enabled', '["foo"]');
+
+        $this->assertEquals([], $this->manager->getAppRestriction('test1'));
+        $this->assertEquals([], $this->manager->getAppRestriction('test2'));
+        $this->assertEquals(['foo'], $this->manager->getAppRestriction('test3'));
+    }
+
+    public static function isBackendRequiredDataProvider(): array {
+        return [
+            // backend available
+            [
+                'caldav',
+                ['app1' => ['caldav']],
+                true,
+            ],
+            [
+                'caldav',
+                ['app1' => [], 'app2' => ['foo'], 'app3' => ['caldav']],
+                true,
+            ],
+            // backend not available
+            [
+                'caldav',
+                ['app3' => [], 'app1' => ['foo'], 'app2' => ['bar', 'baz']],
+                false,
+            ],
+            // no app available
+            [
+                'caldav',
+                [],
+                false,
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider isBackendRequiredDataProvider
+     */
+    public function testIsBackendRequired(
+        string $backend,
+        array $appBackends,
+        bool $expected,
+    ): void {
+        $appInfoData = array_map(
+            static fn (array $backends) => ['dependencies' => ['backend' => $backends]],
+            $appBackends,
+        );
+
+        $reflection = new \ReflectionClass($this->manager);
+        $property = $reflection->getProperty('appInfos');
+        $property->setValue($this->manager, $appInfoData);
+
+        $this->assertEquals($expected, $this->manager->isBackendRequired($backend));
+    }
+
+    public function testGetAppVersion() {
+        $manager = $this->getMockBuilder(AppManager::class)
+            ->setConstructorArgs([
+                $this->userSession,
+                $this->config,
+                $this->groupManager,
+                $this->cacheFactory,
+                $this->eventDispatcher,
+                $this->logger,
+                $this->serverVersion,
+            ])
+            ->onlyMethods([
+                'getAppInfo',
+            ])
+            ->getMock();
+
+        $manager->expects(self::once())
+            ->method('getAppInfo')
+            ->with('myapp')
+            ->willReturn(['version' => '99.99.99-rc.99']);
+
+        $this->serverVersion
+            ->expects(self::never())
+            ->method('getVersionString');
+
+        $this->assertEquals(
+            '99.99.99-rc.99',
+            $manager->getAppVersion('myapp'),
+        );
+    }
+
+    public function testGetAppVersionCore() {
+        $manager = $this->getMockBuilder(AppManager::class)
+            ->setConstructorArgs([
+                $this->userSession,
+                $this->config,
+                $this->groupManager,
+                $this->cacheFactory,
+                $this->eventDispatcher,
+                $this->logger,
+                $this->serverVersion,
+            ])
+            ->onlyMethods([
+                'getAppInfo',
+            ])
+            ->getMock();
+
+        $manager->expects(self::never())
+            ->method('getAppInfo');
+
+        $this->serverVersion
+            ->expects(self::once())
+            ->method('getVersionString')
+            ->willReturn('1.2.3-beta.4');
+
+        $this->assertEquals(
+            '1.2.3-beta.4',
+            $manager->getAppVersion('core'),
+        );
+    }
+
+    public function testGetAppVersionUnknown() {
+        $manager = $this->getMockBuilder(AppManager::class)
+            ->setConstructorArgs([
+                $this->userSession,
+                $this->config,
+                $this->groupManager,
+                $this->cacheFactory,
+                $this->eventDispatcher,
+                $this->logger,
+                $this->serverVersion,
+            ])
+            ->onlyMethods([
+                'getAppInfo',
+            ])
+            ->getMock();
+
+        $manager->expects(self::once())
+            ->method('getAppInfo')
+            ->with('unknown')
+            ->willReturn(null);
+
+        $this->serverVersion
+            ->expects(self::never())
+            ->method('getVersionString');
+
+        $this->assertEquals(
+            '0',
+            $manager->getAppVersion('unknown'),
+        );
+    }
 
 }