nextcloud / server

apps/encryption/tests/SessionTest.php

Indentation +186 added lines, -186 removed lines

@@ -16,190 +16,190 @@
 use Test\TestCase;
 
 class SessionTest extends TestCase {
-	private static $tempStorage = [];
-
-	protected Session $instance;
-	protected ISession&MockObject $sessionMock;
-
-	public function testThatGetPrivateKeyThrowsExceptionWhenNotSet(): void {
-		$this->expectException(PrivateKeyMissingException::class);
-		$this->expectExceptionMessage('Private Key missing for user: please try to log-out and log-in again');
-
-		$this->instance->getPrivateKey();
-	}
-
-	/**
-	 * @depends testThatGetPrivateKeyThrowsExceptionWhenNotSet
-	 */
-	public function testSetAndGetPrivateKey(): void {
-		$this->instance->setPrivateKey('dummyPrivateKey');
-		$this->assertEquals('dummyPrivateKey', $this->instance->getPrivateKey());
-	}
-
-	/**
-	 * @depends testSetAndGetPrivateKey
-	 */
-	public function testIsPrivateKeySet(): void {
-		$this->instance->setPrivateKey('dummyPrivateKey');
-		$this->assertTrue($this->instance->isPrivateKeySet());
-
-		unset(self::$tempStorage['privateKey']);
-		$this->assertFalse($this->instance->isPrivateKeySet());
-
-		// Set private key back so we can test clear method
-		self::$tempStorage['privateKey'] = 'dummyPrivateKey';
-	}
-
-	public function testDecryptAllModeActivated(): void {
-		$this->instance->prepareDecryptAll('user1', 'usersKey');
-		$this->assertTrue($this->instance->decryptAllModeActivated());
-		$this->assertSame('user1', $this->instance->getDecryptAllUid());
-		$this->assertSame('usersKey', $this->instance->getDecryptAllKey());
-	}
-
-	public function testDecryptAllModeDeactivated(): void {
-		$this->assertFalse($this->instance->decryptAllModeActivated());
-	}
-
-	/**
-	 * @expectExceptionMessage 'Please activate decrypt all mode first'
-	 */
-	public function testGetDecryptAllUidException(): void {
-		$this->expectException(\Exception::class);
-
-		$this->instance->getDecryptAllUid();
-	}
-
-	/**
-	 * @expectExceptionMessage 'No uid found while in decrypt all mode'
-	 */
-	public function testGetDecryptAllUidException2(): void {
-		$this->expectException(\Exception::class);
-
-		$this->instance->prepareDecryptAll(null, 'key');
-		$this->instance->getDecryptAllUid();
-	}
-
-	/**
-	 * @expectExceptionMessage 'Please activate decrypt all mode first'
-	 */
-	public function testGetDecryptAllKeyException(): void {
-		$this->expectException(PrivateKeyMissingException::class);
-
-		$this->instance->getDecryptAllKey();
-	}
-
-	/**
-	 * @expectExceptionMessage 'No key found while in decrypt all mode'
-	 */
-	public function testGetDecryptAllKeyException2(): void {
-		$this->expectException(PrivateKeyMissingException::class);
-
-		$this->instance->prepareDecryptAll('user', null);
-		$this->instance->getDecryptAllKey();
-	}
-
-
-	public function testSetAndGetStatusWillSetAndReturn(): void {
-		// Check if get status will return 0 if it has not been set before
-		$this->assertEquals(0, $this->instance->getStatus());
-
-		$this->instance->setStatus(Session::NOT_INITIALIZED);
-		$this->assertEquals(0, $this->instance->getStatus());
-
-		$this->instance->setStatus(Session::INIT_EXECUTED);
-		$this->assertEquals(1, $this->instance->getStatus());
-
-		$this->instance->setStatus(Session::INIT_SUCCESSFUL);
-		$this->assertEquals(2, $this->instance->getStatus());
-	}
-
-	/**
-	 * @dataProvider dataTestIsReady
-	 *
-	 * @param int $status
-	 * @param bool $expected
-	 */
-	public function testIsReady($status, $expected): void {
-		/** @var Session&MockObject $instance */
-		$instance = $this->getMockBuilder(Session::class)
-			->setConstructorArgs([$this->sessionMock])
-			->onlyMethods(['getStatus'])
-			->getMock();
-
-		$instance->expects($this->once())->method('getStatus')
-			->willReturn($status);
-
-		$this->assertSame($expected, $instance->isReady());
-	}
-
-	public static function dataTestIsReady(): array {
-		return [
-			[Session::INIT_SUCCESSFUL, true],
-			[Session::INIT_EXECUTED, false],
-			[Session::NOT_INITIALIZED, false],
-		];
-	}
-
-	/**
-	 * @param $key
-	 * @param $value
-	 */
-	public function setValueTester($key, $value) {
-		self::$tempStorage[$key] = $value;
-	}
-
-	/**
-	 * @param $key
-	 */
-	public function removeValueTester($key) {
-		unset(self::$tempStorage[$key]);
-	}
-
-	/**
-	 * @param $key
-	 * @return mixed
-	 */
-	public function getValueTester($key) {
-		if (!empty(self::$tempStorage[$key])) {
-			return self::$tempStorage[$key];
-		}
-		return null;
-	}
-
-
-	public function testClearWillRemoveValues(): void {
-		$this->instance->setPrivateKey('privateKey');
-		$this->instance->setStatus('initStatus');
-		$this->instance->prepareDecryptAll('user', 'key');
-		$this->assertNotEmpty(self::$tempStorage);
-		$this->instance->clear();
-		$this->assertEmpty(self::$tempStorage);
-	}
-
-
-	protected function setUp(): void {
-		parent::setUp();
-		$this->sessionMock = $this->createMock(ISession::class);
-
-		$this->sessionMock->expects($this->any())
-			->method('set')
-			->willReturnCallback([$this, 'setValueTester']);
-
-		$this->sessionMock->expects($this->any())
-			->method('get')
-			->willReturnCallback([$this, 'getValueTester']);
-
-		$this->sessionMock->expects($this->any())
-			->method('remove')
-			->willReturnCallback([$this, 'removeValueTester']);
-
-
-		$this->instance = new Session($this->sessionMock);
-	}
-
-	protected function tearDown(): void {
-		self::$tempStorage = [];
-		parent::tearDown();
-	}
+    private static $tempStorage = [];
+
+    protected Session $instance;
+    protected ISession&MockObject $sessionMock;
+
+    public function testThatGetPrivateKeyThrowsExceptionWhenNotSet(): void {
+        $this->expectException(PrivateKeyMissingException::class);
+        $this->expectExceptionMessage('Private Key missing for user: please try to log-out and log-in again');
+
+        $this->instance->getPrivateKey();
+    }
+
+    /**
+     * @depends testThatGetPrivateKeyThrowsExceptionWhenNotSet
+     */
+    public function testSetAndGetPrivateKey(): void {
+        $this->instance->setPrivateKey('dummyPrivateKey');
+        $this->assertEquals('dummyPrivateKey', $this->instance->getPrivateKey());
+    }
+
+    /**
+     * @depends testSetAndGetPrivateKey
+     */
+    public function testIsPrivateKeySet(): void {
+        $this->instance->setPrivateKey('dummyPrivateKey');
+        $this->assertTrue($this->instance->isPrivateKeySet());
+
+        unset(self::$tempStorage['privateKey']);
+        $this->assertFalse($this->instance->isPrivateKeySet());
+
+        // Set private key back so we can test clear method
+        self::$tempStorage['privateKey'] = 'dummyPrivateKey';
+    }
+
+    public function testDecryptAllModeActivated(): void {
+        $this->instance->prepareDecryptAll('user1', 'usersKey');
+        $this->assertTrue($this->instance->decryptAllModeActivated());
+        $this->assertSame('user1', $this->instance->getDecryptAllUid());
+        $this->assertSame('usersKey', $this->instance->getDecryptAllKey());
+    }
+
+    public function testDecryptAllModeDeactivated(): void {
+        $this->assertFalse($this->instance->decryptAllModeActivated());
+    }
+
+    /**
+     * @expectExceptionMessage 'Please activate decrypt all mode first'
+     */
+    public function testGetDecryptAllUidException(): void {
+        $this->expectException(\Exception::class);
+
+        $this->instance->getDecryptAllUid();
+    }
+
+    /**
+     * @expectExceptionMessage 'No uid found while in decrypt all mode'
+     */
+    public function testGetDecryptAllUidException2(): void {
+        $this->expectException(\Exception::class);
+
+        $this->instance->prepareDecryptAll(null, 'key');
+        $this->instance->getDecryptAllUid();
+    }
+
+    /**
+     * @expectExceptionMessage 'Please activate decrypt all mode first'
+     */
+    public function testGetDecryptAllKeyException(): void {
+        $this->expectException(PrivateKeyMissingException::class);
+
+        $this->instance->getDecryptAllKey();
+    }
+
+    /**
+     * @expectExceptionMessage 'No key found while in decrypt all mode'
+     */
+    public function testGetDecryptAllKeyException2(): void {
+        $this->expectException(PrivateKeyMissingException::class);
+
+        $this->instance->prepareDecryptAll('user', null);
+        $this->instance->getDecryptAllKey();
+    }
+
+
+    public function testSetAndGetStatusWillSetAndReturn(): void {
+        // Check if get status will return 0 if it has not been set before
+        $this->assertEquals(0, $this->instance->getStatus());
+
+        $this->instance->setStatus(Session::NOT_INITIALIZED);
+        $this->assertEquals(0, $this->instance->getStatus());
+
+        $this->instance->setStatus(Session::INIT_EXECUTED);
+        $this->assertEquals(1, $this->instance->getStatus());
+
+        $this->instance->setStatus(Session::INIT_SUCCESSFUL);
+        $this->assertEquals(2, $this->instance->getStatus());
+    }
+
+    /**
+     * @dataProvider dataTestIsReady
+     *
+     * @param int $status
+     * @param bool $expected
+     */
+    public function testIsReady($status, $expected): void {
+        /** @var Session&MockObject $instance */
+        $instance = $this->getMockBuilder(Session::class)
+            ->setConstructorArgs([$this->sessionMock])
+            ->onlyMethods(['getStatus'])
+            ->getMock();
+
+        $instance->expects($this->once())->method('getStatus')
+            ->willReturn($status);
+
+        $this->assertSame($expected, $instance->isReady());
+    }
+
+    public static function dataTestIsReady(): array {
+        return [
+            [Session::INIT_SUCCESSFUL, true],
+            [Session::INIT_EXECUTED, false],
+            [Session::NOT_INITIALIZED, false],
+        ];
+    }
+
+    /**
+     * @param $key
+     * @param $value
+     */
+    public function setValueTester($key, $value) {
+        self::$tempStorage[$key] = $value;
+    }
+
+    /**
+     * @param $key
+     */
+    public function removeValueTester($key) {
+        unset(self::$tempStorage[$key]);
+    }
+
+    /**
+     * @param $key
+     * @return mixed
+     */
+    public function getValueTester($key) {
+        if (!empty(self::$tempStorage[$key])) {
+            return self::$tempStorage[$key];
+        }
+        return null;
+    }
+
+
+    public function testClearWillRemoveValues(): void {
+        $this->instance->setPrivateKey('privateKey');
+        $this->instance->setStatus('initStatus');
+        $this->instance->prepareDecryptAll('user', 'key');
+        $this->assertNotEmpty(self::$tempStorage);
+        $this->instance->clear();
+        $this->assertEmpty(self::$tempStorage);
+    }
+
+
+    protected function setUp(): void {
+        parent::setUp();
+        $this->sessionMock = $this->createMock(ISession::class);
+
+        $this->sessionMock->expects($this->any())
+            ->method('set')
+            ->willReturnCallback([$this, 'setValueTester']);
+
+        $this->sessionMock->expects($this->any())
+            ->method('get')
+            ->willReturnCallback([$this, 'getValueTester']);
+
+        $this->sessionMock->expects($this->any())
+            ->method('remove')
+            ->willReturnCallback([$this, 'removeValueTester']);
+
+
+        $this->instance = new Session($this->sessionMock);
+    }
+
+    protected function tearDown(): void {
+        self::$tempStorage = [];
+        parent::tearDown();
+    }
 }

apps/encryption/tests/UtilTest.php

Indentation +163 added lines, -163 removed lines

@@ -23,167 +23,167 @@
 
 class UtilTest extends TestCase {
 
-	protected Util $instance;
-	protected static $tempStorage = [];
-
-	protected IConfig&MockObject $configMock;
-	protected View&MockObject $filesMock;
-	protected IUserManager&MockObject $userManagerMock;
-	protected IMountPoint&MockObject $mountMock;
-
-	public function testSetRecoveryForUser(): void {
-		$this->instance->setRecoveryForUser('1');
-		$this->assertArrayHasKey('recoveryEnabled', self::$tempStorage);
-	}
-
-	public function testIsRecoveryEnabledForUser(): void {
-		$this->assertTrue($this->instance->isRecoveryEnabledForUser('admin'));
-
-		// Assert recovery will return default value if not set
-		unset(self::$tempStorage['recoveryEnabled']);
-		$this->assertEquals(0, $this->instance->isRecoveryEnabledForUser('admin'));
-	}
-
-	public function testUserHasFiles(): void {
-		$this->filesMock->expects($this->once())
-			->method('file_exists')
-			->willReturn(true);
-
-		$this->assertTrue($this->instance->userHasFiles('admin'));
-	}
-
-	protected function setUp(): void {
-		parent::setUp();
-		$this->mountMock = $this->createMock(IMountPoint::class);
-		$this->filesMock = $this->createMock(View::class);
-		$this->userManagerMock = $this->createMock(IUserManager::class);
-
-		/** @var Crypt $cryptMock */
-		$cryptMock = $this->getMockBuilder(Crypt::class)
-			->disableOriginalConstructor()
-			->getMock();
-
-		$user = $this->createMock(IUser::class);
-		$user->expects($this->any())
-			->method('getUID')
-			->willReturn('admin');
-
-		/** @var IUserSession|MockObject $userSessionMock */
-		$userSessionMock = $this->createMock(IUserSession::class);
-		$userSessionMock->expects($this->any())
-			->method('getUser')
-			->willReturn($user);
-		$userSessionMock->expects($this->any())
-			->method('isLoggedIn')
-			->willReturn(true);
-
-		$this->configMock = $this->createMock(IConfig::class);
-
-		$this->configMock->expects($this->any())
-			->method('getUserValue')
-			->willReturnCallback([$this, 'getValueTester']);
-
-		$this->configMock->expects($this->any())
-			->method('setUserValue')
-			->willReturnCallback([$this, 'setValueTester']);
-
-		$this->instance = new Util($this->filesMock, $cryptMock, $userSessionMock, $this->configMock, $this->userManagerMock);
-	}
-
-	/**
-	 * @param $userId
-	 * @param $app
-	 * @param $key
-	 * @param $value
-	 */
-	public function setValueTester($userId, $app, $key, $value) {
-		self::$tempStorage[$key] = $value;
-	}
-
-	/**
-	 * @param $userId
-	 * @param $app
-	 * @param $key
-	 * @param $default
-	 * @return mixed
-	 */
-	public function getValueTester($userId, $app, $key, $default) {
-		if (!empty(self::$tempStorage[$key])) {
-			return self::$tempStorage[$key];
-		}
-		return $default ?: null;
-	}
-
-	/**
-	 * @dataProvider dataTestIsMasterKeyEnabled
-	 *
-	 * @param string $value
-	 * @param bool $expect
-	 */
-	public function testIsMasterKeyEnabled($value, $expect): void {
-		$this->configMock->expects($this->once())->method('getAppValue')
-			->with('encryption', 'useMasterKey', '1')->willReturn($value);
-		$this->assertSame($expect,
-			$this->instance->isMasterKeyEnabled()
-		);
-	}
-
-	public static function dataTestIsMasterKeyEnabled(): array {
-		return [
-			['0', false],
-			['1', true]
-		];
-	}
-
-	/**
-	 * @dataProvider dataTestShouldEncryptHomeStorage
-	 * @param string $returnValue return value from getAppValue()
-	 * @param bool $expected
-	 */
-	public function testShouldEncryptHomeStorage($returnValue, $expected): void {
-		$this->configMock->expects($this->once())->method('getAppValue')
-			->with('encryption', 'encryptHomeStorage', '1')
-			->willReturn($returnValue);
-
-		$this->assertSame($expected,
-			$this->instance->shouldEncryptHomeStorage());
-	}
-
-	public static function dataTestShouldEncryptHomeStorage(): array {
-		return [
-			['1', true],
-			['0', false]
-		];
-	}
-
-	/**
-	 * @dataProvider dataTestSetEncryptHomeStorage
-	 * @param $value
-	 * @param $expected
-	 */
-	public function testSetEncryptHomeStorage($value, $expected): void {
-		$this->configMock->expects($this->once())->method('setAppValue')
-			->with('encryption', 'encryptHomeStorage', $expected);
-		$this->instance->setEncryptHomeStorage($value);
-	}
-
-	public static function dataTestSetEncryptHomeStorage(): array {
-		return [
-			[true, '1'],
-			[false, '0']
-		];
-	}
-
-	public function testGetStorage(): void {
-		$return = $this->getMockBuilder(IStorage::class)
-			->disableOriginalConstructor()
-			->getMock();
-
-		$path = '/foo/bar.txt';
-		$this->filesMock->expects($this->once())->method('getMount')->with($path)
-			->willReturn($this->mountMock);
-		$this->mountMock->expects($this->once())->method('getStorage')->willReturn($return);
-
-		$this->assertEquals($return, $this->instance->getStorage($path));
-	}
+    protected Util $instance;
+    protected static $tempStorage = [];
+
+    protected IConfig&MockObject $configMock;
+    protected View&MockObject $filesMock;
+    protected IUserManager&MockObject $userManagerMock;
+    protected IMountPoint&MockObject $mountMock;
+
+    public function testSetRecoveryForUser(): void {
+        $this->instance->setRecoveryForUser('1');
+        $this->assertArrayHasKey('recoveryEnabled', self::$tempStorage);
+    }
+
+    public function testIsRecoveryEnabledForUser(): void {
+        $this->assertTrue($this->instance->isRecoveryEnabledForUser('admin'));
+
+        // Assert recovery will return default value if not set
+        unset(self::$tempStorage['recoveryEnabled']);
+        $this->assertEquals(0, $this->instance->isRecoveryEnabledForUser('admin'));
+    }
+
+    public function testUserHasFiles(): void {
+        $this->filesMock->expects($this->once())
+            ->method('file_exists')
+            ->willReturn(true);
+
+        $this->assertTrue($this->instance->userHasFiles('admin'));
+    }
+
+    protected function setUp(): void {
+        parent::setUp();
+        $this->mountMock = $this->createMock(IMountPoint::class);
+        $this->filesMock = $this->createMock(View::class);
+        $this->userManagerMock = $this->createMock(IUserManager::class);
+
+        /** @var Crypt $cryptMock */
+        $cryptMock = $this->getMockBuilder(Crypt::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $user = $this->createMock(IUser::class);
+        $user->expects($this->any())
+            ->method('getUID')
+            ->willReturn('admin');
+
+        /** @var IUserSession|MockObject $userSessionMock */
+        $userSessionMock = $this->createMock(IUserSession::class);
+        $userSessionMock->expects($this->any())
+            ->method('getUser')
+            ->willReturn($user);
+        $userSessionMock->expects($this->any())
+            ->method('isLoggedIn')
+            ->willReturn(true);
+
+        $this->configMock = $this->createMock(IConfig::class);
+
+        $this->configMock->expects($this->any())
+            ->method('getUserValue')
+            ->willReturnCallback([$this, 'getValueTester']);
+
+        $this->configMock->expects($this->any())
+            ->method('setUserValue')
+            ->willReturnCallback([$this, 'setValueTester']);
+
+        $this->instance = new Util($this->filesMock, $cryptMock, $userSessionMock, $this->configMock, $this->userManagerMock);
+    }
+
+    /**
+     * @param $userId
+     * @param $app
+     * @param $key
+     * @param $value
+     */
+    public function setValueTester($userId, $app, $key, $value) {
+        self::$tempStorage[$key] = $value;
+    }
+
+    /**
+     * @param $userId
+     * @param $app
+     * @param $key
+     * @param $default
+     * @return mixed
+     */
+    public function getValueTester($userId, $app, $key, $default) {
+        if (!empty(self::$tempStorage[$key])) {
+            return self::$tempStorage[$key];
+        }
+        return $default ?: null;
+    }
+
+    /**
+     * @dataProvider dataTestIsMasterKeyEnabled
+     *
+     * @param string $value
+     * @param bool $expect
+     */
+    public function testIsMasterKeyEnabled($value, $expect): void {
+        $this->configMock->expects($this->once())->method('getAppValue')
+            ->with('encryption', 'useMasterKey', '1')->willReturn($value);
+        $this->assertSame($expect,
+            $this->instance->isMasterKeyEnabled()
+        );
+    }
+
+    public static function dataTestIsMasterKeyEnabled(): array {
+        return [
+            ['0', false],
+            ['1', true]
+        ];
+    }
+
+    /**
+     * @dataProvider dataTestShouldEncryptHomeStorage
+     * @param string $returnValue return value from getAppValue()
+     * @param bool $expected
+     */
+    public function testShouldEncryptHomeStorage($returnValue, $expected): void {
+        $this->configMock->expects($this->once())->method('getAppValue')
+            ->with('encryption', 'encryptHomeStorage', '1')
+            ->willReturn($returnValue);
+
+        $this->assertSame($expected,
+            $this->instance->shouldEncryptHomeStorage());
+    }
+
+    public static function dataTestShouldEncryptHomeStorage(): array {
+        return [
+            ['1', true],
+            ['0', false]
+        ];
+    }
+
+    /**
+     * @dataProvider dataTestSetEncryptHomeStorage
+     * @param $value
+     * @param $expected
+     */
+    public function testSetEncryptHomeStorage($value, $expected): void {
+        $this->configMock->expects($this->once())->method('setAppValue')
+            ->with('encryption', 'encryptHomeStorage', $expected);
+        $this->instance->setEncryptHomeStorage($value);
+    }
+
+    public static function dataTestSetEncryptHomeStorage(): array {
+        return [
+            [true, '1'],
+            [false, '0']
+        ];
+    }
+
+    public function testGetStorage(): void {
+        $return = $this->getMockBuilder(IStorage::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $path = '/foo/bar.txt';
+        $this->filesMock->expects($this->once())->method('getMount')->with($path)
+            ->willReturn($this->mountMock);
+        $this->mountMock->expects($this->once())->method('getStorage')->willReturn($return);
+
+        $this->assertEquals($return, $this->instance->getStorage($path));
+    }
 }

apps/encryption/tests/Command/FixEncryptedVersionTest.php

Indentation +274 added lines, -274 removed lines

@@ -33,101 +33,101 @@ 
  * @package OCA\Encryption\Tests\Command
  */
 class FixEncryptedVersionTest extends TestCase {
-	use MountProviderTrait;
-	use EncryptionTrait;
-	use UserTrait;
-
-	private string $userId;
-
-	private FixEncryptedVersion $fixEncryptedVersion;
-
-	private CommandTester $commandTester;
-
-	protected Util&MockObject $util;
-
-	public function setUp(): void {
-		parent::setUp();
-
-		Server::get(IConfig::class)->setAppValue('encryption', 'useMasterKey', '1');
-
-		$this->util = $this->getMockBuilder(Util::class)
-			->disableOriginalConstructor()->getMock();
-
-		$this->userId = $this->getUniqueId('user_');
-
-		$this->createUser($this->userId, 'foo12345678');
-		$tmpFolder = Server::get(ITempManager::class)->getTemporaryFolder();
-		$this->registerMount($this->userId, '\OC\Files\Storage\Local', '/' . $this->userId, ['datadir' => $tmpFolder]);
-		$this->setupForUser($this->userId, 'foo12345678');
-		$this->loginWithEncryption($this->userId);
-
-		$this->fixEncryptedVersion = new FixEncryptedVersion(
-			Server::get(IConfig::class),
-			Server::get(LoggerInterface::class),
-			Server::get(IRootFolder::class),
-			Server::get(IUserManager::class),
-			$this->util,
-			new View('/')
-		);
-		$this->commandTester = new CommandTester($this->fixEncryptedVersion);
-
-		$this->assertTrue(Server::get(\OCP\Encryption\IManager::class)->isEnabled());
-		$this->assertTrue(Server::get(\OCP\Encryption\IManager::class)->isReady());
-		$this->assertTrue(Server::get(\OCP\Encryption\IManager::class)->isReadyForUser($this->userId));
-	}
-
-	/**
-	 * In this test the encrypted version of the file is less than the original value
-	 * but greater than zero
-	 */
-	public function testEncryptedVersionLessThanOriginalValue(): void {
-		$this->util->expects($this->once())->method('isMasterKeyEnabled')
-			->willReturn(true);
-
-		$view = new View('/' . $this->userId . '/files');
-
-		$view->touch('hello.txt');
-		$view->touch('world.txt');
-		$view->touch('foo.txt');
-		$view->file_put_contents('hello.txt', 'a test string for hello');
-		$view->file_put_contents('hello.txt', 'Yet another value');
-		$view->file_put_contents('hello.txt', 'Lets modify again1');
-		$view->file_put_contents('hello.txt', 'Lets modify again2');
-		$view->file_put_contents('hello.txt', 'Lets modify again3');
-		$view->file_put_contents('world.txt', 'a test string for world');
-		$view->file_put_contents('world.txt', 'a test string for world');
-		$view->file_put_contents('world.txt', 'a test string for world');
-		$view->file_put_contents('world.txt', 'a test string for world');
-		$view->file_put_contents('foo.txt', 'a foo test');
-
-		$fileInfo1 = $view->getFileInfo('hello.txt');
-
-		$storage1 = $fileInfo1->getStorage();
-		$cache1 = $storage1->getCache();
-		$fileCache1 = $cache1->get($fileInfo1->getId());
-
-		//Now change the encrypted version to two
-		$cacheInfo = ['encryptedVersion' => 2, 'encrypted' => 2];
-		$cache1->put($fileCache1->getPath(), $cacheInfo);
-
-		$fileInfo2 = $view->getFileInfo('world.txt');
-		$storage2 = $fileInfo2->getStorage();
-		$cache2 = $storage2->getCache();
-		$filecache2 = $cache2->get($fileInfo2->getId());
-
-		//Now change the encrypted version to 1
-		$cacheInfo = ['encryptedVersion' => 1, 'encrypted' => 1];
-		$cache2->put($filecache2->getPath(), $cacheInfo);
-
-		$this->commandTester->execute([
-			'user' => $this->userId
-		]);
-
-		$output = $this->commandTester->getDisplay();
-
-		$this->assertStringContainsString("Verifying the content of file \"/$this->userId/files/foo.txt\"
+    use MountProviderTrait;
+    use EncryptionTrait;
+    use UserTrait;
+
+    private string $userId;
+
+    private FixEncryptedVersion $fixEncryptedVersion;
+
+    private CommandTester $commandTester;
+
+    protected Util&MockObject $util;
+
+    public function setUp(): void {
+        parent::setUp();
+
+        Server::get(IConfig::class)->setAppValue('encryption', 'useMasterKey', '1');
+
+        $this->util = $this->getMockBuilder(Util::class)
+            ->disableOriginalConstructor()->getMock();
+
+        $this->userId = $this->getUniqueId('user_');
+
+        $this->createUser($this->userId, 'foo12345678');
+        $tmpFolder = Server::get(ITempManager::class)->getTemporaryFolder();
+        $this->registerMount($this->userId, '\OC\Files\Storage\Local', '/' . $this->userId, ['datadir' => $tmpFolder]);
+        $this->setupForUser($this->userId, 'foo12345678');
+        $this->loginWithEncryption($this->userId);
+
+        $this->fixEncryptedVersion = new FixEncryptedVersion(
+            Server::get(IConfig::class),
+            Server::get(LoggerInterface::class),
+            Server::get(IRootFolder::class),
+            Server::get(IUserManager::class),
+            $this->util,
+            new View('/')
+        );
+        $this->commandTester = new CommandTester($this->fixEncryptedVersion);
+
+        $this->assertTrue(Server::get(\OCP\Encryption\IManager::class)->isEnabled());
+        $this->assertTrue(Server::get(\OCP\Encryption\IManager::class)->isReady());
+        $this->assertTrue(Server::get(\OCP\Encryption\IManager::class)->isReadyForUser($this->userId));
+    }
+
+    /**
+     * In this test the encrypted version of the file is less than the original value
+     * but greater than zero
+     */
+    public function testEncryptedVersionLessThanOriginalValue(): void {
+        $this->util->expects($this->once())->method('isMasterKeyEnabled')
+            ->willReturn(true);
+
+        $view = new View('/' . $this->userId . '/files');
+
+        $view->touch('hello.txt');
+        $view->touch('world.txt');
+        $view->touch('foo.txt');
+        $view->file_put_contents('hello.txt', 'a test string for hello');
+        $view->file_put_contents('hello.txt', 'Yet another value');
+        $view->file_put_contents('hello.txt', 'Lets modify again1');
+        $view->file_put_contents('hello.txt', 'Lets modify again2');
+        $view->file_put_contents('hello.txt', 'Lets modify again3');
+        $view->file_put_contents('world.txt', 'a test string for world');
+        $view->file_put_contents('world.txt', 'a test string for world');
+        $view->file_put_contents('world.txt', 'a test string for world');
+        $view->file_put_contents('world.txt', 'a test string for world');
+        $view->file_put_contents('foo.txt', 'a foo test');
+
+        $fileInfo1 = $view->getFileInfo('hello.txt');
+
+        $storage1 = $fileInfo1->getStorage();
+        $cache1 = $storage1->getCache();
+        $fileCache1 = $cache1->get($fileInfo1->getId());
+
+        //Now change the encrypted version to two
+        $cacheInfo = ['encryptedVersion' => 2, 'encrypted' => 2];
+        $cache1->put($fileCache1->getPath(), $cacheInfo);
+
+        $fileInfo2 = $view->getFileInfo('world.txt');
+        $storage2 = $fileInfo2->getStorage();
+        $cache2 = $storage2->getCache();
+        $filecache2 = $cache2->get($fileInfo2->getId());
+
+        //Now change the encrypted version to 1
+        $cacheInfo = ['encryptedVersion' => 1, 'encrypted' => 1];
+        $cache2->put($filecache2->getPath(), $cacheInfo);
+
+        $this->commandTester->execute([
+            'user' => $this->userId
+        ]);
+
+        $output = $this->commandTester->getDisplay();
+
+        $this->assertStringContainsString("Verifying the content of file \"/$this->userId/files/foo.txt\"
 The file \"/$this->userId/files/foo.txt\" is: OK", $output);
-		$this->assertStringContainsString("Verifying the content of file \"/$this->userId/files/hello.txt\"
+        $this->assertStringContainsString("Verifying the content of file \"/$this->userId/files/hello.txt\"
 Attempting to fix the path: \"/$this->userId/files/hello.txt\"
 Decrement the encrypted version to 1
 Increment the encrypted version to 3
@@ -135,256 +135,256 @@ 
 Increment the encrypted version to 5
 The file \"/$this->userId/files/hello.txt\" is: OK
 Fixed the file: \"/$this->userId/files/hello.txt\" with version 5", $output);
-		$this->assertStringContainsString("Verifying the content of file \"/$this->userId/files/world.txt\"
+        $this->assertStringContainsString("Verifying the content of file \"/$this->userId/files/world.txt\"
 Attempting to fix the path: \"/$this->userId/files/world.txt\"
 Increment the encrypted version to 2
 Increment the encrypted version to 3
 Increment the encrypted version to 4
 The file \"/$this->userId/files/world.txt\" is: OK
 Fixed the file: \"/$this->userId/files/world.txt\" with version 4", $output);
-	}
-
-	/**
-	 * In this test the encrypted version of the file is greater than the original value
-	 * but greater than zero
-	 */
-	public function testEncryptedVersionGreaterThanOriginalValue(): void {
-		$this->util->expects($this->once())->method('isMasterKeyEnabled')
-			->willReturn(true);
-
-		$view = new View('/' . $this->userId . '/files');
-
-		$view->touch('hello.txt');
-		$view->touch('world.txt');
-		$view->touch('foo.txt');
-		$view->file_put_contents('hello.txt', 'a test string for hello');
-		$view->file_put_contents('hello.txt', 'Lets modify again2');
-		$view->file_put_contents('hello.txt', 'Lets modify again3');
-		$view->file_put_contents('world.txt', 'a test string for world');
-		$view->file_put_contents('world.txt', 'a test string for world');
-		$view->file_put_contents('world.txt', 'a test string for world');
-		$view->file_put_contents('world.txt', 'a test string for world');
-		$view->file_put_contents('foo.txt', 'a foo test');
-
-		$fileInfo1 = $view->getFileInfo('hello.txt');
-
-		$storage1 = $fileInfo1->getStorage();
-		$cache1 = $storage1->getCache();
-		$fileCache1 = $cache1->get($fileInfo1->getId());
-
-		//Now change the encrypted version to fifteen
-		$cacheInfo = ['encryptedVersion' => 5, 'encrypted' => 5];
-		$cache1->put($fileCache1->getPath(), $cacheInfo);
-
-		$fileInfo2 = $view->getFileInfo('world.txt');
-		$storage2 = $fileInfo2->getStorage();
-		$cache2 = $storage2->getCache();
-		$filecache2 = $cache2->get($fileInfo2->getId());
-
-		//Now change the encrypted version to 1
-		$cacheInfo = ['encryptedVersion' => 6, 'encrypted' => 6];
-		$cache2->put($filecache2->getPath(), $cacheInfo);
-
-		$this->commandTester->execute([
-			'user' => $this->userId
-		]);
-
-		$output = $this->commandTester->getDisplay();
-
-		$this->assertStringContainsString("Verifying the content of file \"/$this->userId/files/foo.txt\"
+    }
+
+    /**
+     * In this test the encrypted version of the file is greater than the original value
+     * but greater than zero
+     */
+    public function testEncryptedVersionGreaterThanOriginalValue(): void {
+        $this->util->expects($this->once())->method('isMasterKeyEnabled')
+            ->willReturn(true);
+
+        $view = new View('/' . $this->userId . '/files');
+
+        $view->touch('hello.txt');
+        $view->touch('world.txt');
+        $view->touch('foo.txt');
+        $view->file_put_contents('hello.txt', 'a test string for hello');
+        $view->file_put_contents('hello.txt', 'Lets modify again2');
+        $view->file_put_contents('hello.txt', 'Lets modify again3');
+        $view->file_put_contents('world.txt', 'a test string for world');
+        $view->file_put_contents('world.txt', 'a test string for world');
+        $view->file_put_contents('world.txt', 'a test string for world');
+        $view->file_put_contents('world.txt', 'a test string for world');
+        $view->file_put_contents('foo.txt', 'a foo test');
+
+        $fileInfo1 = $view->getFileInfo('hello.txt');
+
+        $storage1 = $fileInfo1->getStorage();
+        $cache1 = $storage1->getCache();
+        $fileCache1 = $cache1->get($fileInfo1->getId());
+
+        //Now change the encrypted version to fifteen
+        $cacheInfo = ['encryptedVersion' => 5, 'encrypted' => 5];
+        $cache1->put($fileCache1->getPath(), $cacheInfo);
+
+        $fileInfo2 = $view->getFileInfo('world.txt');
+        $storage2 = $fileInfo2->getStorage();
+        $cache2 = $storage2->getCache();
+        $filecache2 = $cache2->get($fileInfo2->getId());
+
+        //Now change the encrypted version to 1
+        $cacheInfo = ['encryptedVersion' => 6, 'encrypted' => 6];
+        $cache2->put($filecache2->getPath(), $cacheInfo);
+
+        $this->commandTester->execute([
+            'user' => $this->userId
+        ]);
+
+        $output = $this->commandTester->getDisplay();
+
+        $this->assertStringContainsString("Verifying the content of file \"/$this->userId/files/foo.txt\"
 The file \"/$this->userId/files/foo.txt\" is: OK", $output);
-		$this->assertStringContainsString("Verifying the content of file \"/$this->userId/files/hello.txt\"
+        $this->assertStringContainsString("Verifying the content of file \"/$this->userId/files/hello.txt\"
 Attempting to fix the path: \"/$this->userId/files/hello.txt\"
 Decrement the encrypted version to 4
 Decrement the encrypted version to 3
 The file \"/$this->userId/files/hello.txt\" is: OK
 Fixed the file: \"/$this->userId/files/hello.txt\" with version 3", $output);
-		$this->assertStringContainsString("Verifying the content of file \"/$this->userId/files/world.txt\"
+        $this->assertStringContainsString("Verifying the content of file \"/$this->userId/files/world.txt\"
 Attempting to fix the path: \"/$this->userId/files/world.txt\"
 Decrement the encrypted version to 5
 Decrement the encrypted version to 4
 The file \"/$this->userId/files/world.txt\" is: OK
 Fixed the file: \"/$this->userId/files/world.txt\" with version 4", $output);
-	}
+    }
 
-	public function testVersionIsRestoredToOriginalIfNoFixIsFound(): void {
-		$this->util->expects($this->once())->method('isMasterKeyEnabled')
-			->willReturn(true);
+    public function testVersionIsRestoredToOriginalIfNoFixIsFound(): void {
+        $this->util->expects($this->once())->method('isMasterKeyEnabled')
+            ->willReturn(true);
 
-		$view = new View('/' . $this->userId . '/files');
+        $view = new View('/' . $this->userId . '/files');
 
-		$view->touch('bar.txt');
-		for ($i = 0; $i < 40; $i++) {
-			$view->file_put_contents('bar.txt', 'a test string for hello ' . $i);
-		}
+        $view->touch('bar.txt');
+        for ($i = 0; $i < 40; $i++) {
+            $view->file_put_contents('bar.txt', 'a test string for hello ' . $i);
+        }
 
-		$fileInfo = $view->getFileInfo('bar.txt');
+        $fileInfo = $view->getFileInfo('bar.txt');
 
-		$storage = $fileInfo->getStorage();
-		$cache = $storage->getCache();
-		$fileCache = $cache->get($fileInfo->getId());
+        $storage = $fileInfo->getStorage();
+        $cache = $storage->getCache();
+        $fileCache = $cache->get($fileInfo->getId());
 
-		$cacheInfo = ['encryptedVersion' => 15, 'encrypted' => 15];
-		$cache->put($fileCache->getPath(), $cacheInfo);
+        $cacheInfo = ['encryptedVersion' => 15, 'encrypted' => 15];
+        $cache->put($fileCache->getPath(), $cacheInfo);
 
-		$this->commandTester->execute([
-			'user' => $this->userId
-		]);
+        $this->commandTester->execute([
+            'user' => $this->userId
+        ]);
 
-		$cacheInfo = $cache->get($fileInfo->getId());
-		$encryptedVersion = $cacheInfo['encryptedVersion'];
+        $cacheInfo = $cache->get($fileInfo->getId());
+        $encryptedVersion = $cacheInfo['encryptedVersion'];
 
-		$this->assertEquals(15, $encryptedVersion);
-	}
+        $this->assertEquals(15, $encryptedVersion);
+    }
 
-	public function testRepairUnencryptedFileWhenVersionIsSet(): void {
-		$this->util->expects($this->once())->method('isMasterKeyEnabled')
-			->willReturn(true);
+    public function testRepairUnencryptedFileWhenVersionIsSet(): void {
+        $this->util->expects($this->once())->method('isMasterKeyEnabled')
+            ->willReturn(true);
 
-		$view = new View('/' . $this->userId . '/files');
+        $view = new View('/' . $this->userId . '/files');
 
-		// create a file, it's encrypted and also the version is set in the database
-		$view->touch('hello.txt');
+        // create a file, it's encrypted and also the version is set in the database
+        $view->touch('hello.txt');
 
-		$fileInfo1 = $view->getFileInfo('hello.txt');
+        $fileInfo1 = $view->getFileInfo('hello.txt');
 
-		$storage1 = $fileInfo1->getStorage();
-		$cache1 = $storage1->getCache();
-		$fileCache1 = $cache1->get($fileInfo1->getId());
+        $storage1 = $fileInfo1->getStorage();
+        $cache1 = $storage1->getCache();
+        $fileCache1 = $cache1->get($fileInfo1->getId());
 
-		// Now change the encrypted version
-		$cacheInfo = ['encryptedVersion' => 1, 'encrypted' => 1];
-		$cache1->put($fileCache1->getPath(), $cacheInfo);
+        // Now change the encrypted version
+        $cacheInfo = ['encryptedVersion' => 1, 'encrypted' => 1];
+        $cache1->put($fileCache1->getPath(), $cacheInfo);
 
-		$absPath = $storage1->getSourcePath('') . $fileInfo1->getInternalPath();
+        $absPath = $storage1->getSourcePath('') . $fileInfo1->getInternalPath();
 
-		// create unencrypted file on disk, the version stays
-		file_put_contents($absPath, 'hello contents');
+        // create unencrypted file on disk, the version stays
+        file_put_contents($absPath, 'hello contents');
 
-		$this->commandTester->execute([
-			'user' => $this->userId
-		]);
+        $this->commandTester->execute([
+            'user' => $this->userId
+        ]);
 
-		$output = $this->commandTester->getDisplay();
+        $output = $this->commandTester->getDisplay();
 
-		$this->assertStringContainsString("Verifying the content of file \"/$this->userId/files/hello.txt\"
+        $this->assertStringContainsString("Verifying the content of file \"/$this->userId/files/hello.txt\"
 Attempting to fix the path: \"/$this->userId/files/hello.txt\"
 Set the encrypted version to 0 (unencrypted)
 The file \"/$this->userId/files/hello.txt\" is: OK
 Fixed the file: \"/$this->userId/files/hello.txt\" with version 0 (unencrypted)", $output);
 
-		// the file can be decrypted
-		$this->assertEquals('hello contents', $view->file_get_contents('hello.txt'));
-	}
+        // the file can be decrypted
+        $this->assertEquals('hello contents', $view->file_get_contents('hello.txt'));
+    }
 
-	/**
-	 * Test commands with a file path
-	 */
-	public function testExecuteWithFilePathOption(): void {
-		$this->util->expects($this->once())->method('isMasterKeyEnabled')
-			->willReturn(true);
+    /**
+     * Test commands with a file path
+     */
+    public function testExecuteWithFilePathOption(): void {
+        $this->util->expects($this->once())->method('isMasterKeyEnabled')
+            ->willReturn(true);
 
-		$view = new View('/' . $this->userId . '/files');
+        $view = new View('/' . $this->userId . '/files');
 
-		$view->touch('hello.txt');
-		$view->touch('world.txt');
+        $view->touch('hello.txt');
+        $view->touch('world.txt');
 
-		$this->commandTester->execute([
-			'user' => $this->userId,
-			'--path' => '/hello.txt'
-		]);
+        $this->commandTester->execute([
+            'user' => $this->userId,
+            '--path' => '/hello.txt'
+        ]);
 
-		$output = $this->commandTester->getDisplay();
+        $output = $this->commandTester->getDisplay();
 
-		$this->assertStringContainsString("Verifying the content of file \"/$this->userId/files/hello.txt\"
+        $this->assertStringContainsString("Verifying the content of file \"/$this->userId/files/hello.txt\"
 The file \"/$this->userId/files/hello.txt\" is: OK", $output);
-		$this->assertStringNotContainsString('world.txt', $output);
-	}
+        $this->assertStringNotContainsString('world.txt', $output);
+    }
 
-	/**
-	 * Test commands with a directory path
-	 */
-	public function testExecuteWithDirectoryPathOption(): void {
-		$this->util->expects($this->once())->method('isMasterKeyEnabled')
-			->willReturn(true);
+    /**
+     * Test commands with a directory path
+     */
+    public function testExecuteWithDirectoryPathOption(): void {
+        $this->util->expects($this->once())->method('isMasterKeyEnabled')
+            ->willReturn(true);
 
-		$view = new View('/' . $this->userId . '/files');
+        $view = new View('/' . $this->userId . '/files');
 
-		$view->mkdir('sub');
-		$view->touch('sub/hello.txt');
-		$view->touch('world.txt');
+        $view->mkdir('sub');
+        $view->touch('sub/hello.txt');
+        $view->touch('world.txt');
 
-		$this->commandTester->execute([
-			'user' => $this->userId,
-			'--path' => '/sub'
-		]);
+        $this->commandTester->execute([
+            'user' => $this->userId,
+            '--path' => '/sub'
+        ]);
 
-		$output = $this->commandTester->getDisplay();
+        $output = $this->commandTester->getDisplay();
 
-		$this->assertStringContainsString("Verifying the content of file \"/$this->userId/files/sub/hello.txt\"
+        $this->assertStringContainsString("Verifying the content of file \"/$this->userId/files/sub/hello.txt\"
 The file \"/$this->userId/files/sub/hello.txt\" is: OK", $output);
-		$this->assertStringNotContainsString('world.txt', $output);
-	}
+        $this->assertStringNotContainsString('world.txt', $output);
+    }
 
-	public function testExecuteWithNoUser(): void {
-		$this->util->expects($this->once())->method('isMasterKeyEnabled')
-			->willReturn(true);
+    public function testExecuteWithNoUser(): void {
+        $this->util->expects($this->once())->method('isMasterKeyEnabled')
+            ->willReturn(true);
 
-		$this->commandTester->execute([
-			'user' => null,
-			'--path' => '/'
-		]);
+        $this->commandTester->execute([
+            'user' => null,
+            '--path' => '/'
+        ]);
 
-		$output = $this->commandTester->getDisplay();
+        $output = $this->commandTester->getDisplay();
 
-		$this->assertStringContainsString('Either a user id or --all needs to be provided', $output);
-	}
+        $this->assertStringContainsString('Either a user id or --all needs to be provided', $output);
+    }
 
-	public function testExecuteWithBadUser(): void {
-		$this->util->expects($this->once())->method('isMasterKeyEnabled')
-			->willReturn(true);
+    public function testExecuteWithBadUser(): void {
+        $this->util->expects($this->once())->method('isMasterKeyEnabled')
+            ->willReturn(true);
 
-		$this->commandTester->execute([
-			'user' => 'nonexisting',
-			'--path' => '/'
-		]);
+        $this->commandTester->execute([
+            'user' => 'nonexisting',
+            '--path' => '/'
+        ]);
 
-		$output = $this->commandTester->getDisplay();
+        $output = $this->commandTester->getDisplay();
 
-		$this->assertStringContainsString('does not exist', $output);
-	}
+        $this->assertStringContainsString('does not exist', $output);
+    }
 
-	/**
-	 * Test commands with a directory path
-	 */
-	public function testExecuteWithNonExistentPath(): void {
-		$this->util->expects($this->once())->method('isMasterKeyEnabled')
-			->willReturn(true);
+    /**
+     * Test commands with a directory path
+     */
+    public function testExecuteWithNonExistentPath(): void {
+        $this->util->expects($this->once())->method('isMasterKeyEnabled')
+            ->willReturn(true);
 
-		$this->commandTester->execute([
-			'user' => $this->userId,
-			'--path' => '/non-exist'
-		]);
+        $this->commandTester->execute([
+            'user' => $this->userId,
+            '--path' => '/non-exist'
+        ]);
 
-		$output = $this->commandTester->getDisplay();
+        $output = $this->commandTester->getDisplay();
 
-		$this->assertStringContainsString('Please provide a valid path.', $output);
-	}
+        $this->assertStringContainsString('Please provide a valid path.', $output);
+    }
 
-	/**
-	 * Test commands without master key
-	 */
-	public function testExecuteWithNoMasterKey(): void {
-		Server::get(IConfig::class)->setAppValue('encryption', 'useMasterKey', '0');
-		$this->util->expects($this->once())->method('isMasterKeyEnabled')
-			->willReturn(false);
+    /**
+     * Test commands without master key
+     */
+    public function testExecuteWithNoMasterKey(): void {
+        Server::get(IConfig::class)->setAppValue('encryption', 'useMasterKey', '0');
+        $this->util->expects($this->once())->method('isMasterKeyEnabled')
+            ->willReturn(false);
 
-		$this->commandTester->execute([
-			'user' => $this->userId,
-		]);
+        $this->commandTester->execute([
+            'user' => $this->userId,
+        ]);
 
-		$output = $this->commandTester->getDisplay();
+        $output = $this->commandTester->getDisplay();
 
-		$this->assertStringContainsString('only works with master key', $output);
-	}
+        $this->assertStringContainsString('only works with master key', $output);
+    }
 }

apps/encryption/tests/Controller/SettingsControllerTest.php

Indentation +185 added lines, -185 removed lines

@@ -26,189 +26,189 @@
 
 class SettingsControllerTest extends TestCase {
 
-	protected SettingsController $controller;
-
-	protected IRequest&MockObject $requestMock;
-	protected IL10N&MockObject $l10nMock;
-	protected IUserManager&MockObject $userManagerMock;
-	protected IUserSession&MockObject $userSessionMock;
-	protected KeyManager&MockObject $keyManagerMock;
-	protected Crypt&MockObject $cryptMock;
-	protected Session&MockObject $sessionMock;
-	protected IUser&MockObject $user;
-	protected ISession&MockObject $ocSessionMock;
-	protected Util&MockObject $utilMock;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->requestMock = $this->createMock(IRequest::class);
-
-		$this->l10nMock = $this->getMockBuilder(IL10N::class)
-			->disableOriginalConstructor()->getMock();
-
-		$this->l10nMock->expects($this->any())
-			->method('t')
-			->willReturnCallback(function ($message) {
-				return $message;
-			});
-
-		$this->userManagerMock = $this->getMockBuilder(IUserManager::class)
-			->disableOriginalConstructor()->getMock();
-
-		$this->keyManagerMock = $this->getMockBuilder(KeyManager::class)
-			->disableOriginalConstructor()->getMock();
-
-		$this->cryptMock = $this->getMockBuilder(Crypt::class)
-			->disableOriginalConstructor()->getMock();
-
-		$this->ocSessionMock = $this->getMockBuilder(ISession::class)->disableOriginalConstructor()->getMock();
-
-		$this->user = $this->createMock(IUser::class);
-		$this->user->expects($this->any())
-			->method('getUID')
-			->willReturn('testUserUid');
-
-		$this->userSessionMock = $this->createMock(IUserSession::class);
-		$this->userSessionMock->expects($this->any())
-			->method('getUser')
-			->willReturn($this->user);
-
-		$this->sessionMock = $this->getMockBuilder(Session::class)
-			->disableOriginalConstructor()->getMock();
-
-		$this->utilMock = $this->getMockBuilder(Util::class)
-			->disableOriginalConstructor()
-			->getMock();
-
-		$this->controller = new SettingsController(
-			'encryption',
-			$this->requestMock,
-			$this->l10nMock,
-			$this->userManagerMock,
-			$this->userSessionMock,
-			$this->keyManagerMock,
-			$this->cryptMock,
-			$this->sessionMock,
-			$this->ocSessionMock,
-			$this->utilMock
-		);
-	}
-
-	/**
-	 * test updatePrivateKeyPassword() if wrong new password was entered
-	 */
-	public function testUpdatePrivateKeyPasswordWrongNewPassword(): void {
-		$oldPassword = 'old';
-		$newPassword = 'new';
-
-		$this->user->expects($this->any())
-			->method('getUID')
-			->willReturn('uid');
-
-		$this->userManagerMock
-			->expects($this->exactly(2))
-			->method('checkPassword')
-			->willReturn(false);
-
-		$result = $this->controller->updatePrivateKeyPassword($oldPassword, $newPassword);
-
-		$data = $result->getData();
-
-		$this->assertSame(Http::STATUS_BAD_REQUEST, $result->getStatus());
-		$this->assertSame('The current log-in password was not correct, please try again.',
-			$data['message']);
-	}
-
-	/**
-	 * test updatePrivateKeyPassword() if wrong old password was entered
-	 */
-	public function testUpdatePrivateKeyPasswordWrongOldPassword(): void {
-		$oldPassword = 'old';
-		$newPassword = 'new';
-
-		$this->userManagerMock
-			->expects($this->once())
-			->method('checkPassword')
-			->willReturn(true);
-
-		$this->cryptMock
-			->expects($this->once())
-			->method('decryptPrivateKey')
-			->willReturn(false);
-
-		$result = $this->controller->updatePrivateKeyPassword($oldPassword, $newPassword);
-
-		$data = $result->getData();
-
-		$this->assertSame(Http::STATUS_BAD_REQUEST, $result->getStatus());
-		$this->assertSame('The old password was not correct, please try again.',
-			$data['message']);
-	}
-
-	/**
-	 * test updatePrivateKeyPassword() with the correct old and new password
-	 */
-	public function testUpdatePrivateKeyPassword(): void {
-		$oldPassword = 'old';
-		$newPassword = 'new';
-
-		$this->ocSessionMock->expects($this->once())
-			->method('get')
-			->with('loginname')
-			->willReturn('testUser');
-
-		$this->userManagerMock
-			->expects($this->exactly(2))
-			->method('checkPassword')
-			->willReturnMap([
-				['testUserUid', 'new', false],
-				['testUser', 'new', true],
-			]);
-
-		$this->cryptMock
-			->expects($this->once())
-			->method('decryptPrivateKey')
-			->willReturn('decryptedKey');
-
-		$this->cryptMock
-			->expects($this->once())
-			->method('encryptPrivateKey')
-			->willReturn('encryptedKey');
-
-		$this->cryptMock
-			->expects($this->once())
-			->method('generateHeader')
-			->willReturn('header.');
-
-		// methods which must be called after successful changing the key password
-		$this->keyManagerMock
-			->expects($this->once())
-			->method('setPrivateKey')
-			->with($this->equalTo('testUserUid'), $this->equalTo('header.encryptedKey'));
-
-		$this->sessionMock
-			->expects($this->once())
-			->method('setPrivateKey')
-			->with($this->equalTo('decryptedKey'));
-
-		$this->sessionMock
-			->expects($this->once())
-			->method('setStatus')
-			->with($this->equalTo(Session::INIT_SUCCESSFUL));
-
-		$result = $this->controller->updatePrivateKeyPassword($oldPassword, $newPassword);
-
-		$data = $result->getData();
-
-		$this->assertSame(Http::STATUS_OK, $result->getStatus());
-		$this->assertSame('Private key password successfully updated.',
-			$data['message']);
-	}
-
-	public function testSetEncryptHomeStorage(): void {
-		$value = true;
-		$this->utilMock->expects($this->once())->method('setEncryptHomeStorage')->with($value);
-		$this->controller->setEncryptHomeStorage($value);
-	}
+    protected SettingsController $controller;
+
+    protected IRequest&MockObject $requestMock;
+    protected IL10N&MockObject $l10nMock;
+    protected IUserManager&MockObject $userManagerMock;
+    protected IUserSession&MockObject $userSessionMock;
+    protected KeyManager&MockObject $keyManagerMock;
+    protected Crypt&MockObject $cryptMock;
+    protected Session&MockObject $sessionMock;
+    protected IUser&MockObject $user;
+    protected ISession&MockObject $ocSessionMock;
+    protected Util&MockObject $utilMock;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->requestMock = $this->createMock(IRequest::class);
+
+        $this->l10nMock = $this->getMockBuilder(IL10N::class)
+            ->disableOriginalConstructor()->getMock();
+
+        $this->l10nMock->expects($this->any())
+            ->method('t')
+            ->willReturnCallback(function ($message) {
+                return $message;
+            });
+
+        $this->userManagerMock = $this->getMockBuilder(IUserManager::class)
+            ->disableOriginalConstructor()->getMock();
+
+        $this->keyManagerMock = $this->getMockBuilder(KeyManager::class)
+            ->disableOriginalConstructor()->getMock();
+
+        $this->cryptMock = $this->getMockBuilder(Crypt::class)
+            ->disableOriginalConstructor()->getMock();
+
+        $this->ocSessionMock = $this->getMockBuilder(ISession::class)->disableOriginalConstructor()->getMock();
+
+        $this->user = $this->createMock(IUser::class);
+        $this->user->expects($this->any())
+            ->method('getUID')
+            ->willReturn('testUserUid');
+
+        $this->userSessionMock = $this->createMock(IUserSession::class);
+        $this->userSessionMock->expects($this->any())
+            ->method('getUser')
+            ->willReturn($this->user);
+
+        $this->sessionMock = $this->getMockBuilder(Session::class)
+            ->disableOriginalConstructor()->getMock();
+
+        $this->utilMock = $this->getMockBuilder(Util::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $this->controller = new SettingsController(
+            'encryption',
+            $this->requestMock,
+            $this->l10nMock,
+            $this->userManagerMock,
+            $this->userSessionMock,
+            $this->keyManagerMock,
+            $this->cryptMock,
+            $this->sessionMock,
+            $this->ocSessionMock,
+            $this->utilMock
+        );
+    }
+
+    /**
+     * test updatePrivateKeyPassword() if wrong new password was entered
+     */
+    public function testUpdatePrivateKeyPasswordWrongNewPassword(): void {
+        $oldPassword = 'old';
+        $newPassword = 'new';
+
+        $this->user->expects($this->any())
+            ->method('getUID')
+            ->willReturn('uid');
+
+        $this->userManagerMock
+            ->expects($this->exactly(2))
+            ->method('checkPassword')
+            ->willReturn(false);
+
+        $result = $this->controller->updatePrivateKeyPassword($oldPassword, $newPassword);
+
+        $data = $result->getData();
+
+        $this->assertSame(Http::STATUS_BAD_REQUEST, $result->getStatus());
+        $this->assertSame('The current log-in password was not correct, please try again.',
+            $data['message']);
+    }
+
+    /**
+     * test updatePrivateKeyPassword() if wrong old password was entered
+     */
+    public function testUpdatePrivateKeyPasswordWrongOldPassword(): void {
+        $oldPassword = 'old';
+        $newPassword = 'new';
+
+        $this->userManagerMock
+            ->expects($this->once())
+            ->method('checkPassword')
+            ->willReturn(true);
+
+        $this->cryptMock
+            ->expects($this->once())
+            ->method('decryptPrivateKey')
+            ->willReturn(false);
+
+        $result = $this->controller->updatePrivateKeyPassword($oldPassword, $newPassword);
+
+        $data = $result->getData();
+
+        $this->assertSame(Http::STATUS_BAD_REQUEST, $result->getStatus());
+        $this->assertSame('The old password was not correct, please try again.',
+            $data['message']);
+    }
+
+    /**
+     * test updatePrivateKeyPassword() with the correct old and new password
+     */
+    public function testUpdatePrivateKeyPassword(): void {
+        $oldPassword = 'old';
+        $newPassword = 'new';
+
+        $this->ocSessionMock->expects($this->once())
+            ->method('get')
+            ->with('loginname')
+            ->willReturn('testUser');
+
+        $this->userManagerMock
+            ->expects($this->exactly(2))
+            ->method('checkPassword')
+            ->willReturnMap([
+                ['testUserUid', 'new', false],
+                ['testUser', 'new', true],
+            ]);
+
+        $this->cryptMock
+            ->expects($this->once())
+            ->method('decryptPrivateKey')
+            ->willReturn('decryptedKey');
+
+        $this->cryptMock
+            ->expects($this->once())
+            ->method('encryptPrivateKey')
+            ->willReturn('encryptedKey');
+
+        $this->cryptMock
+            ->expects($this->once())
+            ->method('generateHeader')
+            ->willReturn('header.');
+
+        // methods which must be called after successful changing the key password
+        $this->keyManagerMock
+            ->expects($this->once())
+            ->method('setPrivateKey')
+            ->with($this->equalTo('testUserUid'), $this->equalTo('header.encryptedKey'));
+
+        $this->sessionMock
+            ->expects($this->once())
+            ->method('setPrivateKey')
+            ->with($this->equalTo('decryptedKey'));
+
+        $this->sessionMock
+            ->expects($this->once())
+            ->method('setStatus')
+            ->with($this->equalTo(Session::INIT_SUCCESSFUL));
+
+        $result = $this->controller->updatePrivateKeyPassword($oldPassword, $newPassword);
+
+        $data = $result->getData();
+
+        $this->assertSame(Http::STATUS_OK, $result->getStatus());
+        $this->assertSame('Private key password successfully updated.',
+            $data['message']);
+    }
+
+    public function testSetEncryptHomeStorage(): void {
+        $value = true;
+        $this->utilMock->expects($this->once())->method('setEncryptHomeStorage')->with($value);
+        $this->controller->setEncryptHomeStorage($value);
+    }
 }

apps/encryption/tests/Controller/StatusControllerTest.php

Indentation +45 added lines, -45 removed lines

@@ -19,56 +19,56 @@
 
 class StatusControllerTest extends TestCase {
 
-	protected IRequest&MockObject $requestMock;
-	protected IL10N&MockObject $l10nMock;
-	protected Session&MockObject $sessionMock;
-	protected IManager&MockObject $encryptionManagerMock;
+    protected IRequest&MockObject $requestMock;
+    protected IL10N&MockObject $l10nMock;
+    protected Session&MockObject $sessionMock;
+    protected IManager&MockObject $encryptionManagerMock;
 
-	protected StatusController $controller;
+    protected StatusController $controller;
 
-	protected function setUp(): void {
-		parent::setUp();
+    protected function setUp(): void {
+        parent::setUp();
 
-		$this->sessionMock = $this->getMockBuilder(Session::class)
-			->disableOriginalConstructor()->getMock();
-		$this->requestMock = $this->createMock(IRequest::class);
+        $this->sessionMock = $this->getMockBuilder(Session::class)
+            ->disableOriginalConstructor()->getMock();
+        $this->requestMock = $this->createMock(IRequest::class);
 
-		$this->l10nMock = $this->getMockBuilder(IL10N::class)
-			->disableOriginalConstructor()->getMock();
-		$this->l10nMock->expects($this->any())
-			->method('t')
-			->willReturnCallback(function ($message) {
-				return $message;
-			});
-		$this->encryptionManagerMock = $this->createMock(IManager::class);
+        $this->l10nMock = $this->getMockBuilder(IL10N::class)
+            ->disableOriginalConstructor()->getMock();
+        $this->l10nMock->expects($this->any())
+            ->method('t')
+            ->willReturnCallback(function ($message) {
+                return $message;
+            });
+        $this->encryptionManagerMock = $this->createMock(IManager::class);
 
-		$this->controller = new StatusController('encryptionTest',
-			$this->requestMock,
-			$this->l10nMock,
-			$this->sessionMock,
-			$this->encryptionManagerMock);
-	}
+        $this->controller = new StatusController('encryptionTest',
+            $this->requestMock,
+            $this->l10nMock,
+            $this->sessionMock,
+            $this->encryptionManagerMock);
+    }
 
-	/**
-	 * @dataProvider dataTestGetStatus
-	 *
-	 * @param string $status
-	 * @param string $expectedStatus
-	 */
-	public function testGetStatus($status, $expectedStatus): void {
-		$this->sessionMock->expects($this->once())
-			->method('getStatus')->willReturn($status);
-		$result = $this->controller->getStatus();
-		$data = $result->getData();
-		$this->assertSame($expectedStatus, $data['status']);
-	}
+    /**
+     * @dataProvider dataTestGetStatus
+     *
+     * @param string $status
+     * @param string $expectedStatus
+     */
+    public function testGetStatus($status, $expectedStatus): void {
+        $this->sessionMock->expects($this->once())
+            ->method('getStatus')->willReturn($status);
+        $result = $this->controller->getStatus();
+        $data = $result->getData();
+        $this->assertSame($expectedStatus, $data['status']);
+    }
 
-	public static function dataTestGetStatus(): array {
-		return [
-			[Session::INIT_EXECUTED, 'interactionNeeded'],
-			[Session::INIT_SUCCESSFUL, 'success'],
-			[Session::NOT_INITIALIZED, 'interactionNeeded'],
-			['unknown', 'error'],
-		];
-	}
+    public static function dataTestGetStatus(): array {
+        return [
+            [Session::INIT_EXECUTED, 'interactionNeeded'],
+            [Session::INIT_SUCCESSFUL, 'success'],
+            [Session::NOT_INITIALIZED, 'interactionNeeded'],
+            ['unknown', 'error'],
+        ];
+    }
 }

apps/encryption/tests/Controller/RecoveryControllerTest.php

Indentation +137 added lines, -137 removed lines

@@ -19,141 +19,141 @@
 use Test\TestCase;
 
 class RecoveryControllerTest extends TestCase {
-	protected RecoveryController $controller;
-
-	protected IRequest&MockObject $requestMock;
-	protected IConfig&MockObject $configMock;
-	protected IL10N&MockObject $l10nMock;
-	protected Recovery&MockObject $recoveryMock;
-
-	public static function adminRecoveryProvider(): array {
-		return [
-			['test', 'test', '1', 'Recovery key successfully enabled', Http::STATUS_OK],
-			['', 'test', '1', 'Missing recovery key password', Http::STATUS_BAD_REQUEST],
-			['test', '', '1', 'Please repeat the recovery key password', Http::STATUS_BAD_REQUEST],
-			['test', 'something that doesn\'t match', '1', 'Repeated recovery key password does not match the provided recovery key password', Http::STATUS_BAD_REQUEST],
-			['test', 'test', '0', 'Recovery key successfully disabled', Http::STATUS_OK],
-		];
-	}
-
-	/**
-	 * @dataProvider adminRecoveryProvider
-	 * @param $recoveryPassword
-	 * @param $passConfirm
-	 * @param $enableRecovery
-	 * @param $expectedMessage
-	 * @param $expectedStatus
-	 */
-	public function testAdminRecovery($recoveryPassword, $passConfirm, $enableRecovery, $expectedMessage, $expectedStatus): void {
-		$this->recoveryMock->expects($this->any())
-			->method('enableAdminRecovery')
-			->willReturn(true);
-
-		$this->recoveryMock->expects($this->any())
-			->method('disableAdminRecovery')
-			->willReturn(true);
-
-		$response = $this->controller->adminRecovery($recoveryPassword,
-			$passConfirm,
-			$enableRecovery);
-
-
-		$this->assertEquals($expectedMessage, $response->getData()['data']['message']);
-		$this->assertEquals($expectedStatus, $response->getStatus());
-	}
-
-	public static function changeRecoveryPasswordProvider(): array {
-		return [
-			['test', 'test', 'oldtestFail', 'Could not change the password. Maybe the old password was not correct.', Http::STATUS_BAD_REQUEST],
-			['test', 'test', 'oldtest', 'Password successfully changed.', Http::STATUS_OK],
-			['test', 'notmatch', 'oldtest', 'Repeated recovery key password does not match the provided recovery key password', Http::STATUS_BAD_REQUEST],
-			['', 'test', 'oldtest', 'Please provide a new recovery password', Http::STATUS_BAD_REQUEST],
-			['test', 'test', '', 'Please provide the old recovery password', Http::STATUS_BAD_REQUEST]
-		];
-	}
-
-	/**
-	 * @dataProvider changeRecoveryPasswordProvider
-	 * @param $password
-	 * @param $confirmPassword
-	 * @param $oldPassword
-	 * @param $expectedMessage
-	 * @param $expectedStatus
-	 */
-	public function testChangeRecoveryPassword($password, $confirmPassword, $oldPassword, $expectedMessage, $expectedStatus): void {
-		$this->recoveryMock->expects($this->any())
-			->method('changeRecoveryKeyPassword')
-			->with($password, $oldPassword)
-			->willReturnMap([
-				['test', 'oldTestFail', false],
-				['test', 'oldtest', true]
-			]);
-
-		$response = $this->controller->changeRecoveryPassword($password,
-			$oldPassword,
-			$confirmPassword);
-
-		$this->assertEquals($expectedMessage, $response->getData()['data']['message']);
-		$this->assertEquals($expectedStatus, $response->getStatus());
-	}
-
-	public static function userSetRecoveryProvider(): array {
-		return [
-			['1', 'Recovery Key enabled', Http::STATUS_OK],
-			['0', 'Could not enable the recovery key, please try again or contact your administrator', Http::STATUS_BAD_REQUEST]
-		];
-	}
-
-	/**
-	 * @dataProvider userSetRecoveryProvider
-	 * @param $enableRecovery
-	 * @param $expectedMessage
-	 * @param $expectedStatus
-	 */
-	public function testUserSetRecovery($enableRecovery, $expectedMessage, $expectedStatus): void {
-		$this->recoveryMock->expects($this->any())
-			->method('setRecoveryForUser')
-			->with($enableRecovery)
-			->willReturnMap([
-				['1', true],
-				['0', false]
-			]);
-
-
-		$response = $this->controller->userSetRecovery($enableRecovery);
-
-		$this->assertEquals($expectedMessage, $response->getData()['data']['message']);
-		$this->assertEquals($expectedStatus, $response->getStatus());
-	}
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->requestMock = $this->getMockBuilder(IRequest::class)
-			->disableOriginalConstructor()
-			->getMock();
-
-		$this->configMock = $this->getMockBuilder(IConfig::class)
-			->disableOriginalConstructor()
-			->getMock();
-
-		$this->l10nMock = $this->getMockBuilder(IL10N::class)
-			->disableOriginalConstructor()
-			->getMock();
-
-		// Make l10n work in our tests
-		$this->l10nMock->expects($this->any())
-			->method('t')
-			->willReturnArgument(0);
-
-		$this->recoveryMock = $this->getMockBuilder(Recovery::class)
-			->disableOriginalConstructor()
-			->getMock();
-
-		$this->controller = new RecoveryController('encryption',
-			$this->requestMock,
-			$this->configMock,
-			$this->l10nMock,
-			$this->recoveryMock);
-	}
+    protected RecoveryController $controller;
+
+    protected IRequest&MockObject $requestMock;
+    protected IConfig&MockObject $configMock;
+    protected IL10N&MockObject $l10nMock;
+    protected Recovery&MockObject $recoveryMock;
+
+    public static function adminRecoveryProvider(): array {
+        return [
+            ['test', 'test', '1', 'Recovery key successfully enabled', Http::STATUS_OK],
+            ['', 'test', '1', 'Missing recovery key password', Http::STATUS_BAD_REQUEST],
+            ['test', '', '1', 'Please repeat the recovery key password', Http::STATUS_BAD_REQUEST],
+            ['test', 'something that doesn\'t match', '1', 'Repeated recovery key password does not match the provided recovery key password', Http::STATUS_BAD_REQUEST],
+            ['test', 'test', '0', 'Recovery key successfully disabled', Http::STATUS_OK],
+        ];
+    }
+
+    /**
+     * @dataProvider adminRecoveryProvider
+     * @param $recoveryPassword
+     * @param $passConfirm
+     * @param $enableRecovery
+     * @param $expectedMessage
+     * @param $expectedStatus
+     */
+    public function testAdminRecovery($recoveryPassword, $passConfirm, $enableRecovery, $expectedMessage, $expectedStatus): void {
+        $this->recoveryMock->expects($this->any())
+            ->method('enableAdminRecovery')
+            ->willReturn(true);
+
+        $this->recoveryMock->expects($this->any())
+            ->method('disableAdminRecovery')
+            ->willReturn(true);
+
+        $response = $this->controller->adminRecovery($recoveryPassword,
+            $passConfirm,
+            $enableRecovery);
+
+
+        $this->assertEquals($expectedMessage, $response->getData()['data']['message']);
+        $this->assertEquals($expectedStatus, $response->getStatus());
+    }
+
+    public static function changeRecoveryPasswordProvider(): array {
+        return [
+            ['test', 'test', 'oldtestFail', 'Could not change the password. Maybe the old password was not correct.', Http::STATUS_BAD_REQUEST],
+            ['test', 'test', 'oldtest', 'Password successfully changed.', Http::STATUS_OK],
+            ['test', 'notmatch', 'oldtest', 'Repeated recovery key password does not match the provided recovery key password', Http::STATUS_BAD_REQUEST],
+            ['', 'test', 'oldtest', 'Please provide a new recovery password', Http::STATUS_BAD_REQUEST],
+            ['test', 'test', '', 'Please provide the old recovery password', Http::STATUS_BAD_REQUEST]
+        ];
+    }
+
+    /**
+     * @dataProvider changeRecoveryPasswordProvider
+     * @param $password
+     * @param $confirmPassword
+     * @param $oldPassword
+     * @param $expectedMessage
+     * @param $expectedStatus
+     */
+    public function testChangeRecoveryPassword($password, $confirmPassword, $oldPassword, $expectedMessage, $expectedStatus): void {
+        $this->recoveryMock->expects($this->any())
+            ->method('changeRecoveryKeyPassword')
+            ->with($password, $oldPassword)
+            ->willReturnMap([
+                ['test', 'oldTestFail', false],
+                ['test', 'oldtest', true]
+            ]);
+
+        $response = $this->controller->changeRecoveryPassword($password,
+            $oldPassword,
+            $confirmPassword);
+
+        $this->assertEquals($expectedMessage, $response->getData()['data']['message']);
+        $this->assertEquals($expectedStatus, $response->getStatus());
+    }
+
+    public static function userSetRecoveryProvider(): array {
+        return [
+            ['1', 'Recovery Key enabled', Http::STATUS_OK],
+            ['0', 'Could not enable the recovery key, please try again or contact your administrator', Http::STATUS_BAD_REQUEST]
+        ];
+    }
+
+    /**
+     * @dataProvider userSetRecoveryProvider
+     * @param $enableRecovery
+     * @param $expectedMessage
+     * @param $expectedStatus
+     */
+    public function testUserSetRecovery($enableRecovery, $expectedMessage, $expectedStatus): void {
+        $this->recoveryMock->expects($this->any())
+            ->method('setRecoveryForUser')
+            ->with($enableRecovery)
+            ->willReturnMap([
+                ['1', true],
+                ['0', false]
+            ]);
+
+
+        $response = $this->controller->userSetRecovery($enableRecovery);
+
+        $this->assertEquals($expectedMessage, $response->getData()['data']['message']);
+        $this->assertEquals($expectedStatus, $response->getStatus());
+    }
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->requestMock = $this->getMockBuilder(IRequest::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $this->configMock = $this->getMockBuilder(IConfig::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $this->l10nMock = $this->getMockBuilder(IL10N::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        // Make l10n work in our tests
+        $this->l10nMock->expects($this->any())
+            ->method('t')
+            ->willReturnArgument(0);
+
+        $this->recoveryMock = $this->getMockBuilder(Recovery::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $this->controller = new RecoveryController('encryption',
+            $this->requestMock,
+            $this->configMock,
+            $this->l10nMock,
+            $this->recoveryMock);
+    }
 }

apps/encryption/tests/Crypto/EncryptionTest.php

Indentation +379 added lines, -379 removed lines

@@ -29,383 +29,383 @@
 
 class EncryptionTest extends TestCase {
 
-	protected Encryption $instance;
-
-	protected KeyManager&MockObject $keyManagerMock;
-	protected EncryptAll&MockObject $encryptAllMock;
-	protected DecryptAll&MockObject $decryptAllMock;
-	protected Session&MockObject $sessionMock;
-	protected Crypt&MockObject $cryptMock;
-	protected Util&MockObject $utilMock;
-	protected LoggerInterface&MockObject $loggerMock;
-	protected IL10N&MockObject $l10nMock;
-	protected IStorage&MockObject $storageMock;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->storageMock = $this->getMockBuilder(IStorage::class)
-			->disableOriginalConstructor()->getMock();
-		$this->cryptMock = $this->getMockBuilder(Crypt::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$this->utilMock = $this->getMockBuilder(Util::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$this->keyManagerMock = $this->getMockBuilder(KeyManager::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$this->sessionMock = $this->getMockBuilder(Session::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$this->encryptAllMock = $this->getMockBuilder(EncryptAll::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$this->decryptAllMock = $this->getMockBuilder(DecryptAll::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$this->loggerMock = $this->getMockBuilder(LoggerInterface::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$this->l10nMock = $this->getMockBuilder(IL10N::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$this->l10nMock->expects($this->any())
-			->method('t')
-			->with($this->anything())
-			->willReturnArgument(0);
-
-		$this->instance = new Encryption(
-			$this->cryptMock,
-			$this->keyManagerMock,
-			$this->utilMock,
-			$this->sessionMock,
-			$this->encryptAllMock,
-			$this->decryptAllMock,
-			$this->loggerMock,
-			$this->l10nMock
-		);
-	}
-
-	/**
-	 * test if public key from one of the recipients is missing
-	 */
-	public function testEndUser1(): void {
-		$this->sessionMock->expects($this->once())
-			->method('decryptAllModeActivated')
-			->willReturn(false);
-
-		$this->instance->begin('/foo/bar', 'user1', 'r', [], ['users' => ['user1', 'user2', 'user3']]);
-		$this->endTest();
-	}
-
-	/**
-	 * test if public key from owner is missing
-	 *
-	 */
-	public function testEndUser2(): void {
-		$this->sessionMock->expects($this->once())
-			->method('decryptAllModeActivated')
-			->willReturn(false);
-
-		$this->expectException(PublicKeyMissingException::class);
-
-		$this->instance->begin('/foo/bar', 'user2', 'r', [], ['users' => ['user1', 'user2', 'user3']]);
-		$this->endTest();
-	}
-
-	/**
-	 * common part of testEndUser1 and testEndUser2
-	 *
-	 * @throws PublicKeyMissingException
-	 */
-	public function endTest() {
-		// prepare internal variables
-		self::invokePrivate($this->instance, 'isWriteOperation', [true]);
-		self::invokePrivate($this->instance, 'writeCache', ['']);
-
-		$this->keyManagerMock->expects($this->any())
-			->method('getPublicKey')
-			->willReturnCallback([$this, 'getPublicKeyCallback']);
-		$this->keyManagerMock->expects($this->any())
-			->method('addSystemKeys')
-			->willReturnCallback([$this, 'addSystemKeysCallback']);
-		$this->cryptMock->expects($this->any())
-			->method('multiKeyEncrypt')
-			->willReturn([]);
-
-		$this->instance->end('/foo/bar');
-	}
-
-
-	public function getPublicKeyCallback($uid) {
-		if ($uid === 'user2') {
-			throw new PublicKeyMissingException($uid);
-		}
-		return $uid;
-	}
-
-	public function addSystemKeysCallback($accessList, $publicKeys) {
-		$this->assertSame(2, count($publicKeys));
-		$this->assertArrayHasKey('user1', $publicKeys);
-		$this->assertArrayHasKey('user3', $publicKeys);
-		return $publicKeys;
-	}
-
-	/**
-	 * @dataProvider dataProviderForTestGetPathToRealFile
-	 */
-	public function testGetPathToRealFile($path, $expected): void {
-		$this->assertSame($expected,
-			self::invokePrivate($this->instance, 'getPathToRealFile', [$path])
-		);
-	}
-
-	public static function dataProviderForTestGetPathToRealFile(): array {
-		return [
-			['/user/files/foo/bar.txt', '/user/files/foo/bar.txt'],
-			['/user/files/foo.txt', '/user/files/foo.txt'],
-			['/user/files_versions/foo.txt.v543534', '/user/files/foo.txt'],
-			['/user/files_versions/foo/bar.txt.v5454', '/user/files/foo/bar.txt'],
-		];
-	}
-
-	/**
-	 * @dataProvider dataTestBegin
-	 */
-	public function testBegin($mode, $header, $legacyCipher, $defaultCipher, $fileKey, $expected): void {
-		$this->sessionMock->expects($this->once())
-			->method('decryptAllModeActivated')
-			->willReturn(false);
-
-		$this->sessionMock->expects($this->never())->method('getDecryptAllUid');
-		$this->sessionMock->expects($this->never())->method('getDecryptAllKey');
-		$this->keyManagerMock->expects($this->never())->method('getEncryptedFileKey');
-		$this->keyManagerMock->expects($this->never())->method('getShareKey');
-		$this->cryptMock->expects($this->never())->method('multiKeyDecrypt');
-
-		$this->cryptMock->expects($this->any())
-			->method('getCipher')
-			->willReturn($defaultCipher);
-		$this->cryptMock->expects($this->any())
-			->method('getLegacyCipher')
-			->willReturn($legacyCipher);
-		if (empty($fileKey)) {
-			$this->cryptMock->expects($this->once())
-				->method('generateFileKey')
-				->willReturn('fileKey');
-		} else {
-			$this->cryptMock->expects($this->never())
-				->method('generateFileKey');
-		}
-
-		$this->keyManagerMock->expects($this->once())
-			->method('getFileKey')
-			->willReturn($fileKey);
-
-		$result = $this->instance->begin('/user/files/foo.txt', 'user', $mode, $header, []);
-
-		$this->assertArrayHasKey('cipher', $result);
-		$this->assertSame($expected, $result['cipher']);
-		if ($mode === 'w') {
-			$this->assertTrue(self::invokePrivate($this->instance, 'isWriteOperation'));
-		} else {
-			$this->assertFalse(self::invokePrivate($this->instance, 'isWriteOperation'));
-		}
-	}
-
-	public static function dataTestBegin(): array {
-		return [
-			['w', ['cipher' => 'myCipher'], 'legacyCipher', 'defaultCipher', 'fileKey', 'defaultCipher'],
-			['r', ['cipher' => 'myCipher'], 'legacyCipher', 'defaultCipher', 'fileKey', 'myCipher'],
-			['w', [], 'legacyCipher', 'defaultCipher', '', 'defaultCipher'],
-			['r', [], 'legacyCipher', 'defaultCipher', 'file_key', 'legacyCipher'],
-		];
-	}
-
-
-	/**
-	 * test begin() if decryptAll mode was activated
-	 */
-	public function testBeginDecryptAll(): void {
-		$path = '/user/files/foo.txt';
-		$fileKey = 'fileKey';
-
-		$this->sessionMock->expects($this->once())
-			->method('decryptAllModeActivated')
-			->willReturn(true);
-		$this->keyManagerMock->expects($this->once())
-			->method('getFileKey')
-			->with($path, 'user', null, true)
-			->willReturn($fileKey);
-
-		$this->instance->begin($path, 'user', 'r', [], []);
-
-		$this->assertSame($fileKey,
-			$this->invokePrivate($this->instance, 'fileKey')
-		);
-	}
-
-	/**
-	 * test begin() if encryption is not initialized but the master key is enabled
-	 * in this case we can initialize the encryption without a username/password
-	 * and continue
-	 */
-	public function testBeginInitMasterKey(): void {
-		$this->sessionMock->expects($this->once())
-			->method('decryptAllModeActivated')
-			->willReturn(false);
-
-		$this->sessionMock->expects($this->once())->method('isReady')->willReturn(false);
-		$this->utilMock->expects($this->once())->method('isMasterKeyEnabled')
-			->willReturn(true);
-		$this->keyManagerMock->expects($this->once())->method('init')->with('', '');
-
-		$this->instance->begin('/user/files/welcome.txt', 'user', 'r', [], []);
-	}
-
-	/**
-	 * @dataProvider dataTestUpdate
-	 *
-	 * @param string $fileKey
-	 * @param boolean $expected
-	 */
-	public function testUpdate($fileKey, $expected): void {
-		$this->keyManagerMock->expects($this->once())
-			->method('getFileKey')->willReturn($fileKey);
-
-		$this->keyManagerMock->expects($this->any())
-			->method('getPublicKey')->willReturn('publicKey');
-
-		$this->keyManagerMock->expects($this->any())
-			->method('addSystemKeys')
-			->willReturnCallback(function ($accessList, $publicKeys) {
-				return $publicKeys;
-			});
-
-		$this->keyManagerMock->expects($this->never())->method('getVersion');
-		$this->keyManagerMock->expects($this->never())->method('setVersion');
-
-		$this->assertSame($expected,
-			$this->instance->update('path', 'user1', ['users' => ['user1']])
-		);
-	}
-
-	public static function dataTestUpdate(): array {
-		return [
-			['', false],
-			['fileKey', true]
-		];
-	}
-
-	public function testUpdateNoUsers(): void {
-		$this->invokePrivate($this->instance, 'rememberVersion', [['path' => 2]]);
-
-		$this->keyManagerMock->expects($this->never())->method('getFileKey');
-		$this->keyManagerMock->expects($this->never())->method('getPublicKey');
-		$this->keyManagerMock->expects($this->never())->method('addSystemKeys');
-		$this->keyManagerMock->expects($this->once())->method('setVersion')
-			->willReturnCallback(function ($path, $version, $view): void {
-				$this->assertSame('path', $path);
-				$this->assertSame(2, $version);
-				$this->assertTrue($view instanceof View);
-			});
-		$this->instance->update('path', 'user1', []);
-	}
-
-	/**
-	 * Test case if the public key is missing. Nextcloud should still encrypt
-	 * the file for the remaining users
-	 */
-	public function testUpdateMissingPublicKey(): void {
-		$this->keyManagerMock->expects($this->once())
-			->method('getFileKey')->willReturn('fileKey');
-
-		$this->keyManagerMock->expects($this->any())
-			->method('getPublicKey')->willReturnCallback(
-				function ($user): void {
-					throw new PublicKeyMissingException($user);
-				}
-			);
-
-		$this->keyManagerMock->expects($this->any())
-			->method('addSystemKeys')
-			->willReturnCallback(function ($accessList, $publicKeys) {
-				return $publicKeys;
-			});
-
-		$this->cryptMock->expects($this->once())->method('multiKeyEncrypt')
-			->willReturnCallback(
-				function ($fileKey, $publicKeys) {
-					$this->assertEmpty($publicKeys);
-					$this->assertSame('fileKey', $fileKey);
-					return [];
-				}
-			);
-
-		$this->keyManagerMock->expects($this->never())->method('getVersion');
-		$this->keyManagerMock->expects($this->never())->method('setVersion');
-
-		$this->assertTrue(
-			$this->instance->update('path', 'user1', ['users' => ['user1']])
-		);
-	}
-
-	/**
-	 * by default the encryption module should encrypt regular files, files in
-	 * files_versions and files in files_trashbin
-	 *
-	 * @dataProvider dataTestShouldEncrypt
-	 */
-	public function testShouldEncrypt($path, $shouldEncryptHomeStorage, $isHomeStorage, $expected): void {
-		$this->utilMock->expects($this->once())->method('shouldEncryptHomeStorage')
-			->willReturn($shouldEncryptHomeStorage);
-
-		if ($shouldEncryptHomeStorage === false) {
-			$this->storageMock->expects($this->once())->method('instanceOfStorage')
-				->with('\OCP\Files\IHomeStorage')->willReturn($isHomeStorage);
-			$this->utilMock->expects($this->once())->method('getStorage')->with($path)
-				->willReturn($this->storageMock);
-		}
-
-		$this->assertSame($expected,
-			$this->instance->shouldEncrypt($path)
-		);
-	}
-
-	public static function dataTestShouldEncrypt(): array {
-		return [
-			['/user1/files/foo.txt', true, true, true],
-			['/user1/files_versions/foo.txt', true, true, true],
-			['/user1/files_trashbin/foo.txt', true, true, true],
-			['/user1/some_folder/foo.txt', true, true, false],
-			['/user1/foo.txt', true, true, false],
-			['/user1/files', true, true, false],
-			['/user1/files_trashbin', true, true, false],
-			['/user1/files_versions', true, true, false],
-			// test if shouldEncryptHomeStorage is set to false
-			['/user1/files/foo.txt', false, true, false],
-			['/user1/files_versions/foo.txt', false, false, true],
-		];
-	}
-
-
-	public function testDecrypt(): void {
-		$this->expectException(DecryptionFailedException::class);
-		$this->expectExceptionMessage('Cannot decrypt this file, probably this is a shared file. Please ask the file owner to reshare the file with you.');
-
-		$this->instance->decrypt('abc');
-	}
-
-	public function testPrepareDecryptAll(): void {
-		/** @var \Symfony\Component\Console\Input\InputInterface $input */
-		$input = $this->createMock(InputInterface::class);
-		/** @var \Symfony\Component\Console\Output\OutputInterface $output */
-		$output = $this->createMock(OutputInterface::class);
-
-		$this->decryptAllMock->expects($this->once())->method('prepare')
-			->with($input, $output, 'user');
-
-		$this->instance->prepareDecryptAll($input, $output, 'user');
-	}
+    protected Encryption $instance;
+
+    protected KeyManager&MockObject $keyManagerMock;
+    protected EncryptAll&MockObject $encryptAllMock;
+    protected DecryptAll&MockObject $decryptAllMock;
+    protected Session&MockObject $sessionMock;
+    protected Crypt&MockObject $cryptMock;
+    protected Util&MockObject $utilMock;
+    protected LoggerInterface&MockObject $loggerMock;
+    protected IL10N&MockObject $l10nMock;
+    protected IStorage&MockObject $storageMock;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->storageMock = $this->getMockBuilder(IStorage::class)
+            ->disableOriginalConstructor()->getMock();
+        $this->cryptMock = $this->getMockBuilder(Crypt::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $this->utilMock = $this->getMockBuilder(Util::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $this->keyManagerMock = $this->getMockBuilder(KeyManager::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $this->sessionMock = $this->getMockBuilder(Session::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $this->encryptAllMock = $this->getMockBuilder(EncryptAll::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $this->decryptAllMock = $this->getMockBuilder(DecryptAll::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $this->loggerMock = $this->getMockBuilder(LoggerInterface::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $this->l10nMock = $this->getMockBuilder(IL10N::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $this->l10nMock->expects($this->any())
+            ->method('t')
+            ->with($this->anything())
+            ->willReturnArgument(0);
+
+        $this->instance = new Encryption(
+            $this->cryptMock,
+            $this->keyManagerMock,
+            $this->utilMock,
+            $this->sessionMock,
+            $this->encryptAllMock,
+            $this->decryptAllMock,
+            $this->loggerMock,
+            $this->l10nMock
+        );
+    }
+
+    /**
+     * test if public key from one of the recipients is missing
+     */
+    public function testEndUser1(): void {
+        $this->sessionMock->expects($this->once())
+            ->method('decryptAllModeActivated')
+            ->willReturn(false);
+
+        $this->instance->begin('/foo/bar', 'user1', 'r', [], ['users' => ['user1', 'user2', 'user3']]);
+        $this->endTest();
+    }
+
+    /**
+     * test if public key from owner is missing
+     *
+     */
+    public function testEndUser2(): void {
+        $this->sessionMock->expects($this->once())
+            ->method('decryptAllModeActivated')
+            ->willReturn(false);
+
+        $this->expectException(PublicKeyMissingException::class);
+
+        $this->instance->begin('/foo/bar', 'user2', 'r', [], ['users' => ['user1', 'user2', 'user3']]);
+        $this->endTest();
+    }
+
+    /**
+     * common part of testEndUser1 and testEndUser2
+     *
+     * @throws PublicKeyMissingException
+     */
+    public function endTest() {
+        // prepare internal variables
+        self::invokePrivate($this->instance, 'isWriteOperation', [true]);
+        self::invokePrivate($this->instance, 'writeCache', ['']);
+
+        $this->keyManagerMock->expects($this->any())
+            ->method('getPublicKey')
+            ->willReturnCallback([$this, 'getPublicKeyCallback']);
+        $this->keyManagerMock->expects($this->any())
+            ->method('addSystemKeys')
+            ->willReturnCallback([$this, 'addSystemKeysCallback']);
+        $this->cryptMock->expects($this->any())
+            ->method('multiKeyEncrypt')
+            ->willReturn([]);
+
+        $this->instance->end('/foo/bar');
+    }
+
+
+    public function getPublicKeyCallback($uid) {
+        if ($uid === 'user2') {
+            throw new PublicKeyMissingException($uid);
+        }
+        return $uid;
+    }
+
+    public function addSystemKeysCallback($accessList, $publicKeys) {
+        $this->assertSame(2, count($publicKeys));
+        $this->assertArrayHasKey('user1', $publicKeys);
+        $this->assertArrayHasKey('user3', $publicKeys);
+        return $publicKeys;
+    }
+
+    /**
+     * @dataProvider dataProviderForTestGetPathToRealFile
+     */
+    public function testGetPathToRealFile($path, $expected): void {
+        $this->assertSame($expected,
+            self::invokePrivate($this->instance, 'getPathToRealFile', [$path])
+        );
+    }
+
+    public static function dataProviderForTestGetPathToRealFile(): array {
+        return [
+            ['/user/files/foo/bar.txt', '/user/files/foo/bar.txt'],
+            ['/user/files/foo.txt', '/user/files/foo.txt'],
+            ['/user/files_versions/foo.txt.v543534', '/user/files/foo.txt'],
+            ['/user/files_versions/foo/bar.txt.v5454', '/user/files/foo/bar.txt'],
+        ];
+    }
+
+    /**
+     * @dataProvider dataTestBegin
+     */
+    public function testBegin($mode, $header, $legacyCipher, $defaultCipher, $fileKey, $expected): void {
+        $this->sessionMock->expects($this->once())
+            ->method('decryptAllModeActivated')
+            ->willReturn(false);
+
+        $this->sessionMock->expects($this->never())->method('getDecryptAllUid');
+        $this->sessionMock->expects($this->never())->method('getDecryptAllKey');
+        $this->keyManagerMock->expects($this->never())->method('getEncryptedFileKey');
+        $this->keyManagerMock->expects($this->never())->method('getShareKey');
+        $this->cryptMock->expects($this->never())->method('multiKeyDecrypt');
+
+        $this->cryptMock->expects($this->any())
+            ->method('getCipher')
+            ->willReturn($defaultCipher);
+        $this->cryptMock->expects($this->any())
+            ->method('getLegacyCipher')
+            ->willReturn($legacyCipher);
+        if (empty($fileKey)) {
+            $this->cryptMock->expects($this->once())
+                ->method('generateFileKey')
+                ->willReturn('fileKey');
+        } else {
+            $this->cryptMock->expects($this->never())
+                ->method('generateFileKey');
+        }
+
+        $this->keyManagerMock->expects($this->once())
+            ->method('getFileKey')
+            ->willReturn($fileKey);
+
+        $result = $this->instance->begin('/user/files/foo.txt', 'user', $mode, $header, []);
+
+        $this->assertArrayHasKey('cipher', $result);
+        $this->assertSame($expected, $result['cipher']);
+        if ($mode === 'w') {
+            $this->assertTrue(self::invokePrivate($this->instance, 'isWriteOperation'));
+        } else {
+            $this->assertFalse(self::invokePrivate($this->instance, 'isWriteOperation'));
+        }
+    }
+
+    public static function dataTestBegin(): array {
+        return [
+            ['w', ['cipher' => 'myCipher'], 'legacyCipher', 'defaultCipher', 'fileKey', 'defaultCipher'],
+            ['r', ['cipher' => 'myCipher'], 'legacyCipher', 'defaultCipher', 'fileKey', 'myCipher'],
+            ['w', [], 'legacyCipher', 'defaultCipher', '', 'defaultCipher'],
+            ['r', [], 'legacyCipher', 'defaultCipher', 'file_key', 'legacyCipher'],
+        ];
+    }
+
+
+    /**
+     * test begin() if decryptAll mode was activated
+     */
+    public function testBeginDecryptAll(): void {
+        $path = '/user/files/foo.txt';
+        $fileKey = 'fileKey';
+
+        $this->sessionMock->expects($this->once())
+            ->method('decryptAllModeActivated')
+            ->willReturn(true);
+        $this->keyManagerMock->expects($this->once())
+            ->method('getFileKey')
+            ->with($path, 'user', null, true)
+            ->willReturn($fileKey);
+
+        $this->instance->begin($path, 'user', 'r', [], []);
+
+        $this->assertSame($fileKey,
+            $this->invokePrivate($this->instance, 'fileKey')
+        );
+    }
+
+    /**
+     * test begin() if encryption is not initialized but the master key is enabled
+     * in this case we can initialize the encryption without a username/password
+     * and continue
+     */
+    public function testBeginInitMasterKey(): void {
+        $this->sessionMock->expects($this->once())
+            ->method('decryptAllModeActivated')
+            ->willReturn(false);
+
+        $this->sessionMock->expects($this->once())->method('isReady')->willReturn(false);
+        $this->utilMock->expects($this->once())->method('isMasterKeyEnabled')
+            ->willReturn(true);
+        $this->keyManagerMock->expects($this->once())->method('init')->with('', '');
+
+        $this->instance->begin('/user/files/welcome.txt', 'user', 'r', [], []);
+    }
+
+    /**
+     * @dataProvider dataTestUpdate
+     *
+     * @param string $fileKey
+     * @param boolean $expected
+     */
+    public function testUpdate($fileKey, $expected): void {
+        $this->keyManagerMock->expects($this->once())
+            ->method('getFileKey')->willReturn($fileKey);
+
+        $this->keyManagerMock->expects($this->any())
+            ->method('getPublicKey')->willReturn('publicKey');
+
+        $this->keyManagerMock->expects($this->any())
+            ->method('addSystemKeys')
+            ->willReturnCallback(function ($accessList, $publicKeys) {
+                return $publicKeys;
+            });
+
+        $this->keyManagerMock->expects($this->never())->method('getVersion');
+        $this->keyManagerMock->expects($this->never())->method('setVersion');
+
+        $this->assertSame($expected,
+            $this->instance->update('path', 'user1', ['users' => ['user1']])
+        );
+    }
+
+    public static function dataTestUpdate(): array {
+        return [
+            ['', false],
+            ['fileKey', true]
+        ];
+    }
+
+    public function testUpdateNoUsers(): void {
+        $this->invokePrivate($this->instance, 'rememberVersion', [['path' => 2]]);
+
+        $this->keyManagerMock->expects($this->never())->method('getFileKey');
+        $this->keyManagerMock->expects($this->never())->method('getPublicKey');
+        $this->keyManagerMock->expects($this->never())->method('addSystemKeys');
+        $this->keyManagerMock->expects($this->once())->method('setVersion')
+            ->willReturnCallback(function ($path, $version, $view): void {
+                $this->assertSame('path', $path);
+                $this->assertSame(2, $version);
+                $this->assertTrue($view instanceof View);
+            });
+        $this->instance->update('path', 'user1', []);
+    }
+
+    /**
+     * Test case if the public key is missing. Nextcloud should still encrypt
+     * the file for the remaining users
+     */
+    public function testUpdateMissingPublicKey(): void {
+        $this->keyManagerMock->expects($this->once())
+            ->method('getFileKey')->willReturn('fileKey');
+
+        $this->keyManagerMock->expects($this->any())
+            ->method('getPublicKey')->willReturnCallback(
+                function ($user): void {
+                    throw new PublicKeyMissingException($user);
+                }
+            );
+
+        $this->keyManagerMock->expects($this->any())
+            ->method('addSystemKeys')
+            ->willReturnCallback(function ($accessList, $publicKeys) {
+                return $publicKeys;
+            });
+
+        $this->cryptMock->expects($this->once())->method('multiKeyEncrypt')
+            ->willReturnCallback(
+                function ($fileKey, $publicKeys) {
+                    $this->assertEmpty($publicKeys);
+                    $this->assertSame('fileKey', $fileKey);
+                    return [];
+                }
+            );
+
+        $this->keyManagerMock->expects($this->never())->method('getVersion');
+        $this->keyManagerMock->expects($this->never())->method('setVersion');
+
+        $this->assertTrue(
+            $this->instance->update('path', 'user1', ['users' => ['user1']])
+        );
+    }
+
+    /**
+     * by default the encryption module should encrypt regular files, files in
+     * files_versions and files in files_trashbin
+     *
+     * @dataProvider dataTestShouldEncrypt
+     */
+    public function testShouldEncrypt($path, $shouldEncryptHomeStorage, $isHomeStorage, $expected): void {
+        $this->utilMock->expects($this->once())->method('shouldEncryptHomeStorage')
+            ->willReturn($shouldEncryptHomeStorage);
+
+        if ($shouldEncryptHomeStorage === false) {
+            $this->storageMock->expects($this->once())->method('instanceOfStorage')
+                ->with('\OCP\Files\IHomeStorage')->willReturn($isHomeStorage);
+            $this->utilMock->expects($this->once())->method('getStorage')->with($path)
+                ->willReturn($this->storageMock);
+        }
+
+        $this->assertSame($expected,
+            $this->instance->shouldEncrypt($path)
+        );
+    }
+
+    public static function dataTestShouldEncrypt(): array {
+        return [
+            ['/user1/files/foo.txt', true, true, true],
+            ['/user1/files_versions/foo.txt', true, true, true],
+            ['/user1/files_trashbin/foo.txt', true, true, true],
+            ['/user1/some_folder/foo.txt', true, true, false],
+            ['/user1/foo.txt', true, true, false],
+            ['/user1/files', true, true, false],
+            ['/user1/files_trashbin', true, true, false],
+            ['/user1/files_versions', true, true, false],
+            // test if shouldEncryptHomeStorage is set to false
+            ['/user1/files/foo.txt', false, true, false],
+            ['/user1/files_versions/foo.txt', false, false, true],
+        ];
+    }
+
+
+    public function testDecrypt(): void {
+        $this->expectException(DecryptionFailedException::class);
+        $this->expectExceptionMessage('Cannot decrypt this file, probably this is a shared file. Please ask the file owner to reshare the file with you.');
+
+        $this->instance->decrypt('abc');
+    }
+
+    public function testPrepareDecryptAll(): void {
+        /** @var \Symfony\Component\Console\Input\InputInterface $input */
+        $input = $this->createMock(InputInterface::class);
+        /** @var \Symfony\Component\Console\Output\OutputInterface $output */
+        $output = $this->createMock(OutputInterface::class);
+
+        $this->decryptAllMock->expects($this->once())->method('prepare')
+            ->with($input, $output, 'user');
+
+        $this->instance->prepareDecryptAll($input, $output, 'user');
+    }
 }

apps/encryption/tests/Crypto/EncryptAllTest.php

Indentation +344 added lines, -344 removed lines

@@ -32,348 +32,348 @@
 
 class EncryptAllTest extends TestCase {
 
-	protected KeyManager&MockObject $keyManager;
-	protected Util&MockObject $util;
-	protected IUserManager&MockObject $userManager;
-	protected Setup&MockObject $setupUser;
-	protected View&MockObject $view;
-	protected IConfig&MockObject $config;
-	protected IMailer&MockObject $mailer;
-	protected IL10N&MockObject $l;
-	protected IFactory&MockObject $l10nFactory;
-	protected \Symfony\Component\Console\Helper\QuestionHelper&MockObject $questionHelper;
-	protected \Symfony\Component\Console\Input\InputInterface&MockObject $inputInterface;
-	protected \Symfony\Component\Console\Output\OutputInterface&MockObject $outputInterface;
-	protected UserInterface&MockObject $userInterface;
-	protected ISecureRandom&MockObject $secureRandom;
-
-	protected EncryptAll $encryptAll;
-
-	protected function setUp(): void {
-		parent::setUp();
-		$this->setupUser = $this->getMockBuilder(Setup::class)
-			->disableOriginalConstructor()->getMock();
-		$this->keyManager = $this->getMockBuilder(KeyManager::class)
-			->disableOriginalConstructor()->getMock();
-		$this->util = $this->getMockBuilder(Util::class)
-			->disableOriginalConstructor()->getMock();
-		$this->userManager = $this->getMockBuilder(IUserManager::class)
-			->disableOriginalConstructor()->getMock();
-		$this->view = $this->getMockBuilder(View::class)
-			->disableOriginalConstructor()->getMock();
-		$this->config = $this->getMockBuilder(IConfig::class)
-			->disableOriginalConstructor()->getMock();
-		$this->mailer = $this->getMockBuilder(IMailer::class)
-			->disableOriginalConstructor()->getMock();
-		$this->l10nFactory = $this->createMock(IFactory::class);
-		$this->l = $this->getMockBuilder(IL10N::class)
-			->disableOriginalConstructor()->getMock();
-		$this->questionHelper = $this->getMockBuilder(QuestionHelper::class)
-			->disableOriginalConstructor()->getMock();
-		$this->inputInterface = $this->getMockBuilder(InputInterface::class)
-			->disableOriginalConstructor()->getMock();
-		$this->outputInterface = $this->getMockBuilder(OutputInterface::class)
-			->disableOriginalConstructor()->getMock();
-		$this->userInterface = $this->getMockBuilder(UserInterface::class)
-			->disableOriginalConstructor()->getMock();
-
-		/**
-		 * We need format method to return a string
-		 * @var OutputFormatterInterface|\PHPUnit\Framework\MockObject\MockObject
-		 */
-		$outputFormatter = $this->createMock(OutputFormatterInterface::class);
-		$outputFormatter->method('isDecorated')->willReturn(false);
-		$outputFormatter->method('format')->willReturnArgument(0);
-
-		$this->outputInterface->expects($this->any())->method('getFormatter')
-			->willReturn($outputFormatter);
-
-		$this->userManager->expects($this->any())->method('getBackends')->willReturn([$this->userInterface]);
-		$this->userInterface->expects($this->any())->method('getUsers')->willReturn(['user1', 'user2']);
-
-		$this->secureRandom = $this->getMockBuilder(ISecureRandom::class)->disableOriginalConstructor()->getMock();
-		$this->secureRandom->expects($this->any())->method('generate')->willReturn('12345678');
-
-
-		$this->encryptAll = new EncryptAll(
-			$this->setupUser,
-			$this->userManager,
-			$this->view,
-			$this->keyManager,
-			$this->util,
-			$this->config,
-			$this->mailer,
-			$this->l,
-			$this->l10nFactory,
-			$this->questionHelper,
-			$this->secureRandom
-		);
-	}
-
-	public function testEncryptAll(): void {
-		/** @var EncryptAll | \PHPUnit\Framework\MockObject\MockObject  $encryptAll */
-		$encryptAll = $this->getMockBuilder(EncryptAll::class)
-			->setConstructorArgs(
-				[
-					$this->setupUser,
-					$this->userManager,
-					$this->view,
-					$this->keyManager,
-					$this->util,
-					$this->config,
-					$this->mailer,
-					$this->l,
-					$this->l10nFactory,
-					$this->questionHelper,
-					$this->secureRandom
-				]
-			)
-			->onlyMethods(['createKeyPairs', 'encryptAllUsersFiles', 'outputPasswords'])
-			->getMock();
-
-		$this->util->expects($this->any())->method('isMasterKeyEnabled')->willReturn(false);
-		$encryptAll->expects($this->once())->method('createKeyPairs')->with();
-		$encryptAll->expects($this->once())->method('outputPasswords')->with();
-		$encryptAll->expects($this->once())->method('encryptAllUsersFiles')->with();
-
-		$encryptAll->encryptAll($this->inputInterface, $this->outputInterface);
-	}
-
-	public function testEncryptAllWithMasterKey(): void {
-		/** @var EncryptAll | \PHPUnit\Framework\MockObject\MockObject  $encryptAll */
-		$encryptAll = $this->getMockBuilder(EncryptAll::class)
-			->setConstructorArgs(
-				[
-					$this->setupUser,
-					$this->userManager,
-					$this->view,
-					$this->keyManager,
-					$this->util,
-					$this->config,
-					$this->mailer,
-					$this->l,
-					$this->l10nFactory,
-					$this->questionHelper,
-					$this->secureRandom
-				]
-			)
-			->onlyMethods(['createKeyPairs', 'encryptAllUsersFiles', 'outputPasswords'])
-			->getMock();
-
-		$this->util->expects($this->any())->method('isMasterKeyEnabled')->willReturn(true);
-		$encryptAll->expects($this->never())->method('createKeyPairs');
-		$this->keyManager->expects($this->once())->method('validateMasterKey');
-		$encryptAll->expects($this->once())->method('encryptAllUsersFiles')->with();
-		$encryptAll->expects($this->never())->method('outputPasswords');
-
-		$encryptAll->encryptAll($this->inputInterface, $this->outputInterface);
-	}
-
-	public function testCreateKeyPairs(): void {
-		/** @var EncryptAll | \PHPUnit\Framework\MockObject\MockObject  $encryptAll */
-		$encryptAll = $this->getMockBuilder(EncryptAll::class)
-			->setConstructorArgs(
-				[
-					$this->setupUser,
-					$this->userManager,
-					$this->view,
-					$this->keyManager,
-					$this->util,
-					$this->config,
-					$this->mailer,
-					$this->l,
-					$this->l10nFactory,
-					$this->questionHelper,
-					$this->secureRandom
-				]
-			)
-			->onlyMethods(['setupUserFS', 'generateOneTimePassword'])
-			->getMock();
-
-
-		// set protected property $output
-		$this->invokePrivate($encryptAll, 'output', [$this->outputInterface]);
-
-		$this->keyManager->expects($this->exactly(2))->method('userHasKeys')
-			->willReturnCallback(
-				function ($user) {
-					if ($user === 'user1') {
-						return false;
-					}
-					return true;
-				}
-			);
-
-		$encryptAll->expects($this->once())->method('setupUserFS')->with('user1');
-		$encryptAll->expects($this->once())->method('generateOneTimePassword')->with('user1')->willReturn('password');
-		$this->setupUser->expects($this->once())->method('setupUser')->with('user1', 'password');
-
-		$this->invokePrivate($encryptAll, 'createKeyPairs');
-
-		$userPasswords = $this->invokePrivate($encryptAll, 'userPasswords');
-
-		// we only expect the skipped user, because generateOneTimePassword which
-		// would set the user with the new password was mocked.
-		// This method will be tested separately
-		$this->assertSame(1, count($userPasswords));
-		$this->assertSame('', $userPasswords['user2']);
-	}
-
-	public function testEncryptAllUsersFiles(): void {
-		/** @var EncryptAll&MockObject $encryptAll */
-		$encryptAll = $this->getMockBuilder(EncryptAll::class)
-			->setConstructorArgs(
-				[
-					$this->setupUser,
-					$this->userManager,
-					$this->view,
-					$this->keyManager,
-					$this->util,
-					$this->config,
-					$this->mailer,
-					$this->l,
-					$this->l10nFactory,
-					$this->questionHelper,
-					$this->secureRandom
-				]
-			)
-			->onlyMethods(['encryptUsersFiles'])
-			->getMock();
-
-		$this->util->expects($this->any())->method('isMasterKeyEnabled')->willReturn(false);
-
-		// set protected property $output
-		$this->invokePrivate($encryptAll, 'output', [$this->outputInterface]);
-		$this->invokePrivate($encryptAll, 'userPasswords', [['user1' => 'pwd1', 'user2' => 'pwd2']]);
-
-		$encryptAllCalls = [];
-		$encryptAll->expects($this->exactly(2))
-			->method('encryptUsersFiles')
-			->willReturnCallback(function ($uid) use (&$encryptAllCalls) {
-				$encryptAllCalls[] = $uid;
-			});
-
-		$this->invokePrivate($encryptAll, 'encryptAllUsersFiles');
-		self::assertEquals([
-			'user1',
-			'user2',
-		], $encryptAllCalls);
-	}
-
-	public function testEncryptUsersFiles(): void {
-		/** @var EncryptAll&MockObject $encryptAll */
-		$encryptAll = $this->getMockBuilder(EncryptAll::class)
-			->setConstructorArgs(
-				[
-					$this->setupUser,
-					$this->userManager,
-					$this->view,
-					$this->keyManager,
-					$this->util,
-					$this->config,
-					$this->mailer,
-					$this->l,
-					$this->l10nFactory,
-					$this->questionHelper,
-					$this->secureRandom
-				]
-			)
-			->onlyMethods(['encryptFile', 'setupUserFS'])
-			->getMock();
-
-		$this->util->expects($this->any())->method('isMasterKeyEnabled')->willReturn(false);
-
-		$this->view->expects($this->exactly(2))->method('getDirectoryContent')
-			->willReturnMap([
-				[
-					'/user1/files',
-					'',
-					null,
-					[
-						['name' => 'foo', 'type' => 'dir'],
-						['name' => 'bar', 'type' => 'file'],
-					],
-				],
-				[
-					'/user1/files/foo',
-					'',
-					null,
-					[
-						['name' => 'subfile', 'type' => 'file']
-					],
-				],
-			]);
-
-		$this->view->expects($this->any())->method('is_dir')
-			->willReturnCallback(
-				function ($path) {
-					if ($path === '/user1/files/foo') {
-						return true;
-					}
-					return false;
-				}
-			);
-
-		$encryptAllCalls = [];
-		$encryptAll->expects($this->exactly(2))
-			->method('encryptFile')
-			->willReturnCallback(function (string $path) use (&$encryptAllCalls) {
-				$encryptAllCalls[] = $path;
-			});
-
-		$outputFormatter = $this->createMock(OutputFormatterInterface::class);
-		$outputFormatter->method('isDecorated')->willReturn(false);
-		$this->outputInterface->expects($this->any())
-			->method('getFormatter')
-			->willReturn($outputFormatter);
-		$progressBar = new ProgressBar($this->outputInterface);
-
-		$this->invokePrivate($encryptAll, 'encryptUsersFiles', ['user1', $progressBar, '']);
-		self::assertEquals([
-			'/user1/files/bar',
-			'/user1/files/foo/subfile',
-		], $encryptAllCalls);
-	}
-
-	public function testGenerateOneTimePassword(): void {
-		$password = $this->invokePrivate($this->encryptAll, 'generateOneTimePassword', ['user1']);
-		$this->assertTrue(is_string($password));
-		$this->assertSame(8, strlen($password));
-
-		$userPasswords = $this->invokePrivate($this->encryptAll, 'userPasswords');
-		$this->assertSame(1, count($userPasswords));
-		$this->assertSame($password, $userPasswords['user1']);
-	}
-
-	/**
-	 * @dataProvider dataTestEncryptFile
-	 * @param $isEncrypted
-	 */
-	public function testEncryptFile($isEncrypted): void {
-		$fileInfo = $this->createMock(FileInfo::class);
-		$fileInfo->expects($this->any())->method('isEncrypted')
-			->willReturn($isEncrypted);
-		$this->view->expects($this->any())->method('getFileInfo')
-			->willReturn($fileInfo);
-
-
-		if ($isEncrypted) {
-			$this->view->expects($this->never())->method('copy');
-			$this->view->expects($this->never())->method('rename');
-		} else {
-			$this->view->expects($this->once())->method('copy');
-			$this->view->expects($this->once())->method('rename');
-		}
-
-		$this->assertTrue(
-			$this->invokePrivate($this->encryptAll, 'encryptFile', ['foo.txt'])
-		);
-	}
-
-	public static function dataTestEncryptFile(): array {
-		return [
-			[true],
-			[false],
-		];
-	}
+    protected KeyManager&MockObject $keyManager;
+    protected Util&MockObject $util;
+    protected IUserManager&MockObject $userManager;
+    protected Setup&MockObject $setupUser;
+    protected View&MockObject $view;
+    protected IConfig&MockObject $config;
+    protected IMailer&MockObject $mailer;
+    protected IL10N&MockObject $l;
+    protected IFactory&MockObject $l10nFactory;
+    protected \Symfony\Component\Console\Helper\QuestionHelper&MockObject $questionHelper;
+    protected \Symfony\Component\Console\Input\InputInterface&MockObject $inputInterface;
+    protected \Symfony\Component\Console\Output\OutputInterface&MockObject $outputInterface;
+    protected UserInterface&MockObject $userInterface;
+    protected ISecureRandom&MockObject $secureRandom;
+
+    protected EncryptAll $encryptAll;
+
+    protected function setUp(): void {
+        parent::setUp();
+        $this->setupUser = $this->getMockBuilder(Setup::class)
+            ->disableOriginalConstructor()->getMock();
+        $this->keyManager = $this->getMockBuilder(KeyManager::class)
+            ->disableOriginalConstructor()->getMock();
+        $this->util = $this->getMockBuilder(Util::class)
+            ->disableOriginalConstructor()->getMock();
+        $this->userManager = $this->getMockBuilder(IUserManager::class)
+            ->disableOriginalConstructor()->getMock();
+        $this->view = $this->getMockBuilder(View::class)
+            ->disableOriginalConstructor()->getMock();
+        $this->config = $this->getMockBuilder(IConfig::class)
+            ->disableOriginalConstructor()->getMock();
+        $this->mailer = $this->getMockBuilder(IMailer::class)
+            ->disableOriginalConstructor()->getMock();
+        $this->l10nFactory = $this->createMock(IFactory::class);
+        $this->l = $this->getMockBuilder(IL10N::class)
+            ->disableOriginalConstructor()->getMock();
+        $this->questionHelper = $this->getMockBuilder(QuestionHelper::class)
+            ->disableOriginalConstructor()->getMock();
+        $this->inputInterface = $this->getMockBuilder(InputInterface::class)
+            ->disableOriginalConstructor()->getMock();
+        $this->outputInterface = $this->getMockBuilder(OutputInterface::class)
+            ->disableOriginalConstructor()->getMock();
+        $this->userInterface = $this->getMockBuilder(UserInterface::class)
+            ->disableOriginalConstructor()->getMock();
+
+        /**
+         * We need format method to return a string
+         * @var OutputFormatterInterface|\PHPUnit\Framework\MockObject\MockObject
+         */
+        $outputFormatter = $this->createMock(OutputFormatterInterface::class);
+        $outputFormatter->method('isDecorated')->willReturn(false);
+        $outputFormatter->method('format')->willReturnArgument(0);
+
+        $this->outputInterface->expects($this->any())->method('getFormatter')
+            ->willReturn($outputFormatter);
+
+        $this->userManager->expects($this->any())->method('getBackends')->willReturn([$this->userInterface]);
+        $this->userInterface->expects($this->any())->method('getUsers')->willReturn(['user1', 'user2']);
+
+        $this->secureRandom = $this->getMockBuilder(ISecureRandom::class)->disableOriginalConstructor()->getMock();
+        $this->secureRandom->expects($this->any())->method('generate')->willReturn('12345678');
+
+
+        $this->encryptAll = new EncryptAll(
+            $this->setupUser,
+            $this->userManager,
+            $this->view,
+            $this->keyManager,
+            $this->util,
+            $this->config,
+            $this->mailer,
+            $this->l,
+            $this->l10nFactory,
+            $this->questionHelper,
+            $this->secureRandom
+        );
+    }
+
+    public function testEncryptAll(): void {
+        /** @var EncryptAll | \PHPUnit\Framework\MockObject\MockObject  $encryptAll */
+        $encryptAll = $this->getMockBuilder(EncryptAll::class)
+            ->setConstructorArgs(
+                [
+                    $this->setupUser,
+                    $this->userManager,
+                    $this->view,
+                    $this->keyManager,
+                    $this->util,
+                    $this->config,
+                    $this->mailer,
+                    $this->l,
+                    $this->l10nFactory,
+                    $this->questionHelper,
+                    $this->secureRandom
+                ]
+            )
+            ->onlyMethods(['createKeyPairs', 'encryptAllUsersFiles', 'outputPasswords'])
+            ->getMock();
+
+        $this->util->expects($this->any())->method('isMasterKeyEnabled')->willReturn(false);
+        $encryptAll->expects($this->once())->method('createKeyPairs')->with();
+        $encryptAll->expects($this->once())->method('outputPasswords')->with();
+        $encryptAll->expects($this->once())->method('encryptAllUsersFiles')->with();
+
+        $encryptAll->encryptAll($this->inputInterface, $this->outputInterface);
+    }
+
+    public function testEncryptAllWithMasterKey(): void {
+        /** @var EncryptAll | \PHPUnit\Framework\MockObject\MockObject  $encryptAll */
+        $encryptAll = $this->getMockBuilder(EncryptAll::class)
+            ->setConstructorArgs(
+                [
+                    $this->setupUser,
+                    $this->userManager,
+                    $this->view,
+                    $this->keyManager,
+                    $this->util,
+                    $this->config,
+                    $this->mailer,
+                    $this->l,
+                    $this->l10nFactory,
+                    $this->questionHelper,
+                    $this->secureRandom
+                ]
+            )
+            ->onlyMethods(['createKeyPairs', 'encryptAllUsersFiles', 'outputPasswords'])
+            ->getMock();
+
+        $this->util->expects($this->any())->method('isMasterKeyEnabled')->willReturn(true);
+        $encryptAll->expects($this->never())->method('createKeyPairs');
+        $this->keyManager->expects($this->once())->method('validateMasterKey');
+        $encryptAll->expects($this->once())->method('encryptAllUsersFiles')->with();
+        $encryptAll->expects($this->never())->method('outputPasswords');
+
+        $encryptAll->encryptAll($this->inputInterface, $this->outputInterface);
+    }
+
+    public function testCreateKeyPairs(): void {
+        /** @var EncryptAll | \PHPUnit\Framework\MockObject\MockObject  $encryptAll */
+        $encryptAll = $this->getMockBuilder(EncryptAll::class)
+            ->setConstructorArgs(
+                [
+                    $this->setupUser,
+                    $this->userManager,
+                    $this->view,
+                    $this->keyManager,
+                    $this->util,
+                    $this->config,
+                    $this->mailer,
+                    $this->l,
+                    $this->l10nFactory,
+                    $this->questionHelper,
+                    $this->secureRandom
+                ]
+            )
+            ->onlyMethods(['setupUserFS', 'generateOneTimePassword'])
+            ->getMock();
+
+
+        // set protected property $output
+        $this->invokePrivate($encryptAll, 'output', [$this->outputInterface]);
+
+        $this->keyManager->expects($this->exactly(2))->method('userHasKeys')
+            ->willReturnCallback(
+                function ($user) {
+                    if ($user === 'user1') {
+                        return false;
+                    }
+                    return true;
+                }
+            );
+
+        $encryptAll->expects($this->once())->method('setupUserFS')->with('user1');
+        $encryptAll->expects($this->once())->method('generateOneTimePassword')->with('user1')->willReturn('password');
+        $this->setupUser->expects($this->once())->method('setupUser')->with('user1', 'password');
+
+        $this->invokePrivate($encryptAll, 'createKeyPairs');
+
+        $userPasswords = $this->invokePrivate($encryptAll, 'userPasswords');
+
+        // we only expect the skipped user, because generateOneTimePassword which
+        // would set the user with the new password was mocked.
+        // This method will be tested separately
+        $this->assertSame(1, count($userPasswords));
+        $this->assertSame('', $userPasswords['user2']);
+    }
+
+    public function testEncryptAllUsersFiles(): void {
+        /** @var EncryptAll&MockObject $encryptAll */
+        $encryptAll = $this->getMockBuilder(EncryptAll::class)
+            ->setConstructorArgs(
+                [
+                    $this->setupUser,
+                    $this->userManager,
+                    $this->view,
+                    $this->keyManager,
+                    $this->util,
+                    $this->config,
+                    $this->mailer,
+                    $this->l,
+                    $this->l10nFactory,
+                    $this->questionHelper,
+                    $this->secureRandom
+                ]
+            )
+            ->onlyMethods(['encryptUsersFiles'])
+            ->getMock();
+
+        $this->util->expects($this->any())->method('isMasterKeyEnabled')->willReturn(false);
+
+        // set protected property $output
+        $this->invokePrivate($encryptAll, 'output', [$this->outputInterface]);
+        $this->invokePrivate($encryptAll, 'userPasswords', [['user1' => 'pwd1', 'user2' => 'pwd2']]);
+
+        $encryptAllCalls = [];
+        $encryptAll->expects($this->exactly(2))
+            ->method('encryptUsersFiles')
+            ->willReturnCallback(function ($uid) use (&$encryptAllCalls) {
+                $encryptAllCalls[] = $uid;
+            });
+
+        $this->invokePrivate($encryptAll, 'encryptAllUsersFiles');
+        self::assertEquals([
+            'user1',
+            'user2',
+        ], $encryptAllCalls);
+    }
+
+    public function testEncryptUsersFiles(): void {
+        /** @var EncryptAll&MockObject $encryptAll */
+        $encryptAll = $this->getMockBuilder(EncryptAll::class)
+            ->setConstructorArgs(
+                [
+                    $this->setupUser,
+                    $this->userManager,
+                    $this->view,
+                    $this->keyManager,
+                    $this->util,
+                    $this->config,
+                    $this->mailer,
+                    $this->l,
+                    $this->l10nFactory,
+                    $this->questionHelper,
+                    $this->secureRandom
+                ]
+            )
+            ->onlyMethods(['encryptFile', 'setupUserFS'])
+            ->getMock();
+
+        $this->util->expects($this->any())->method('isMasterKeyEnabled')->willReturn(false);
+
+        $this->view->expects($this->exactly(2))->method('getDirectoryContent')
+            ->willReturnMap([
+                [
+                    '/user1/files',
+                    '',
+                    null,
+                    [
+                        ['name' => 'foo', 'type' => 'dir'],
+                        ['name' => 'bar', 'type' => 'file'],
+                    ],
+                ],
+                [
+                    '/user1/files/foo',
+                    '',
+                    null,
+                    [
+                        ['name' => 'subfile', 'type' => 'file']
+                    ],
+                ],
+            ]);
+
+        $this->view->expects($this->any())->method('is_dir')
+            ->willReturnCallback(
+                function ($path) {
+                    if ($path === '/user1/files/foo') {
+                        return true;
+                    }
+                    return false;
+                }
+            );
+
+        $encryptAllCalls = [];
+        $encryptAll->expects($this->exactly(2))
+            ->method('encryptFile')
+            ->willReturnCallback(function (string $path) use (&$encryptAllCalls) {
+                $encryptAllCalls[] = $path;
+            });
+
+        $outputFormatter = $this->createMock(OutputFormatterInterface::class);
+        $outputFormatter->method('isDecorated')->willReturn(false);
+        $this->outputInterface->expects($this->any())
+            ->method('getFormatter')
+            ->willReturn($outputFormatter);
+        $progressBar = new ProgressBar($this->outputInterface);
+
+        $this->invokePrivate($encryptAll, 'encryptUsersFiles', ['user1', $progressBar, '']);
+        self::assertEquals([
+            '/user1/files/bar',
+            '/user1/files/foo/subfile',
+        ], $encryptAllCalls);
+    }
+
+    public function testGenerateOneTimePassword(): void {
+        $password = $this->invokePrivate($this->encryptAll, 'generateOneTimePassword', ['user1']);
+        $this->assertTrue(is_string($password));
+        $this->assertSame(8, strlen($password));
+
+        $userPasswords = $this->invokePrivate($this->encryptAll, 'userPasswords');
+        $this->assertSame(1, count($userPasswords));
+        $this->assertSame($password, $userPasswords['user1']);
+    }
+
+    /**
+     * @dataProvider dataTestEncryptFile
+     * @param $isEncrypted
+     */
+    public function testEncryptFile($isEncrypted): void {
+        $fileInfo = $this->createMock(FileInfo::class);
+        $fileInfo->expects($this->any())->method('isEncrypted')
+            ->willReturn($isEncrypted);
+        $this->view->expects($this->any())->method('getFileInfo')
+            ->willReturn($fileInfo);
+
+
+        if ($isEncrypted) {
+            $this->view->expects($this->never())->method('copy');
+            $this->view->expects($this->never())->method('rename');
+        } else {
+            $this->view->expects($this->once())->method('copy');
+            $this->view->expects($this->once())->method('rename');
+        }
+
+        $this->assertTrue(
+            $this->invokePrivate($this->encryptAll, 'encryptFile', ['foo.txt'])
+        );
+    }
+
+    public static function dataTestEncryptFile(): array {
+        return [
+            [true],
+            [false],
+        ];
+    }
 }

Spacing +4 added lines, -4 removed lines

@@ -196,7 +196,7 @@ 
 
 		$this->keyManager->expects($this->exactly(2))->method('userHasKeys')
 			->willReturnCallback(
-				function ($user) {
+				function($user) {
 					if ($user === 'user1') {
 						return false;
 					}
@@ -249,7 +249,7 @@ 
 		$encryptAllCalls = [];
 		$encryptAll->expects($this->exactly(2))
 			->method('encryptUsersFiles')
-			->willReturnCallback(function ($uid) use (&$encryptAllCalls) {
+			->willReturnCallback(function($uid) use (&$encryptAllCalls) {
 				$encryptAllCalls[] = $uid;
 			});
 
@@ -306,7 +306,7 @@ 
 
 		$this->view->expects($this->any())->method('is_dir')
 			->willReturnCallback(
-				function ($path) {
+				function($path) {
 					if ($path === '/user1/files/foo') {
 						return true;
 					}
@@ -317,7 +317,7 @@ 
 		$encryptAllCalls = [];
 		$encryptAll->expects($this->exactly(2))
 			->method('encryptFile')
-			->willReturnCallback(function (string $path) use (&$encryptAllCalls) {
+			->willReturnCallback(function(string $path) use (&$encryptAllCalls) {
 				$encryptAllCalls[] = $path;
 			});
 

apps/encryption/tests/Crypto/DecryptAllTest.php

Indentation +86 added lines, -86 removed lines

@@ -20,90 +20,90 @@
 
 class DecryptAllTest extends TestCase {
 
-	protected DecryptAll $instance;
-
-	protected Util&MockObject $util;
-	protected KeyManager&MockObject $keyManager;
-	protected Crypt&MockObject $crypt;
-	protected Session&MockObject $session;
-	protected QuestionHelper&MockObject $questionHelper;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->util = $this->getMockBuilder(Util::class)
-			->disableOriginalConstructor()->getMock();
-		$this->keyManager = $this->getMockBuilder(KeyManager::class)
-			->disableOriginalConstructor()->getMock();
-		$this->crypt = $this->getMockBuilder(Crypt::class)
-			->disableOriginalConstructor()->getMock();
-		$this->session = $this->getMockBuilder(Session::class)
-			->disableOriginalConstructor()->getMock();
-		$this->questionHelper = $this->getMockBuilder(QuestionHelper::class)
-			->disableOriginalConstructor()->getMock();
-
-		$this->instance = new DecryptAll(
-			$this->util,
-			$this->keyManager,
-			$this->crypt,
-			$this->session,
-			$this->questionHelper
-		);
-	}
-
-	public function testUpdateSession(): void {
-		$this->session->expects($this->once())->method('prepareDecryptAll')
-			->with('user1', 'key1');
-
-		$this->invokePrivate($this->instance, 'updateSession', ['user1', 'key1']);
-	}
-
-	/**
-	 * @dataProvider dataTestGetPrivateKey
-	 *
-	 * @param string $user
-	 * @param string $recoveryKeyId
-	 */
-	public function testGetPrivateKey($user, $recoveryKeyId, $masterKeyId): void {
-		$password = 'passwd';
-		$recoveryKey = 'recoveryKey';
-		$userKey = 'userKey';
-		$masterKey = 'userKey';
-		$unencryptedKey = 'unencryptedKey';
-
-		$this->keyManager->expects($this->any())->method('getRecoveryKeyId')
-			->willReturn($recoveryKeyId);
-
-		if ($user === $recoveryKeyId) {
-			$this->keyManager->expects($this->once())->method('getSystemPrivateKey')
-				->with($recoveryKeyId)->willReturn($recoveryKey);
-			$this->keyManager->expects($this->never())->method('getPrivateKey');
-			$this->crypt->expects($this->once())->method('decryptPrivateKey')
-				->with($recoveryKey, $password)->willReturn($unencryptedKey);
-		} elseif ($user === $masterKeyId) {
-			$this->keyManager->expects($this->once())->method('getSystemPrivateKey')
-				->with($masterKeyId)->willReturn($masterKey);
-			$this->keyManager->expects($this->never())->method('getPrivateKey');
-			$this->crypt->expects($this->once())->method('decryptPrivateKey')
-				->with($masterKey, $password, $masterKeyId)->willReturn($unencryptedKey);
-		} else {
-			$this->keyManager->expects($this->never())->method('getSystemPrivateKey');
-			$this->keyManager->expects($this->once())->method('getPrivateKey')
-				->with($user)->willReturn($userKey);
-			$this->crypt->expects($this->once())->method('decryptPrivateKey')
-				->with($userKey, $password, $user)->willReturn($unencryptedKey);
-		}
-
-		$this->assertSame($unencryptedKey,
-			$this->invokePrivate($this->instance, 'getPrivateKey', [$user, $password])
-		);
-	}
-
-	public static function dataTestGetPrivateKey() {
-		return [
-			['user1', 'recoveryKey', 'masterKeyId'],
-			['recoveryKeyId', 'recoveryKeyId', 'masterKeyId'],
-			['masterKeyId', 'masterKeyId', 'masterKeyId']
-		];
-	}
+    protected DecryptAll $instance;
+
+    protected Util&MockObject $util;
+    protected KeyManager&MockObject $keyManager;
+    protected Crypt&MockObject $crypt;
+    protected Session&MockObject $session;
+    protected QuestionHelper&MockObject $questionHelper;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->util = $this->getMockBuilder(Util::class)
+            ->disableOriginalConstructor()->getMock();
+        $this->keyManager = $this->getMockBuilder(KeyManager::class)
+            ->disableOriginalConstructor()->getMock();
+        $this->crypt = $this->getMockBuilder(Crypt::class)
+            ->disableOriginalConstructor()->getMock();
+        $this->session = $this->getMockBuilder(Session::class)
+            ->disableOriginalConstructor()->getMock();
+        $this->questionHelper = $this->getMockBuilder(QuestionHelper::class)
+            ->disableOriginalConstructor()->getMock();
+
+        $this->instance = new DecryptAll(
+            $this->util,
+            $this->keyManager,
+            $this->crypt,
+            $this->session,
+            $this->questionHelper
+        );
+    }
+
+    public function testUpdateSession(): void {
+        $this->session->expects($this->once())->method('prepareDecryptAll')
+            ->with('user1', 'key1');
+
+        $this->invokePrivate($this->instance, 'updateSession', ['user1', 'key1']);
+    }
+
+    /**
+     * @dataProvider dataTestGetPrivateKey
+     *
+     * @param string $user
+     * @param string $recoveryKeyId
+     */
+    public function testGetPrivateKey($user, $recoveryKeyId, $masterKeyId): void {
+        $password = 'passwd';
+        $recoveryKey = 'recoveryKey';
+        $userKey = 'userKey';
+        $masterKey = 'userKey';
+        $unencryptedKey = 'unencryptedKey';
+
+        $this->keyManager->expects($this->any())->method('getRecoveryKeyId')
+            ->willReturn($recoveryKeyId);
+
+        if ($user === $recoveryKeyId) {
+            $this->keyManager->expects($this->once())->method('getSystemPrivateKey')
+                ->with($recoveryKeyId)->willReturn($recoveryKey);
+            $this->keyManager->expects($this->never())->method('getPrivateKey');
+            $this->crypt->expects($this->once())->method('decryptPrivateKey')
+                ->with($recoveryKey, $password)->willReturn($unencryptedKey);
+        } elseif ($user === $masterKeyId) {
+            $this->keyManager->expects($this->once())->method('getSystemPrivateKey')
+                ->with($masterKeyId)->willReturn($masterKey);
+            $this->keyManager->expects($this->never())->method('getPrivateKey');
+            $this->crypt->expects($this->once())->method('decryptPrivateKey')
+                ->with($masterKey, $password, $masterKeyId)->willReturn($unencryptedKey);
+        } else {
+            $this->keyManager->expects($this->never())->method('getSystemPrivateKey');
+            $this->keyManager->expects($this->once())->method('getPrivateKey')
+                ->with($user)->willReturn($userKey);
+            $this->crypt->expects($this->once())->method('decryptPrivateKey')
+                ->with($userKey, $password, $user)->willReturn($unencryptedKey);
+        }
+
+        $this->assertSame($unencryptedKey,
+            $this->invokePrivate($this->instance, 'getPrivateKey', [$user, $password])
+        );
+    }
+
+    public static function dataTestGetPrivateKey() {
+        return [
+            ['user1', 'recoveryKey', 'masterKeyId'],
+            ['recoveryKeyId', 'recoveryKeyId', 'masterKeyId'],
+            ['masterKeyId', 'masterKeyId', 'masterKeyId']
+        ];
+    }
 }