nextcloud / server

apps/files_external/tests/Service/UserStoragesServiceTest.php

Indentation +164 added lines, -164 removed lines

@@ -26,168 +26,168 @@
  * @group DB
  */
 class UserStoragesServiceTest extends StoragesServiceTestCase {
-	use UserTrait;
-
-	protected User $user;
-
-	protected string $userId;
-	protected StoragesService $globalStoragesService;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->globalStoragesService = new GlobalStoragesService($this->backendService, $this->dbConfig, $this->mountCache, $this->eventDispatcher);
-
-		$this->userId = $this->getUniqueID('user_');
-		$this->createUser($this->userId, $this->userId);
-		$this->user = Server::get(IUserManager::class)->get($this->userId);
-
-		/** @var IUserSession&MockObject $userSession */
-		$userSession = $this->createMock(IUserSession::class);
-		$userSession
-			->expects($this->any())
-			->method('getUser')
-			->willReturn($this->user);
-
-		$this->service = new UserStoragesService($this->backendService, $this->dbConfig, $userSession, $this->mountCache, $this->eventDispatcher);
-	}
-
-	private function makeTestStorageData() {
-		return $this->makeStorageConfig([
-			'mountPoint' => 'mountpoint',
-			'backendIdentifier' => 'identifier:\OCA\Files_External\Lib\Backend\SMB',
-			'authMechanismIdentifier' => 'identifier:\Auth\Mechanism',
-			'backendOptions' => [
-				'option1' => 'value1',
-				'option2' => 'value2',
-				'password' => 'testPassword',
-			],
-			'mountOptions' => [
-				'preview' => false,
-			]
-		]);
-	}
-
-	public function testAddStorage(): void {
-		$storage = $this->makeTestStorageData();
-
-		$newStorage = $this->service->addStorage($storage);
-
-		$id = $newStorage->getId();
-
-		$newStorage = $this->service->getStorage($id);
-
-		$this->assertEquals($storage->getMountPoint(), $newStorage->getMountPoint());
-		$this->assertEquals($storage->getBackend(), $newStorage->getBackend());
-		$this->assertEquals($storage->getAuthMechanism(), $newStorage->getAuthMechanism());
-		$this->assertEquals($storage->getBackendOptions(), $newStorage->getBackendOptions());
-		$this->assertEquals(0, $newStorage->getStatus());
-
-		// hook called once for user
-		$this->assertHookCall(
-			current(self::$hookCalls),
-			Filesystem::signal_create_mount,
-			$storage->getMountPoint(),
-			MountConfig::MOUNT_TYPE_USER,
-			$this->userId
-		);
-
-		$nextStorage = $this->service->addStorage($storage);
-		$this->assertEquals($id + 1, $nextStorage->getId());
-	}
-
-	public function testUpdateStorage(): void {
-		$storage = $this->makeStorageConfig([
-			'mountPoint' => 'mountpoint',
-			'backendIdentifier' => 'identifier:\OCA\Files_External\Lib\Backend\SMB',
-			'authMechanismIdentifier' => 'identifier:\Auth\Mechanism',
-			'backendOptions' => [
-				'option1' => 'value1',
-				'option2' => 'value2',
-				'password' => 'testPassword',
-			],
-		]);
-
-		$newStorage = $this->service->addStorage($storage);
-
-		$backendOptions = $newStorage->getBackendOptions();
-		$backendOptions['password'] = 'anotherPassword';
-		$newStorage->setBackendOptions($backendOptions);
-
-		self::$hookCalls = [];
-
-		$newStorage = $this->service->updateStorage($newStorage);
-
-		$this->assertEquals('anotherPassword', $newStorage->getBackendOptions()['password']);
-		$this->assertEquals([$this->userId], $newStorage->getApplicableUsers());
-		// these attributes are unused for user storages
-		$this->assertEmpty($newStorage->getApplicableGroups());
-		$this->assertEquals(0, $newStorage->getStatus());
-
-		// no hook calls
-		$this->assertEmpty(self::$hookCalls);
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('deleteStorageDataProvider')]
-	public function testDeleteStorage($backendOptions, $rustyStorageId): void {
-		parent::testDeleteStorage($backendOptions, $rustyStorageId);
-
-		// hook called once for user (first one was during test creation)
-		$this->assertHookCall(
-			self::$hookCalls[1],
-			Filesystem::signal_delete_mount,
-			'/mountpoint',
-			MountConfig::MOUNT_TYPE_USER,
-			$this->userId
-		);
-	}
-
-	public function testHooksRenameMountPoint(): void {
-		$storage = $this->makeTestStorageData();
-		$storage = $this->service->addStorage($storage);
-
-		$storage->setMountPoint('renamedMountpoint');
-
-		// reset calls
-		self::$hookCalls = [];
-
-		$this->service->updateStorage($storage);
-
-		// hook called twice
-		$this->assertHookCall(
-			self::$hookCalls[0],
-			Filesystem::signal_delete_mount,
-			'/mountpoint',
-			MountConfig::MOUNT_TYPE_USER,
-			$this->userId
-		);
-		$this->assertHookCall(
-			self::$hookCalls[1],
-			Filesystem::signal_create_mount,
-			'/renamedMountpoint',
-			MountConfig::MOUNT_TYPE_USER,
-			$this->userId
-		);
-	}
-
-
-	public function testGetAdminStorage(): void {
-		$this->expectException(NotFoundException::class);
-
-		$backend = $this->backendService->getBackend('identifier:\OCA\Files_External\Lib\Backend\SMB');
-		$authMechanism = $this->backendService->getAuthMechanism('identifier:\Auth\Mechanism');
-
-		$storage = new StorageConfig();
-		$storage->setMountPoint('mountpoint');
-		$storage->setBackend($backend);
-		$storage->setAuthMechanism($authMechanism);
-		$storage->setBackendOptions(['password' => 'testPassword']);
-		$storage->setApplicableUsers([$this->userId]);
-
-		$newStorage = $this->globalStoragesService->addStorage($storage);
-
-		$this->assertInstanceOf('\OCA\Files_External\Lib\StorageConfig', $this->globalStoragesService->getStorage($newStorage->getId()));
-
-		$this->service->getStorage($newStorage->getId());
-	}
+    use UserTrait;
+
+    protected User $user;
+
+    protected string $userId;
+    protected StoragesService $globalStoragesService;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->globalStoragesService = new GlobalStoragesService($this->backendService, $this->dbConfig, $this->mountCache, $this->eventDispatcher);
+
+        $this->userId = $this->getUniqueID('user_');
+        $this->createUser($this->userId, $this->userId);
+        $this->user = Server::get(IUserManager::class)->get($this->userId);
+
+        /** @var IUserSession&MockObject $userSession */
+        $userSession = $this->createMock(IUserSession::class);
+        $userSession
+            ->expects($this->any())
+            ->method('getUser')
+            ->willReturn($this->user);
+
+        $this->service = new UserStoragesService($this->backendService, $this->dbConfig, $userSession, $this->mountCache, $this->eventDispatcher);
+    }
+
+    private function makeTestStorageData() {
+        return $this->makeStorageConfig([
+            'mountPoint' => 'mountpoint',
+            'backendIdentifier' => 'identifier:\OCA\Files_External\Lib\Backend\SMB',
+            'authMechanismIdentifier' => 'identifier:\Auth\Mechanism',
+            'backendOptions' => [
+                'option1' => 'value1',
+                'option2' => 'value2',
+                'password' => 'testPassword',
+            ],
+            'mountOptions' => [
+                'preview' => false,
+            ]
+        ]);
+    }
+
+    public function testAddStorage(): void {
+        $storage = $this->makeTestStorageData();
+
+        $newStorage = $this->service->addStorage($storage);
+
+        $id = $newStorage->getId();
+
+        $newStorage = $this->service->getStorage($id);
+
+        $this->assertEquals($storage->getMountPoint(), $newStorage->getMountPoint());
+        $this->assertEquals($storage->getBackend(), $newStorage->getBackend());
+        $this->assertEquals($storage->getAuthMechanism(), $newStorage->getAuthMechanism());
+        $this->assertEquals($storage->getBackendOptions(), $newStorage->getBackendOptions());
+        $this->assertEquals(0, $newStorage->getStatus());
+
+        // hook called once for user
+        $this->assertHookCall(
+            current(self::$hookCalls),
+            Filesystem::signal_create_mount,
+            $storage->getMountPoint(),
+            MountConfig::MOUNT_TYPE_USER,
+            $this->userId
+        );
+
+        $nextStorage = $this->service->addStorage($storage);
+        $this->assertEquals($id + 1, $nextStorage->getId());
+    }
+
+    public function testUpdateStorage(): void {
+        $storage = $this->makeStorageConfig([
+            'mountPoint' => 'mountpoint',
+            'backendIdentifier' => 'identifier:\OCA\Files_External\Lib\Backend\SMB',
+            'authMechanismIdentifier' => 'identifier:\Auth\Mechanism',
+            'backendOptions' => [
+                'option1' => 'value1',
+                'option2' => 'value2',
+                'password' => 'testPassword',
+            ],
+        ]);
+
+        $newStorage = $this->service->addStorage($storage);
+
+        $backendOptions = $newStorage->getBackendOptions();
+        $backendOptions['password'] = 'anotherPassword';
+        $newStorage->setBackendOptions($backendOptions);
+
+        self::$hookCalls = [];
+
+        $newStorage = $this->service->updateStorage($newStorage);
+
+        $this->assertEquals('anotherPassword', $newStorage->getBackendOptions()['password']);
+        $this->assertEquals([$this->userId], $newStorage->getApplicableUsers());
+        // these attributes are unused for user storages
+        $this->assertEmpty($newStorage->getApplicableGroups());
+        $this->assertEquals(0, $newStorage->getStatus());
+
+        // no hook calls
+        $this->assertEmpty(self::$hookCalls);
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('deleteStorageDataProvider')]
+    public function testDeleteStorage($backendOptions, $rustyStorageId): void {
+        parent::testDeleteStorage($backendOptions, $rustyStorageId);
+
+        // hook called once for user (first one was during test creation)
+        $this->assertHookCall(
+            self::$hookCalls[1],
+            Filesystem::signal_delete_mount,
+            '/mountpoint',
+            MountConfig::MOUNT_TYPE_USER,
+            $this->userId
+        );
+    }
+
+    public function testHooksRenameMountPoint(): void {
+        $storage = $this->makeTestStorageData();
+        $storage = $this->service->addStorage($storage);
+
+        $storage->setMountPoint('renamedMountpoint');
+
+        // reset calls
+        self::$hookCalls = [];
+
+        $this->service->updateStorage($storage);
+
+        // hook called twice
+        $this->assertHookCall(
+            self::$hookCalls[0],
+            Filesystem::signal_delete_mount,
+            '/mountpoint',
+            MountConfig::MOUNT_TYPE_USER,
+            $this->userId
+        );
+        $this->assertHookCall(
+            self::$hookCalls[1],
+            Filesystem::signal_create_mount,
+            '/renamedMountpoint',
+            MountConfig::MOUNT_TYPE_USER,
+            $this->userId
+        );
+    }
+
+
+    public function testGetAdminStorage(): void {
+        $this->expectException(NotFoundException::class);
+
+        $backend = $this->backendService->getBackend('identifier:\OCA\Files_External\Lib\Backend\SMB');
+        $authMechanism = $this->backendService->getAuthMechanism('identifier:\Auth\Mechanism');
+
+        $storage = new StorageConfig();
+        $storage->setMountPoint('mountpoint');
+        $storage->setBackend($backend);
+        $storage->setAuthMechanism($authMechanism);
+        $storage->setBackendOptions(['password' => 'testPassword']);
+        $storage->setApplicableUsers([$this->userId]);
+
+        $newStorage = $this->globalStoragesService->addStorage($storage);
+
+        $this->assertInstanceOf('\OCA\Files_External\Lib\StorageConfig', $this->globalStoragesService->getStorage($newStorage->getId()));
+
+        $this->service->getStorage($newStorage->getId());
+    }
 }

apps/files_external/tests/Service/BackendServiceTest.php

Indentation +224 added lines, -224 removed lines

@@ -17,228 +17,228 @@
 use PHPUnit\Framework\MockObject\MockObject;
 
 class BackendServiceTest extends \Test\TestCase {
-	protected IAppConfig&MockObject $appConfig;
-
-	protected function setUp(): void {
-		$this->appConfig = $this->createMock(IAppConfig::class);
-	}
-
-	/**
-	 * @return \OCA\Files_External\Lib\Backend\Backend&MockObject
-	 */
-	protected function getBackendMock(string $class) {
-		$backend = $this->createMock(Backend::class);
-		$backend->method('getIdentifier')->willReturn('identifier:' . $class);
-		$backend->method('getIdentifierAliases')->willReturn(['identifier:' . $class]);
-		return $backend;
-	}
-
-	/**
-	 * @param string $class
-	 *
-	 * @return AuthMechanism&MockObject
-	 */
-	protected function getAuthMechanismMock($class) {
-		$backend = $this->createMock(AuthMechanism::class);
-		$backend->method('getIdentifier')->willReturn('identifier:' . $class);
-		$backend->method('getIdentifierAliases')->willReturn(['identifier:' . $class]);
-		return $backend;
-	}
-
-	public function testRegisterBackend(): void {
-		$service = new BackendService($this->appConfig);
-
-		$backend = $this->getBackendMock('\Foo\Bar');
-
-		/** @var \OCA\Files_External\Lib\Backend\Backend&MockObject $backendAlias */
-		$backendAlias = $this->createMock(Backend::class);
-		$backendAlias->method('getIdentifierAliases')
-			->willReturn(['identifier_real', 'identifier_alias']);
-		$backendAlias->method('getIdentifier')
-			->willReturn('identifier_real');
-
-		$service->registerBackend($backend);
-		$service->registerBackend($backendAlias);
-
-		$this->assertEquals($backend, $service->getBackend('identifier:\Foo\Bar'));
-		$this->assertEquals($backendAlias, $service->getBackend('identifier_real'));
-		$this->assertEquals($backendAlias, $service->getBackend('identifier_alias'));
-
-		$backends = $service->getBackends();
-		$this->assertCount(2, $backends);
-		$this->assertArrayHasKey('identifier:\Foo\Bar', $backends);
-		$this->assertArrayHasKey('identifier_real', $backends);
-		$this->assertArrayNotHasKey('identifier_alias', $backends);
-	}
-
-	public function testBackendProvider(): void {
-		$service = new BackendService($this->appConfig);
-
-		$backend1 = $this->getBackendMock('\Foo\Bar');
-		$backend2 = $this->getBackendMock('\Bar\Foo');
-
-		/** @var IBackendProvider&MockObject $providerMock */
-		$providerMock = $this->createMock(IBackendProvider::class);
-		$providerMock->expects($this->once())
-			->method('getBackends')
-			->willReturn([$backend1, $backend2]);
-		$service->registerBackendProvider($providerMock);
-
-		$this->assertEquals($backend1, $service->getBackend('identifier:\Foo\Bar'));
-		$this->assertEquals($backend2, $service->getBackend('identifier:\Bar\Foo'));
-
-		$this->assertCount(2, $service->getBackends());
-	}
-
-	public function testAuthMechanismProvider(): void {
-		$service = new BackendService($this->appConfig);
-
-		$backend1 = $this->getAuthMechanismMock('\Foo\Bar');
-		$backend2 = $this->getAuthMechanismMock('\Bar\Foo');
-
-		/** @var IAuthMechanismProvider&MockObject $providerMock */
-		$providerMock = $this->createMock(IAuthMechanismProvider::class);
-		$providerMock->expects($this->once())
-			->method('getAuthMechanisms')
-			->willReturn([$backend1, $backend2]);
-		$service->registerAuthMechanismProvider($providerMock);
-
-		$this->assertEquals($backend1, $service->getAuthMechanism('identifier:\Foo\Bar'));
-		$this->assertEquals($backend2, $service->getAuthMechanism('identifier:\Bar\Foo'));
-
-		$this->assertCount(2, $service->getAuthMechanisms());
-	}
-
-	public function testMultipleBackendProviders(): void {
-		$service = new BackendService($this->appConfig);
-
-		$backend1a = $this->getBackendMock('\Foo\Bar');
-		$backend1b = $this->getBackendMock('\Bar\Foo');
-
-		$backend2 = $this->getBackendMock('\Dead\Beef');
-
-		/** @var IBackendProvider&MockObject $provider1Mock */
-		$provider1Mock = $this->createMock(IBackendProvider::class);
-		$provider1Mock->expects($this->once())
-			->method('getBackends')
-			->willReturn([$backend1a, $backend1b]);
-		$service->registerBackendProvider($provider1Mock);
-		/** @var IBackendProvider&MockObject $provider2Mock */
-		$provider2Mock = $this->createMock(IBackendProvider::class);
-		$provider2Mock->expects($this->once())
-			->method('getBackends')
-			->willReturn([$backend2]);
-		$service->registerBackendProvider($provider2Mock);
-
-		$this->assertEquals($backend1a, $service->getBackend('identifier:\Foo\Bar'));
-		$this->assertEquals($backend1b, $service->getBackend('identifier:\Bar\Foo'));
-		$this->assertEquals($backend2, $service->getBackend('identifier:\Dead\Beef'));
-
-		$this->assertCount(3, $service->getBackends());
-	}
-
-	public function testUserMountingBackends(): void {
-		$this->appConfig->expects($this->once())
-			->method('getValueString')
-			->with('files_external', 'user_mounting_backends')
-			->willReturn('identifier:\User\Mount\Allowed,identifier_alias');
-		$this->appConfig->expects($this->once())
-			->method('getValueBool')
-			->with('files_external', 'allow_user_mounting')
-			->willReturn(true);
-
-		$service = new BackendService($this->appConfig);
-
-		$backendAllowed = $this->getBackendMock('\User\Mount\Allowed');
-		$backendAllowed->expects($this->never())
-			->method('removeVisibility');
-		$backendNotAllowed = $this->getBackendMock('\User\Mount\NotAllowed');
-		$backendNotAllowed->expects($this->once())
-			->method('removeVisibility')
-			->with(BackendService::VISIBILITY_PERSONAL);
-
-		$backendAlias = $this->getMockBuilder(Backend::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$backendAlias->method('getIdentifierAliases')
-			->willReturn(['identifier_real', 'identifier_alias']);
-		$backendAlias->expects($this->never())
-			->method('removeVisibility');
-
-		$service->registerBackend($backendAllowed);
-		$service->registerBackend($backendNotAllowed);
-		$service->registerBackend($backendAlias);
-	}
-
-	public function testGetAvailableBackends(): void {
-		$service = new BackendService($this->appConfig);
-
-		$backendAvailable = $this->getBackendMock('\Backend\Available');
-		$backendAvailable->expects($this->once())
-			->method('checkDependencies')
-			->willReturn([]);
-		$backendNotAvailable = $this->getBackendMock('\Backend\NotAvailable');
-		$backendNotAvailable->expects($this->once())
-			->method('checkDependencies')
-			->willReturn([
-				$this->getMockBuilder('\OCA\Files_External\Lib\MissingDependency')
-					->disableOriginalConstructor()
-					->getMock()
-			]);
-
-		$service->registerBackend($backendAvailable);
-		$service->registerBackend($backendNotAvailable);
-
-		$availableBackends = $service->getAvailableBackends();
-		$this->assertArrayHasKey('identifier:\Backend\Available', $availableBackends);
-		$this->assertArrayNotHasKey('identifier:\Backend\NotAvailable', $availableBackends);
-	}
-
-	public static function invalidConfigPlaceholderProvider(): array {
-		return [
-			[['@user']],
-			[['$user']],
-			[['hællo']],
-			[['spa ce']],
-			[['yo\o']],
-			[['<script>…</script>']],
-			[['xxyoloxx', 'invÆlid']],
-			[['tautology', 'tautology']],
-			[['tautology2', 'TAUTOLOGY2']],
-		];
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('invalidConfigPlaceholderProvider')]
-	public function testRegisterConfigHandlerInvalid(array $placeholders): void {
-		$this->expectException(\RuntimeException::class);
-
-		$service = new BackendService($this->appConfig);
-		$mock = $this->createMock(IConfigHandler::class);
-		$cb = function () use ($mock) {
-			return $mock;
-		};
-		foreach ($placeholders as $placeholder) {
-			$service->registerConfigHandler($placeholder, $cb);
-		}
-	}
-
-	public function testConfigHandlers(): void {
-		$service = new BackendService($this->appConfig);
-		$mock = $this->createMock(IConfigHandler::class);
-		$mock->expects($this->exactly(3))
-			->method('handle');
-		$cb = function () use ($mock) {
-			return $mock;
-		};
-		$service->registerConfigHandler('one', $cb);
-		$service->registerConfigHandler('2', $cb);
-		$service->registerConfigHandler('Three', $cb);
-
-		/** @var IConfigHandler[] $handlers */
-		$handlers = $service->getConfigHandlers();
-
-		foreach ($handlers as $handler) {
-			$handler->handle('Something');
-		}
-	}
+    protected IAppConfig&MockObject $appConfig;
+
+    protected function setUp(): void {
+        $this->appConfig = $this->createMock(IAppConfig::class);
+    }
+
+    /**
+     * @return \OCA\Files_External\Lib\Backend\Backend&MockObject
+     */
+    protected function getBackendMock(string $class) {
+        $backend = $this->createMock(Backend::class);
+        $backend->method('getIdentifier')->willReturn('identifier:' . $class);
+        $backend->method('getIdentifierAliases')->willReturn(['identifier:' . $class]);
+        return $backend;
+    }
+
+    /**
+     * @param string $class
+     *
+     * @return AuthMechanism&MockObject
+     */
+    protected function getAuthMechanismMock($class) {
+        $backend = $this->createMock(AuthMechanism::class);
+        $backend->method('getIdentifier')->willReturn('identifier:' . $class);
+        $backend->method('getIdentifierAliases')->willReturn(['identifier:' . $class]);
+        return $backend;
+    }
+
+    public function testRegisterBackend(): void {
+        $service = new BackendService($this->appConfig);
+
+        $backend = $this->getBackendMock('\Foo\Bar');
+
+        /** @var \OCA\Files_External\Lib\Backend\Backend&MockObject $backendAlias */
+        $backendAlias = $this->createMock(Backend::class);
+        $backendAlias->method('getIdentifierAliases')
+            ->willReturn(['identifier_real', 'identifier_alias']);
+        $backendAlias->method('getIdentifier')
+            ->willReturn('identifier_real');
+
+        $service->registerBackend($backend);
+        $service->registerBackend($backendAlias);
+
+        $this->assertEquals($backend, $service->getBackend('identifier:\Foo\Bar'));
+        $this->assertEquals($backendAlias, $service->getBackend('identifier_real'));
+        $this->assertEquals($backendAlias, $service->getBackend('identifier_alias'));
+
+        $backends = $service->getBackends();
+        $this->assertCount(2, $backends);
+        $this->assertArrayHasKey('identifier:\Foo\Bar', $backends);
+        $this->assertArrayHasKey('identifier_real', $backends);
+        $this->assertArrayNotHasKey('identifier_alias', $backends);
+    }
+
+    public function testBackendProvider(): void {
+        $service = new BackendService($this->appConfig);
+
+        $backend1 = $this->getBackendMock('\Foo\Bar');
+        $backend2 = $this->getBackendMock('\Bar\Foo');
+
+        /** @var IBackendProvider&MockObject $providerMock */
+        $providerMock = $this->createMock(IBackendProvider::class);
+        $providerMock->expects($this->once())
+            ->method('getBackends')
+            ->willReturn([$backend1, $backend2]);
+        $service->registerBackendProvider($providerMock);
+
+        $this->assertEquals($backend1, $service->getBackend('identifier:\Foo\Bar'));
+        $this->assertEquals($backend2, $service->getBackend('identifier:\Bar\Foo'));
+
+        $this->assertCount(2, $service->getBackends());
+    }
+
+    public function testAuthMechanismProvider(): void {
+        $service = new BackendService($this->appConfig);
+
+        $backend1 = $this->getAuthMechanismMock('\Foo\Bar');
+        $backend2 = $this->getAuthMechanismMock('\Bar\Foo');
+
+        /** @var IAuthMechanismProvider&MockObject $providerMock */
+        $providerMock = $this->createMock(IAuthMechanismProvider::class);
+        $providerMock->expects($this->once())
+            ->method('getAuthMechanisms')
+            ->willReturn([$backend1, $backend2]);
+        $service->registerAuthMechanismProvider($providerMock);
+
+        $this->assertEquals($backend1, $service->getAuthMechanism('identifier:\Foo\Bar'));
+        $this->assertEquals($backend2, $service->getAuthMechanism('identifier:\Bar\Foo'));
+
+        $this->assertCount(2, $service->getAuthMechanisms());
+    }
+
+    public function testMultipleBackendProviders(): void {
+        $service = new BackendService($this->appConfig);
+
+        $backend1a = $this->getBackendMock('\Foo\Bar');
+        $backend1b = $this->getBackendMock('\Bar\Foo');
+
+        $backend2 = $this->getBackendMock('\Dead\Beef');
+
+        /** @var IBackendProvider&MockObject $provider1Mock */
+        $provider1Mock = $this->createMock(IBackendProvider::class);
+        $provider1Mock->expects($this->once())
+            ->method('getBackends')
+            ->willReturn([$backend1a, $backend1b]);
+        $service->registerBackendProvider($provider1Mock);
+        /** @var IBackendProvider&MockObject $provider2Mock */
+        $provider2Mock = $this->createMock(IBackendProvider::class);
+        $provider2Mock->expects($this->once())
+            ->method('getBackends')
+            ->willReturn([$backend2]);
+        $service->registerBackendProvider($provider2Mock);
+
+        $this->assertEquals($backend1a, $service->getBackend('identifier:\Foo\Bar'));
+        $this->assertEquals($backend1b, $service->getBackend('identifier:\Bar\Foo'));
+        $this->assertEquals($backend2, $service->getBackend('identifier:\Dead\Beef'));
+
+        $this->assertCount(3, $service->getBackends());
+    }
+
+    public function testUserMountingBackends(): void {
+        $this->appConfig->expects($this->once())
+            ->method('getValueString')
+            ->with('files_external', 'user_mounting_backends')
+            ->willReturn('identifier:\User\Mount\Allowed,identifier_alias');
+        $this->appConfig->expects($this->once())
+            ->method('getValueBool')
+            ->with('files_external', 'allow_user_mounting')
+            ->willReturn(true);
+
+        $service = new BackendService($this->appConfig);
+
+        $backendAllowed = $this->getBackendMock('\User\Mount\Allowed');
+        $backendAllowed->expects($this->never())
+            ->method('removeVisibility');
+        $backendNotAllowed = $this->getBackendMock('\User\Mount\NotAllowed');
+        $backendNotAllowed->expects($this->once())
+            ->method('removeVisibility')
+            ->with(BackendService::VISIBILITY_PERSONAL);
+
+        $backendAlias = $this->getMockBuilder(Backend::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $backendAlias->method('getIdentifierAliases')
+            ->willReturn(['identifier_real', 'identifier_alias']);
+        $backendAlias->expects($this->never())
+            ->method('removeVisibility');
+
+        $service->registerBackend($backendAllowed);
+        $service->registerBackend($backendNotAllowed);
+        $service->registerBackend($backendAlias);
+    }
+
+    public function testGetAvailableBackends(): void {
+        $service = new BackendService($this->appConfig);
+
+        $backendAvailable = $this->getBackendMock('\Backend\Available');
+        $backendAvailable->expects($this->once())
+            ->method('checkDependencies')
+            ->willReturn([]);
+        $backendNotAvailable = $this->getBackendMock('\Backend\NotAvailable');
+        $backendNotAvailable->expects($this->once())
+            ->method('checkDependencies')
+            ->willReturn([
+                $this->getMockBuilder('\OCA\Files_External\Lib\MissingDependency')
+                    ->disableOriginalConstructor()
+                    ->getMock()
+            ]);
+
+        $service->registerBackend($backendAvailable);
+        $service->registerBackend($backendNotAvailable);
+
+        $availableBackends = $service->getAvailableBackends();
+        $this->assertArrayHasKey('identifier:\Backend\Available', $availableBackends);
+        $this->assertArrayNotHasKey('identifier:\Backend\NotAvailable', $availableBackends);
+    }
+
+    public static function invalidConfigPlaceholderProvider(): array {
+        return [
+            [['@user']],
+            [['$user']],
+            [['hællo']],
+            [['spa ce']],
+            [['yo\o']],
+            [['<script>…</script>']],
+            [['xxyoloxx', 'invÆlid']],
+            [['tautology', 'tautology']],
+            [['tautology2', 'TAUTOLOGY2']],
+        ];
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('invalidConfigPlaceholderProvider')]
+    public function testRegisterConfigHandlerInvalid(array $placeholders): void {
+        $this->expectException(\RuntimeException::class);
+
+        $service = new BackendService($this->appConfig);
+        $mock = $this->createMock(IConfigHandler::class);
+        $cb = function () use ($mock) {
+            return $mock;
+        };
+        foreach ($placeholders as $placeholder) {
+            $service->registerConfigHandler($placeholder, $cb);
+        }
+    }
+
+    public function testConfigHandlers(): void {
+        $service = new BackendService($this->appConfig);
+        $mock = $this->createMock(IConfigHandler::class);
+        $mock->expects($this->exactly(3))
+            ->method('handle');
+        $cb = function () use ($mock) {
+            return $mock;
+        };
+        $service->registerConfigHandler('one', $cb);
+        $service->registerConfigHandler('2', $cb);
+        $service->registerConfigHandler('Three', $cb);
+
+        /** @var IConfigHandler[] $handlers */
+        $handlers = $service->getConfigHandlers();
+
+        foreach ($handlers as $handler) {
+            $handler->handle('Something');
+        }
+    }
 }

apps/files_external/tests/Backend/BackendTest.php

Indentation +49 added lines, -49 removed lines

@@ -12,62 +12,62 @@
 use OCA\Files_External\Lib\StorageConfig;
 
 class BackendTest extends \Test\TestCase {
-	public function testJsonSerialization(): void {
-		$backend = $this->getMockBuilder(Backend::class)
-			->onlyMethods(['jsonSerializeDefinition'])
-			->getMock();
-		$backend->expects($this->once())
-			->method('jsonSerializeDefinition')
-			->willReturn(['foo' => 'bar', 'name' => 'abc']);
+    public function testJsonSerialization(): void {
+        $backend = $this->getMockBuilder(Backend::class)
+            ->onlyMethods(['jsonSerializeDefinition'])
+            ->getMock();
+        $backend->expects($this->once())
+            ->method('jsonSerializeDefinition')
+            ->willReturn(['foo' => 'bar', 'name' => 'abc']);
 
-		$backend->setPriority(57);
-		$backend->addAuthScheme('foopass');
-		$backend->addAuthScheme('barauth');
+        $backend->setPriority(57);
+        $backend->addAuthScheme('foopass');
+        $backend->addAuthScheme('barauth');
 
-		$json = $backend->jsonSerialize();
-		$this->assertEquals('bar', $json['foo']);
-		$this->assertEquals('abc', $json['name']);
-		$this->assertEquals($json['name'], $json['backend']);
-		$this->assertEquals(57, $json['priority']);
+        $json = $backend->jsonSerialize();
+        $this->assertEquals('bar', $json['foo']);
+        $this->assertEquals('abc', $json['name']);
+        $this->assertEquals($json['name'], $json['backend']);
+        $this->assertEquals(57, $json['priority']);
 
-		$this->assertContains('foopass', array_keys($json['authSchemes']));
-		$this->assertContains('barauth', array_keys($json['authSchemes']));
-	}
+        $this->assertContains('foopass', array_keys($json['authSchemes']));
+        $this->assertContains('barauth', array_keys($json['authSchemes']));
+    }
 
-	public static function validateStorageProvider(): array {
-		return [
-			[true, true],
-			[false, false],
-		];
-	}
+    public static function validateStorageProvider(): array {
+        return [
+            [true, true],
+            [false, false],
+        ];
+    }
 
-	#[\PHPUnit\Framework\Attributes\DataProvider('validateStorageProvider')]
-	public function testValidateStorage(bool $expectedSuccess, bool $definitionSuccess): void {
-		$backend = $this->getMockBuilder(Backend::class)
-			->onlyMethods(['validateStorageDefinition'])
-			->getMock();
-		$backend->expects($this->atMost(1))
-			->method('validateStorageDefinition')
-			->willReturn($definitionSuccess);
+    #[\PHPUnit\Framework\Attributes\DataProvider('validateStorageProvider')]
+    public function testValidateStorage(bool $expectedSuccess, bool $definitionSuccess): void {
+        $backend = $this->getMockBuilder(Backend::class)
+            ->onlyMethods(['validateStorageDefinition'])
+            ->getMock();
+        $backend->expects($this->atMost(1))
+            ->method('validateStorageDefinition')
+            ->willReturn($definitionSuccess);
 
-		$storageConfig = $this->getMockBuilder(StorageConfig::class)
-			->disableOriginalConstructor()
-			->getMock();
+        $storageConfig = $this->getMockBuilder(StorageConfig::class)
+            ->disableOriginalConstructor()
+            ->getMock();
 
-		$this->assertEquals($expectedSuccess, $backend->validateStorage($storageConfig));
-	}
+        $this->assertEquals($expectedSuccess, $backend->validateStorage($storageConfig));
+    }
 
-	public function testLegacyAuthMechanismCallback(): void {
-		$backend = new Backend();
-		$backend->setLegacyAuthMechanismCallback(function (array $params) {
-			if (isset($params['ping'])) {
-				return 'pong';
-			}
-			return 'foobar';
-		});
+    public function testLegacyAuthMechanismCallback(): void {
+        $backend = new Backend();
+        $backend->setLegacyAuthMechanismCallback(function (array $params) {
+            if (isset($params['ping'])) {
+                return 'pong';
+            }
+            return 'foobar';
+        });
 
-		$this->assertEquals('pong', $backend->getLegacyAuthMechanism(['ping' => true]));
-		$this->assertEquals('foobar', $backend->getLegacyAuthMechanism(['other' => true]));
-		$this->assertEquals('foobar', $backend->getLegacyAuthMechanism());
-	}
+        $this->assertEquals('pong', $backend->getLegacyAuthMechanism(['ping' => true]));
+        $this->assertEquals('foobar', $backend->getLegacyAuthMechanism(['other' => true]));
+        $this->assertEquals('foobar', $backend->getLegacyAuthMechanism());
+    }
 }

apps/files_external/tests/OwnCloudFunctionsTest.php

Indentation +75 added lines, -75 removed lines

@@ -18,80 +18,80 @@
  * @package OCA\Files_External\Tests
  */
 class OwnCloudFunctionsTest extends \Test\TestCase {
-	public static function configUrlProvider(): array {
-		return [
-			[
-				[
-					'host' => 'testhost',
-					'root' => 'testroot',
-					'secure' => false
-				],
-				'http://testhost/remote.php/webdav/testroot/',
-			],
-			[
-				[
-					'host' => 'testhost',
-					'root' => 'testroot',
-					'secure' => true
-				],
-				'https://testhost/remote.php/webdav/testroot/',
-			],
-			[
-				[
-					'host' => 'http://testhost',
-					'root' => 'testroot',
-					'secure' => false
-				],
-				'http://testhost/remote.php/webdav/testroot/',
-			],
-			[
-				[
-					'host' => 'https://testhost',
-					'root' => 'testroot',
-					'secure' => false
-				],
-				'https://testhost/remote.php/webdav/testroot/',
-			],
-			[
-				[
-					'host' => 'https://testhost/testroot',
-					'root' => '',
-					'secure' => false
-				],
-				'https://testhost/testroot/remote.php/webdav/',
-			],
-			[
-				[
-					'host' => 'https://testhost/testroot',
-					'root' => 'subdir',
-					'secure' => false
-				],
-				'https://testhost/testroot/remote.php/webdav/subdir/',
-			],
-			[
-				[
-					'host' => 'http://testhost/testroot',
-					'root' => 'subdir',
-					'secure' => true
-				],
-				'http://testhost/testroot/remote.php/webdav/subdir/',
-			],
-			[
-				[
-					'host' => 'http://testhost/testroot/',
-					'root' => '/subdir',
-					'secure' => false
-				],
-				'http://testhost/testroot/remote.php/webdav/subdir/',
-			],
-		];
-	}
+    public static function configUrlProvider(): array {
+        return [
+            [
+                [
+                    'host' => 'testhost',
+                    'root' => 'testroot',
+                    'secure' => false
+                ],
+                'http://testhost/remote.php/webdav/testroot/',
+            ],
+            [
+                [
+                    'host' => 'testhost',
+                    'root' => 'testroot',
+                    'secure' => true
+                ],
+                'https://testhost/remote.php/webdav/testroot/',
+            ],
+            [
+                [
+                    'host' => 'http://testhost',
+                    'root' => 'testroot',
+                    'secure' => false
+                ],
+                'http://testhost/remote.php/webdav/testroot/',
+            ],
+            [
+                [
+                    'host' => 'https://testhost',
+                    'root' => 'testroot',
+                    'secure' => false
+                ],
+                'https://testhost/remote.php/webdav/testroot/',
+            ],
+            [
+                [
+                    'host' => 'https://testhost/testroot',
+                    'root' => '',
+                    'secure' => false
+                ],
+                'https://testhost/testroot/remote.php/webdav/',
+            ],
+            [
+                [
+                    'host' => 'https://testhost/testroot',
+                    'root' => 'subdir',
+                    'secure' => false
+                ],
+                'https://testhost/testroot/remote.php/webdav/subdir/',
+            ],
+            [
+                [
+                    'host' => 'http://testhost/testroot',
+                    'root' => 'subdir',
+                    'secure' => true
+                ],
+                'http://testhost/testroot/remote.php/webdav/subdir/',
+            ],
+            [
+                [
+                    'host' => 'http://testhost/testroot/',
+                    'root' => '/subdir',
+                    'secure' => false
+                ],
+                'http://testhost/testroot/remote.php/webdav/subdir/',
+            ],
+        ];
+    }
 
-	#[\PHPUnit\Framework\Attributes\DataProvider('configUrlProvider')]
-	public function testConfig(array $config, string $expectedUri): void {
-		$config['user'] = 'someuser';
-		$config['password'] = 'somepassword';
-		$instance = new OwnCloud($config);
-		$this->assertEquals($expectedUri, $instance->createBaseUri());
-	}
+    #[\PHPUnit\Framework\Attributes\DataProvider('configUrlProvider')]
+    public function testConfig(array $config, string $expectedUri): void {
+        $config['user'] = 'someuser';
+        $config['password'] = 'somepassword';
+        $instance = new OwnCloud($config);
+        $this->assertEquals($expectedUri, $instance->createBaseUri());
+    }
 }

apps/files_external/tests/DefinitionParameterTest.php

Indentation +60 added lines, -60 removed lines

@@ -11,72 +11,72 @@
 use OCA\Files_External\Lib\DefinitionParameter as Param;
 
 class DefinitionParameterTest extends \Test\TestCase {
-	public function testJsonSerialization(): void {
-		$param = new Param('foo', 'bar');
-		$this->assertEquals([
-			'value' => 'bar',
-			'flags' => 0,
-			'type' => 0,
-			'tooltip' => '',
-		], $param->jsonSerialize());
+    public function testJsonSerialization(): void {
+        $param = new Param('foo', 'bar');
+        $this->assertEquals([
+            'value' => 'bar',
+            'flags' => 0,
+            'type' => 0,
+            'tooltip' => '',
+        ], $param->jsonSerialize());
 
-		$param->setType(Param::VALUE_BOOLEAN);
-		$param->setDefaultValue(true);
-		$this->assertEquals([
-			'value' => 'bar',
-			'flags' => 0,
-			'type' => Param::VALUE_BOOLEAN,
-			'tooltip' => '',
-			'defaultValue' => true,
-		], $param->jsonSerialize());
+        $param->setType(Param::VALUE_BOOLEAN);
+        $param->setDefaultValue(true);
+        $this->assertEquals([
+            'value' => 'bar',
+            'flags' => 0,
+            'type' => Param::VALUE_BOOLEAN,
+            'tooltip' => '',
+            'defaultValue' => true,
+        ], $param->jsonSerialize());
 
-		$param->setType(Param::VALUE_PASSWORD);
-		$param->setFlag(Param::FLAG_OPTIONAL);
-		$param->setDefaultValue(null);
-		$this->assertEquals([
-			'value' => 'bar',
-			'flags' => Param::FLAG_OPTIONAL,
-			'type' => Param::VALUE_PASSWORD,
-			'tooltip' => '',
-		], $param->jsonSerialize());
+        $param->setType(Param::VALUE_PASSWORD);
+        $param->setFlag(Param::FLAG_OPTIONAL);
+        $param->setDefaultValue(null);
+        $this->assertEquals([
+            'value' => 'bar',
+            'flags' => Param::FLAG_OPTIONAL,
+            'type' => Param::VALUE_PASSWORD,
+            'tooltip' => '',
+        ], $param->jsonSerialize());
 
-		$param->setType(Param::VALUE_TEXT);
-		$param->setFlags(Param::FLAG_HIDDEN);
-		$this->assertEquals([
-			'value' => 'bar',
-			'flags' => Param::FLAG_HIDDEN,
-			'type' => Param::VALUE_TEXT,
-			'tooltip' => '',
-		], $param->jsonSerialize());
-	}
+        $param->setType(Param::VALUE_TEXT);
+        $param->setFlags(Param::FLAG_HIDDEN);
+        $this->assertEquals([
+            'value' => 'bar',
+            'flags' => Param::FLAG_HIDDEN,
+            'type' => Param::VALUE_TEXT,
+            'tooltip' => '',
+        ], $param->jsonSerialize());
+    }
 
-	public static function validateValueProvider(): array {
-		return [
-			[Param::VALUE_TEXT, Param::FLAG_NONE, 'abc', true],
-			[Param::VALUE_TEXT, Param::FLAG_NONE, '', false],
-			[Param::VALUE_TEXT, Param::FLAG_OPTIONAL, '', true],
-			[Param::VALUE_TEXT, Param::FLAG_HIDDEN, '', false],
+    public static function validateValueProvider(): array {
+        return [
+            [Param::VALUE_TEXT, Param::FLAG_NONE, 'abc', true],
+            [Param::VALUE_TEXT, Param::FLAG_NONE, '', false],
+            [Param::VALUE_TEXT, Param::FLAG_OPTIONAL, '', true],
+            [Param::VALUE_TEXT, Param::FLAG_HIDDEN, '', false],
 
-			[Param::VALUE_BOOLEAN, Param::FLAG_NONE, false, true],
-			[Param::VALUE_BOOLEAN, Param::FLAG_NONE, 123, false],
-			// conversion from string to boolean
-			[Param::VALUE_BOOLEAN, Param::FLAG_NONE, 'false', true, false],
-			[Param::VALUE_BOOLEAN, Param::FLAG_NONE, 'true', true, true],
+            [Param::VALUE_BOOLEAN, Param::FLAG_NONE, false, true],
+            [Param::VALUE_BOOLEAN, Param::FLAG_NONE, 123, false],
+            // conversion from string to boolean
+            [Param::VALUE_BOOLEAN, Param::FLAG_NONE, 'false', true, false],
+            [Param::VALUE_BOOLEAN, Param::FLAG_NONE, 'true', true, true],
 
-			[Param::VALUE_PASSWORD, Param::FLAG_NONE, 'foobar', true],
-			[Param::VALUE_PASSWORD, Param::FLAG_NONE, '', false],
-		];
-	}
+            [Param::VALUE_PASSWORD, Param::FLAG_NONE, 'foobar', true],
+            [Param::VALUE_PASSWORD, Param::FLAG_NONE, '', false],
+        ];
+    }
 
-	#[\PHPUnit\Framework\Attributes\DataProvider('validateValueProvider')]
-	public function testValidateValue($type, $flags, $value, $success, $expectedValue = null): void {
-		$param = new Param('foo', 'bar');
-		$param->setType($type);
-		$param->setFlags($flags);
+    #[\PHPUnit\Framework\Attributes\DataProvider('validateValueProvider')]
+    public function testValidateValue($type, $flags, $value, $success, $expectedValue = null): void {
+        $param = new Param('foo', 'bar');
+        $param->setType($type);
+        $param->setFlags($flags);
 
-		$this->assertEquals($success, $param->validateValue($value));
-		if (isset($expectedValue)) {
-			$this->assertEquals($expectedValue, $value);
-		}
-	}
+        $this->assertEquals($success, $param->validateValue($value));
+        if (isset($expectedValue)) {
+            $this->assertEquals($expectedValue, $value);
+        }
+    }
 }

apps/files_external/tests/LegacyDependencyCheckPolyfillTest.php

Indentation +21 added lines, -21 removed lines

@@ -13,27 +13,27 @@
 
 class LegacyDependencyCheckPolyfillTest extends \Test\TestCase {
 
-	/**
-	 * @return MissingDependency[]
-	 */
-	public static function checkDependencies(): array {
-		return [
-			(new MissingDependency('dependency'))->setMessage('missing dependency'),
-			(new MissingDependency('program'))->setMessage('cannot find program'),
-		];
-	}
+    /**
+     * @return MissingDependency[]
+     */
+    public static function checkDependencies(): array {
+        return [
+            (new MissingDependency('dependency'))->setMessage('missing dependency'),
+            (new MissingDependency('program'))->setMessage('cannot find program'),
+        ];
+    }
 
-	public function testCheckDependencies(): void {
-		$trait = $this->getMockForTrait(LegacyDependencyCheckPolyfill::class);
-		$trait->expects($this->once())
-			->method('getStorageClass')
-			->willReturn(self::class);
+    public function testCheckDependencies(): void {
+        $trait = $this->getMockForTrait(LegacyDependencyCheckPolyfill::class);
+        $trait->expects($this->once())
+            ->method('getStorageClass')
+            ->willReturn(self::class);
 
-		$dependencies = $trait->checkDependencies();
-		$this->assertCount(2, $dependencies);
-		$this->assertEquals('dependency', $dependencies[0]->getDependency());
-		$this->assertEquals('missing dependency', $dependencies[0]->getMessage());
-		$this->assertEquals('program', $dependencies[1]->getDependency());
-		$this->assertEquals('cannot find program', $dependencies[1]->getMessage());
-	}
+        $dependencies = $trait->checkDependencies();
+        $this->assertCount(2, $dependencies);
+        $this->assertEquals('dependency', $dependencies[0]->getDependency());
+        $this->assertEquals('missing dependency', $dependencies[0]->getMessage());
+        $this->assertEquals('program', $dependencies[1]->getDependency());
+        $this->assertEquals('cannot find program', $dependencies[1]->getMessage());
+    }
 }

apps/oauth2/tests/Controller/OauthApiControllerTest.php

Indentation +572 added lines, -572 removed lines

@@ -29,579 +29,579 @@
 
 /* We have to use this to add a property to the mocked request and avoid warnings about dynamic properties on PHP>=8.2 */
 abstract class RequestMock implements IRequest {
-	public array $server = [];
+    public array $server = [];
 }
 
 class OauthApiControllerTest extends TestCase {
-	/** @var IRequest|\PHPUnit\Framework\MockObject\MockObject */
-	private $request;
-	/** @var ICrypto|\PHPUnit\Framework\MockObject\MockObject */
-	private $crypto;
-	/** @var AccessTokenMapper|\PHPUnit\Framework\MockObject\MockObject */
-	private $accessTokenMapper;
-	/** @var ClientMapper|\PHPUnit\Framework\MockObject\MockObject */
-	private $clientMapper;
-	/** @var TokenProvider|\PHPUnit\Framework\MockObject\MockObject */
-	private $tokenProvider;
-	/** @var ISecureRandom|\PHPUnit\Framework\MockObject\MockObject */
-	private $secureRandom;
-	/** @var ITimeFactory|\PHPUnit\Framework\MockObject\MockObject */
-	private $time;
-	/** @var IThrottler|\PHPUnit\Framework\MockObject\MockObject */
-	private $throttler;
-	/** @var LoggerInterface|\PHPUnit\Framework\MockObject\MockObject */
-	private $logger;
-	/** @var ITimeFactory|\PHPUnit\Framework\MockObject\MockObject */
-	private $timeFactory;
-	/** @var OauthApiController */
-	private $oauthApiController;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->request = $this->createMock(RequestMock::class);
-		$this->crypto = $this->createMock(ICrypto::class);
-		$this->accessTokenMapper = $this->createMock(AccessTokenMapper::class);
-		$this->clientMapper = $this->createMock(ClientMapper::class);
-		$this->tokenProvider = $this->createMock(TokenProvider::class);
-		$this->secureRandom = $this->createMock(ISecureRandom::class);
-		$this->time = $this->createMock(ITimeFactory::class);
-		$this->throttler = $this->createMock(IThrottler::class);
-		$this->logger = $this->createMock(LoggerInterface::class);
-		$this->timeFactory = $this->createMock(ITimeFactory::class);
-
-		$this->oauthApiController = new OauthApiController(
-			'oauth2',
-			$this->request,
-			$this->crypto,
-			$this->accessTokenMapper,
-			$this->clientMapper,
-			$this->tokenProvider,
-			$this->secureRandom,
-			$this->time,
-			$this->logger,
-			$this->throttler,
-			$this->timeFactory
-		);
-	}
-
-	public function testGetTokenInvalidGrantType(): void {
-		$expected = new JSONResponse([
-			'error' => 'invalid_grant',
-		], Http::STATUS_BAD_REQUEST);
-		$expected->throttle(['invalid_grant' => 'foo']);
-
-		$this->assertEquals($expected, $this->oauthApiController->getToken('foo', null, null, null, null));
-	}
-
-	public function testGetTokenInvalidCode(): void {
-		$expected = new JSONResponse([
-			'error' => 'invalid_request',
-		], Http::STATUS_BAD_REQUEST);
-		$expected->throttle(['invalid_request' => 'token not found', 'code' => 'invalidcode']);
-
-		$this->accessTokenMapper->method('getByCode')
-			->with('invalidcode')
-			->willThrowException(new AccessTokenNotFoundException());
-
-		$this->assertEquals($expected, $this->oauthApiController->getToken('authorization_code', 'invalidcode', null, null, null));
-	}
-
-	public function testGetTokenExpiredCode(): void {
-		$codeCreatedAt = 100;
-		$expiredSince = 123;
-
-		$expected = new JSONResponse([
-			'error' => 'invalid_request',
-		], Http::STATUS_BAD_REQUEST);
-		$expected->throttle(['invalid_request' => 'authorization_code_expired', 'expired_since' => $expiredSince]);
-
-		$accessToken = new AccessToken();
-		$accessToken->setClientId(42);
-		$accessToken->setCodeCreatedAt($codeCreatedAt);
-
-		$this->accessTokenMapper->method('getByCode')
-			->with('validcode')
-			->willReturn($accessToken);
-
-		$tsNow = $codeCreatedAt + OauthApiController::AUTHORIZATION_CODE_EXPIRES_AFTER + $expiredSince;
-		$dateNow = (new \DateTimeImmutable())->setTimestamp($tsNow);
-		$this->timeFactory->method('now')
-			->willReturn($dateNow);
-
-		$this->assertEquals($expected, $this->oauthApiController->getToken('authorization_code', 'validcode', null, null, null));
-	}
-
-	public function testGetTokenWithCodeForActiveToken(): void {
-		// if a token has already delivered oauth tokens,
-		// it should not be possible to get a new oauth token from a valid authorization code
-		$codeCreatedAt = 100;
-
-		$expected = new JSONResponse([
-			'error' => 'invalid_request',
-		], Http::STATUS_BAD_REQUEST);
-		$expected->throttle(['invalid_request' => 'authorization_code_received_for_active_token']);
-
-		$accessToken = new AccessToken();
-		$accessToken->setClientId(42);
-		$accessToken->setCodeCreatedAt($codeCreatedAt);
-		$accessToken->setTokenCount(1);
-
-		$this->accessTokenMapper->method('getByCode')
-			->with('validcode')
-			->willReturn($accessToken);
-
-		$tsNow = $codeCreatedAt + 1;
-		$dateNow = (new \DateTimeImmutable())->setTimestamp($tsNow);
-		$this->timeFactory->method('now')
-			->willReturn($dateNow);
-
-		$this->assertEquals($expected, $this->oauthApiController->getToken('authorization_code', 'validcode', null, null, null));
-	}
-
-	public function testGetTokenClientDoesNotExist(): void {
-		// In this test, the token's authorization code is valid and has not expired
-		// and we check what happens when the associated Oauth client does not exist
-		$codeCreatedAt = 100;
-
-		$expected = new JSONResponse([
-			'error' => 'invalid_request',
-		], Http::STATUS_BAD_REQUEST);
-		$expected->throttle(['invalid_request' => 'client not found', 'client_id' => 42]);
-
-		$accessToken = new AccessToken();
-		$accessToken->setClientId(42);
-		$accessToken->setCodeCreatedAt($codeCreatedAt);
-
-		$this->accessTokenMapper->method('getByCode')
-			->with('validcode')
-			->willReturn($accessToken);
-
-		// 'now' is before the token's authorization code expiration
-		$tsNow = $codeCreatedAt + OauthApiController::AUTHORIZATION_CODE_EXPIRES_AFTER - 1;
-		$dateNow = (new \DateTimeImmutable())->setTimestamp($tsNow);
-		$this->timeFactory->method('now')
-			->willReturn($dateNow);
-
-		$this->clientMapper->method('getByUid')
-			->with(42)
-			->willThrowException(new ClientNotFoundException());
-
-		$this->assertEquals($expected, $this->oauthApiController->getToken('authorization_code', 'validcode', null, null, null));
-	}
-
-	public function testRefreshTokenInvalidRefreshToken(): void {
-		$expected = new JSONResponse([
-			'error' => 'invalid_request',
-		], Http::STATUS_BAD_REQUEST);
-		$expected->throttle(['invalid_request' => 'token not found', 'code' => 'invalidrefresh']);
-
-		$this->accessTokenMapper->method('getByCode')
-			->with('invalidrefresh')
-			->willThrowException(new AccessTokenNotFoundException());
-
-		$this->assertEquals($expected, $this->oauthApiController->getToken('refresh_token', null, 'invalidrefresh', null, null));
-	}
-
-	public function testRefreshTokenClientDoesNotExist(): void {
-		$expected = new JSONResponse([
-			'error' => 'invalid_request',
-		], Http::STATUS_BAD_REQUEST);
-		$expected->throttle(['invalid_request' => 'client not found', 'client_id' => 42]);
-
-		$accessToken = new AccessToken();
-		$accessToken->setClientId(42);
-
-		$this->accessTokenMapper->method('getByCode')
-			->with('validrefresh')
-			->willReturn($accessToken);
-
-		$this->clientMapper->method('getByUid')
-			->with(42)
-			->willThrowException(new ClientNotFoundException());
-
-		$this->assertEquals($expected, $this->oauthApiController->getToken('refresh_token', null, 'validrefresh', null, null));
-	}
-
-	public static function invalidClientProvider() {
-		return [
-			['invalidClientId', 'invalidClientSecret'],
-			['clientId', 'invalidClientSecret'],
-			['invalidClientId', 'clientSecret'],
-		];
-	}
-
-	/**
-	 *
-	 * @param string $clientId
-	 * @param string $clientSecret
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('invalidClientProvider')]
-	public function testRefreshTokenInvalidClient($clientId, $clientSecret): void {
-		$expected = new JSONResponse([
-			'error' => 'invalid_client',
-		], Http::STATUS_BAD_REQUEST);
-		$expected->throttle(['invalid_client' => 'client ID or secret does not match']);
-
-		$accessToken = new AccessToken();
-		$accessToken->setClientId(42);
-
-		$this->accessTokenMapper->method('getByCode')
-			->with('validrefresh')
-			->willReturn($accessToken);
-
-		$this->crypto
-			->method('calculateHMAC')
-			->with($this->callback(function (string $text) {
-				return $text === 'clientSecret' || $text === 'invalidClientSecret';
-			}))
-			->willReturnCallback(function (string $text) {
-				return $text === 'clientSecret'
-					? 'hashedClientSecret'
-					: 'hashedInvalidClientSecret';
-			});
-
-		$client = new Client();
-		$client->setClientIdentifier('clientId');
-		$client->setSecret(bin2hex('hashedClientSecret'));
-		$this->clientMapper->method('getByUid')
-			->with(42)
-			->willReturn($client);
-
-		$this->assertEquals($expected, $this->oauthApiController->getToken('refresh_token', null, 'validrefresh', $clientId, $clientSecret));
-	}
-
-	public function testRefreshTokenInvalidAppToken(): void {
-		$expected = new JSONResponse([
-			'error' => 'invalid_request',
-		], Http::STATUS_BAD_REQUEST);
-		$expected->throttle(['invalid_request' => 'token is invalid']);
-
-		$accessToken = new AccessToken();
-		$accessToken->setClientId(42);
-		$accessToken->setTokenId(1337);
-		$accessToken->setEncryptedToken('encryptedToken');
-
-		$this->accessTokenMapper->method('getByCode')
-			->with('validrefresh')
-			->willReturn($accessToken);
-
-		$client = new Client();
-		$client->setClientIdentifier('clientId');
-		$client->setSecret(bin2hex('hashedClientSecret'));
-		$this->clientMapper->method('getByUid')
-			->with(42)
-			->willReturn($client);
-
-		$this->crypto
-			->method('decrypt')
-			->with('encryptedToken')
-			->willReturn('decryptedToken');
-
-		$this->crypto
-			->method('calculateHMAC')
-			->with('clientSecret')
-			->willReturn('hashedClientSecret');
-
-		$this->tokenProvider->method('getTokenById')
-			->with(1337)
-			->willThrowException(new InvalidTokenException());
-
-		$this->accessTokenMapper->expects($this->once())
-			->method('delete')
-			->with($accessToken);
-
-		$this->assertEquals($expected, $this->oauthApiController->getToken('refresh_token', null, 'validrefresh', 'clientId', 'clientSecret'));
-	}
-
-	public function testRefreshTokenValidAppToken(): void {
-		$accessToken = new AccessToken();
-		$accessToken->setClientId(42);
-		$accessToken->setTokenId(1337);
-		$accessToken->setEncryptedToken('encryptedToken');
-
-		$this->accessTokenMapper->method('getByCode')
-			->with('validrefresh')
-			->willReturn($accessToken);
-
-		$client = new Client();
-		$client->setClientIdentifier('clientId');
-		$client->setSecret(bin2hex('hashedClientSecret'));
-		$this->clientMapper->method('getByUid')
-			->with(42)
-			->willReturn($client);
-
-		$this->crypto
-			->method('decrypt')
-			->with('encryptedToken')
-			->willReturn('decryptedToken');
-
-		$this->crypto
-			->method('calculateHMAC')
-			->with('clientSecret')
-			->willReturn('hashedClientSecret');
-
-		$appToken = new PublicKeyToken();
-		$appToken->setUid('userId');
-		$this->tokenProvider->method('getTokenById')
-			->with(1337)
-			->willThrowException(new ExpiredTokenException($appToken));
-
-		$this->accessTokenMapper->expects($this->never())
-			->method('delete')
-			->with($accessToken);
-
-		$this->secureRandom->method('generate')
-			->willReturnCallback(function ($len) {
-				return 'random' . $len;
-			});
-
-		$this->tokenProvider->expects($this->once())
-			->method('rotate')
-			->with(
-				$appToken,
-				'decryptedToken',
-				'random72'
-			)->willReturn($appToken);
-
-		$this->time->method('getTime')
-			->willReturn(1000);
-
-		$this->tokenProvider->expects($this->once())
-			->method('updateToken')
-			->with(
-				$this->callback(function (PublicKeyToken $token) {
-					return $token->getExpires() === 4600;
-				})
-			);
-
-		$this->crypto->method('encrypt')
-			->with('random72', 'random128')
-			->willReturn('newEncryptedToken');
-
-		$this->accessTokenMapper->expects($this->once())
-			->method('update')
-			->with(
-				$this->callback(function (AccessToken $token) {
-					return $token->getHashedCode() === hash('sha512', 'random128')
-						&& $token->getEncryptedToken() === 'newEncryptedToken';
-				})
-			);
-
-		$expected = new JSONResponse([
-			'access_token' => 'random72',
-			'token_type' => 'Bearer',
-			'expires_in' => 3600,
-			'refresh_token' => 'random128',
-			'user_id' => 'userId',
-		]);
-
-		$this->request->method('getRemoteAddress')
-			->willReturn('1.2.3.4');
-
-		$this->throttler->expects($this->once())
-			->method('resetDelay')
-			->with(
-				'1.2.3.4',
-				'login',
-				['user' => 'userId']
-			);
-
-		$this->assertEquals($expected, $this->oauthApiController->getToken('refresh_token', null, 'validrefresh', 'clientId', 'clientSecret'));
-	}
-
-	public function testRefreshTokenValidAppTokenBasicAuth(): void {
-		$accessToken = new AccessToken();
-		$accessToken->setClientId(42);
-		$accessToken->setTokenId(1337);
-		$accessToken->setEncryptedToken('encryptedToken');
-
-		$this->accessTokenMapper->method('getByCode')
-			->with('validrefresh')
-			->willReturn($accessToken);
-
-		$client = new Client();
-		$client->setClientIdentifier('clientId');
-		$client->setSecret(bin2hex('hashedClientSecret'));
-		$this->clientMapper->method('getByUid')
-			->with(42)
-			->willReturn($client);
-
-		$this->crypto
-			->method('decrypt')
-			->with('encryptedToken')
-			->willReturn('decryptedToken');
-
-		$this->crypto
-			->method('calculateHMAC')
-			->with('clientSecret')
-			->willReturn('hashedClientSecret');
-
-		$appToken = new PublicKeyToken();
-		$appToken->setUid('userId');
-		$this->tokenProvider->method('getTokenById')
-			->with(1337)
-			->willThrowException(new ExpiredTokenException($appToken));
-
-		$this->accessTokenMapper->expects($this->never())
-			->method('delete')
-			->with($accessToken);
-
-		$this->secureRandom->method('generate')
-			->willReturnCallback(function ($len) {
-				return 'random' . $len;
-			});
-
-		$this->tokenProvider->expects($this->once())
-			->method('rotate')
-			->with(
-				$appToken,
-				'decryptedToken',
-				'random72'
-			)->willReturn($appToken);
-
-		$this->time->method('getTime')
-			->willReturn(1000);
-
-		$this->tokenProvider->expects($this->once())
-			->method('updateToken')
-			->with(
-				$this->callback(function (PublicKeyToken $token) {
-					return $token->getExpires() === 4600;
-				})
-			);
-
-		$this->crypto->method('encrypt')
-			->with('random72', 'random128')
-			->willReturn('newEncryptedToken');
-
-		$this->accessTokenMapper->expects($this->once())
-			->method('update')
-			->with(
-				$this->callback(function (AccessToken $token) {
-					return $token->getHashedCode() === hash('sha512', 'random128')
-						&& $token->getEncryptedToken() === 'newEncryptedToken';
-				})
-			);
-
-		$expected = new JSONResponse([
-			'access_token' => 'random72',
-			'token_type' => 'Bearer',
-			'expires_in' => 3600,
-			'refresh_token' => 'random128',
-			'user_id' => 'userId',
-		]);
-
-		$this->request->server['PHP_AUTH_USER'] = 'clientId';
-		$this->request->server['PHP_AUTH_PW'] = 'clientSecret';
-
-		$this->request->method('getRemoteAddress')
-			->willReturn('1.2.3.4');
-
-		$this->throttler->expects($this->once())
-			->method('resetDelay')
-			->with(
-				'1.2.3.4',
-				'login',
-				['user' => 'userId']
-			);
-
-		$this->assertEquals($expected, $this->oauthApiController->getToken('refresh_token', null, 'validrefresh', null, null));
-	}
-
-	public function testRefreshTokenExpiredAppToken(): void {
-		$accessToken = new AccessToken();
-		$accessToken->setClientId(42);
-		$accessToken->setTokenId(1337);
-		$accessToken->setEncryptedToken('encryptedToken');
-
-		$this->accessTokenMapper->method('getByCode')
-			->with('validrefresh')
-			->willReturn($accessToken);
-
-		$client = new Client();
-		$client->setClientIdentifier('clientId');
-		$client->setSecret(bin2hex('hashedClientSecret'));
-		$this->clientMapper->method('getByUid')
-			->with(42)
-			->willReturn($client);
-
-		$this->crypto
-			->method('decrypt')
-			->with('encryptedToken')
-			->willReturn('decryptedToken');
-
-		$this->crypto
-			->method('calculateHMAC')
-			->with('clientSecret')
-			->willReturn('hashedClientSecret');
-
-		$appToken = new PublicKeyToken();
-		$appToken->setUid('userId');
-		$this->tokenProvider->method('getTokenById')
-			->with(1337)
-			->willReturn($appToken);
-
-		$this->accessTokenMapper->expects($this->never())
-			->method('delete')
-			->with($accessToken);
-
-		$this->secureRandom->method('generate')
-			->willReturnCallback(function ($len) {
-				return 'random' . $len;
-			});
-
-		$this->tokenProvider->expects($this->once())
-			->method('rotate')
-			->with(
-				$appToken,
-				'decryptedToken',
-				'random72'
-			)->willReturn($appToken);
-
-		$this->time->method('getTime')
-			->willReturn(1000);
-
-		$this->tokenProvider->expects($this->once())
-			->method('updateToken')
-			->with(
-				$this->callback(function (PublicKeyToken $token) {
-					return $token->getExpires() === 4600;
-				})
-			);
-
-		$this->crypto->method('encrypt')
-			->with('random72', 'random128')
-			->willReturn('newEncryptedToken');
-
-		$this->accessTokenMapper->expects($this->once())
-			->method('update')
-			->with(
-				$this->callback(function (AccessToken $token) {
-					return $token->getHashedCode() === hash('sha512', 'random128')
-						&& $token->getEncryptedToken() === 'newEncryptedToken';
-				})
-			);
-
-		$expected = new JSONResponse([
-			'access_token' => 'random72',
-			'token_type' => 'Bearer',
-			'expires_in' => 3600,
-			'refresh_token' => 'random128',
-			'user_id' => 'userId',
-		]);
-
-		$this->request->method('getRemoteAddress')
-			->willReturn('1.2.3.4');
-
-		$this->throttler->expects($this->once())
-			->method('resetDelay')
-			->with(
-				'1.2.3.4',
-				'login',
-				['user' => 'userId']
-			);
-
-		$this->assertEquals($expected, $this->oauthApiController->getToken('refresh_token', null, 'validrefresh', 'clientId', 'clientSecret'));
-	}
+    /** @var IRequest|\PHPUnit\Framework\MockObject\MockObject */
+    private $request;
+    /** @var ICrypto|\PHPUnit\Framework\MockObject\MockObject */
+    private $crypto;
+    /** @var AccessTokenMapper|\PHPUnit\Framework\MockObject\MockObject */
+    private $accessTokenMapper;
+    /** @var ClientMapper|\PHPUnit\Framework\MockObject\MockObject */
+    private $clientMapper;
+    /** @var TokenProvider|\PHPUnit\Framework\MockObject\MockObject */
+    private $tokenProvider;
+    /** @var ISecureRandom|\PHPUnit\Framework\MockObject\MockObject */
+    private $secureRandom;
+    /** @var ITimeFactory|\PHPUnit\Framework\MockObject\MockObject */
+    private $time;
+    /** @var IThrottler|\PHPUnit\Framework\MockObject\MockObject */
+    private $throttler;
+    /** @var LoggerInterface|\PHPUnit\Framework\MockObject\MockObject */
+    private $logger;
+    /** @var ITimeFactory|\PHPUnit\Framework\MockObject\MockObject */
+    private $timeFactory;
+    /** @var OauthApiController */
+    private $oauthApiController;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->request = $this->createMock(RequestMock::class);
+        $this->crypto = $this->createMock(ICrypto::class);
+        $this->accessTokenMapper = $this->createMock(AccessTokenMapper::class);
+        $this->clientMapper = $this->createMock(ClientMapper::class);
+        $this->tokenProvider = $this->createMock(TokenProvider::class);
+        $this->secureRandom = $this->createMock(ISecureRandom::class);
+        $this->time = $this->createMock(ITimeFactory::class);
+        $this->throttler = $this->createMock(IThrottler::class);
+        $this->logger = $this->createMock(LoggerInterface::class);
+        $this->timeFactory = $this->createMock(ITimeFactory::class);
+
+        $this->oauthApiController = new OauthApiController(
+            'oauth2',
+            $this->request,
+            $this->crypto,
+            $this->accessTokenMapper,
+            $this->clientMapper,
+            $this->tokenProvider,
+            $this->secureRandom,
+            $this->time,
+            $this->logger,
+            $this->throttler,
+            $this->timeFactory
+        );
+    }
+
+    public function testGetTokenInvalidGrantType(): void {
+        $expected = new JSONResponse([
+            'error' => 'invalid_grant',
+        ], Http::STATUS_BAD_REQUEST);
+        $expected->throttle(['invalid_grant' => 'foo']);
+
+        $this->assertEquals($expected, $this->oauthApiController->getToken('foo', null, null, null, null));
+    }
+
+    public function testGetTokenInvalidCode(): void {
+        $expected = new JSONResponse([
+            'error' => 'invalid_request',
+        ], Http::STATUS_BAD_REQUEST);
+        $expected->throttle(['invalid_request' => 'token not found', 'code' => 'invalidcode']);
+
+        $this->accessTokenMapper->method('getByCode')
+            ->with('invalidcode')
+            ->willThrowException(new AccessTokenNotFoundException());
+
+        $this->assertEquals($expected, $this->oauthApiController->getToken('authorization_code', 'invalidcode', null, null, null));
+    }
+
+    public function testGetTokenExpiredCode(): void {
+        $codeCreatedAt = 100;
+        $expiredSince = 123;
+
+        $expected = new JSONResponse([
+            'error' => 'invalid_request',
+        ], Http::STATUS_BAD_REQUEST);
+        $expected->throttle(['invalid_request' => 'authorization_code_expired', 'expired_since' => $expiredSince]);
+
+        $accessToken = new AccessToken();
+        $accessToken->setClientId(42);
+        $accessToken->setCodeCreatedAt($codeCreatedAt);
+
+        $this->accessTokenMapper->method('getByCode')
+            ->with('validcode')
+            ->willReturn($accessToken);
+
+        $tsNow = $codeCreatedAt + OauthApiController::AUTHORIZATION_CODE_EXPIRES_AFTER + $expiredSince;
+        $dateNow = (new \DateTimeImmutable())->setTimestamp($tsNow);
+        $this->timeFactory->method('now')
+            ->willReturn($dateNow);
+
+        $this->assertEquals($expected, $this->oauthApiController->getToken('authorization_code', 'validcode', null, null, null));
+    }
+
+    public function testGetTokenWithCodeForActiveToken(): void {
+        // if a token has already delivered oauth tokens,
+        // it should not be possible to get a new oauth token from a valid authorization code
+        $codeCreatedAt = 100;
+
+        $expected = new JSONResponse([
+            'error' => 'invalid_request',
+        ], Http::STATUS_BAD_REQUEST);
+        $expected->throttle(['invalid_request' => 'authorization_code_received_for_active_token']);
+
+        $accessToken = new AccessToken();
+        $accessToken->setClientId(42);
+        $accessToken->setCodeCreatedAt($codeCreatedAt);
+        $accessToken->setTokenCount(1);
+
+        $this->accessTokenMapper->method('getByCode')
+            ->with('validcode')
+            ->willReturn($accessToken);
+
+        $tsNow = $codeCreatedAt + 1;
+        $dateNow = (new \DateTimeImmutable())->setTimestamp($tsNow);
+        $this->timeFactory->method('now')
+            ->willReturn($dateNow);
+
+        $this->assertEquals($expected, $this->oauthApiController->getToken('authorization_code', 'validcode', null, null, null));
+    }
+
+    public function testGetTokenClientDoesNotExist(): void {
+        // In this test, the token's authorization code is valid and has not expired
+        // and we check what happens when the associated Oauth client does not exist
+        $codeCreatedAt = 100;
+
+        $expected = new JSONResponse([
+            'error' => 'invalid_request',
+        ], Http::STATUS_BAD_REQUEST);
+        $expected->throttle(['invalid_request' => 'client not found', 'client_id' => 42]);
+
+        $accessToken = new AccessToken();
+        $accessToken->setClientId(42);
+        $accessToken->setCodeCreatedAt($codeCreatedAt);
+
+        $this->accessTokenMapper->method('getByCode')
+            ->with('validcode')
+            ->willReturn($accessToken);
+
+        // 'now' is before the token's authorization code expiration
+        $tsNow = $codeCreatedAt + OauthApiController::AUTHORIZATION_CODE_EXPIRES_AFTER - 1;
+        $dateNow = (new \DateTimeImmutable())->setTimestamp($tsNow);
+        $this->timeFactory->method('now')
+            ->willReturn($dateNow);
+
+        $this->clientMapper->method('getByUid')
+            ->with(42)
+            ->willThrowException(new ClientNotFoundException());
+
+        $this->assertEquals($expected, $this->oauthApiController->getToken('authorization_code', 'validcode', null, null, null));
+    }
+
+    public function testRefreshTokenInvalidRefreshToken(): void {
+        $expected = new JSONResponse([
+            'error' => 'invalid_request',
+        ], Http::STATUS_BAD_REQUEST);
+        $expected->throttle(['invalid_request' => 'token not found', 'code' => 'invalidrefresh']);
+
+        $this->accessTokenMapper->method('getByCode')
+            ->with('invalidrefresh')
+            ->willThrowException(new AccessTokenNotFoundException());
+
+        $this->assertEquals($expected, $this->oauthApiController->getToken('refresh_token', null, 'invalidrefresh', null, null));
+    }
+
+    public function testRefreshTokenClientDoesNotExist(): void {
+        $expected = new JSONResponse([
+            'error' => 'invalid_request',
+        ], Http::STATUS_BAD_REQUEST);
+        $expected->throttle(['invalid_request' => 'client not found', 'client_id' => 42]);
+
+        $accessToken = new AccessToken();
+        $accessToken->setClientId(42);
+
+        $this->accessTokenMapper->method('getByCode')
+            ->with('validrefresh')
+            ->willReturn($accessToken);
+
+        $this->clientMapper->method('getByUid')
+            ->with(42)
+            ->willThrowException(new ClientNotFoundException());
+
+        $this->assertEquals($expected, $this->oauthApiController->getToken('refresh_token', null, 'validrefresh', null, null));
+    }
+
+    public static function invalidClientProvider() {
+        return [
+            ['invalidClientId', 'invalidClientSecret'],
+            ['clientId', 'invalidClientSecret'],
+            ['invalidClientId', 'clientSecret'],
+        ];
+    }
+
+    /**
+     *
+     * @param string $clientId
+     * @param string $clientSecret
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('invalidClientProvider')]
+    public function testRefreshTokenInvalidClient($clientId, $clientSecret): void {
+        $expected = new JSONResponse([
+            'error' => 'invalid_client',
+        ], Http::STATUS_BAD_REQUEST);
+        $expected->throttle(['invalid_client' => 'client ID or secret does not match']);
+
+        $accessToken = new AccessToken();
+        $accessToken->setClientId(42);
+
+        $this->accessTokenMapper->method('getByCode')
+            ->with('validrefresh')
+            ->willReturn($accessToken);
+
+        $this->crypto
+            ->method('calculateHMAC')
+            ->with($this->callback(function (string $text) {
+                return $text === 'clientSecret' || $text === 'invalidClientSecret';
+            }))
+            ->willReturnCallback(function (string $text) {
+                return $text === 'clientSecret'
+                    ? 'hashedClientSecret'
+                    : 'hashedInvalidClientSecret';
+            });
+
+        $client = new Client();
+        $client->setClientIdentifier('clientId');
+        $client->setSecret(bin2hex('hashedClientSecret'));
+        $this->clientMapper->method('getByUid')
+            ->with(42)
+            ->willReturn($client);
+
+        $this->assertEquals($expected, $this->oauthApiController->getToken('refresh_token', null, 'validrefresh', $clientId, $clientSecret));
+    }
+
+    public function testRefreshTokenInvalidAppToken(): void {
+        $expected = new JSONResponse([
+            'error' => 'invalid_request',
+        ], Http::STATUS_BAD_REQUEST);
+        $expected->throttle(['invalid_request' => 'token is invalid']);
+
+        $accessToken = new AccessToken();
+        $accessToken->setClientId(42);
+        $accessToken->setTokenId(1337);
+        $accessToken->setEncryptedToken('encryptedToken');
+
+        $this->accessTokenMapper->method('getByCode')
+            ->with('validrefresh')
+            ->willReturn($accessToken);
+
+        $client = new Client();
+        $client->setClientIdentifier('clientId');
+        $client->setSecret(bin2hex('hashedClientSecret'));
+        $this->clientMapper->method('getByUid')
+            ->with(42)
+            ->willReturn($client);
+
+        $this->crypto
+            ->method('decrypt')
+            ->with('encryptedToken')
+            ->willReturn('decryptedToken');
+
+        $this->crypto
+            ->method('calculateHMAC')
+            ->with('clientSecret')
+            ->willReturn('hashedClientSecret');
+
+        $this->tokenProvider->method('getTokenById')
+            ->with(1337)
+            ->willThrowException(new InvalidTokenException());
+
+        $this->accessTokenMapper->expects($this->once())
+            ->method('delete')
+            ->with($accessToken);
+
+        $this->assertEquals($expected, $this->oauthApiController->getToken('refresh_token', null, 'validrefresh', 'clientId', 'clientSecret'));
+    }
+
+    public function testRefreshTokenValidAppToken(): void {
+        $accessToken = new AccessToken();
+        $accessToken->setClientId(42);
+        $accessToken->setTokenId(1337);
+        $accessToken->setEncryptedToken('encryptedToken');
+
+        $this->accessTokenMapper->method('getByCode')
+            ->with('validrefresh')
+            ->willReturn($accessToken);
+
+        $client = new Client();
+        $client->setClientIdentifier('clientId');
+        $client->setSecret(bin2hex('hashedClientSecret'));
+        $this->clientMapper->method('getByUid')
+            ->with(42)
+            ->willReturn($client);
+
+        $this->crypto
+            ->method('decrypt')
+            ->with('encryptedToken')
+            ->willReturn('decryptedToken');
+
+        $this->crypto
+            ->method('calculateHMAC')
+            ->with('clientSecret')
+            ->willReturn('hashedClientSecret');
+
+        $appToken = new PublicKeyToken();
+        $appToken->setUid('userId');
+        $this->tokenProvider->method('getTokenById')
+            ->with(1337)
+            ->willThrowException(new ExpiredTokenException($appToken));
+
+        $this->accessTokenMapper->expects($this->never())
+            ->method('delete')
+            ->with($accessToken);
+
+        $this->secureRandom->method('generate')
+            ->willReturnCallback(function ($len) {
+                return 'random' . $len;
+            });
+
+        $this->tokenProvider->expects($this->once())
+            ->method('rotate')
+            ->with(
+                $appToken,
+                'decryptedToken',
+                'random72'
+            )->willReturn($appToken);
+
+        $this->time->method('getTime')
+            ->willReturn(1000);
+
+        $this->tokenProvider->expects($this->once())
+            ->method('updateToken')
+            ->with(
+                $this->callback(function (PublicKeyToken $token) {
+                    return $token->getExpires() === 4600;
+                })
+            );
+
+        $this->crypto->method('encrypt')
+            ->with('random72', 'random128')
+            ->willReturn('newEncryptedToken');
+
+        $this->accessTokenMapper->expects($this->once())
+            ->method('update')
+            ->with(
+                $this->callback(function (AccessToken $token) {
+                    return $token->getHashedCode() === hash('sha512', 'random128')
+                        && $token->getEncryptedToken() === 'newEncryptedToken';
+                })
+            );
+
+        $expected = new JSONResponse([
+            'access_token' => 'random72',
+            'token_type' => 'Bearer',
+            'expires_in' => 3600,
+            'refresh_token' => 'random128',
+            'user_id' => 'userId',
+        ]);
+
+        $this->request->method('getRemoteAddress')
+            ->willReturn('1.2.3.4');
+
+        $this->throttler->expects($this->once())
+            ->method('resetDelay')
+            ->with(
+                '1.2.3.4',
+                'login',
+                ['user' => 'userId']
+            );
+
+        $this->assertEquals($expected, $this->oauthApiController->getToken('refresh_token', null, 'validrefresh', 'clientId', 'clientSecret'));
+    }
+
+    public function testRefreshTokenValidAppTokenBasicAuth(): void {
+        $accessToken = new AccessToken();
+        $accessToken->setClientId(42);
+        $accessToken->setTokenId(1337);
+        $accessToken->setEncryptedToken('encryptedToken');
+
+        $this->accessTokenMapper->method('getByCode')
+            ->with('validrefresh')
+            ->willReturn($accessToken);
+
+        $client = new Client();
+        $client->setClientIdentifier('clientId');
+        $client->setSecret(bin2hex('hashedClientSecret'));
+        $this->clientMapper->method('getByUid')
+            ->with(42)
+            ->willReturn($client);
+
+        $this->crypto
+            ->method('decrypt')
+            ->with('encryptedToken')
+            ->willReturn('decryptedToken');
+
+        $this->crypto
+            ->method('calculateHMAC')
+            ->with('clientSecret')
+            ->willReturn('hashedClientSecret');
+
+        $appToken = new PublicKeyToken();
+        $appToken->setUid('userId');
+        $this->tokenProvider->method('getTokenById')
+            ->with(1337)
+            ->willThrowException(new ExpiredTokenException($appToken));
+
+        $this->accessTokenMapper->expects($this->never())
+            ->method('delete')
+            ->with($accessToken);
+
+        $this->secureRandom->method('generate')
+            ->willReturnCallback(function ($len) {
+                return 'random' . $len;
+            });
+
+        $this->tokenProvider->expects($this->once())
+            ->method('rotate')
+            ->with(
+                $appToken,
+                'decryptedToken',
+                'random72'
+            )->willReturn($appToken);
+
+        $this->time->method('getTime')
+            ->willReturn(1000);
+
+        $this->tokenProvider->expects($this->once())
+            ->method('updateToken')
+            ->with(
+                $this->callback(function (PublicKeyToken $token) {
+                    return $token->getExpires() === 4600;
+                })
+            );
+
+        $this->crypto->method('encrypt')
+            ->with('random72', 'random128')
+            ->willReturn('newEncryptedToken');
+
+        $this->accessTokenMapper->expects($this->once())
+            ->method('update')
+            ->with(
+                $this->callback(function (AccessToken $token) {
+                    return $token->getHashedCode() === hash('sha512', 'random128')
+                        && $token->getEncryptedToken() === 'newEncryptedToken';
+                })
+            );
+
+        $expected = new JSONResponse([
+            'access_token' => 'random72',
+            'token_type' => 'Bearer',
+            'expires_in' => 3600,
+            'refresh_token' => 'random128',
+            'user_id' => 'userId',
+        ]);
+
+        $this->request->server['PHP_AUTH_USER'] = 'clientId';
+        $this->request->server['PHP_AUTH_PW'] = 'clientSecret';
+
+        $this->request->method('getRemoteAddress')
+            ->willReturn('1.2.3.4');
+
+        $this->throttler->expects($this->once())
+            ->method('resetDelay')
+            ->with(
+                '1.2.3.4',
+                'login',
+                ['user' => 'userId']
+            );
+
+        $this->assertEquals($expected, $this->oauthApiController->getToken('refresh_token', null, 'validrefresh', null, null));
+    }
+
+    public function testRefreshTokenExpiredAppToken(): void {
+        $accessToken = new AccessToken();
+        $accessToken->setClientId(42);
+        $accessToken->setTokenId(1337);
+        $accessToken->setEncryptedToken('encryptedToken');
+
+        $this->accessTokenMapper->method('getByCode')
+            ->with('validrefresh')
+            ->willReturn($accessToken);
+
+        $client = new Client();
+        $client->setClientIdentifier('clientId');
+        $client->setSecret(bin2hex('hashedClientSecret'));
+        $this->clientMapper->method('getByUid')
+            ->with(42)
+            ->willReturn($client);
+
+        $this->crypto
+            ->method('decrypt')
+            ->with('encryptedToken')
+            ->willReturn('decryptedToken');
+
+        $this->crypto
+            ->method('calculateHMAC')
+            ->with('clientSecret')
+            ->willReturn('hashedClientSecret');
+
+        $appToken = new PublicKeyToken();
+        $appToken->setUid('userId');
+        $this->tokenProvider->method('getTokenById')
+            ->with(1337)
+            ->willReturn($appToken);
+
+        $this->accessTokenMapper->expects($this->never())
+            ->method('delete')
+            ->with($accessToken);
+
+        $this->secureRandom->method('generate')
+            ->willReturnCallback(function ($len) {
+                return 'random' . $len;
+            });
+
+        $this->tokenProvider->expects($this->once())
+            ->method('rotate')
+            ->with(
+                $appToken,
+                'decryptedToken',
+                'random72'
+            )->willReturn($appToken);
+
+        $this->time->method('getTime')
+            ->willReturn(1000);
+
+        $this->tokenProvider->expects($this->once())
+            ->method('updateToken')
+            ->with(
+                $this->callback(function (PublicKeyToken $token) {
+                    return $token->getExpires() === 4600;
+                })
+            );
+
+        $this->crypto->method('encrypt')
+            ->with('random72', 'random128')
+            ->willReturn('newEncryptedToken');
+
+        $this->accessTokenMapper->expects($this->once())
+            ->method('update')
+            ->with(
+                $this->callback(function (AccessToken $token) {
+                    return $token->getHashedCode() === hash('sha512', 'random128')
+                        && $token->getEncryptedToken() === 'newEncryptedToken';
+                })
+            );
+
+        $expected = new JSONResponse([
+            'access_token' => 'random72',
+            'token_type' => 'Bearer',
+            'expires_in' => 3600,
+            'refresh_token' => 'random128',
+            'user_id' => 'userId',
+        ]);
+
+        $this->request->method('getRemoteAddress')
+            ->willReturn('1.2.3.4');
+
+        $this->throttler->expects($this->once())
+            ->method('resetDelay')
+            ->with(
+                '1.2.3.4',
+                'login',
+                ['user' => 'userId']
+            );
+
+        $this->assertEquals($expected, $this->oauthApiController->getToken('refresh_token', null, 'validrefresh', 'clientId', 'clientSecret'));
+    }
 }

apps/theming/tests/Themes/AccessibleThemeTestCase.php

Indentation +150 added lines, -150 removed lines

@@ -12,161 +12,161 @@
 use Test\TestCase;
 
 class AccessibleThemeTestCase extends TestCase {
-	protected ITheme $theme;
-	protected Util $util;
+    protected ITheme $theme;
+    protected Util $util;
 
-	/**
-	 * Set to true to check for WCAG AAA level accessibility
-	 */
-	protected static bool $WCAGaaa = false;
+    /**
+     * Set to true to check for WCAG AAA level accessibility
+     */
+    protected static bool $WCAGaaa = false;
 
-	public static function dataAccessibilityPairs(): array {
-		$textContrast = self::$WCAGaaa ? 7.0 : 4.5;
-		$elementContrast = 3.0;
+    public static function dataAccessibilityPairs(): array {
+        $textContrast = self::$WCAGaaa ? 7.0 : 4.5;
+        $elementContrast = 3.0;
 
-		return [
-			'primary-element on background' => [
-				[
-					'--color-primary-element',
-					'--color-primary-element-hover',
-				],
-				[
-					'--color-main-background',
-					'--color-background-hover',
-					'--color-background-dark',
-					'--color-background-darker',
-					'--color-main-background-blur',
-				],
-				$elementContrast,
-			],
-			'status color elements on background' => [
-				[
-					'--color-error',
-					'--color-error-hover',
-					'--color-warning',
-					'--color-warning-hover',
-					'--color-info',
-					'--color-info-hover',
-					'--color-success',
-					'--color-success-hover',
-					'--color-favorite',
-				],
-				[
-					'--color-main-background',
-					'--color-background-hover',
-					'--color-background-dark',
-					'--color-background-darker',
-					'--color-main-background-blur',
-				],
-				$elementContrast,
-			],
-			'border-colors' => [
-				[
-					'--color-border-maxcontrast',
-				],
-				[
-					'--color-main-background',
-					'--color-background-hover',
-					'--color-background-dark',
-					'--color-main-background-blur',
-				],
-				$elementContrast,
-			],
-			// Those two colors are used for borders which will be `color-main-text` on focussed state, thus need 3:1 contrast to it
-			'success-error-border-colors' => [
-				[
-					'--color-error',
-					'--color-success',
-				],
-				[
-					'--color-main-text',
-				],
-				$elementContrast,
-			],
-			'primary-element-text' => [
-				[
-					'--color-primary-element-text',
-					'--color-primary-element-text-dark',
-				],
-				[
-					'--color-primary-element',
-					'--color-primary-element-hover',
-				],
-				$textContrast,
-			],
-			'primary-element-light-text' => [
-				['--color-primary-element-light-text'],
-				[
-					'--color-primary-element-light',
-					'--color-primary-element-light-hover',
-				],
-				$textContrast,
-			],
-			'main-text' => [
-				['--color-main-text'],
-				[
-					'--color-main-background',
-					'--color-background-hover',
-					'--color-background-dark',
-					'--color-background-darker',
-					'--color-main-background-blur',
-				],
-				$textContrast,
-			],
-			'max-contrast-text' => [
-				['--color-text-maxcontrast'],
-				[
-					'--color-main-background',
-					'--color-background-hover',
-					'--color-background-dark',
-				],
-				$textContrast,
-			],
-			'max-contrast text-on blur' => [
-				['--color-text-maxcontrast-background-blur'],
-				[
-					'--color-main-background-blur',
-				],
-				$textContrast,
-			],
-			'status-text' => [
-				[
-					'--color-error-text',
-					'--color-warning-text',
-					'--color-success-text',
-					'--color-info-text',
-				],
-				[
-					'--color-main-background',
-					'--color-background-hover',
-					'--color-background-dark',
-					'--color-main-background-blur',
-				],
-				$textContrast,
-			],
-		];
-	}
+        return [
+            'primary-element on background' => [
+                [
+                    '--color-primary-element',
+                    '--color-primary-element-hover',
+                ],
+                [
+                    '--color-main-background',
+                    '--color-background-hover',
+                    '--color-background-dark',
+                    '--color-background-darker',
+                    '--color-main-background-blur',
+                ],
+                $elementContrast,
+            ],
+            'status color elements on background' => [
+                [
+                    '--color-error',
+                    '--color-error-hover',
+                    '--color-warning',
+                    '--color-warning-hover',
+                    '--color-info',
+                    '--color-info-hover',
+                    '--color-success',
+                    '--color-success-hover',
+                    '--color-favorite',
+                ],
+                [
+                    '--color-main-background',
+                    '--color-background-hover',
+                    '--color-background-dark',
+                    '--color-background-darker',
+                    '--color-main-background-blur',
+                ],
+                $elementContrast,
+            ],
+            'border-colors' => [
+                [
+                    '--color-border-maxcontrast',
+                ],
+                [
+                    '--color-main-background',
+                    '--color-background-hover',
+                    '--color-background-dark',
+                    '--color-main-background-blur',
+                ],
+                $elementContrast,
+            ],
+            // Those two colors are used for borders which will be `color-main-text` on focussed state, thus need 3:1 contrast to it
+            'success-error-border-colors' => [
+                [
+                    '--color-error',
+                    '--color-success',
+                ],
+                [
+                    '--color-main-text',
+                ],
+                $elementContrast,
+            ],
+            'primary-element-text' => [
+                [
+                    '--color-primary-element-text',
+                    '--color-primary-element-text-dark',
+                ],
+                [
+                    '--color-primary-element',
+                    '--color-primary-element-hover',
+                ],
+                $textContrast,
+            ],
+            'primary-element-light-text' => [
+                ['--color-primary-element-light-text'],
+                [
+                    '--color-primary-element-light',
+                    '--color-primary-element-light-hover',
+                ],
+                $textContrast,
+            ],
+            'main-text' => [
+                ['--color-main-text'],
+                [
+                    '--color-main-background',
+                    '--color-background-hover',
+                    '--color-background-dark',
+                    '--color-background-darker',
+                    '--color-main-background-blur',
+                ],
+                $textContrast,
+            ],
+            'max-contrast-text' => [
+                ['--color-text-maxcontrast'],
+                [
+                    '--color-main-background',
+                    '--color-background-hover',
+                    '--color-background-dark',
+                ],
+                $textContrast,
+            ],
+            'max-contrast text-on blur' => [
+                ['--color-text-maxcontrast-background-blur'],
+                [
+                    '--color-main-background-blur',
+                ],
+                $textContrast,
+            ],
+            'status-text' => [
+                [
+                    '--color-error-text',
+                    '--color-warning-text',
+                    '--color-success-text',
+                    '--color-info-text',
+                ],
+                [
+                    '--color-main-background',
+                    '--color-background-hover',
+                    '--color-background-dark',
+                    '--color-main-background-blur',
+                ],
+                $textContrast,
+            ],
+        ];
+    }
 
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataAccessibilityPairs')]
-	public function testAccessibilityOfVariables(array $mainColors, array $backgroundColors, float $minContrast): void {
-		if (!isset($this->theme)) {
-			$this->markTestSkipped('You need to setup $this->theme in your setUp function');
-		} elseif (!isset($this->util)) {
-			$this->markTestSkipped('You need to setup $this->util in your setUp function');
-		}
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataAccessibilityPairs')]
+    public function testAccessibilityOfVariables(array $mainColors, array $backgroundColors, float $minContrast): void {
+        if (!isset($this->theme)) {
+            $this->markTestSkipped('You need to setup $this->theme in your setUp function');
+        } elseif (!isset($this->util)) {
+            $this->markTestSkipped('You need to setup $this->util in your setUp function');
+        }
 
-		$variables = $this->theme->getCSSVariables();
+        $variables = $this->theme->getCSSVariables();
 
-		// Blur effect does not work so we mockup the color - worst supported case is the default "clouds" background image (on dark themes the clouds with white color are bad on bright themes the primary color as sky is bad)
-		$variables['--color-main-background-blur'] = $this->util->mix($variables['--color-main-background'], $this->util->isBrightColor($variables['--color-main-background']) ? '#000000' : '#ffffff', 75);
+        // Blur effect does not work so we mockup the color - worst supported case is the default "clouds" background image (on dark themes the clouds with white color are bad on bright themes the primary color as sky is bad)
+        $variables['--color-main-background-blur'] = $this->util->mix($variables['--color-main-background'], $this->util->isBrightColor($variables['--color-main-background']) ? '#000000' : '#ffffff', 75);
 
-		foreach ($backgroundColors as $background) {
-			$this->assertStringStartsWith('#', $variables[$background], 'Is not a plain color variable - consider to remove or fix this test');
-			foreach ($mainColors as $main) {
-				$this->assertStringStartsWith('#', $variables[$main], 'Is not a plain color variable - consider to remove or fix this test');
-				$realContrast = $this->util->colorContrast($variables[$main], $variables[$background]);
-				$this->assertGreaterThanOrEqual($minContrast, $realContrast, "Contrast is not high enough for $main (" . $variables[$main] . ") on $background (" . $variables[$background] . ')');
-			}
-		}
-	}
+        foreach ($backgroundColors as $background) {
+            $this->assertStringStartsWith('#', $variables[$background], 'Is not a plain color variable - consider to remove or fix this test');
+            foreach ($mainColors as $main) {
+                $this->assertStringStartsWith('#', $variables[$main], 'Is not a plain color variable - consider to remove or fix this test');
+                $realContrast = $this->util->colorContrast($variables[$main], $variables[$background]);
+                $this->assertGreaterThanOrEqual($minContrast, $realContrast, "Contrast is not high enough for $main (" . $variables[$main] . ") on $background (" . $variables[$background] . ')');
+            }
+        }
+    }
 }

apps/theming/tests/Themes/DyslexiaFontTest.php

Indentation +133 added lines, -133 removed lines

@@ -27,137 +27,137 @@
 use Test\TestCase;
 
 class DyslexiaFontTest extends TestCase {
-	private ThemingDefaults&MockObject $themingDefaults;
-	private IUserSession&MockObject $userSession;
-	private IURLGenerator $urlGenerator;
-	private ImageManager&MockObject $imageManager;
-	private IConfig&MockObject $config;
-	private IL10N&MockObject $l10n;
-	private IAppManager&MockObject $appManager;
-
-	private DyslexiaFont $dyslexiaFont;
-
-	protected function setUp(): void {
-		$this->themingDefaults = $this->createMock(ThemingDefaults::class);
-		$this->userSession = $this->createMock(IUserSession::class);
-		$this->imageManager = $this->createMock(ImageManager::class);
-		$this->config = $this->createMock(IConfig::class);
-		$this->l10n = $this->createMock(IL10N::class);
-		$this->appManager = $this->createMock(IAppManager::class);
-
-		$util = new Util(
-			$this->createMock(ServerVersion::class),
-			$this->config,
-			$this->appManager,
-			$this->createMock(IAppData::class),
-			$this->imageManager
-		);
-
-		$userSession = $this->createMock(IUserSession::class);
-		$cacheFactory = $this->createMock(ICacheFactory::class);
-		$request = $this->createMock(IRequest::class);
-		$router = $this->createMock(Router::class);
-		$this->urlGenerator = new URLGenerator(
-			$this->config,
-			$userSession,
-			$cacheFactory,
-			$request,
-			$router
-		);
-
-		$this->themingDefaults
-			->expects($this->any())
-			->method('getColorPrimary')
-			->willReturn('#0082c9');
-
-		$this->themingDefaults
-			->expects($this->any())
-			->method('getDefaultColorPrimary')
-			->willReturn('#0082c9');
-
-		$this->themingDefaults
-			->expects($this->any())
-			->method('getColorBackground')
-			->willReturn('#0082c9');
-
-		$this->themingDefaults
-			->expects($this->any())
-			->method('getDefaultColorBackground')
-			->willReturn('#0082c9');
-
-		$this->l10n
-			->expects($this->any())
-			->method('t')
-			->willReturnCallback(function ($text, $parameters = []) {
-				return vsprintf($text, $parameters);
-			});
-
-		$this->dyslexiaFont = new DyslexiaFont(
-			$util,
-			$this->themingDefaults,
-			$this->userSession,
-			$this->urlGenerator,
-			$this->imageManager,
-			$this->config,
-			$this->l10n,
-			$this->appManager,
-			null,
-		);
-
-		parent::setUp();
-	}
-
-
-	public function testGetId(): void {
-		$this->assertEquals('opendyslexic', $this->dyslexiaFont->getId());
-	}
-
-	public function testGetType(): void {
-		$this->assertEquals(ITheme::TYPE_FONT, $this->dyslexiaFont->getType());
-	}
-
-	public function testGetTitle(): void {
-		$this->assertNotEmpty($this->dyslexiaFont->getTitle());
-	}
-
-	public function testGetEnableLabel(): void {
-		$this->assertNotEmpty($this->dyslexiaFont->getEnableLabel());
-	}
-
-	public function testGetDescription(): void {
-		$this->assertNotEmpty($this->dyslexiaFont->getDescription());
-	}
-
-	public function testGetMediaQuery(): void {
-		$this->assertEquals('', $this->dyslexiaFont->getMediaQuery());
-	}
-
-	public function testGetCSSVariables(): void {
-		$this->assertStringStartsWith('OpenDyslexic', $this->dyslexiaFont->getCSSVariables()['--font-face']);
-	}
-
-	public static function dataTestGetCustomCss(): array {
-		return [
-			['', true],
-			['', false],
-			['/subfolder', true],
-			['/subfolder', false],
-		];
-	}
-
-	/**
-	 * Ensure the fonts are always loaded from the web root
-	 * despite having url rewriting enabled or not
-	 */
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataTestGetCustomCss')]
-	public function testGetCustomCss(string $webRoot, bool $prettyUrlsEnabled): void {
-		\OC::$WEBROOT = $webRoot;
-		$this->config->expects($this->any())
-			->method('getSystemValue')
-			->with('htaccess.IgnoreFrontController', false)
-			->willReturn($prettyUrlsEnabled);
-
-		$this->assertStringContainsString("'$webRoot/apps/theming/fonts/OpenDyslexic-Regular.otf'", $this->dyslexiaFont->getCustomCss());
-		$this->assertStringNotContainsString('index.php', $this->dyslexiaFont->getCustomCss());
-	}
+    private ThemingDefaults&MockObject $themingDefaults;
+    private IUserSession&MockObject $userSession;
+    private IURLGenerator $urlGenerator;
+    private ImageManager&MockObject $imageManager;
+    private IConfig&MockObject $config;
+    private IL10N&MockObject $l10n;
+    private IAppManager&MockObject $appManager;
+
+    private DyslexiaFont $dyslexiaFont;
+
+    protected function setUp(): void {
+        $this->themingDefaults = $this->createMock(ThemingDefaults::class);
+        $this->userSession = $this->createMock(IUserSession::class);
+        $this->imageManager = $this->createMock(ImageManager::class);
+        $this->config = $this->createMock(IConfig::class);
+        $this->l10n = $this->createMock(IL10N::class);
+        $this->appManager = $this->createMock(IAppManager::class);
+
+        $util = new Util(
+            $this->createMock(ServerVersion::class),
+            $this->config,
+            $this->appManager,
+            $this->createMock(IAppData::class),
+            $this->imageManager
+        );
+
+        $userSession = $this->createMock(IUserSession::class);
+        $cacheFactory = $this->createMock(ICacheFactory::class);
+        $request = $this->createMock(IRequest::class);
+        $router = $this->createMock(Router::class);
+        $this->urlGenerator = new URLGenerator(
+            $this->config,
+            $userSession,
+            $cacheFactory,
+            $request,
+            $router
+        );
+
+        $this->themingDefaults
+            ->expects($this->any())
+            ->method('getColorPrimary')
+            ->willReturn('#0082c9');
+
+        $this->themingDefaults
+            ->expects($this->any())
+            ->method('getDefaultColorPrimary')
+            ->willReturn('#0082c9');
+
+        $this->themingDefaults
+            ->expects($this->any())
+            ->method('getColorBackground')
+            ->willReturn('#0082c9');
+
+        $this->themingDefaults
+            ->expects($this->any())
+            ->method('getDefaultColorBackground')
+            ->willReturn('#0082c9');
+
+        $this->l10n
+            ->expects($this->any())
+            ->method('t')
+            ->willReturnCallback(function ($text, $parameters = []) {
+                return vsprintf($text, $parameters);
+            });
+
+        $this->dyslexiaFont = new DyslexiaFont(
+            $util,
+            $this->themingDefaults,
+            $this->userSession,
+            $this->urlGenerator,
+            $this->imageManager,
+            $this->config,
+            $this->l10n,
+            $this->appManager,
+            null,
+        );
+
+        parent::setUp();
+    }
+
+
+    public function testGetId(): void {
+        $this->assertEquals('opendyslexic', $this->dyslexiaFont->getId());
+    }
+
+    public function testGetType(): void {
+        $this->assertEquals(ITheme::TYPE_FONT, $this->dyslexiaFont->getType());
+    }
+
+    public function testGetTitle(): void {
+        $this->assertNotEmpty($this->dyslexiaFont->getTitle());
+    }
+
+    public function testGetEnableLabel(): void {
+        $this->assertNotEmpty($this->dyslexiaFont->getEnableLabel());
+    }
+
+    public function testGetDescription(): void {
+        $this->assertNotEmpty($this->dyslexiaFont->getDescription());
+    }
+
+    public function testGetMediaQuery(): void {
+        $this->assertEquals('', $this->dyslexiaFont->getMediaQuery());
+    }
+
+    public function testGetCSSVariables(): void {
+        $this->assertStringStartsWith('OpenDyslexic', $this->dyslexiaFont->getCSSVariables()['--font-face']);
+    }
+
+    public static function dataTestGetCustomCss(): array {
+        return [
+            ['', true],
+            ['', false],
+            ['/subfolder', true],
+            ['/subfolder', false],
+        ];
+    }
+
+    /**
+     * Ensure the fonts are always loaded from the web root
+     * despite having url rewriting enabled or not
+     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataTestGetCustomCss')]
+    public function testGetCustomCss(string $webRoot, bool $prettyUrlsEnabled): void {
+        \OC::$WEBROOT = $webRoot;
+        $this->config->expects($this->any())
+            ->method('getSystemValue')
+            ->with('htaccess.IgnoreFrontController', false)
+            ->willReturn($prettyUrlsEnabled);
+
+        $this->assertStringContainsString("'$webRoot/apps/theming/fonts/OpenDyslexic-Regular.otf'", $this->dyslexiaFont->getCustomCss());
+        $this->assertStringNotContainsString('index.php', $this->dyslexiaFont->getCustomCss());
+    }
 }