nextcloud / server

apps/provisioning_api/tests/Middleware/ProvisioningApiMiddlewareTest.php

Indentation +80 added lines, -80 removed lines

@@ -16,93 +16,93 @@
 
 class ProvisioningApiMiddlewareTest extends TestCase {
 
-	/** @var IControllerMethodReflector|\PHPUnit\Framework\MockObject\MockObject */
-	private $reflector;
+    /** @var IControllerMethodReflector|\PHPUnit\Framework\MockObject\MockObject */
+    private $reflector;
 
-	protected function setUp(): void {
-		parent::setUp();
+    protected function setUp(): void {
+        parent::setUp();
 
-		$this->reflector = $this->createMock(IControllerMethodReflector::class);
-	}
+        $this->reflector = $this->createMock(IControllerMethodReflector::class);
+    }
 
-	public static function dataAnnotation(): array {
-		return [
-			[false, false, false, false, false],
-			[false, false, true, false, false],
-			[false, true, true, false, false],
-			[true, false, false, false, true],
-			[true, false, true, false, false],
-			[true, true, false, false, false],
-			[true, true, true, false, false],
-			[false, false, false, true, false],
-			[false, false, true, true, false],
-			[false, true, true, true, false],
-			[true, false, false, true, false],
-			[true, false, true, true, false],
-			[true, true, false, true, false],
-			[true, true, true, true, false],
-		];
-	}
+    public static function dataAnnotation(): array {
+        return [
+            [false, false, false, false, false],
+            [false, false, true, false, false],
+            [false, true, true, false, false],
+            [true, false, false, false, true],
+            [true, false, true, false, false],
+            [true, true, false, false, false],
+            [true, true, true, false, false],
+            [false, false, false, true, false],
+            [false, false, true, true, false],
+            [false, true, true, true, false],
+            [true, false, false, true, false],
+            [true, false, true, true, false],
+            [true, true, false, true, false],
+            [true, true, true, true, false],
+        ];
+    }
 
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataAnnotation')]
-	public function testBeforeController(bool $subadminRequired, bool $isAdmin, bool $isSubAdmin, bool $hasSettingAuthorizationAnnotation, bool $shouldThrowException): void {
-		$middleware = new ProvisioningApiMiddleware(
-			$this->reflector,
-			$isAdmin,
-			$isSubAdmin
-		);
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataAnnotation')]
+    public function testBeforeController(bool $subadminRequired, bool $isAdmin, bool $isSubAdmin, bool $hasSettingAuthorizationAnnotation, bool $shouldThrowException): void {
+        $middleware = new ProvisioningApiMiddleware(
+            $this->reflector,
+            $isAdmin,
+            $isSubAdmin
+        );
 
-		$this->reflector->method('hasAnnotation')
-			->willReturnCallback(function ($annotation) use ($subadminRequired, $hasSettingAuthorizationAnnotation) {
-				if ($annotation === 'NoSubAdminRequired') {
-					return !$subadminRequired;
-				}
-				if ($annotation === 'AuthorizedAdminSetting') {
-					return $hasSettingAuthorizationAnnotation;
-				}
-				return false;
-			});
+        $this->reflector->method('hasAnnotation')
+            ->willReturnCallback(function ($annotation) use ($subadminRequired, $hasSettingAuthorizationAnnotation) {
+                if ($annotation === 'NoSubAdminRequired') {
+                    return !$subadminRequired;
+                }
+                if ($annotation === 'AuthorizedAdminSetting') {
+                    return $hasSettingAuthorizationAnnotation;
+                }
+                return false;
+            });
 
-		try {
-			$middleware->beforeController(
-				$this->createMock(Controller::class),
-				'myMethod'
-			);
-			$this->assertFalse($shouldThrowException);
-		} catch (NotSubAdminException $e) {
-			$this->assertTrue($shouldThrowException);
-		}
-	}
+        try {
+            $middleware->beforeController(
+                $this->createMock(Controller::class),
+                'myMethod'
+            );
+            $this->assertFalse($shouldThrowException);
+        } catch (NotSubAdminException $e) {
+            $this->assertTrue($shouldThrowException);
+        }
+    }
 
-	public static function dataAfterException(): array {
-		return [
-			[new NotSubAdminException(), false],
-			[new \Exception('test', 42), true],
-		];
-	}
+    public static function dataAfterException(): array {
+        return [
+            [new NotSubAdminException(), false],
+            [new \Exception('test', 42), true],
+        ];
+    }
 
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataAfterException')]
-	public function testAfterException(\Exception $exception, bool $forwared): void {
-		$middleware = new ProvisioningApiMiddleware(
-			$this->reflector,
-			false,
-			false
-		);
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataAfterException')]
+    public function testAfterException(\Exception $exception, bool $forwared): void {
+        $middleware = new ProvisioningApiMiddleware(
+            $this->reflector,
+            false,
+            false
+        );
 
-		try {
-			$middleware->afterException(
-				$this->createMock(Controller::class),
-				'myMethod',
-				$exception
-			);
-			$this->fail();
-		} catch (OCSException $e) {
-			$this->assertFalse($forwared);
-			$this->assertSame($exception->getMessage(), $e->getMessage());
-			$this->assertSame(Http::STATUS_FORBIDDEN, $e->getCode());
-		} catch (\Exception $e) {
-			$this->assertTrue($forwared);
-			$this->assertSame($exception, $e);
-		}
-	}
+        try {
+            $middleware->afterException(
+                $this->createMock(Controller::class),
+                'myMethod',
+                $exception
+            );
+            $this->fail();
+        } catch (OCSException $e) {
+            $this->assertFalse($forwared);
+            $this->assertSame($exception->getMessage(), $e->getMessage());
+            $this->assertSame(Http::STATUS_FORBIDDEN, $e->getCode());
+        } catch (\Exception $e) {
+            $this->assertTrue($forwared);
+            $this->assertSame($exception, $e);
+        }
+    }
 }

apps/provisioning_api/tests/CapabilitiesTest.php

Indentation +44 added lines, -44 removed lines

@@ -23,55 +23,55 @@
  */
 class CapabilitiesTest extends TestCase {
 
-	protected IAppManager&MockObject $appManager;
-	protected Capabilities $capabilities;
+    protected IAppManager&MockObject $appManager;
+    protected Capabilities $capabilities;
 
-	public function setUp(): void {
-		parent::setUp();
-		$this->appManager = $this->createMock(IAppManager::class);
-		$this->capabilities = new Capabilities($this->appManager);
+    public function setUp(): void {
+        parent::setUp();
+        $this->appManager = $this->createMock(IAppManager::class);
+        $this->capabilities = new Capabilities($this->appManager);
 
-		$this->appManager->expects($this->once())
-			->method('getAppVersion')
-			->with('provisioning_api')
-			->willReturn('1.12');
-	}
+        $this->appManager->expects($this->once())
+            ->method('getAppVersion')
+            ->with('provisioning_api')
+            ->willReturn('1.12');
+    }
 
-	public static function getCapabilitiesProvider(): array {
-		return [
-			[true, false, false, true, false],
-			[true, true, false, true, false],
-			[true, true, true, true, true],
-			[false, false, false, false, false],
-			[false, true, false, false, false],
-			[false, true, true, false, true],
-		];
-	}
+    public static function getCapabilitiesProvider(): array {
+        return [
+            [true, false, false, true, false],
+            [true, true, false, true, false],
+            [true, true, true, true, true],
+            [false, false, false, false, false],
+            [false, true, false, false, false],
+            [false, true, true, false, true],
+        ];
+    }
 
-	#[\PHPUnit\Framework\Attributes\DataProvider('getCapabilitiesProvider')]
-	public function testGetCapabilities(bool $federationAppEnabled, bool $federatedFileSharingAppEnabled, bool $lookupServerEnabled, bool $expectedFederatedScopeEnabled, bool $expectedPublishedScopeEnabled): void {
-		$this->appManager->expects($this->any())
-			->method('isEnabledForUser')
-			->willReturnMap([
-				['federation', null, $federationAppEnabled],
-				['federatedfilesharing', null, $federatedFileSharingAppEnabled],
-			]);
+    #[\PHPUnit\Framework\Attributes\DataProvider('getCapabilitiesProvider')]
+    public function testGetCapabilities(bool $federationAppEnabled, bool $federatedFileSharingAppEnabled, bool $lookupServerEnabled, bool $expectedFederatedScopeEnabled, bool $expectedPublishedScopeEnabled): void {
+        $this->appManager->expects($this->any())
+            ->method('isEnabledForUser')
+            ->willReturnMap([
+                ['federation', null, $federationAppEnabled],
+                ['federatedfilesharing', null, $federatedFileSharingAppEnabled],
+            ]);
 
-		$federatedShareProvider = $this->createMock(FederatedShareProvider::class);
-		$this->overwriteService(FederatedShareProvider::class, $federatedShareProvider);
+        $federatedShareProvider = $this->createMock(FederatedShareProvider::class);
+        $this->overwriteService(FederatedShareProvider::class, $federatedShareProvider);
 
-		$federatedShareProvider->expects($this->any())
-			->method('isLookupServerUploadEnabled')
-			->willReturn($lookupServerEnabled);
+        $federatedShareProvider->expects($this->any())
+            ->method('isLookupServerUploadEnabled')
+            ->willReturn($lookupServerEnabled);
 
-		$expected = [
-			'provisioning_api' => [
-				'version' => '1.12',
-				'AccountPropertyScopesVersion' => 2,
-				'AccountPropertyScopesFederatedEnabled' => $expectedFederatedScopeEnabled,
-				'AccountPropertyScopesPublishedEnabled' => $expectedPublishedScopeEnabled,
-			],
-		];
-		$this->assertSame($expected, $this->capabilities->getCapabilities());
-	}
+        $expected = [
+            'provisioning_api' => [
+                'version' => '1.12',
+                'AccountPropertyScopesVersion' => 2,
+                'AccountPropertyScopesFederatedEnabled' => $expectedFederatedScopeEnabled,
+                'AccountPropertyScopesPublishedEnabled' => $expectedPublishedScopeEnabled,
+            ],
+        ];
+        $this->assertSame($expected, $this->capabilities->getCapabilities());
+    }
 }

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());
-	}
-
-	/**
-	 *
-	 * @param int $status
-	 * @param bool $expected
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestIsReady')]
-	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());
+    }
+
+    /**
+     *
+     * @param int $status
+     * @param bool $expected
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestIsReady')]
+    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;
-	}
-
-	/**
-	 *
-	 * @param string $value
-	 * @param bool $expect
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestIsMasterKeyEnabled')]
-	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]
-		];
-	}
-
-	/**
-	 * @param string $returnValue return value from getAppValue()
-	 * @param bool $expected
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestShouldEncryptHomeStorage')]
-	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]
-		];
-	}
-
-	/**
-	 * @param $value
-	 * @param $expected
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestSetEncryptHomeStorage')]
-	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;
+    }
+
+    /**
+     *
+     * @param string $value
+     * @param bool $expect
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestIsMasterKeyEnabled')]
+    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]
+        ];
+    }
+
+    /**
+     * @param string $returnValue return value from getAppValue()
+     * @param bool $expected
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestShouldEncryptHomeStorage')]
+    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]
+        ];
+    }
+
+    /**
+     * @param $value
+     * @param $expected
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestSetEncryptHomeStorage')]
+    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/TestEnableMasterKey.php

Indentation +70 added lines, -70 removed lines

@@ -19,74 +19,74 @@
 
 class TestEnableMasterKey extends TestCase {
 
-	/** @var EnableMasterKey */
-	protected $enableMasterKey;
-
-	/** @var Util | \PHPUnit\Framework\MockObject\MockObject */
-	protected $util;
-
-	/** @var IConfig|\PHPUnit\Framework\MockObject\MockObject */
-	protected $config;
-
-	/** @var \Symfony\Component\Console\Helper\QuestionHelper | \PHPUnit\Framework\MockObject\MockObject */
-	protected $questionHelper;
-
-	/** @var \Symfony\Component\Console\Output\OutputInterface | \PHPUnit\Framework\MockObject\MockObject */
-	protected $output;
-
-	/** @var \Symfony\Component\Console\Input\InputInterface | \PHPUnit\Framework\MockObject\MockObject */
-	protected $input;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->util = $this->getMockBuilder(Util::class)
-			->disableOriginalConstructor()->getMock();
-		$this->config = $this->getMockBuilder(IConfig::class)
-			->disableOriginalConstructor()->getMock();
-		$this->questionHelper = $this->getMockBuilder(QuestionHelper::class)
-			->disableOriginalConstructor()->getMock();
-		$this->output = $this->getMockBuilder(OutputInterface::class)
-			->disableOriginalConstructor()->getMock();
-		$this->input = $this->getMockBuilder(InputInterface::class)
-			->disableOriginalConstructor()->getMock();
-
-		$this->enableMasterKey = new EnableMasterKey($this->util, $this->config, $this->questionHelper);
-	}
-
-	/**
-	 *
-	 * @param bool $isAlreadyEnabled
-	 * @param string $answer
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestExecute')]
-	public function testExecute($isAlreadyEnabled, $answer): void {
-		$this->util->expects($this->once())->method('isMasterKeyEnabled')
-			->willReturn($isAlreadyEnabled);
-
-		if ($isAlreadyEnabled) {
-			$this->output->expects($this->once())->method('writeln')
-				->with('Master key already enabled');
-		} else {
-			if ($answer === 'y') {
-				$this->questionHelper->expects($this->once())->method('ask')->willReturn(true);
-				$this->config->expects($this->once())->method('setAppValue')
-					->with('encryption', 'useMasterKey', '1');
-			} else {
-				$this->questionHelper->expects($this->once())->method('ask')->willReturn(false);
-				$this->config->expects($this->never())->method('setAppValue');
-			}
-		}
-
-		$this->invokePrivate($this->enableMasterKey, 'execute', [$this->input, $this->output]);
-	}
-
-	public static function dataTestExecute() {
-		return [
-			[true, ''],
-			[false, 'y'],
-			[false, 'n'],
-			[false, '']
-		];
-	}
+    /** @var EnableMasterKey */
+    protected $enableMasterKey;
+
+    /** @var Util | \PHPUnit\Framework\MockObject\MockObject */
+    protected $util;
+
+    /** @var IConfig|\PHPUnit\Framework\MockObject\MockObject */
+    protected $config;
+
+    /** @var \Symfony\Component\Console\Helper\QuestionHelper | \PHPUnit\Framework\MockObject\MockObject */
+    protected $questionHelper;
+
+    /** @var \Symfony\Component\Console\Output\OutputInterface | \PHPUnit\Framework\MockObject\MockObject */
+    protected $output;
+
+    /** @var \Symfony\Component\Console\Input\InputInterface | \PHPUnit\Framework\MockObject\MockObject */
+    protected $input;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->util = $this->getMockBuilder(Util::class)
+            ->disableOriginalConstructor()->getMock();
+        $this->config = $this->getMockBuilder(IConfig::class)
+            ->disableOriginalConstructor()->getMock();
+        $this->questionHelper = $this->getMockBuilder(QuestionHelper::class)
+            ->disableOriginalConstructor()->getMock();
+        $this->output = $this->getMockBuilder(OutputInterface::class)
+            ->disableOriginalConstructor()->getMock();
+        $this->input = $this->getMockBuilder(InputInterface::class)
+            ->disableOriginalConstructor()->getMock();
+
+        $this->enableMasterKey = new EnableMasterKey($this->util, $this->config, $this->questionHelper);
+    }
+
+    /**
+     *
+     * @param bool $isAlreadyEnabled
+     * @param string $answer
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestExecute')]
+    public function testExecute($isAlreadyEnabled, $answer): void {
+        $this->util->expects($this->once())->method('isMasterKeyEnabled')
+            ->willReturn($isAlreadyEnabled);
+
+        if ($isAlreadyEnabled) {
+            $this->output->expects($this->once())->method('writeln')
+                ->with('Master key already enabled');
+        } else {
+            if ($answer === 'y') {
+                $this->questionHelper->expects($this->once())->method('ask')->willReturn(true);
+                $this->config->expects($this->once())->method('setAppValue')
+                    ->with('encryption', 'useMasterKey', '1');
+            } else {
+                $this->questionHelper->expects($this->once())->method('ask')->willReturn(false);
+                $this->config->expects($this->never())->method('setAppValue');
+            }
+        }
+
+        $this->invokePrivate($this->enableMasterKey, 'execute', [$this->input, $this->output]);
+    }
+
+    public static function dataTestExecute() {
+        return [
+            [true, ''],
+            [false, 'y'],
+            [false, 'n'],
+            [false, '']
+        ];
+    }
 }

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);
+    }
 
-	/**
-	 *
-	 * @param string $status
-	 * @param string $expectedStatus
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestGetStatus')]
-	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']);
-	}
+    /**
+     *
+     * @param string $status
+     * @param string $expectedStatus
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestGetStatus')]
+    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],
-		];
-	}
-
-	/**
-	 * @param $recoveryPassword
-	 * @param $passConfirm
-	 * @param $enableRecovery
-	 * @param $expectedMessage
-	 * @param $expectedStatus
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('adminRecoveryProvider')]
-	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]
-		];
-	}
-
-	/**
-	 * @param $password
-	 * @param $confirmPassword
-	 * @param $oldPassword
-	 * @param $expectedMessage
-	 * @param $expectedStatus
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('changeRecoveryPasswordProvider')]
-	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]
-		];
-	}
-
-	/**
-	 * @param $enableRecovery
-	 * @param $expectedMessage
-	 * @param $expectedStatus
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('userSetRecoveryProvider')]
-	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],
+        ];
+    }
+
+    /**
+     * @param $recoveryPassword
+     * @param $passConfirm
+     * @param $enableRecovery
+     * @param $expectedMessage
+     * @param $expectedStatus
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('adminRecoveryProvider')]
+    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]
+        ];
+    }
+
+    /**
+     * @param $password
+     * @param $confirmPassword
+     * @param $oldPassword
+     * @param $expectedMessage
+     * @param $expectedStatus
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('changeRecoveryPasswordProvider')]
+    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]
+        ];
+    }
+
+    /**
+     * @param $enableRecovery
+     * @param $expectedMessage
+     * @param $expectedStatus
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('userSetRecoveryProvider')]
+    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 +374 added lines, -374 removed lines

@@ -29,378 +29,378 @@
 
 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;
-	}
-
-	#[\PHPUnit\Framework\Attributes\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'],
-		];
-	}
-
-	#[\PHPUnit\Framework\Attributes\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', [], []);
-	}
-
-	/**
-	 *
-	 * @param string $fileKey
-	 * @param boolean $expected
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestUpdate')]
-	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
-	 */
-	#[\PHPUnit\Framework\Attributes\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;
+    }
+
+    #[\PHPUnit\Framework\Attributes\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'],
+        ];
+    }
+
+    #[\PHPUnit\Framework\Attributes\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', [], []);
+    }
+
+    /**
+     *
+     * @param string $fileKey
+     * @param boolean $expected
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestUpdate')]
+    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
+     */
+    #[\PHPUnit\Framework\Attributes\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): void {
-				$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): void {
-				$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']);
-	}
-
-	/**
-	 * @param $isEncrypted
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestEncryptFile')]
-	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): void {
+                $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): void {
+                $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']);
+    }
+
+    /**
+     * @param $isEncrypted
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestEncryptFile')]
+    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): void {
+			->willReturnCallback(function($uid) use (&$encryptAllCalls): void {
 				$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): void {
+			->willReturnCallback(function(string $path) use (&$encryptAllCalls): void {
 				$encryptAllCalls[] = $path;
 			});