nextcloud / server

apps/encryption/tests/Crypto/CryptTest.php

Indentation +407 added lines, -407 removed lines

@@ -19,411 +19,411 @@
 use Test\TestCase;
 
 class CryptTest extends TestCase {
-	protected LoggerInterface&MockObject $logger;
-	protected IUserSession&MockObject $userSession;
-	protected IConfig&MockObject $config;
-	protected IL10N&MockObject $l;
-
-	protected Crypt $crypt;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->logger = $this->getMockBuilder(LoggerInterface::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$this->logger->expects($this->any())
-			->method('warning');
-		$this->userSession = $this->getMockBuilder(IUserSession::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$this->config = $this->getMockBuilder(IConfig::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$this->l = $this->createMock(IL10N::class);
-
-		$this->crypt = new Crypt($this->logger, $this->userSession, $this->config, $this->l);
-	}
-
-	/**
-	 * test getOpenSSLConfig without any additional parameters
-	 */
-	public function testGetOpenSSLConfigBasic(): void {
-		$this->config->expects($this->once())
-			->method('getSystemValue')
-			->with($this->equalTo('openssl'), $this->equalTo([]))
-			->willReturn([]);
-
-		$result = self::invokePrivate($this->crypt, 'getOpenSSLConfig');
-		$this->assertSame(1, count($result));
-		$this->assertArrayHasKey('private_key_bits', $result);
-		$this->assertSame(4096, $result['private_key_bits']);
-	}
-
-	/**
-	 * test getOpenSSLConfig with additional parameters defined in config.php
-	 */
-	public function testGetOpenSSLConfig(): void {
-		$this->config->expects($this->once())
-			->method('getSystemValue')
-			->with($this->equalTo('openssl'), $this->equalTo([]))
-			->willReturn(['foo' => 'bar', 'private_key_bits' => 1028]);
-
-		$result = self::invokePrivate($this->crypt, 'getOpenSSLConfig');
-		$this->assertSame(2, count($result));
-		$this->assertArrayHasKey('private_key_bits', $result);
-		$this->assertArrayHasKey('foo', $result);
-		$this->assertSame(1028, $result['private_key_bits']);
-		$this->assertSame('bar', $result['foo']);
-	}
-
-
-	/**
-	 * test generateHeader with valid key formats
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestGenerateHeader')]
-	public function testGenerateHeader($keyFormat, $expected): void {
-		$this->config->expects($this->once())
-			->method('getSystemValueString')
-			->with($this->equalTo('cipher'), $this->equalTo('AES-256-CTR'))
-			->willReturn('AES-128-CFB');
-
-		if ($keyFormat) {
-			$result = $this->crypt->generateHeader($keyFormat);
-		} else {
-			$result = $this->crypt->generateHeader();
-		}
-
-		$this->assertSame($expected, $result);
-	}
-
-	/**
-	 * test generateHeader with invalid key format
-	 *
-	 */
-	public function testGenerateHeaderInvalid(): void {
-		$this->expectException(\InvalidArgumentException::class);
-
-		$this->crypt->generateHeader('unknown');
-	}
-
-	public static function dataTestGenerateHeader(): array {
-		return [
-			[null, 'HBEGIN:cipher:AES-128-CFB:keyFormat:hash2:encoding:binary:HEND'],
-			['password', 'HBEGIN:cipher:AES-128-CFB:keyFormat:password:encoding:binary:HEND'],
-			['hash', 'HBEGIN:cipher:AES-128-CFB:keyFormat:hash:encoding:binary:HEND']
-		];
-	}
-
-	public function testGetCipherWithInvalidCipher(): void {
-		$this->config->expects($this->once())
-			->method('getSystemValueString')
-			->with($this->equalTo('cipher'), $this->equalTo('AES-256-CTR'))
-			->willReturn('Not-Existing-Cipher');
-		$this->logger
-			->expects($this->once())
-			->method('warning')
-			->with('Unsupported cipher (Not-Existing-Cipher) defined in config.php supported. Falling back to AES-256-CTR');
-
-		$this->assertSame('AES-256-CTR', $this->crypt->getCipher());
-	}
-
-	/**
-	 * @param string $configValue
-	 * @param string $expected
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataProviderGetCipher')]
-	public function testGetCipher($configValue, $expected): void {
-		$this->config->expects($this->once())
-			->method('getSystemValueString')
-			->with($this->equalTo('cipher'), $this->equalTo('AES-256-CTR'))
-			->willReturn($configValue);
-
-		$this->assertSame($expected,
-			$this->crypt->getCipher()
-		);
-	}
-
-	/**
-	 * data provider for testGetCipher
-	 */
-	public static function dataProviderGetCipher(): array {
-		return [
-			['AES-128-CFB', 'AES-128-CFB'],
-			['AES-256-CFB', 'AES-256-CFB'],
-			['AES-128-CTR', 'AES-128-CTR'],
-			['AES-256-CTR', 'AES-256-CTR'],
-
-			['unknown', 'AES-256-CTR']
-		];
-	}
-
-	/**
-	 * test concatIV()
-	 */
-	public function testConcatIV(): void {
-		$result = self::invokePrivate(
-			$this->crypt,
-			'concatIV',
-			['content', 'my_iv']);
-
-		$this->assertSame('content00iv00my_iv',
-			$result
-		);
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestSplitMetaData')]
-	public function testSplitMetaData($data, $expected): void {
-		$this->config->method('getSystemValueBool')
-			->with('encryption_skip_signature_check', false)
-			->willReturn(true);
-		$result = self::invokePrivate($this->crypt, 'splitMetaData', [$data, 'AES-256-CFB']);
-		$this->assertTrue(is_array($result));
-		$this->assertSame(3, count($result));
-		$this->assertArrayHasKey('encrypted', $result);
-		$this->assertArrayHasKey('iv', $result);
-		$this->assertArrayHasKey('signature', $result);
-		$this->assertSame($expected['encrypted'], $result['encrypted']);
-		$this->assertSame($expected['iv'], $result['iv']);
-		$this->assertSame($expected['signature'], $result['signature']);
-	}
-
-	public static function dataTestSplitMetaData(): array {
-		return [
-			['encryptedContent00iv001234567890123456xx',
-				['encrypted' => 'encryptedContent', 'iv' => '1234567890123456', 'signature' => false]],
-			['encryptedContent00iv00123456789012345600sig00e1992521e437f6915f9173b190a512cfc38a00ac24502db44e0ba10c2bb0cc86xxx',
-				['encrypted' => 'encryptedContent', 'iv' => '1234567890123456', 'signature' => 'e1992521e437f6915f9173b190a512cfc38a00ac24502db44e0ba10c2bb0cc86']],
-		];
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestHasSignature')]
-	public function testHasSignature($data, $expected): void {
-		$this->config->method('getSystemValueBool')
-			->with('encryption_skip_signature_check', false)
-			->willReturn(true);
-		$this->assertSame($expected,
-			$this->invokePrivate($this->crypt, 'hasSignature', [$data, 'AES-256-CFB'])
-		);
-	}
-
-	public static function dataTestHasSignature(): array {
-		return [
-			['encryptedContent00iv001234567890123456xx', false],
-			['encryptedContent00iv00123456789012345600sig00e1992521e437f6915f9173b190a512cfc38a00ac24502db44e0ba10c2bb0cc86xxx', true]
-		];
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestHasSignatureFail')]
-	public function testHasSignatureFail($cipher): void {
-		$this->expectException(GenericEncryptionException::class);
-
-		$data = 'encryptedContent00iv001234567890123456xx';
-		$this->invokePrivate($this->crypt, 'hasSignature', [$data, $cipher]);
-	}
-
-	public static function dataTestHasSignatureFail(): array {
-		return [
-			['AES-256-CTR'],
-			['aes-256-ctr'],
-			['AES-128-CTR'],
-			['ctr-256-ctr']
-		];
-	}
-
-	/**
-	 * test addPadding()
-	 */
-	public function testAddPadding(): void {
-		$result = self::invokePrivate($this->crypt, 'addPadding', ['data']);
-		$this->assertSame('dataxxx', $result);
-	}
-
-	/**
-	 * test removePadding()
-	 *
-	 * @param $data
-	 * @param $expected
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataProviderRemovePadding')]
-	public function testRemovePadding($data, $expected): void {
-		$result = self::invokePrivate($this->crypt, 'removePadding', [$data]);
-		$this->assertSame($expected, $result);
-	}
-
-	/**
-	 * data provider for testRemovePadding
-	 */
-	public static function dataProviderRemovePadding(): array {
-		return [
-			['dataxx', 'data'],
-			['data', false]
-		];
-	}
-
-	/**
-	 * test parseHeader()
-	 */
-	public function testParseHeader(): void {
-		$header = 'HBEGIN:foo:bar:cipher:AES-256-CFB:encoding:binary:HEND';
-		$result = self::invokePrivate($this->crypt, 'parseHeader', [$header]);
-
-		$this->assertTrue(is_array($result));
-		$this->assertSame(3, count($result));
-		$this->assertArrayHasKey('foo', $result);
-		$this->assertArrayHasKey('cipher', $result);
-		$this->assertArrayHasKey('encoding', $result);
-		$this->assertSame('bar', $result['foo']);
-		$this->assertSame('AES-256-CFB', $result['cipher']);
-		$this->assertSame('binary', $result['encoding']);
-	}
-
-	/**
-	 * test encrypt()
-	 *
-	 * @return string
-	 */
-	public function testEncrypt() {
-		$decrypted = 'content';
-		$password = 'password';
-		$cipher = 'AES-256-CTR';
-		$iv = self::invokePrivate($this->crypt, 'generateIv');
-
-		$this->assertTrue(is_string($iv));
-		$this->assertSame(16, strlen($iv));
-
-		$result = self::invokePrivate($this->crypt, 'encrypt', [$decrypted, $iv, $password, $cipher]);
-
-		$this->assertTrue(is_string($result));
-
-		return [
-			'password' => $password,
-			'iv' => $iv,
-			'cipher' => $cipher,
-			'encrypted' => $result,
-			'decrypted' => $decrypted];
-	}
-
-	/**
-	 * test decrypt()
-	 *
-	 * @depends testEncrypt
-	 */
-	public function testDecrypt($data): void {
-		$result = self::invokePrivate(
-			$this->crypt,
-			'decrypt',
-			[$data['encrypted'], $data['iv'], $data['password'], $data['cipher'], true]);
-
-		$this->assertSame($data['decrypted'], $result);
-	}
-
-	/**
-	 * test return values of valid ciphers
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestGetKeySize')]
-	public function testGetKeySize($cipher, $expected): void {
-		$result = $this->invokePrivate($this->crypt, 'getKeySize', [$cipher]);
-		$this->assertSame($expected, $result);
-	}
-
-	/**
-	 * test exception if cipher is unknown
-	 *
-	 */
-	public function testGetKeySizeFailure(): void {
-		$this->expectException(\InvalidArgumentException::class);
-
-		$this->invokePrivate($this->crypt, 'getKeySize', ['foo']);
-	}
-
-	public static function dataTestGetKeySize(): array {
-		return [
-			['AES-256-CFB', 32],
-			['AES-128-CFB', 16],
-			['AES-256-CTR', 32],
-			['AES-128-CTR', 16],
-		];
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestDecryptPrivateKey')]
-	public function testDecryptPrivateKey($header, $privateKey, $expectedCipher, $isValidKey, $expected): void {
-		$this->config->method('getSystemValueBool')
-			->willReturnMap([
-				['encryption.legacy_format_support', false, true],
-				['encryption.use_legacy_base64_encoding', false, false],
-			]);
-
-		/** @var Crypt|\PHPUnit\Framework\MockObject\MockObject $crypt */
-		$crypt = $this->getMockBuilder(Crypt::class)
-			->setConstructorArgs([
-				$this->logger,
-				$this->userSession,
-				$this->config,
-				$this->l
-			])
-			->onlyMethods([
-				'parseHeader',
-				'generatePasswordHash',
-				'symmetricDecryptFileContent',
-				'isValidPrivateKey'
-			])
-			->getMock();
-
-		$crypt->expects($this->once())->method('parseHeader')->willReturn($header);
-		if (isset($header['keyFormat']) && $header['keyFormat'] === 'hash') {
-			$crypt->expects($this->once())->method('generatePasswordHash')->willReturn('hash');
-			$password = 'hash';
-		} else {
-			$crypt->expects($this->never())->method('generatePasswordHash');
-			$password = 'password';
-		}
-
-		$crypt->expects($this->once())->method('symmetricDecryptFileContent')
-			->with('privateKey', $password, $expectedCipher)->willReturn('key');
-		$crypt->expects($this->once())->method('isValidPrivateKey')->willReturn($isValidKey);
-
-		$result = $crypt->decryptPrivateKey($privateKey, 'password');
-
-		$this->assertSame($expected, $result);
-	}
-
-	public static function dataTestDecryptPrivateKey(): array {
-		return [
-			[['cipher' => 'AES-128-CFB', 'keyFormat' => 'password'], 'HBEGIN:HENDprivateKey', 'AES-128-CFB', true, 'key'],
-			[['cipher' => 'AES-256-CFB', 'keyFormat' => 'password'], 'HBEGIN:HENDprivateKey', 'AES-256-CFB', true, 'key'],
-			[['cipher' => 'AES-256-CFB', 'keyFormat' => 'password'], 'HBEGIN:HENDprivateKey', 'AES-256-CFB', false, false],
-			[['cipher' => 'AES-256-CFB', 'keyFormat' => 'hash'], 'HBEGIN:HENDprivateKey', 'AES-256-CFB', true, 'key'],
-			[['cipher' => 'AES-256-CFB'], 'HBEGIN:HENDprivateKey', 'AES-256-CFB', true, 'key'],
-			[[], 'privateKey', 'AES-128-CFB', true, 'key'],
-		];
-	}
-
-	public function testIsValidPrivateKey(): void {
-		$res = openssl_pkey_new();
-		openssl_pkey_export($res, $privateKey);
-
-		// valid private key
-		$this->assertTrue(
-			$this->invokePrivate($this->crypt, 'isValidPrivateKey', [$privateKey])
-		);
-
-		// invalid private key
-		$this->assertFalse(
-			$this->invokePrivate($this->crypt, 'isValidPrivateKey', ['foo'])
-		);
-	}
-
-	public function testMultiKeyEncrypt(): void {
-		$res = openssl_pkey_new();
-		openssl_pkey_export($res, $privateKey);
-		$publicKeyPem = openssl_pkey_get_details($res)['key'];
-		$publicKey = openssl_pkey_get_public($publicKeyPem);
-
-		$shareKeys = $this->crypt->multiKeyEncrypt('content', ['user1' => $publicKey]);
-		$this->assertEquals(
-			'content',
-			$this->crypt->multiKeyDecrypt($shareKeys['user1'], $privateKey)
-		);
-	}
+    protected LoggerInterface&MockObject $logger;
+    protected IUserSession&MockObject $userSession;
+    protected IConfig&MockObject $config;
+    protected IL10N&MockObject $l;
+
+    protected Crypt $crypt;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->logger = $this->getMockBuilder(LoggerInterface::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $this->logger->expects($this->any())
+            ->method('warning');
+        $this->userSession = $this->getMockBuilder(IUserSession::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $this->config = $this->getMockBuilder(IConfig::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $this->l = $this->createMock(IL10N::class);
+
+        $this->crypt = new Crypt($this->logger, $this->userSession, $this->config, $this->l);
+    }
+
+    /**
+     * test getOpenSSLConfig without any additional parameters
+     */
+    public function testGetOpenSSLConfigBasic(): void {
+        $this->config->expects($this->once())
+            ->method('getSystemValue')
+            ->with($this->equalTo('openssl'), $this->equalTo([]))
+            ->willReturn([]);
+
+        $result = self::invokePrivate($this->crypt, 'getOpenSSLConfig');
+        $this->assertSame(1, count($result));
+        $this->assertArrayHasKey('private_key_bits', $result);
+        $this->assertSame(4096, $result['private_key_bits']);
+    }
+
+    /**
+     * test getOpenSSLConfig with additional parameters defined in config.php
+     */
+    public function testGetOpenSSLConfig(): void {
+        $this->config->expects($this->once())
+            ->method('getSystemValue')
+            ->with($this->equalTo('openssl'), $this->equalTo([]))
+            ->willReturn(['foo' => 'bar', 'private_key_bits' => 1028]);
+
+        $result = self::invokePrivate($this->crypt, 'getOpenSSLConfig');
+        $this->assertSame(2, count($result));
+        $this->assertArrayHasKey('private_key_bits', $result);
+        $this->assertArrayHasKey('foo', $result);
+        $this->assertSame(1028, $result['private_key_bits']);
+        $this->assertSame('bar', $result['foo']);
+    }
+
+
+    /**
+     * test generateHeader with valid key formats
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestGenerateHeader')]
+    public function testGenerateHeader($keyFormat, $expected): void {
+        $this->config->expects($this->once())
+            ->method('getSystemValueString')
+            ->with($this->equalTo('cipher'), $this->equalTo('AES-256-CTR'))
+            ->willReturn('AES-128-CFB');
+
+        if ($keyFormat) {
+            $result = $this->crypt->generateHeader($keyFormat);
+        } else {
+            $result = $this->crypt->generateHeader();
+        }
+
+        $this->assertSame($expected, $result);
+    }
+
+    /**
+     * test generateHeader with invalid key format
+     *
+     */
+    public function testGenerateHeaderInvalid(): void {
+        $this->expectException(\InvalidArgumentException::class);
+
+        $this->crypt->generateHeader('unknown');
+    }
+
+    public static function dataTestGenerateHeader(): array {
+        return [
+            [null, 'HBEGIN:cipher:AES-128-CFB:keyFormat:hash2:encoding:binary:HEND'],
+            ['password', 'HBEGIN:cipher:AES-128-CFB:keyFormat:password:encoding:binary:HEND'],
+            ['hash', 'HBEGIN:cipher:AES-128-CFB:keyFormat:hash:encoding:binary:HEND']
+        ];
+    }
+
+    public function testGetCipherWithInvalidCipher(): void {
+        $this->config->expects($this->once())
+            ->method('getSystemValueString')
+            ->with($this->equalTo('cipher'), $this->equalTo('AES-256-CTR'))
+            ->willReturn('Not-Existing-Cipher');
+        $this->logger
+            ->expects($this->once())
+            ->method('warning')
+            ->with('Unsupported cipher (Not-Existing-Cipher) defined in config.php supported. Falling back to AES-256-CTR');
+
+        $this->assertSame('AES-256-CTR', $this->crypt->getCipher());
+    }
+
+    /**
+     * @param string $configValue
+     * @param string $expected
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataProviderGetCipher')]
+    public function testGetCipher($configValue, $expected): void {
+        $this->config->expects($this->once())
+            ->method('getSystemValueString')
+            ->with($this->equalTo('cipher'), $this->equalTo('AES-256-CTR'))
+            ->willReturn($configValue);
+
+        $this->assertSame($expected,
+            $this->crypt->getCipher()
+        );
+    }
+
+    /**
+     * data provider for testGetCipher
+     */
+    public static function dataProviderGetCipher(): array {
+        return [
+            ['AES-128-CFB', 'AES-128-CFB'],
+            ['AES-256-CFB', 'AES-256-CFB'],
+            ['AES-128-CTR', 'AES-128-CTR'],
+            ['AES-256-CTR', 'AES-256-CTR'],
+
+            ['unknown', 'AES-256-CTR']
+        ];
+    }
+
+    /**
+     * test concatIV()
+     */
+    public function testConcatIV(): void {
+        $result = self::invokePrivate(
+            $this->crypt,
+            'concatIV',
+            ['content', 'my_iv']);
+
+        $this->assertSame('content00iv00my_iv',
+            $result
+        );
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestSplitMetaData')]
+    public function testSplitMetaData($data, $expected): void {
+        $this->config->method('getSystemValueBool')
+            ->with('encryption_skip_signature_check', false)
+            ->willReturn(true);
+        $result = self::invokePrivate($this->crypt, 'splitMetaData', [$data, 'AES-256-CFB']);
+        $this->assertTrue(is_array($result));
+        $this->assertSame(3, count($result));
+        $this->assertArrayHasKey('encrypted', $result);
+        $this->assertArrayHasKey('iv', $result);
+        $this->assertArrayHasKey('signature', $result);
+        $this->assertSame($expected['encrypted'], $result['encrypted']);
+        $this->assertSame($expected['iv'], $result['iv']);
+        $this->assertSame($expected['signature'], $result['signature']);
+    }
+
+    public static function dataTestSplitMetaData(): array {
+        return [
+            ['encryptedContent00iv001234567890123456xx',
+                ['encrypted' => 'encryptedContent', 'iv' => '1234567890123456', 'signature' => false]],
+            ['encryptedContent00iv00123456789012345600sig00e1992521e437f6915f9173b190a512cfc38a00ac24502db44e0ba10c2bb0cc86xxx',
+                ['encrypted' => 'encryptedContent', 'iv' => '1234567890123456', 'signature' => 'e1992521e437f6915f9173b190a512cfc38a00ac24502db44e0ba10c2bb0cc86']],
+        ];
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestHasSignature')]
+    public function testHasSignature($data, $expected): void {
+        $this->config->method('getSystemValueBool')
+            ->with('encryption_skip_signature_check', false)
+            ->willReturn(true);
+        $this->assertSame($expected,
+            $this->invokePrivate($this->crypt, 'hasSignature', [$data, 'AES-256-CFB'])
+        );
+    }
+
+    public static function dataTestHasSignature(): array {
+        return [
+            ['encryptedContent00iv001234567890123456xx', false],
+            ['encryptedContent00iv00123456789012345600sig00e1992521e437f6915f9173b190a512cfc38a00ac24502db44e0ba10c2bb0cc86xxx', true]
+        ];
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestHasSignatureFail')]
+    public function testHasSignatureFail($cipher): void {
+        $this->expectException(GenericEncryptionException::class);
+
+        $data = 'encryptedContent00iv001234567890123456xx';
+        $this->invokePrivate($this->crypt, 'hasSignature', [$data, $cipher]);
+    }
+
+    public static function dataTestHasSignatureFail(): array {
+        return [
+            ['AES-256-CTR'],
+            ['aes-256-ctr'],
+            ['AES-128-CTR'],
+            ['ctr-256-ctr']
+        ];
+    }
+
+    /**
+     * test addPadding()
+     */
+    public function testAddPadding(): void {
+        $result = self::invokePrivate($this->crypt, 'addPadding', ['data']);
+        $this->assertSame('dataxxx', $result);
+    }
+
+    /**
+     * test removePadding()
+     *
+     * @param $data
+     * @param $expected
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataProviderRemovePadding')]
+    public function testRemovePadding($data, $expected): void {
+        $result = self::invokePrivate($this->crypt, 'removePadding', [$data]);
+        $this->assertSame($expected, $result);
+    }
+
+    /**
+     * data provider for testRemovePadding
+     */
+    public static function dataProviderRemovePadding(): array {
+        return [
+            ['dataxx', 'data'],
+            ['data', false]
+        ];
+    }
+
+    /**
+     * test parseHeader()
+     */
+    public function testParseHeader(): void {
+        $header = 'HBEGIN:foo:bar:cipher:AES-256-CFB:encoding:binary:HEND';
+        $result = self::invokePrivate($this->crypt, 'parseHeader', [$header]);
+
+        $this->assertTrue(is_array($result));
+        $this->assertSame(3, count($result));
+        $this->assertArrayHasKey('foo', $result);
+        $this->assertArrayHasKey('cipher', $result);
+        $this->assertArrayHasKey('encoding', $result);
+        $this->assertSame('bar', $result['foo']);
+        $this->assertSame('AES-256-CFB', $result['cipher']);
+        $this->assertSame('binary', $result['encoding']);
+    }
+
+    /**
+     * test encrypt()
+     *
+     * @return string
+     */
+    public function testEncrypt() {
+        $decrypted = 'content';
+        $password = 'password';
+        $cipher = 'AES-256-CTR';
+        $iv = self::invokePrivate($this->crypt, 'generateIv');
+
+        $this->assertTrue(is_string($iv));
+        $this->assertSame(16, strlen($iv));
+
+        $result = self::invokePrivate($this->crypt, 'encrypt', [$decrypted, $iv, $password, $cipher]);
+
+        $this->assertTrue(is_string($result));
+
+        return [
+            'password' => $password,
+            'iv' => $iv,
+            'cipher' => $cipher,
+            'encrypted' => $result,
+            'decrypted' => $decrypted];
+    }
+
+    /**
+     * test decrypt()
+     *
+     * @depends testEncrypt
+     */
+    public function testDecrypt($data): void {
+        $result = self::invokePrivate(
+            $this->crypt,
+            'decrypt',
+            [$data['encrypted'], $data['iv'], $data['password'], $data['cipher'], true]);
+
+        $this->assertSame($data['decrypted'], $result);
+    }
+
+    /**
+     * test return values of valid ciphers
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestGetKeySize')]
+    public function testGetKeySize($cipher, $expected): void {
+        $result = $this->invokePrivate($this->crypt, 'getKeySize', [$cipher]);
+        $this->assertSame($expected, $result);
+    }
+
+    /**
+     * test exception if cipher is unknown
+     *
+     */
+    public function testGetKeySizeFailure(): void {
+        $this->expectException(\InvalidArgumentException::class);
+
+        $this->invokePrivate($this->crypt, 'getKeySize', ['foo']);
+    }
+
+    public static function dataTestGetKeySize(): array {
+        return [
+            ['AES-256-CFB', 32],
+            ['AES-128-CFB', 16],
+            ['AES-256-CTR', 32],
+            ['AES-128-CTR', 16],
+        ];
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestDecryptPrivateKey')]
+    public function testDecryptPrivateKey($header, $privateKey, $expectedCipher, $isValidKey, $expected): void {
+        $this->config->method('getSystemValueBool')
+            ->willReturnMap([
+                ['encryption.legacy_format_support', false, true],
+                ['encryption.use_legacy_base64_encoding', false, false],
+            ]);
+
+        /** @var Crypt|\PHPUnit\Framework\MockObject\MockObject $crypt */
+        $crypt = $this->getMockBuilder(Crypt::class)
+            ->setConstructorArgs([
+                $this->logger,
+                $this->userSession,
+                $this->config,
+                $this->l
+            ])
+            ->onlyMethods([
+                'parseHeader',
+                'generatePasswordHash',
+                'symmetricDecryptFileContent',
+                'isValidPrivateKey'
+            ])
+            ->getMock();
+
+        $crypt->expects($this->once())->method('parseHeader')->willReturn($header);
+        if (isset($header['keyFormat']) && $header['keyFormat'] === 'hash') {
+            $crypt->expects($this->once())->method('generatePasswordHash')->willReturn('hash');
+            $password = 'hash';
+        } else {
+            $crypt->expects($this->never())->method('generatePasswordHash');
+            $password = 'password';
+        }
+
+        $crypt->expects($this->once())->method('symmetricDecryptFileContent')
+            ->with('privateKey', $password, $expectedCipher)->willReturn('key');
+        $crypt->expects($this->once())->method('isValidPrivateKey')->willReturn($isValidKey);
+
+        $result = $crypt->decryptPrivateKey($privateKey, 'password');
+
+        $this->assertSame($expected, $result);
+    }
+
+    public static function dataTestDecryptPrivateKey(): array {
+        return [
+            [['cipher' => 'AES-128-CFB', 'keyFormat' => 'password'], 'HBEGIN:HENDprivateKey', 'AES-128-CFB', true, 'key'],
+            [['cipher' => 'AES-256-CFB', 'keyFormat' => 'password'], 'HBEGIN:HENDprivateKey', 'AES-256-CFB', true, 'key'],
+            [['cipher' => 'AES-256-CFB', 'keyFormat' => 'password'], 'HBEGIN:HENDprivateKey', 'AES-256-CFB', false, false],
+            [['cipher' => 'AES-256-CFB', 'keyFormat' => 'hash'], 'HBEGIN:HENDprivateKey', 'AES-256-CFB', true, 'key'],
+            [['cipher' => 'AES-256-CFB'], 'HBEGIN:HENDprivateKey', 'AES-256-CFB', true, 'key'],
+            [[], 'privateKey', 'AES-128-CFB', true, 'key'],
+        ];
+    }
+
+    public function testIsValidPrivateKey(): void {
+        $res = openssl_pkey_new();
+        openssl_pkey_export($res, $privateKey);
+
+        // valid private key
+        $this->assertTrue(
+            $this->invokePrivate($this->crypt, 'isValidPrivateKey', [$privateKey])
+        );
+
+        // invalid private key
+        $this->assertFalse(
+            $this->invokePrivate($this->crypt, 'isValidPrivateKey', ['foo'])
+        );
+    }
+
+    public function testMultiKeyEncrypt(): void {
+        $res = openssl_pkey_new();
+        openssl_pkey_export($res, $privateKey);
+        $publicKeyPem = openssl_pkey_get_details($res)['key'];
+        $publicKey = openssl_pkey_get_public($publicKeyPem);
+
+        $shareKeys = $this->crypt->multiKeyEncrypt('content', ['user1' => $publicKey]);
+        $this->assertEquals(
+            'content',
+            $this->crypt->multiKeyDecrypt($shareKeys['user1'], $privateKey)
+        );
+    }
 }

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')
-			->willReturnCallback(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')
+            ->willReturnCallback(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());
+    }
 }

Spacing +1 added lines, -1 removed lines

@@ -53,7 +53,7 @@
 	public function testGetForm(): void {
 		$this->config
 			->method('getAppValue')
-			->willReturnCallback(function ($app, $key, $default) {
+			->willReturnCallback(function($app, $key, $default) {
 				if ($app === 'encryption' && $key === 'recoveryAdminEnabled' && $default === '0') {
 					return '1';
 				}

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();
-	}
-
-	/**
-	 *
-	 * @param bool $hasKeys
-	 * @param bool $expected
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestSetupUser')]
-	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();
+    }
+
+    /**
+     *
+     * @param bool $hasKeys
+     * @param bool $expected
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestSetupUser')]
+    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 +674 added lines, -674 removed lines

@@ -31,678 +31,678 @@
 
 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')
-		);
-	}
-
-	#[\PHPUnit\Framework\Attributes\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);
-	}
-
-	/**
-	 * @param bool $useMasterKey
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestInit')]
-	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): void {
-				$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, '', ''],
-		];
-	}
-
-	/**
-	 *
-	 * @param $uid
-	 * @param $isMasterKeyEnabled
-	 * @param $privateKey
-	 * @param $expected
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestGetFileKey')]
-	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
-	 *
-	 *
-	 * @param array $accessList
-	 * @param array $publicKeys
-	 * @param string $uid
-	 * @param array $expectedKeys
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestAddSystemKeys')]
-	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', []);
-	}
-
-	/**
-	 * @param $masterKey
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestValidateMasterKey')]
-	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')
+        );
+    }
+
+    #[\PHPUnit\Framework\Attributes\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);
+    }
+
+    /**
+     * @param bool $useMasterKey
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestInit')]
+    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): void {
+                $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, '', ''],
+        ];
+    }
+
+    /**
+     *
+     * @param $uid
+     * @param $isMasterKeyEnabled
+     * @param $privateKey
+     * @param $expected
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestGetFileKey')]
+    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
+     *
+     *
+     * @param array $accessList
+     * @param array $publicKeys
+     * @param string $uid
+     * @param array $expectedKeys
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestAddSystemKeys')]
+    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', []);
+    }
+
+    /**
+     * @param $masterKey
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestValidateMasterKey')]
+    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');
+    }
 }

Spacing +10 added lines, -10 removed lines

@@ -116,7 +116,7 @@ 
 	public function testRecoveryKeyExists(): void {
 		$this->keyStorageMock->expects($this->any())
 			->method('getSystemUserKey')
-			->with($this->equalTo($this->systemKeyId . '.publicKey'))
+			->with($this->equalTo($this->systemKeyId.'.publicKey'))
 			->willReturn('recoveryKey');
 
 
@@ -126,7 +126,7 @@ 
 	public function testCheckRecoveryKeyPassword(): void {
 		$this->keyStorageMock->expects($this->any())
 			->method('getSystemUserKey')
-			->with($this->equalTo($this->systemKeyId . '.privateKey'))
+			->with($this->equalTo($this->systemKeyId.'.privateKey'))
 			->willReturn('recoveryKey');
 		$this->cryptMock->expects($this->any())
 			->method('decryptPrivateKey')
@@ -192,7 +192,7 @@ 
 
 		$this->keyStorageMock->expects($this->exactly(2))
 			->method('getUserKey')
-			->willReturnCallback(function ($uid, $keyID, $encryptionModuleId) {
+			->willReturnCallback(function($uid, $keyID, $encryptionModuleId) {
 				if ($keyID === 'privateKey') {
 					return '';
 				}
@@ -208,7 +208,7 @@ 
 
 		$this->keyStorageMock->expects($this->exactly(2))
 			->method('getUserKey')
-			->willReturnCallback(function ($uid, $keyID, $encryptionModuleId) {
+			->willReturnCallback(function($uid, $keyID, $encryptionModuleId) {
 				if ($keyID === 'publicKey') {
 					return '';
 				}
@@ -245,7 +245,7 @@ 
 		$sessionSetStatusCalls = [];
 		$this->sessionMock->expects($this->exactly(2))
 			->method('setStatus')
-			->willReturnCallback(function (string $status) use (&$sessionSetStatusCalls): void {
+			->willReturnCallback(function(string $status) use (&$sessionSetStatusCalls): void {
 				$sessionSetStatusCalls[] = $status;
 			});
 
@@ -379,7 +379,7 @@ 
 			->method('getFileKey')
 			->willReturnMap([
 				[$path, 'fileKey', 'OC_DEFAULT_MODULE', $encryptedFileKey],
-				[$path, $expectedUid . '.shareKey', 'OC_DEFAULT_MODULE', 'fileKey'],
+				[$path, $expectedUid.'.shareKey', 'OC_DEFAULT_MODULE', 'fileKey'],
 			]);
 
 		$this->utilMock->expects($this->any())->method('isMasterKeyEnabled')
@@ -462,13 +462,13 @@ 
 
 		$this->keyStorageMock->expects($this->any())
 			->method('getSystemUserKey')
-			->willReturnCallback(function ($keyId, $encryptionModuleId) {
+			->willReturnCallback(function($keyId, $encryptionModuleId) {
 				return $keyId;
 			});
 
 		$this->utilMock->expects($this->any())
 			->method('isRecoveryEnabledForUser')
-			->willReturnCallback(function ($uid) {
+			->willReturnCallback(function($uid) {
 				if ($uid === 'user1') {
 					return true;
 				}
@@ -495,9 +495,9 @@ 
 	 */
 	public static function dataTestAddSystemKeys(): array {
 		return [
-			[['public' => true],[], 'user1', ['publicShareKey', 'recoveryKey']],
+			[['public' => true], [], 'user1', ['publicShareKey', 'recoveryKey']],
 			[['public' => false], [], 'user1', ['recoveryKey']],
-			[['public' => true],[], 'user2', ['publicShareKey']],
+			[['public' => true], [], 'user2', ['publicShareKey']],
 			[['public' => false], [], 'user2', []],
 		];
 	}

apps/user_status/tests/Unit/Db/UserStatusMapperTest.php

Indentation +314 added lines, -314 removed lines

@@ -15,318 +15,318 @@
 use Test\TestCase;
 
 class UserStatusMapperTest extends TestCase {
-	private UserStatusMapper $mapper;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		// make sure that DB is empty
-		$qb = self::$realDatabase->getQueryBuilder();
-		$qb->delete('user_status')->execute();
-
-		$this->mapper = new UserStatusMapper(self::$realDatabase);
-	}
-
-	public function testGetTableName(): void {
-		$this->assertEquals('user_status', $this->mapper->getTableName());
-	}
-
-	public function testGetFindAll(): void {
-		$this->insertSampleStatuses();
-
-		$allResults = $this->mapper->findAll();
-		$this->assertCount(3, $allResults);
-
-		$limitedResults = $this->mapper->findAll(2);
-		$this->assertCount(2, $limitedResults);
-		$this->assertEquals('admin', $limitedResults[0]->getUserId());
-		$this->assertEquals('user1', $limitedResults[1]->getUserId());
-
-		$offsetResults = $this->mapper->findAll(null, 2);
-		$this->assertCount(1, $offsetResults);
-		$this->assertEquals('user2', $offsetResults[0]->getUserId());
-	}
-
-	public function testFindAllRecent(): void {
-		$this->insertSampleStatuses();
-
-		$allResults = $this->mapper->findAllRecent(2, 0);
-		$this->assertCount(2, $allResults);
-		$this->assertEquals('user2', $allResults[0]->getUserId());
-		$this->assertEquals('user1', $allResults[1]->getUserId());
-	}
-
-	public function testGetFind(): void {
-		$this->insertSampleStatuses();
-
-		$adminStatus = $this->mapper->findByUserId('admin');
-		$this->assertEquals('admin', $adminStatus->getUserId());
-		$this->assertEquals('offline', $adminStatus->getStatus());
-		$this->assertEquals(0, $adminStatus->getStatusTimestamp());
-		$this->assertEquals(false, $adminStatus->getIsUserDefined());
-		$this->assertEquals(null, $adminStatus->getCustomIcon());
-		$this->assertEquals(null, $adminStatus->getCustomMessage());
-		$this->assertEquals(null, $adminStatus->getClearAt());
-
-		$user1Status = $this->mapper->findByUserId('user1');
-		$this->assertEquals('user1', $user1Status->getUserId());
-		$this->assertEquals('dnd', $user1Status->getStatus());
-		$this->assertEquals(5000, $user1Status->getStatusTimestamp());
-		$this->assertEquals(true, $user1Status->getIsUserDefined());
-		$this->assertEquals('

apps/user_status/tests/Unit/Controller/UserStatusControllerTest.php

Indentation +283 added lines, -283 removed lines

@@ -27,287 +27,287 @@
 use Throwable;
 
 class UserStatusControllerTest extends TestCase {
-	private LoggerInterface&MockObject $logger;
-	private StatusService&MockObject $statusService;
-	private CalendarStatusService&MockObject $calendarStatusService;
-	private UserStatusController $controller;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$request = $this->createMock(IRequest::class);
-		$userId = 'john.doe';
-		$this->logger = $this->createMock(LoggerInterface::class);
-		$this->statusService = $this->createMock(StatusService::class);
-		$this->calendarStatusService = $this->createMock(CalendarStatusService::class);
-
-		$this->controller = new UserStatusController(
-			'user_status',
-			$request,
-			$userId,
-			$this->logger,
-			$this->statusService,
-			$this->calendarStatusService,
-		);
-	}
-
-	public function testGetStatus(): void {
-		$userStatus = $this->getUserStatus();
-
-		$this->statusService->expects($this->once())
-			->method('findByUserId')
-			->with('john.doe')
-			->willReturn($userStatus);
-
-		$response = $this->controller->getStatus();
-		$this->assertEquals([
-			'userId' => 'john.doe',
-			'status' => 'invisible',
-			'icon' => '

apps/user_status/tests/Unit/Service/StatusServiceTest.php

Indentation +794 added lines, -794 removed lines

@@ -31,798 +31,798 @@
 use Test\TestCase;
 
 class StatusServiceTest extends TestCase {
-	private UserStatusMapper&MockObject $mapper;
-	private ITimeFactory&MockObject $timeFactory;
-	private PredefinedStatusService&MockObject $predefinedStatusService;
-	private IEmojiHelper&MockObject $emojiHelper;
-	private IConfig&MockObject $config;
-	private IUserManager&MockObject $userManager;
-	private LoggerInterface&MockObject $logger;
-
-	private StatusService $service;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->mapper = $this->createMock(UserStatusMapper::class);
-		$this->timeFactory = $this->createMock(ITimeFactory::class);
-		$this->predefinedStatusService = $this->createMock(PredefinedStatusService::class);
-		$this->emojiHelper = $this->createMock(IEmojiHelper::class);
-		$this->userManager = $this->createMock(IUserManager::class);
-		$this->config = $this->createMock(IConfig::class);
-		$this->logger = $this->createMock(LoggerInterface::class);
-
-		$this->config->method('getAppValue')
-			->willReturnMap([
-				['core', 'shareapi_allow_share_dialog_user_enumeration', 'yes', 'yes'],
-				['core', 'shareapi_restrict_user_enumeration_to_group', 'no', 'no']
-			]);
-
-		$this->service = new StatusService($this->mapper,
-			$this->timeFactory,
-			$this->predefinedStatusService,
-			$this->emojiHelper,
-			$this->config,
-			$this->userManager,
-			$this->logger,
-		);
-	}
-
-	public function testFindAll(): void {
-		$status1 = $this->createMock(UserStatus::class);
-		$status2 = $this->createMock(UserStatus::class);
-
-		$this->mapper->expects($this->once())
-			->method('findAll')
-			->with(20, 50)
-			->willReturn([$status1, $status2]);
-
-		$this->assertEquals([
-			$status1,
-			$status2,
-		], $this->service->findAll(20, 50));
-	}
-
-	public function testFindAllRecentStatusChanges(): void {
-		$status1 = $this->createMock(UserStatus::class);
-		$status2 = $this->createMock(UserStatus::class);
-
-		$this->mapper->expects($this->once())
-			->method('findAllRecent')
-			->with(20, 50)
-			->willReturn([$status1, $status2]);
-
-		$this->assertEquals([
-			$status1,
-			$status2,
-		], $this->service->findAllRecentStatusChanges(20, 50));
-	}
-
-	public function testFindAllRecentStatusChangesNoEnumeration(): void {
-		$status1 = $this->createMock(UserStatus::class);
-		$status2 = $this->createMock(UserStatus::class);
-
-		$this->mapper->method('findAllRecent')
-			->with(20, 50)
-			->willReturn([$status1, $status2]);
-
-		// Rebuild $this->service with user enumeration turned off
-		$this->config = $this->createMock(IConfig::class);
-
-		$this->config->method('getAppValue')
-			->willReturnMap([
-				['core', 'shareapi_allow_share_dialog_user_enumeration', 'yes', 'no'],
-				['core', 'shareapi_restrict_user_enumeration_to_group', 'no', 'no']
-			]);
-
-		$this->service = new StatusService($this->mapper,
-			$this->timeFactory,
-			$this->predefinedStatusService,
-			$this->emojiHelper,
-			$this->config,
-			$this->userManager,
-			$this->logger,
-		);
-
-		$this->assertEquals([], $this->service->findAllRecentStatusChanges(20, 50));
-
-		// Rebuild $this->service with user enumeration limited to common groups
-		$this->config = $this->createMock(IConfig::class);
-
-		$this->config->method('getAppValue')
-			->willReturnMap([
-				['core', 'shareapi_allow_share_dialog_user_enumeration', 'yes', 'yes'],
-				['core', 'shareapi_restrict_user_enumeration_to_group', 'no', 'yes']
-			]);
-
-		$this->service = new StatusService($this->mapper,
-			$this->timeFactory,
-			$this->predefinedStatusService,
-			$this->emojiHelper,
-			$this->config,
-			$this->userManager,
-			$this->logger,
-		);
-
-		$this->assertEquals([], $this->service->findAllRecentStatusChanges(20, 50));
-	}
-
-	public function testFindByUserIdDoesNotExist(): void {
-		$this->mapper->expects($this->once())
-			->method('findByUserId')
-			->with('john.doe')
-			->willThrowException(new DoesNotExistException(''));
-
-		$this->expectException(DoesNotExistException::class);
-		$this->service->findByUserId('john.doe');
-	}
-
-	public function testFindAllAddDefaultMessage(): void {
-		$status = new UserStatus();
-		$status->setMessageId('commuting');
-
-		$this->predefinedStatusService->expects($this->once())
-			->method('getDefaultStatusById')
-			->with('commuting')
-			->willReturn([
-				'id' => 'commuting',
-				'icon' => '

Spacing +65 added lines, -65 removed lines

@@ -286,59 +286,59 @@ 
 
 	public static function setStatusDataProvider(): array {
 		return [
-			['john.doe', 'online', 50,   true,  true,  true, false, false, null, null],
-			['john.doe', 'online', 50,   true,  false, true, false, false, null, null],
-			['john.doe', 'online', 50,   false, true,  true, false, false, null, null],
-			['john.doe', 'online', 50,   false, false, true, false, false, null, null],
-			['john.doe', 'online', null, true,  true,  true, true,  false, null, null],
-			['john.doe', 'online', null, true,  false, true, true,  false, null, null],
-			['john.doe', 'online', null, false, true,  true, true,  false, null, null],
-			['john.doe', 'online', null, false, false, true, true,  false, null, null],
-
-			['john.doe', 'away', 50,   true,  true,  true, false, false, null, null],
-			['john.doe', 'away', 50,   true,  false, true, false, false, null, null],
-			['john.doe', 'away', 50,   false, true,  true, false, false, null, null],
-			['john.doe', 'away', 50,   false, false, true, false, false, null, null],
-			['john.doe', 'away', null, true,  true,  true, true,  false, null, null],
-			['john.doe', 'away', null, true,  false, true, true,  false, null, null],
-			['john.doe', 'away', null, false, true,  true, true,  false, null, null],
-			['john.doe', 'away', null, false, false, true, true,  false, null, null],
-
-			['john.doe', 'dnd', 50,   true,  true,  true, false, false, null, null],
-			['john.doe', 'dnd', 50,   true,  false, true, false, false, null, null],
-			['john.doe', 'dnd', 50,   false, true,  true, false, false, null, null],
-			['john.doe', 'dnd', 50,   false, false, true, false, false, null, null],
-			['john.doe', 'dnd', null, true,  true,  true, true,  false, null, null],
-			['john.doe', 'dnd', null, true,  false, true, true,  false, null, null],
-			['john.doe', 'dnd', null, false, true,  true, true,  false, null, null],
-			['john.doe', 'dnd', null, false, false, true, true,  false, null, null],
-
-			['john.doe', 'invisible', 50,   true,  true,  true, false, false, null, null],
-			['john.doe', 'invisible', 50,   true,  false, true, false, false, null, null],
-			['john.doe', 'invisible', 50,   false, true,  true, false, false, null, null],
-			['john.doe', 'invisible', 50,   false, false, true, false, false, null, null],
-			['john.doe', 'invisible', null, true,  true,  true, true,  false, null, null],
-			['john.doe', 'invisible', null, true,  false, true, true,  false, null, null],
-			['john.doe', 'invisible', null, false, true,  true, true,  false, null, null],
-			['john.doe', 'invisible', null, false, false, true, true,  false, null, null],
-
-			['john.doe', 'offline', 50,   true,  true,  true, false, false, null, null],
-			['john.doe', 'offline', 50,   true,  false, true, false, false, null, null],
-			['john.doe', 'offline', 50,   false, true,  true, false, false, null, null],
-			['john.doe', 'offline', 50,   false, false, true, false, false, null, null],
-			['john.doe', 'offline', null, true,  true,  true, true,  false, null, null],
-			['john.doe', 'offline', null, true,  false, true, true,  false, null, null],
-			['john.doe', 'offline', null, false, true,  true, true,  false, null, null],
-			['john.doe', 'offline', null, false, false, true, true,  false, null, null],
-
-			['john.doe', 'illegal-status', 50,   true,  true,  false, false, true, InvalidStatusTypeException::class, 'Status-type "illegal-status" is not supported'],
-			['john.doe', 'illegal-status', 50,   true,  false, false, false, true, InvalidStatusTypeException::class, 'Status-type "illegal-status" is not supported'],
-			['john.doe', 'illegal-status', 50,   false, true,  false, false, true, InvalidStatusTypeException::class, 'Status-type "illegal-status" is not supported'],
-			['john.doe', 'illegal-status', 50,   false, false, false, false, true, InvalidStatusTypeException::class, 'Status-type "illegal-status" is not supported'],
-			['john.doe', 'illegal-status', null, true,  true,  false, true,  true, InvalidStatusTypeException::class, 'Status-type "illegal-status" is not supported'],
-			['john.doe', 'illegal-status', null, true,  false, false, true,  true, InvalidStatusTypeException::class, 'Status-type "illegal-status" is not supported'],
-			['john.doe', 'illegal-status', null, false, true,  false, true,  true, InvalidStatusTypeException::class, 'Status-type "illegal-status" is not supported'],
-			['john.doe', 'illegal-status', null, false, false, false, true,  true, InvalidStatusTypeException::class, 'Status-type "illegal-status" is not supported'],
+			['john.doe', 'online', 50, true, true, true, false, false, null, null],
+			['john.doe', 'online', 50, true, false, true, false, false, null, null],
+			['john.doe', 'online', 50, false, true, true, false, false, null, null],
+			['john.doe', 'online', 50, false, false, true, false, false, null, null],
+			['john.doe', 'online', null, true, true, true, true, false, null, null],
+			['john.doe', 'online', null, true, false, true, true, false, null, null],
+			['john.doe', 'online', null, false, true, true, true, false, null, null],
+			['john.doe', 'online', null, false, false, true, true, false, null, null],
+
+			['john.doe', 'away', 50, true, true, true, false, false, null, null],
+			['john.doe', 'away', 50, true, false, true, false, false, null, null],
+			['john.doe', 'away', 50, false, true, true, false, false, null, null],
+			['john.doe', 'away', 50, false, false, true, false, false, null, null],
+			['john.doe', 'away', null, true, true, true, true, false, null, null],
+			['john.doe', 'away', null, true, false, true, true, false, null, null],
+			['john.doe', 'away', null, false, true, true, true, false, null, null],
+			['john.doe', 'away', null, false, false, true, true, false, null, null],
+
+			['john.doe', 'dnd', 50, true, true, true, false, false, null, null],
+			['john.doe', 'dnd', 50, true, false, true, false, false, null, null],
+			['john.doe', 'dnd', 50, false, true, true, false, false, null, null],
+			['john.doe', 'dnd', 50, false, false, true, false, false, null, null],
+			['john.doe', 'dnd', null, true, true, true, true, false, null, null],
+			['john.doe', 'dnd', null, true, false, true, true, false, null, null],
+			['john.doe', 'dnd', null, false, true, true, true, false, null, null],
+			['john.doe', 'dnd', null, false, false, true, true, false, null, null],
+
+			['john.doe', 'invisible', 50, true, true, true, false, false, null, null],
+			['john.doe', 'invisible', 50, true, false, true, false, false, null, null],
+			['john.doe', 'invisible', 50, false, true, true, false, false, null, null],
+			['john.doe', 'invisible', 50, false, false, true, false, false, null, null],
+			['john.doe', 'invisible', null, true, true, true, true, false, null, null],
+			['john.doe', 'invisible', null, true, false, true, true, false, null, null],
+			['john.doe', 'invisible', null, false, true, true, true, false, null, null],
+			['john.doe', 'invisible', null, false, false, true, true, false, null, null],
+
+			['john.doe', 'offline', 50, true, true, true, false, false, null, null],
+			['john.doe', 'offline', 50, true, false, true, false, false, null, null],
+			['john.doe', 'offline', 50, false, true, true, false, false, null, null],
+			['john.doe', 'offline', 50, false, false, true, false, false, null, null],
+			['john.doe', 'offline', null, true, true, true, true, false, null, null],
+			['john.doe', 'offline', null, true, false, true, true, false, null, null],
+			['john.doe', 'offline', null, false, true, true, true, false, null, null],
+			['john.doe', 'offline', null, false, false, true, true, false, null, null],
+
+			['john.doe', 'illegal-status', 50, true, true, false, false, true, InvalidStatusTypeException::class, 'Status-type "illegal-status" is not supported'],
+			['john.doe', 'illegal-status', 50, true, false, false, false, true, InvalidStatusTypeException::class, 'Status-type "illegal-status" is not supported'],
+			['john.doe', 'illegal-status', 50, false, true, false, false, true, InvalidStatusTypeException::class, 'Status-type "illegal-status" is not supported'],
+			['john.doe', 'illegal-status', 50, false, false, false, false, true, InvalidStatusTypeException::class, 'Status-type "illegal-status" is not supported'],
+			['john.doe', 'illegal-status', null, true, true, false, true, true, InvalidStatusTypeException::class, 'Status-type "illegal-status" is not supported'],
+			['john.doe', 'illegal-status', null, true, false, false, true, true, InvalidStatusTypeException::class, 'Status-type "illegal-status" is not supported'],
+			['john.doe', 'illegal-status', null, false, true, false, true, true, InvalidStatusTypeException::class, 'Status-type "illegal-status" is not supported'],
+			['john.doe', 'illegal-status', null, false, false, false, true, true, InvalidStatusTypeException::class, 'Status-type "illegal-status" is not supported'],
 		];
 	}
 
@@ -418,12 +418,12 @@ 
 
 	public static function setPredefinedMessageDataProvider(): array {
 		return [
-			['john.doe', 'sick-leave', true, null, true,  true,  false, null, null],
-			['john.doe', 'sick-leave', true, null, false, true,  false, null, null],
-			['john.doe', 'sick-leave', true, 20,   true,  false, true,  InvalidClearAtException::class, 'ClearAt is in the past'],
-			['john.doe', 'sick-leave', true, 20,   false, false, true,  InvalidClearAtException::class, 'ClearAt is in the past'],
-			['john.doe', 'sick-leave', true, 60,   true,  true,  false, null, null],
-			['john.doe', 'sick-leave', true, 60,   false, true,  false, null, null],
+			['john.doe', 'sick-leave', true, null, true, true, false, null, null],
+			['john.doe', 'sick-leave', true, null, false, true, false, null, null],
+			['john.doe', 'sick-leave', true, 20, true, false, true, InvalidClearAtException::class, 'ClearAt is in the past'],
+			['john.doe', 'sick-leave', true, 20, false, false, true, InvalidClearAtException::class, 'ClearAt is in the past'],
+			['john.doe', 'sick-leave', true, 60, true, true, false, null, null],
+			['john.doe', 'sick-leave', true, 60, false, true, false, null, null],
 			['john.doe', 'illegal-message-id', false, null, true, false, true, InvalidMessageIdException::class, 'Message-Id "illegal-message-id" is not supported'],
 			['john.doe', 'illegal-message-id', false, null, false, false, true, InvalidMessageIdException::class, 'Message-Id "illegal-message-id" is not supported'],
 		];
@@ -504,17 +504,17 @@ 
 
 	public static function setCustomMessageDataProvider(): array {
 		return [
-			['john.doe', '

apps/user_status/tests/Unit/Service/PredefinedStatusServiceTest.php

Indentation +155 added lines, -155 removed lines

@@ -14,159 +14,159 @@
 use Test\TestCase;
 
 class PredefinedStatusServiceTest extends TestCase {
-	protected IL10N&MockObject $l10n;
-	protected PredefinedStatusService $service;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->l10n = $this->createMock(IL10N::class);
-
-		$this->service = new PredefinedStatusService($this->l10n);
-	}
-
-	public function testGetDefaultStatuses(): void {
-		$this->l10n->expects($this->exactly(7))
-			->method('t')
-			->willReturnCallback(function ($text, $parameters = []) {
-				return vsprintf($text, $parameters);
-			});
-
-		$actual = $this->service->getDefaultStatuses();
-		$this->assertEquals([
-			[
-				'id' => 'meeting',
-				'icon' => '

apps/user_status/tests/Unit/Listener/UserLiveStatusListenerTest.php

Indentation +123 added lines, -123 removed lines

@@ -23,127 +23,127 @@
 use Test\TestCase;
 
 class UserLiveStatusListenerTest extends TestCase {
-	private UserStatusMapper&MockObject $mapper;
-	private StatusService&MockObject $statusService;
-	private ITimeFactory&MockObject $timeFactory;
-	private CalendarStatusService&MockObject $calendarStatusService;
-
-	private LoggerInterface&MockObject $logger;
-	private UserLiveStatusListener $listener;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->mapper = $this->createMock(UserStatusMapper::class);
-		$this->statusService = $this->createMock(StatusService::class);
-		$this->timeFactory = $this->createMock(ITimeFactory::class);
-		$this->calendarStatusService = $this->createMock(CalendarStatusService::class);
-		$this->logger = $this->createMock(LoggerInterface::class);
-
-		$this->listener = new UserLiveStatusListener(
-			$this->mapper,
-			$this->statusService,
-			$this->timeFactory,
-			$this->calendarStatusService,
-			$this->logger,
-		);
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('handleEventWithCorrectEventDataProvider')]
-	public function testHandleWithCorrectEvent(
-		string $userId,
-		string $previousStatus,
-		int $previousTimestamp,
-		bool $previousIsUserDefined,
-		string $eventStatus,
-		int $eventTimestamp,
-		bool $expectExisting,
-		bool $expectUpdate,
-	): void {
-		$userStatus = new UserStatus();
-
-		if ($expectExisting) {
-			$userStatus->setId(42);
-			$userStatus->setUserId($userId);
-			$userStatus->setStatus($previousStatus);
-			$userStatus->setStatusTimestamp($previousTimestamp);
-			$userStatus->setIsUserDefined($previousIsUserDefined);
-
-			$this->statusService->expects($this->once())
-				->method('findByUserId')
-				->with($userId)
-				->willReturn($userStatus);
-		} else {
-			$this->statusService->expects($this->once())
-				->method('findByUserId')
-				->with($userId)
-				->willThrowException(new DoesNotExistException(''));
-		}
-
-		$user = $this->createMock(IUser::class);
-		$user->method('getUID')->willReturn($userId);
-		$event = new UserLiveStatusEvent($user, $eventStatus, $eventTimestamp);
-
-		$this->timeFactory->expects($this->atMost(1))
-			->method('getTime')
-			->willReturn(5000);
-
-		if ($expectUpdate) {
-			if ($expectExisting) {
-				$this->mapper->expects($this->never())
-					->method('insert');
-				$this->mapper->expects($this->once())
-					->method('update')
-					->with($this->callback(function ($userStatus) use ($eventStatus, $eventTimestamp) {
-						$this->assertEquals($eventStatus, $userStatus->getStatus());
-						$this->assertEquals($eventTimestamp, $userStatus->getStatusTimestamp());
-						$this->assertFalse($userStatus->getIsUserDefined());
-
-						return true;
-					}));
-			} else {
-				$this->mapper->expects($this->once())
-					->method('insert')
-					->with($this->callback(function ($userStatus) use ($eventStatus, $eventTimestamp) {
-						$this->assertEquals($eventStatus, $userStatus->getStatus());
-						$this->assertEquals($eventTimestamp, $userStatus->getStatusTimestamp());
-						$this->assertFalse($userStatus->getIsUserDefined());
-
-						return true;
-					}));
-				$this->mapper->expects($this->never())
-					->method('update');
-			}
-
-			$this->listener->handle($event);
-		} else {
-			$this->mapper->expects($this->never())
-				->method('insert');
-			$this->mapper->expects($this->never())
-				->method('update');
-
-			$this->listener->handle($event);
-		}
-	}
-
-	public static function handleEventWithCorrectEventDataProvider(): array {
-		return [
-			['john.doe', 'offline', 0, false, 'online', 5000, true, true],
-			['john.doe', 'offline', 0, false, 'online', 5000, false, true],
-			['john.doe', 'online', 5000, false, 'online', 5000, true, false],
-			['john.doe', 'online', 5000, false, 'online', 5000, false, true],
-			['john.doe', 'away', 5000, false, 'online', 5000, true, true],
-			['john.doe', 'online', 5000, false, 'away', 5000, true, false],
-			['john.doe', 'away', 5000, true, 'online', 5000, true, false],
-			['john.doe', 'online', 5000, true, 'away', 5000, true, false],
-		];
-	}
-
-	public function testHandleWithWrongEvent(): void {
-		$this->mapper->expects($this->never())
-			->method('insertOrUpdate');
-
-		$event = new GenericEvent();
-		$this->listener->handle($event);
-	}
+    private UserStatusMapper&MockObject $mapper;
+    private StatusService&MockObject $statusService;
+    private ITimeFactory&MockObject $timeFactory;
+    private CalendarStatusService&MockObject $calendarStatusService;
+
+    private LoggerInterface&MockObject $logger;
+    private UserLiveStatusListener $listener;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->mapper = $this->createMock(UserStatusMapper::class);
+        $this->statusService = $this->createMock(StatusService::class);
+        $this->timeFactory = $this->createMock(ITimeFactory::class);
+        $this->calendarStatusService = $this->createMock(CalendarStatusService::class);
+        $this->logger = $this->createMock(LoggerInterface::class);
+
+        $this->listener = new UserLiveStatusListener(
+            $this->mapper,
+            $this->statusService,
+            $this->timeFactory,
+            $this->calendarStatusService,
+            $this->logger,
+        );
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('handleEventWithCorrectEventDataProvider')]
+    public function testHandleWithCorrectEvent(
+        string $userId,
+        string $previousStatus,
+        int $previousTimestamp,
+        bool $previousIsUserDefined,
+        string $eventStatus,
+        int $eventTimestamp,
+        bool $expectExisting,
+        bool $expectUpdate,
+    ): void {
+        $userStatus = new UserStatus();
+
+        if ($expectExisting) {
+            $userStatus->setId(42);
+            $userStatus->setUserId($userId);
+            $userStatus->setStatus($previousStatus);
+            $userStatus->setStatusTimestamp($previousTimestamp);
+            $userStatus->setIsUserDefined($previousIsUserDefined);
+
+            $this->statusService->expects($this->once())
+                ->method('findByUserId')
+                ->with($userId)
+                ->willReturn($userStatus);
+        } else {
+            $this->statusService->expects($this->once())
+                ->method('findByUserId')
+                ->with($userId)
+                ->willThrowException(new DoesNotExistException(''));
+        }
+
+        $user = $this->createMock(IUser::class);
+        $user->method('getUID')->willReturn($userId);
+        $event = new UserLiveStatusEvent($user, $eventStatus, $eventTimestamp);
+
+        $this->timeFactory->expects($this->atMost(1))
+            ->method('getTime')
+            ->willReturn(5000);
+
+        if ($expectUpdate) {
+            if ($expectExisting) {
+                $this->mapper->expects($this->never())
+                    ->method('insert');
+                $this->mapper->expects($this->once())
+                    ->method('update')
+                    ->with($this->callback(function ($userStatus) use ($eventStatus, $eventTimestamp) {
+                        $this->assertEquals($eventStatus, $userStatus->getStatus());
+                        $this->assertEquals($eventTimestamp, $userStatus->getStatusTimestamp());
+                        $this->assertFalse($userStatus->getIsUserDefined());
+
+                        return true;
+                    }));
+            } else {
+                $this->mapper->expects($this->once())
+                    ->method('insert')
+                    ->with($this->callback(function ($userStatus) use ($eventStatus, $eventTimestamp) {
+                        $this->assertEquals($eventStatus, $userStatus->getStatus());
+                        $this->assertEquals($eventTimestamp, $userStatus->getStatusTimestamp());
+                        $this->assertFalse($userStatus->getIsUserDefined());
+
+                        return true;
+                    }));
+                $this->mapper->expects($this->never())
+                    ->method('update');
+            }
+
+            $this->listener->handle($event);
+        } else {
+            $this->mapper->expects($this->never())
+                ->method('insert');
+            $this->mapper->expects($this->never())
+                ->method('update');
+
+            $this->listener->handle($event);
+        }
+    }
+
+    public static function handleEventWithCorrectEventDataProvider(): array {
+        return [
+            ['john.doe', 'offline', 0, false, 'online', 5000, true, true],
+            ['john.doe', 'offline', 0, false, 'online', 5000, false, true],
+            ['john.doe', 'online', 5000, false, 'online', 5000, true, false],
+            ['john.doe', 'online', 5000, false, 'online', 5000, false, true],
+            ['john.doe', 'away', 5000, false, 'online', 5000, true, true],
+            ['john.doe', 'online', 5000, false, 'away', 5000, true, false],
+            ['john.doe', 'away', 5000, true, 'online', 5000, true, false],
+            ['john.doe', 'online', 5000, true, 'away', 5000, true, false],
+        ];
+    }
+
+    public function testHandleWithWrongEvent(): void {
+        $this->mapper->expects($this->never())
+            ->method('insertOrUpdate');
+
+        $event = new GenericEvent();
+        $this->listener->handle($event);
+    }
 }