nextcloud / server

apps/dav/tests/integration/UserMigration/CalendarMigratorTest.php

Indentation +88 added lines, -88 removed lines

@@ -27,92 +27,92 @@
  */
 class CalendarMigratorTest extends TestCase {
 
-	private IUserManager $userManager;
-
-	private CalendarMigrator $migrator;
-
-	private OutputInterface $output;
-
-	private const ASSETS_DIR = __DIR__ . '/assets/calendars/';
-
-	protected function setUp(): void {
-		$app = new App(Application::APP_ID);
-		$container = $app->getContainer();
-
-		$this->userManager = $container->get(IUserManager::class);
-		$this->migrator = $container->get(CalendarMigrator::class);
-		$this->output = $this->createMock(OutputInterface::class);
-	}
-
-	public static function dataAssets(): array {
-		return array_map(
-			function (string $filename) {
-				/** @var VCalendar $vCalendar */
-				$vCalendar = VObjectReader::read(
-					fopen(self::ASSETS_DIR . $filename, 'r'),
-					VObjectReader::OPTION_FORGIVING,
-				);
-				[$initialCalendarUri, $ext] = explode('.', $filename, 2);
-				return [UUIDUtil::getUUID(), $filename, $initialCalendarUri, $vCalendar];
-			},
-			array_diff(
-				scandir(self::ASSETS_DIR),
-				// Exclude current and parent directories
-				['.', '..'],
-			),
-		);
-	}
-
-	private function getProperties(VCalendar $vCalendar): array {
-		return array_map(
-			fn (VObjectProperty $property) => $property->serialize(),
-			array_values(array_filter(
-				$vCalendar->children(),
-				fn ($child) => $child instanceof VObjectProperty,
-			)),
-		);
-	}
-
-	private function getComponents(VCalendar $vCalendar): array {
-		return array_map(
-			// Elements of the serialized blob are sorted
-			fn (VObjectComponent $component) => $component->serialize(),
-			$vCalendar->getComponents(),
-		);
-	}
-
-	private function getSanitizedComponents(VCalendar $vCalendar): array {
-		return array_map(
-			// Elements of the serialized blob are sorted
-			fn (VObjectComponent $component) => $this->invokePrivate($this->migrator, 'sanitizeComponent', [$component])->serialize(),
-			$vCalendar->getComponents(),
-		);
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataAssets')]
-	public function testImportExportAsset(string $userId, string $filename, string $initialCalendarUri, VCalendar $importCalendar): void {
-		$user = $this->userManager->createUser($userId, 'topsecretpassword');
-
-		$problems = $importCalendar->validate();
-		$this->assertEmpty($problems);
-
-		$this->invokePrivate($this->migrator, 'importCalendar', [$user, $filename, $initialCalendarUri, $importCalendar, $this->output]);
-
-		$calendarExports = $this->invokePrivate($this->migrator, 'getCalendarExports', [$user, $this->output]);
-		$this->assertCount(1, $calendarExports);
-
-		/** @var VCalendar $exportCalendar */
-		['vCalendar' => $exportCalendar] = reset($calendarExports);
-
-		$this->assertEqualsCanonicalizing(
-			$this->getProperties($importCalendar),
-			$this->getProperties($exportCalendar),
-		);
-
-		$this->assertEqualsCanonicalizing(
-			// Components are expected to be sanitized on import
-			$this->getSanitizedComponents($importCalendar),
-			$this->getComponents($exportCalendar),
-		);
-	}
+    private IUserManager $userManager;
+
+    private CalendarMigrator $migrator;
+
+    private OutputInterface $output;
+
+    private const ASSETS_DIR = __DIR__ . '/assets/calendars/';
+
+    protected function setUp(): void {
+        $app = new App(Application::APP_ID);
+        $container = $app->getContainer();
+
+        $this->userManager = $container->get(IUserManager::class);
+        $this->migrator = $container->get(CalendarMigrator::class);
+        $this->output = $this->createMock(OutputInterface::class);
+    }
+
+    public static function dataAssets(): array {
+        return array_map(
+            function (string $filename) {
+                /** @var VCalendar $vCalendar */
+                $vCalendar = VObjectReader::read(
+                    fopen(self::ASSETS_DIR . $filename, 'r'),
+                    VObjectReader::OPTION_FORGIVING,
+                );
+                [$initialCalendarUri, $ext] = explode('.', $filename, 2);
+                return [UUIDUtil::getUUID(), $filename, $initialCalendarUri, $vCalendar];
+            },
+            array_diff(
+                scandir(self::ASSETS_DIR),
+                // Exclude current and parent directories
+                ['.', '..'],
+            ),
+        );
+    }
+
+    private function getProperties(VCalendar $vCalendar): array {
+        return array_map(
+            fn (VObjectProperty $property) => $property->serialize(),
+            array_values(array_filter(
+                $vCalendar->children(),
+                fn ($child) => $child instanceof VObjectProperty,
+            )),
+        );
+    }
+
+    private function getComponents(VCalendar $vCalendar): array {
+        return array_map(
+            // Elements of the serialized blob are sorted
+            fn (VObjectComponent $component) => $component->serialize(),
+            $vCalendar->getComponents(),
+        );
+    }
+
+    private function getSanitizedComponents(VCalendar $vCalendar): array {
+        return array_map(
+            // Elements of the serialized blob are sorted
+            fn (VObjectComponent $component) => $this->invokePrivate($this->migrator, 'sanitizeComponent', [$component])->serialize(),
+            $vCalendar->getComponents(),
+        );
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataAssets')]
+    public function testImportExportAsset(string $userId, string $filename, string $initialCalendarUri, VCalendar $importCalendar): void {
+        $user = $this->userManager->createUser($userId, 'topsecretpassword');
+
+        $problems = $importCalendar->validate();
+        $this->assertEmpty($problems);
+
+        $this->invokePrivate($this->migrator, 'importCalendar', [$user, $filename, $initialCalendarUri, $importCalendar, $this->output]);
+
+        $calendarExports = $this->invokePrivate($this->migrator, 'getCalendarExports', [$user, $this->output]);
+        $this->assertCount(1, $calendarExports);
+
+        /** @var VCalendar $exportCalendar */
+        ['vCalendar' => $exportCalendar] = reset($calendarExports);
+
+        $this->assertEqualsCanonicalizing(
+            $this->getProperties($importCalendar),
+            $this->getProperties($exportCalendar),
+        );
+
+        $this->assertEqualsCanonicalizing(
+            // Components are expected to be sanitized on import
+            $this->getSanitizedComponents($importCalendar),
+            $this->getComponents($exportCalendar),
+        );
+    }
 }

Spacing +3 added lines, -3 removed lines

@@ -33,7 +33,7 @@ 
 
 	private OutputInterface $output;
 
-	private const ASSETS_DIR = __DIR__ . '/assets/calendars/';
+	private const ASSETS_DIR = __DIR__.'/assets/calendars/';
 
 	protected function setUp(): void {
 		$app = new App(Application::APP_ID);
@@ -46,10 +46,10 @@ 
 
 	public static function dataAssets(): array {
 		return array_map(
-			function (string $filename) {
+			function(string $filename) {
 				/** @var VCalendar $vCalendar */
 				$vCalendar = VObjectReader::read(
-					fopen(self::ASSETS_DIR . $filename, 'r'),
+					fopen(self::ASSETS_DIR.$filename, 'r'),
 					VObjectReader::OPTION_FORGIVING,
 				);
 				[$initialCalendarUri, $ext] = explode('.', $filename, 2);

apps/files_external/tests/FrontendDefinitionTraitTest.php

Indentation +92 added lines, -92 removed lines

@@ -12,96 +12,96 @@
 use OCA\Files_External\Lib\StorageConfig;
 
 class FrontendDefinitionTraitTest extends \Test\TestCase {
-	public function testJsonSerialization(): void {
-		$param = $this->getMockBuilder(DefinitionParameter::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$param->method('getName')->willReturn('foo');
-
-		$trait = $this->getMockForTrait(FrontendDefinitionTrait::class);
-		$trait->setText('test');
-		$trait->addParameters([$param]);
-		$trait->addCustomJs('foo/bar.js');
-		$trait->addCustomJs('bar/foo.js');
-
-		$json = $trait->jsonSerializeDefinition();
-
-		$this->assertEquals('test', $json['name']);
-		$this->assertContains('foo/bar.js', $json['custom']);
-		$this->assertContains('bar/foo.js', $json['custom']);
-
-		$configuration = $json['configuration'];
-		$this->assertArrayHasKey('foo', $configuration);
-	}
-
-	public static function validateStorageProvider(): array {
-		return [
-			[true, ['foo' => true, 'bar' => true, 'baz' => true]],
-			[false, ['foo' => true, 'bar' => false]]
-		];
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('validateStorageProvider')]
-	public function testValidateStorage(bool $expectedSuccess, array $params): void {
-		$backendParams = [];
-		foreach ($params as $name => $valid) {
-			$param = $this->getMockBuilder(DefinitionParameter::class)
-				->disableOriginalConstructor()
-				->getMock();
-			$param->method('getName')
-				->willReturn($name);
-			$param->method('isOptional')
-				->willReturn(false);
-			$param->expects($this->once())
-				->method('validateValue')
-				->willReturn($valid);
-			$backendParams[] = $param;
-		}
-
-		$storageConfig = $this->getMockBuilder(StorageConfig::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$storageConfig->expects($this->any())
-			->method('getBackendOption')
-			->willReturn(null);
-		$storageConfig->expects($this->any())
-			->method('setBackendOption');
-
-		$trait = $this->getMockForTrait(FrontendDefinitionTrait::class);
-		$trait->setText('test');
-		$trait->addParameters($backendParams);
-
-		$this->assertEquals($expectedSuccess, $trait->validateStorageDefinition($storageConfig));
-	}
-
-	public function testValidateStorageSet(): void {
-		$param = $this->getMockBuilder(DefinitionParameter::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$param->method('getName')
-			->willReturn('param');
-		$param->expects($this->once())
-			->method('validateValue')
-			->willReturnCallback(function (&$value) {
-				$value = 'foobar';
-				return true;
-			});
-
-		$storageConfig = $this->getMockBuilder(StorageConfig::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$storageConfig->expects($this->once())
-			->method('getBackendOption')
-			->with('param')
-			->willReturn('barfoo');
-		$storageConfig->expects($this->once())
-			->method('setBackendOption')
-			->with('param', 'foobar');
-
-		$trait = $this->getMockForTrait(FrontendDefinitionTrait::class);
-		$trait->setText('test');
-		$trait->addParameter($param);
-
-		$this->assertEquals(true, $trait->validateStorageDefinition($storageConfig));
-	}
+    public function testJsonSerialization(): void {
+        $param = $this->getMockBuilder(DefinitionParameter::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $param->method('getName')->willReturn('foo');
+
+        $trait = $this->getMockForTrait(FrontendDefinitionTrait::class);
+        $trait->setText('test');
+        $trait->addParameters([$param]);
+        $trait->addCustomJs('foo/bar.js');
+        $trait->addCustomJs('bar/foo.js');
+
+        $json = $trait->jsonSerializeDefinition();
+
+        $this->assertEquals('test', $json['name']);
+        $this->assertContains('foo/bar.js', $json['custom']);
+        $this->assertContains('bar/foo.js', $json['custom']);
+
+        $configuration = $json['configuration'];
+        $this->assertArrayHasKey('foo', $configuration);
+    }
+
+    public static function validateStorageProvider(): array {
+        return [
+            [true, ['foo' => true, 'bar' => true, 'baz' => true]],
+            [false, ['foo' => true, 'bar' => false]]
+        ];
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('validateStorageProvider')]
+    public function testValidateStorage(bool $expectedSuccess, array $params): void {
+        $backendParams = [];
+        foreach ($params as $name => $valid) {
+            $param = $this->getMockBuilder(DefinitionParameter::class)
+                ->disableOriginalConstructor()
+                ->getMock();
+            $param->method('getName')
+                ->willReturn($name);
+            $param->method('isOptional')
+                ->willReturn(false);
+            $param->expects($this->once())
+                ->method('validateValue')
+                ->willReturn($valid);
+            $backendParams[] = $param;
+        }
+
+        $storageConfig = $this->getMockBuilder(StorageConfig::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $storageConfig->expects($this->any())
+            ->method('getBackendOption')
+            ->willReturn(null);
+        $storageConfig->expects($this->any())
+            ->method('setBackendOption');
+
+        $trait = $this->getMockForTrait(FrontendDefinitionTrait::class);
+        $trait->setText('test');
+        $trait->addParameters($backendParams);
+
+        $this->assertEquals($expectedSuccess, $trait->validateStorageDefinition($storageConfig));
+    }
+
+    public function testValidateStorageSet(): void {
+        $param = $this->getMockBuilder(DefinitionParameter::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $param->method('getName')
+            ->willReturn('param');
+        $param->expects($this->once())
+            ->method('validateValue')
+            ->willReturnCallback(function (&$value) {
+                $value = 'foobar';
+                return true;
+            });
+
+        $storageConfig = $this->getMockBuilder(StorageConfig::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $storageConfig->expects($this->once())
+            ->method('getBackendOption')
+            ->with('param')
+            ->willReturn('barfoo');
+        $storageConfig->expects($this->once())
+            ->method('setBackendOption')
+            ->with('param', 'foobar');
+
+        $trait = $this->getMockForTrait(FrontendDefinitionTrait::class);
+        $trait->setText('test');
+        $trait->addParameter($param);
+
+        $this->assertEquals(true, $trait->validateStorageDefinition($storageConfig));
+    }
 }

apps/files_external/tests/Auth/Password/GlobalAuthTest.php

Indentation +76 added lines, -76 removed lines

@@ -17,80 +17,80 @@
 use Test\TestCase;
 
 class GlobalAuthTest extends TestCase {
-	private IL10N&MockObject $l10n;
-	private ICredentialsManager&MockObject $credentialsManager;
-	private GlobalAuth $instance;
-
-	protected function setUp(): void {
-		parent::setUp();
-		$this->l10n = $this->createMock(IL10N::class);
-		$this->credentialsManager = $this->createMock(ICredentialsManager::class);
-		$this->instance = new GlobalAuth($this->l10n, $this->credentialsManager);
-	}
-
-	private function getStorageConfig($type, $config = []) {
-		/** @var StorageConfig&MockObject $storageConfig */
-		$storageConfig = $this->createMock(StorageConfig::class);
-		$storageConfig->expects($this->any())
-			->method('getType')
-			->willReturn($type);
-		$storageConfig->expects($this->any())
-			->method('getBackendOptions')
-			->willReturnCallback(function () use (&$config) {
-				return $config;
-			});
-		$storageConfig->expects($this->any())
-			->method('getBackendOption')
-			->willReturnCallback(function ($key) use (&$config) {
-				return $config[$key];
-			});
-		$storageConfig->expects($this->any())
-			->method('setBackendOption')
-			->willReturnCallback(function ($key, $value) use (&$config): void {
-				$config[$key] = $value;
-			});
-
-		return $storageConfig;
-	}
-
-	public function testNoCredentials(): void {
-		$this->credentialsManager->expects($this->once())
-			->method('retrieve')
-			->willReturn(null);
-
-		$storage = $this->getStorageConfig(StorageConfig::MOUNT_TYPE_ADMIN);
-
-		$this->instance->manipulateStorageConfig($storage);
-		$this->assertEquals([], $storage->getBackendOptions());
-	}
-
-	public function testSavedCredentials(): void {
-		$this->credentialsManager->expects($this->once())
-			->method('retrieve')
-			->willReturn([
-				'user' => 'a',
-				'password' => 'b'
-			]);
-
-		$storage = $this->getStorageConfig(StorageConfig::MOUNT_TYPE_ADMIN);
-
-		$this->instance->manipulateStorageConfig($storage);
-		$this->assertEquals([
-			'user' => 'a',
-			'password' => 'b'
-		], $storage->getBackendOptions());
-	}
-
-
-	public function testNoCredentialsPersonal(): void {
-		$this->expectException(InsufficientDataForMeaningfulAnswerException::class);
-
-		$this->credentialsManager->expects($this->never())
-			->method('retrieve');
-
-		$storage = $this->getStorageConfig(StorageConfig::MOUNT_TYPE_PERSONAL);
-
-		$this->instance->manipulateStorageConfig($storage);
-		$this->assertEquals([], $storage->getBackendOptions());
-	}
+    private IL10N&MockObject $l10n;
+    private ICredentialsManager&MockObject $credentialsManager;
+    private GlobalAuth $instance;
+
+    protected function setUp(): void {
+        parent::setUp();
+        $this->l10n = $this->createMock(IL10N::class);
+        $this->credentialsManager = $this->createMock(ICredentialsManager::class);
+        $this->instance = new GlobalAuth($this->l10n, $this->credentialsManager);
+    }
+
+    private function getStorageConfig($type, $config = []) {
+        /** @var StorageConfig&MockObject $storageConfig */
+        $storageConfig = $this->createMock(StorageConfig::class);
+        $storageConfig->expects($this->any())
+            ->method('getType')
+            ->willReturn($type);
+        $storageConfig->expects($this->any())
+            ->method('getBackendOptions')
+            ->willReturnCallback(function () use (&$config) {
+                return $config;
+            });
+        $storageConfig->expects($this->any())
+            ->method('getBackendOption')
+            ->willReturnCallback(function ($key) use (&$config) {
+                return $config[$key];
+            });
+        $storageConfig->expects($this->any())
+            ->method('setBackendOption')
+            ->willReturnCallback(function ($key, $value) use (&$config): void {
+                $config[$key] = $value;
+            });
+
+        return $storageConfig;
+    }
+
+    public function testNoCredentials(): void {
+        $this->credentialsManager->expects($this->once())
+            ->method('retrieve')
+            ->willReturn(null);
+
+        $storage = $this->getStorageConfig(StorageConfig::MOUNT_TYPE_ADMIN);
+
+        $this->instance->manipulateStorageConfig($storage);
+        $this->assertEquals([], $storage->getBackendOptions());
+    }
+
+    public function testSavedCredentials(): void {
+        $this->credentialsManager->expects($this->once())
+            ->method('retrieve')
+            ->willReturn([
+                'user' => 'a',
+                'password' => 'b'
+            ]);
+
+        $storage = $this->getStorageConfig(StorageConfig::MOUNT_TYPE_ADMIN);
+
+        $this->instance->manipulateStorageConfig($storage);
+        $this->assertEquals([
+            'user' => 'a',
+            'password' => 'b'
+        ], $storage->getBackendOptions());
+    }
+
+
+    public function testNoCredentialsPersonal(): void {
+        $this->expectException(InsufficientDataForMeaningfulAnswerException::class);
+
+        $this->credentialsManager->expects($this->never())
+            ->method('retrieve');
+
+        $storage = $this->getStorageConfig(StorageConfig::MOUNT_TYPE_PERSONAL);
+
+        $this->instance->manipulateStorageConfig($storage);
+        $this->assertEquals([], $storage->getBackendOptions());
+    }
 }

apps/files_external/tests/Auth/AuthMechanismTest.php

Indentation +47 added lines, -47 removed lines

@@ -13,51 +13,51 @@
 use OCA\Files_External\Lib\StorageConfig;
 
 class AuthMechanismTest extends \Test\TestCase {
-	public function testJsonSerialization(): void {
-		$mechanism = $this->getMockBuilder(AuthMechanism::class)
-			->onlyMethods(['jsonSerializeDefinition'])
-			->getMock();
-		$mechanism->expects($this->once())
-			->method('jsonSerializeDefinition')
-			->willReturn(['foo' => 'bar']);
-
-		$mechanism->setScheme('scheme');
-
-		$json = $mechanism->jsonSerialize();
-		$this->assertEquals('bar', $json['foo']);
-		$this->assertEquals('scheme', $json['scheme']);
-	}
-
-	public static function validateStorageProvider(): array {
-		return [
-			[true, 'scheme', true],
-			[false, 'scheme', false],
-			[true, 'foobar', true],
-			[false, 'barfoo', true],
-		];
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('validateStorageProvider')]
-	public function testValidateStorage(bool $expectedSuccess, string $scheme, bool $definitionSuccess): void {
-		$mechanism = $this->getMockBuilder(AuthMechanism::class)
-			->onlyMethods(['validateStorageDefinition'])
-			->getMock();
-		$mechanism->expects($this->atMost(1))
-			->method('validateStorageDefinition')
-			->willReturn($definitionSuccess);
-
-		$mechanism->setScheme($scheme);
-
-		$backend = $this->createMock(Backend::class);
-		$backend->expects($this->once())
-			->method('getAuthSchemes')
-			->willReturn(['scheme' => true, 'foobar' => true]);
-
-		$storageConfig = $this->createMock(StorageConfig::class);
-		$storageConfig->expects($this->once())
-			->method('getBackend')
-			->willReturn($backend);
-
-		$this->assertEquals($expectedSuccess, $mechanism->validateStorage($storageConfig));
-	}
+    public function testJsonSerialization(): void {
+        $mechanism = $this->getMockBuilder(AuthMechanism::class)
+            ->onlyMethods(['jsonSerializeDefinition'])
+            ->getMock();
+        $mechanism->expects($this->once())
+            ->method('jsonSerializeDefinition')
+            ->willReturn(['foo' => 'bar']);
+
+        $mechanism->setScheme('scheme');
+
+        $json = $mechanism->jsonSerialize();
+        $this->assertEquals('bar', $json['foo']);
+        $this->assertEquals('scheme', $json['scheme']);
+    }
+
+    public static function validateStorageProvider(): array {
+        return [
+            [true, 'scheme', true],
+            [false, 'scheme', false],
+            [true, 'foobar', true],
+            [false, 'barfoo', true],
+        ];
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('validateStorageProvider')]
+    public function testValidateStorage(bool $expectedSuccess, string $scheme, bool $definitionSuccess): void {
+        $mechanism = $this->getMockBuilder(AuthMechanism::class)
+            ->onlyMethods(['validateStorageDefinition'])
+            ->getMock();
+        $mechanism->expects($this->atMost(1))
+            ->method('validateStorageDefinition')
+            ->willReturn($definitionSuccess);
+
+        $mechanism->setScheme($scheme);
+
+        $backend = $this->createMock(Backend::class);
+        $backend->expects($this->once())
+            ->method('getAuthSchemes')
+            ->willReturn(['scheme' => true, 'foobar' => true]);
+
+        $storageConfig = $this->createMock(StorageConfig::class);
+        $storageConfig->expects($this->once())
+            ->method('getBackend')
+            ->willReturn($backend);
+
+        $this->assertEquals($expectedSuccess, $mechanism->validateStorage($storageConfig));
+    }
 }

apps/files_external/tests/Storage/SftpTest.php

Indentation +108 added lines, -108 removed lines

@@ -18,119 +18,119 @@
  * @package OCA\Files_External\Tests\Storage
  */
 class SftpTest extends \Test\Files\Storage\Storage {
-	/**
-	 * @var SFTP instance
-	 */
-	protected $instance;
+    /**
+     * @var SFTP instance
+     */
+    protected $instance;
 
-	private $config;
+    private $config;
 
-	protected function setUp(): void {
-		parent::setUp();
+    protected function setUp(): void {
+        parent::setUp();
 
-		$id = $this->getUniqueID();
-		$this->config = include('files_external/tests/config.sftp.php');
-		if (!is_array($this->config) or !$this->config['run']) {
-			$this->markTestSkipped('SFTP backend not configured');
-		}
-		$this->config['root'] .= '/' . $id; //make sure we have an new empty folder to work in
-		$this->instance = new SFTP($this->config);
-		$this->instance->mkdir('/');
-	}
+        $id = $this->getUniqueID();
+        $this->config = include('files_external/tests/config.sftp.php');
+        if (!is_array($this->config) or !$this->config['run']) {
+            $this->markTestSkipped('SFTP backend not configured');
+        }
+        $this->config['root'] .= '/' . $id; //make sure we have an new empty folder to work in
+        $this->instance = new SFTP($this->config);
+        $this->instance->mkdir('/');
+    }
 
-	protected function tearDown(): void {
-		if ($this->instance) {
-			$this->instance->rmdir('/');
-		}
+    protected function tearDown(): void {
+        if ($this->instance) {
+            $this->instance->rmdir('/');
+        }
 
-		parent::tearDown();
-	}
+        parent::tearDown();
+    }
 
-	#[\PHPUnit\Framework\Attributes\DataProvider('configProvider')]
-	public function testStorageId($config, $expectedStorageId): void {
-		$instance = new SFTP($config);
-		$this->assertEquals($expectedStorageId, $instance->getId());
-	}
+    #[\PHPUnit\Framework\Attributes\DataProvider('configProvider')]
+    public function testStorageId($config, $expectedStorageId): void {
+        $instance = new SFTP($config);
+        $this->assertEquals($expectedStorageId, $instance->getId());
+    }
 
-	public static function configProvider(): array {
-		return [
-			[
-				// no root path
-				[
-					'run' => true,
-					'host' => 'somehost',
-					'user' => 'someuser',
-					'password' => 'somepassword',
-					'root' => '',
-				],
-				'sftp::someuser@somehost//',
-			],
-			[
-				// without leading nor trailing slash
-				[
-					'run' => true,
-					'host' => 'somehost',
-					'user' => 'someuser',
-					'password' => 'somepassword',
-					'root' => 'remotedir/subdir',
-				],
-				'sftp::someuser@somehost//remotedir/subdir/',
-			],
-			[
-				// regular path
-				[
-					'run' => true,
-					'host' => 'somehost',
-					'user' => 'someuser',
-					'password' => 'somepassword',
-					'root' => '/remotedir/subdir/',
-				],
-				'sftp::someuser@somehost//remotedir/subdir/',
-			],
-			[
-				// different port
-				[
-					'run' => true,
-					'host' => 'somehost:8822',
-					'user' => 'someuser',
-					'password' => 'somepassword',
-					'root' => 'remotedir/subdir/',
-				],
-				'sftp::someuser@somehost:8822//remotedir/subdir/',
-			],
-			[
-				// ipv6 with port
-				[
-					'run' => true,
-					'host' => 'FE80:0000:0000:0000:0202:B3FF:FE1E:8329',
-					'user' => 'someuser',
-					'password' => 'somepassword',
-					'root' => 'remotedir/subdir/',
-				],
-				'sftp::someuser@FE80:0000:0000:0000:0202:B3FF:FE1E:8329//remotedir/subdir/',
-			],
-			[
-				// ipv6 without port
-				[
-					'run' => true,
-					'host' => 'FE80:0000:0000:0000:0202:B3FF:FE1E:8329:8822',
-					'user' => 'someuser',
-					'password' => 'somepassword',
-					'root' => 'remotedir/subdir/',
-				],
-				'sftp::someuser@FE80:0000:0000:0000:0202:B3FF:FE1E:8329:8822//remotedir/subdir/',
-			],
-			[
-				// collapsed ipv6 with port
-				[
-					'run' => true,
-					'host' => 'FE80::0202:B3FF:FE1E:8329:8822',
-					'user' => 'someuser',
-					'password' => 'somepassword',
-					'root' => 'remotedir/subdir/',
-				],
-				'sftp::someuser@FE80::0202:B3FF:FE1E:8329:8822//remotedir/subdir/',
-			],
-		];
-	}
+    public static function configProvider(): array {
+        return [
+            [
+                // no root path
+                [
+                    'run' => true,
+                    'host' => 'somehost',
+                    'user' => 'someuser',
+                    'password' => 'somepassword',
+                    'root' => '',
+                ],
+                'sftp::someuser@somehost//',
+            ],
+            [
+                // without leading nor trailing slash
+                [
+                    'run' => true,
+                    'host' => 'somehost',
+                    'user' => 'someuser',
+                    'password' => 'somepassword',
+                    'root' => 'remotedir/subdir',
+                ],
+                'sftp::someuser@somehost//remotedir/subdir/',
+            ],
+            [
+                // regular path
+                [
+                    'run' => true,
+                    'host' => 'somehost',
+                    'user' => 'someuser',
+                    'password' => 'somepassword',
+                    'root' => '/remotedir/subdir/',
+                ],
+                'sftp::someuser@somehost//remotedir/subdir/',
+            ],
+            [
+                // different port
+                [
+                    'run' => true,
+                    'host' => 'somehost:8822',
+                    'user' => 'someuser',
+                    'password' => 'somepassword',
+                    'root' => 'remotedir/subdir/',
+                ],
+                'sftp::someuser@somehost:8822//remotedir/subdir/',
+            ],
+            [
+                // ipv6 with port
+                [
+                    'run' => true,
+                    'host' => 'FE80:0000:0000:0000:0202:B3FF:FE1E:8329',
+                    'user' => 'someuser',
+                    'password' => 'somepassword',
+                    'root' => 'remotedir/subdir/',
+                ],
+                'sftp::someuser@FE80:0000:0000:0000:0202:B3FF:FE1E:8329//remotedir/subdir/',
+            ],
+            [
+                // ipv6 without port
+                [
+                    'run' => true,
+                    'host' => 'FE80:0000:0000:0000:0202:B3FF:FE1E:8329:8822',
+                    'user' => 'someuser',
+                    'password' => 'somepassword',
+                    'root' => 'remotedir/subdir/',
+                ],
+                'sftp::someuser@FE80:0000:0000:0000:0202:B3FF:FE1E:8329:8822//remotedir/subdir/',
+            ],
+            [
+                // collapsed ipv6 with port
+                [
+                    'run' => true,
+                    'host' => 'FE80::0202:B3FF:FE1E:8329:8822',
+                    'user' => 'someuser',
+                    'password' => 'somepassword',
+                    'root' => 'remotedir/subdir/',
+                ],
+                'sftp::someuser@FE80::0202:B3FF:FE1E:8329:8822//remotedir/subdir/',
+            ],
+        ];
+    }
 }

apps/files_external/tests/Config/UserPlaceholderHandlerTest.php

Indentation +42 added lines, -42 removed lines

@@ -17,53 +17,53 @@
 use PHPUnit\Framework\MockObject\MockObject;
 
 class UserPlaceholderHandlerTest extends \Test\TestCase {
-	protected IUser&MockObject $user;
-	protected IUserSession&MockObject $session;
-	protected IManager&MockObject $shareManager;
-	protected IRequest&MockObject $request;
-	protected IUserManager&MockObject $userManager;
-	protected UserPlaceholderHandler $handler;
+    protected IUser&MockObject $user;
+    protected IUserSession&MockObject $session;
+    protected IManager&MockObject $shareManager;
+    protected IRequest&MockObject $request;
+    protected IUserManager&MockObject $userManager;
+    protected UserPlaceholderHandler $handler;
 
-	protected function setUp(): void {
-		parent::setUp();
+    protected function setUp(): void {
+        parent::setUp();
 
-		$this->user = $this->createMock(IUser::class);
-		$this->user->expects($this->any())
-			->method('getUid')
-			->willReturn('alice');
-		$this->session = $this->createMock(IUserSession::class);
-		$this->shareManager = $this->createMock(IManager::class);
-		$this->request = $this->createMock(IRequest::class);
-		$this->userManager = $this->createMock(IUserManager::class);
+        $this->user = $this->createMock(IUser::class);
+        $this->user->expects($this->any())
+            ->method('getUid')
+            ->willReturn('alice');
+        $this->session = $this->createMock(IUserSession::class);
+        $this->shareManager = $this->createMock(IManager::class);
+        $this->request = $this->createMock(IRequest::class);
+        $this->userManager = $this->createMock(IUserManager::class);
 
-		$this->handler = new UserPlaceholderHandler($this->session, $this->shareManager, $this->request, $this->userManager);
-	}
+        $this->handler = new UserPlaceholderHandler($this->session, $this->shareManager, $this->request, $this->userManager);
+    }
 
-	protected function setUser(): void {
-		$this->session->expects($this->any())
-			->method('getUser')
-			->willReturn($this->user);
-	}
+    protected function setUser(): void {
+        $this->session->expects($this->any())
+            ->method('getUser')
+            ->willReturn($this->user);
+    }
 
-	public static function optionProvider(): array {
-		return [
-			['/foo/bar/$user/foobar', '/foo/bar/alice/foobar'],
-			[['/foo/bar/$user/foobar'], ['/foo/bar/alice/foobar']],
-			[['/FOO/BAR/$USER/FOOBAR'], ['/FOO/BAR/alice/FOOBAR']],
-		];
-	}
+    public static function optionProvider(): array {
+        return [
+            ['/foo/bar/$user/foobar', '/foo/bar/alice/foobar'],
+            [['/foo/bar/$user/foobar'], ['/foo/bar/alice/foobar']],
+            [['/FOO/BAR/$USER/FOOBAR'], ['/FOO/BAR/alice/FOOBAR']],
+        ];
+    }
 
-	#[\PHPUnit\Framework\Attributes\DataProvider('optionProvider')]
-	public function testHandle(string|array $option, string|array $expected): void {
-		$this->setUser();
-		$this->assertSame($expected, $this->handler->handle($option));
-	}
+    #[\PHPUnit\Framework\Attributes\DataProvider('optionProvider')]
+    public function testHandle(string|array $option, string|array $expected): void {
+        $this->setUser();
+        $this->assertSame($expected, $this->handler->handle($option));
+    }
 
-	#[\PHPUnit\Framework\Attributes\DataProvider('optionProvider')]
-	public function testHandleNoUser(string|array $option): void {
-		$this->shareManager->expects($this->once())
-			->method('getShareByToken')
-			->willThrowException(new ShareNotFound());
-		$this->assertSame($option, $this->handler->handle($option));
-	}
+    #[\PHPUnit\Framework\Attributes\DataProvider('optionProvider')]
+    public function testHandleNoUser(string|array $option): void {
+        $this->shareManager->expects($this->once())
+            ->method('getShareByToken')
+            ->willThrowException(new ShareNotFound());
+        $this->assertSame($option, $this->handler->handle($option));
+    }
 }

Spacing +2 added lines, -2 removed lines

@@ -54,13 +54,13 @@
 	}
 
 	#[\PHPUnit\Framework\Attributes\DataProvider('optionProvider')]
-	public function testHandle(string|array $option, string|array $expected): void {
+	public function testHandle(string | array $option, string | array $expected): void {
 		$this->setUser();
 		$this->assertSame($expected, $this->handler->handle($option));
 	}
 
 	#[\PHPUnit\Framework\Attributes\DataProvider('optionProvider')]
-	public function testHandleNoUser(string|array $option): void {
+	public function testHandleNoUser(string | array $option): void {
 		$this->shareManager->expects($this->once())
 			->method('getShareByToken')
 			->willThrowException(new ShareNotFound());

apps/files_external/tests/Controller/StoragesControllerTestCase.php

Indentation +383 added lines, -383 removed lines

@@ -23,387 +23,387 @@
 use PHPUnit\Framework\MockObject\MockObject;
 
 abstract class StoragesControllerTestCase extends \Test\TestCase {
-	protected GlobalStoragesController|UserStoragesController $controller;
-	protected GlobalStoragesService|UserStoragesService|MockObject $service;
-
-	protected function setUp(): void {
-		parent::setUp();
-		MountConfig::$skipTest = true;
-	}
-
-	protected function tearDown(): void {
-		MountConfig::$skipTest = false;
-		parent::tearDown();
-	}
-
-	/**
-	 * @return \OCA\Files_External\Lib\Backend\Backend&MockObject
-	 */
-	protected function getBackendMock($class = SMB::class, $storageClass = \OCA\Files_External\Lib\Storage\SMB::class) {
-		$backend = $this->createMock(Backend::class);
-		$backend->method('getStorageClass')
-			->willReturn($storageClass);
-		$backend->method('getIdentifier')
-			->willReturn('identifier:' . $class);
-		$backend->method('getParameters')
-			->willReturn([]);
-		return $backend;
-	}
-
-	/**
-	 * @return AuthMechanism|MockObject
-	 */
-	protected function getAuthMechMock($scheme = 'null', $class = NullMechanism::class) {
-		$authMech = $this->createMock(AuthMechanism::class);
-		$authMech->method('getScheme')
-			->willReturn($scheme);
-		$authMech->method('getIdentifier')
-			->willReturn('identifier:' . $class);
-		$authMech->method('getParameters')
-			->willReturn([]);
-
-		return $authMech;
-	}
-
-	public function testAddStorage(): void {
-		$authMech = $this->getAuthMechMock();
-		$authMech->method('validateStorage')
-			->willReturn(true);
-		$authMech->method('isVisibleFor')
-			->willReturn(true);
-		$backend = $this->getBackendMock();
-		$backend->method('validateStorage')
-			->willReturn(true);
-		$backend->method('isVisibleFor')
-			->willReturn(true);
-
-		$storageConfig = new StorageConfig(1);
-		$storageConfig->setMountPoint('mount');
-		$storageConfig->setBackend($backend);
-		$storageConfig->setAuthMechanism($authMech);
-		$storageConfig->setBackendOptions([]);
-
-		$this->service->expects($this->once())
-			->method('createStorage')
-			->willReturn($storageConfig);
-		$this->service->expects($this->once())
-			->method('addStorage')
-			->willReturn($storageConfig);
-
-		$response = $this->controller->create(
-			'mount',
-			\OCA\Files_External\Lib\Storage\SMB::class,
-			NullMechanism::class,
-			[],
-			[],
-			[],
-			[],
-			null
-		);
-
-		$data = $response->getData();
-		$this->assertEquals(Http::STATUS_CREATED, $response->getStatus());
-		$this->assertEquals($storageConfig->jsonSerialize(), $data);
-	}
-
-	public function testAddLocalStorageWhenDisabled(): void {
-		$authMech = $this->getAuthMechMock();
-		$backend = $this->getBackendMock();
-
-		$storageConfig = new StorageConfig(1);
-		$storageConfig->setMountPoint('mount');
-		$storageConfig->setBackend($backend);
-		$storageConfig->setAuthMechanism($authMech);
-		$storageConfig->setBackendOptions([]);
-
-		$this->service->expects($this->never())
-			->method('createStorage');
-		$this->service->expects($this->never())
-			->method('addStorage');
-
-		$response = $this->controller->create(
-			'mount',
-			'local',
-			NullMechanism::class,
-			[],
-			[],
-			[],
-			[],
-			null
-		);
-
-		$data = $response->getData();
-		$this->assertEquals(Http::STATUS_FORBIDDEN, $response->getStatus());
-	}
-
-	public function testUpdateStorage(): void {
-		$authMech = $this->getAuthMechMock();
-		$authMech->method('validateStorage')
-			->willReturn(true);
-		$authMech->method('isVisibleFor')
-			->willReturn(true);
-		$backend = $this->getBackendMock();
-		$backend->method('validateStorage')
-			->willReturn(true);
-		$backend->method('isVisibleFor')
-			->willReturn(true);
-
-		$storageConfig = new StorageConfig(1);
-		$storageConfig->setMountPoint('mount');
-		$storageConfig->setBackend($backend);
-		$storageConfig->setAuthMechanism($authMech);
-		$storageConfig->setBackendOptions([]);
-
-		$this->service->expects($this->once())
-			->method('createStorage')
-			->willReturn($storageConfig);
-		$this->service->expects($this->once())
-			->method('updateStorage')
-			->willReturn($storageConfig);
-
-		$response = $this->controller->update(
-			1,
-			'mount',
-			\OCA\Files_External\Lib\Storage\SMB::class,
-			NullMechanism::class,
-			[],
-			[],
-			[],
-			[],
-			null
-		);
-
-		$data = $response->getData();
-		$this->assertEquals(Http::STATUS_OK, $response->getStatus());
-		$this->assertEquals($storageConfig->jsonSerialize(), $data);
-	}
-
-	public static function mountPointNamesProvider(): array {
-		return [
-			[''],
-			['/'],
-			['//'],
-		];
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('mountPointNamesProvider')]
-	public function testAddOrUpdateStorageInvalidMountPoint($mountPoint): void {
-		$storageConfig = new StorageConfig(1);
-		$storageConfig->setMountPoint($mountPoint);
-		$storageConfig->setBackend($this->getBackendMock());
-		$storageConfig->setAuthMechanism($this->getAuthMechMock());
-		$storageConfig->setBackendOptions([]);
-
-		$this->service->expects($this->exactly(2))
-			->method('createStorage')
-			->willReturn($storageConfig);
-		$this->service->expects($this->never())
-			->method('addStorage');
-		$this->service->expects($this->never())
-			->method('updateStorage');
-
-		$response = $this->controller->create(
-			$mountPoint,
-			\OCA\Files_External\Lib\Storage\SMB::class,
-			NullMechanism::class,
-			[],
-			[],
-			[],
-			[],
-			null
-		);
-
-		$this->assertEquals(Http::STATUS_UNPROCESSABLE_ENTITY, $response->getStatus());
-
-		$response = $this->controller->update(
-			1,
-			$mountPoint,
-			\OCA\Files_External\Lib\Storage\SMB::class,
-			NullMechanism::class,
-			[],
-			[],
-			[],
-			[],
-			null
-		);
-
-		$this->assertEquals(Http::STATUS_UNPROCESSABLE_ENTITY, $response->getStatus());
-	}
-
-	public function testAddOrUpdateStorageInvalidBackend(): void {
-		$this->service->expects($this->exactly(2))
-			->method('createStorage')
-			->willThrowException(new \InvalidArgumentException());
-		$this->service->expects($this->never())
-			->method('addStorage');
-		$this->service->expects($this->never())
-			->method('updateStorage');
-
-		$response = $this->controller->create(
-			'mount',
-			'\OC\Files\Storage\InvalidStorage',
-			NullMechanism::class,
-			[],
-			[],
-			[],
-			[],
-			null
-		);
-
-		$this->assertEquals(Http::STATUS_UNPROCESSABLE_ENTITY, $response->getStatus());
-
-		$response = $this->controller->update(
-			1,
-			'mount',
-			'\OC\Files\Storage\InvalidStorage',
-			NullMechanism::class,
-			[],
-			[],
-			[],
-			[],
-			null
-		);
-
-		$this->assertEquals(Http::STATUS_UNPROCESSABLE_ENTITY, $response->getStatus());
-	}
-
-	public function testUpdateStorageNonExisting(): void {
-		$authMech = $this->getAuthMechMock();
-		$authMech->method('validateStorage')
-			->willReturn(true);
-		$authMech->method('isVisibleFor')
-			->willReturn(true);
-		$backend = $this->getBackendMock();
-		$backend->method('validateStorage')
-			->willReturn(true);
-		$backend->method('isVisibleFor')
-			->willReturn(true);
-
-		$storageConfig = new StorageConfig(255);
-		$storageConfig->setMountPoint('mount');
-		$storageConfig->setBackend($backend);
-		$storageConfig->setAuthMechanism($authMech);
-		$storageConfig->setBackendOptions([]);
-
-		$this->service->expects($this->once())
-			->method('createStorage')
-			->willReturn($storageConfig);
-		$this->service->expects($this->once())
-			->method('updateStorage')
-			->willThrowException(new NotFoundException());
-
-		$response = $this->controller->update(
-			255,
-			'mount',
-			\OCA\Files_External\Lib\Storage\SMB::class,
-			NullMechanism::class,
-			[],
-			[],
-			[],
-			[],
-			null
-		);
-
-		$this->assertEquals(Http::STATUS_NOT_FOUND, $response->getStatus());
-	}
-
-	public function testDeleteStorage(): void {
-		$this->service->expects($this->once())
-			->method('removeStorage');
-
-		$response = $this->controller->destroy(1);
-		$this->assertEquals(Http::STATUS_NO_CONTENT, $response->getStatus());
-	}
-
-	public function testDeleteStorageNonExisting(): void {
-		$this->service->expects($this->once())
-			->method('removeStorage')
-			->willThrowException(new NotFoundException());
-
-		$response = $this->controller->destroy(255);
-		$this->assertEquals(Http::STATUS_NOT_FOUND, $response->getStatus());
-	}
-
-	public function testGetStorage(): void {
-		$backend = $this->getBackendMock();
-		$authMech = $this->getAuthMechMock();
-		$storageConfig = new StorageConfig(1);
-		$storageConfig->setMountPoint('test');
-		$storageConfig->setBackend($backend);
-		$storageConfig->setAuthMechanism($authMech);
-		$storageConfig->setBackendOptions(['user' => 'test', 'password', 'password123']);
-		$storageConfig->setMountOptions(['priority' => false]);
-
-		$this->service->expects($this->once())
-			->method('getStorage')
-			->with(1)
-			->willReturn($storageConfig);
-		$response = $this->controller->show(1);
-
-		$this->assertEquals(Http::STATUS_OK, $response->getStatus());
-		$expected = $storageConfig->jsonSerialize();
-		$expected['can_edit'] = false;
-		$this->assertEquals($expected, $response->getData());
-	}
-
-	public static function validateStorageProvider(): array {
-		return [
-			[true, true, true],
-			[false, true, false],
-			[true, false, false],
-			[false, false, false]
-		];
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('validateStorageProvider')]
-	public function testValidateStorage(bool $backendValidate, bool $authMechValidate, bool $expectSuccess): void {
-		$backend = $this->getBackendMock();
-		$backend->method('validateStorage')
-			->willReturn($backendValidate);
-		$backend->method('isVisibleFor')
-			->willReturn(true);
-
-		$authMech = $this->getAuthMechMock();
-		$authMech->method('validateStorage')
-			->willReturn($authMechValidate);
-		$authMech->method('isVisibleFor')
-			->willReturn(true);
-
-		$storageConfig = new StorageConfig();
-		$storageConfig->setMountPoint('mount');
-		$storageConfig->setBackend($backend);
-		$storageConfig->setAuthMechanism($authMech);
-		$storageConfig->setBackendOptions([]);
-
-		$this->service->expects($this->once())
-			->method('createStorage')
-			->willReturn($storageConfig);
-
-		if ($expectSuccess) {
-			$this->service->expects($this->once())
-				->method('addStorage')
-				->with($storageConfig)
-				->willReturn($storageConfig);
-		} else {
-			$this->service->expects($this->never())
-				->method('addStorage');
-		}
-
-		$response = $this->controller->create(
-			'mount',
-			\OCA\Files_External\Lib\Storage\SMB::class,
-			NullMechanism::class,
-			[],
-			[],
-			[],
-			[],
-			null
-		);
-
-		if ($expectSuccess) {
-			$this->assertEquals(Http::STATUS_CREATED, $response->getStatus());
-		} else {
-			$this->assertEquals(Http::STATUS_UNPROCESSABLE_ENTITY, $response->getStatus());
-		}
-	}
+    protected GlobalStoragesController|UserStoragesController $controller;
+    protected GlobalStoragesService|UserStoragesService|MockObject $service;
+
+    protected function setUp(): void {
+        parent::setUp();
+        MountConfig::$skipTest = true;
+    }
+
+    protected function tearDown(): void {
+        MountConfig::$skipTest = false;
+        parent::tearDown();
+    }
+
+    /**
+     * @return \OCA\Files_External\Lib\Backend\Backend&MockObject
+     */
+    protected function getBackendMock($class = SMB::class, $storageClass = \OCA\Files_External\Lib\Storage\SMB::class) {
+        $backend = $this->createMock(Backend::class);
+        $backend->method('getStorageClass')
+            ->willReturn($storageClass);
+        $backend->method('getIdentifier')
+            ->willReturn('identifier:' . $class);
+        $backend->method('getParameters')
+            ->willReturn([]);
+        return $backend;
+    }
+
+    /**
+     * @return AuthMechanism|MockObject
+     */
+    protected function getAuthMechMock($scheme = 'null', $class = NullMechanism::class) {
+        $authMech = $this->createMock(AuthMechanism::class);
+        $authMech->method('getScheme')
+            ->willReturn($scheme);
+        $authMech->method('getIdentifier')
+            ->willReturn('identifier:' . $class);
+        $authMech->method('getParameters')
+            ->willReturn([]);
+
+        return $authMech;
+    }
+
+    public function testAddStorage(): void {
+        $authMech = $this->getAuthMechMock();
+        $authMech->method('validateStorage')
+            ->willReturn(true);
+        $authMech->method('isVisibleFor')
+            ->willReturn(true);
+        $backend = $this->getBackendMock();
+        $backend->method('validateStorage')
+            ->willReturn(true);
+        $backend->method('isVisibleFor')
+            ->willReturn(true);
+
+        $storageConfig = new StorageConfig(1);
+        $storageConfig->setMountPoint('mount');
+        $storageConfig->setBackend($backend);
+        $storageConfig->setAuthMechanism($authMech);
+        $storageConfig->setBackendOptions([]);
+
+        $this->service->expects($this->once())
+            ->method('createStorage')
+            ->willReturn($storageConfig);
+        $this->service->expects($this->once())
+            ->method('addStorage')
+            ->willReturn($storageConfig);
+
+        $response = $this->controller->create(
+            'mount',
+            \OCA\Files_External\Lib\Storage\SMB::class,
+            NullMechanism::class,
+            [],
+            [],
+            [],
+            [],
+            null
+        );
+
+        $data = $response->getData();
+        $this->assertEquals(Http::STATUS_CREATED, $response->getStatus());
+        $this->assertEquals($storageConfig->jsonSerialize(), $data);
+    }
+
+    public function testAddLocalStorageWhenDisabled(): void {
+        $authMech = $this->getAuthMechMock();
+        $backend = $this->getBackendMock();
+
+        $storageConfig = new StorageConfig(1);
+        $storageConfig->setMountPoint('mount');
+        $storageConfig->setBackend($backend);
+        $storageConfig->setAuthMechanism($authMech);
+        $storageConfig->setBackendOptions([]);
+
+        $this->service->expects($this->never())
+            ->method('createStorage');
+        $this->service->expects($this->never())
+            ->method('addStorage');
+
+        $response = $this->controller->create(
+            'mount',
+            'local',
+            NullMechanism::class,
+            [],
+            [],
+            [],
+            [],
+            null
+        );
+
+        $data = $response->getData();
+        $this->assertEquals(Http::STATUS_FORBIDDEN, $response->getStatus());
+    }
+
+    public function testUpdateStorage(): void {
+        $authMech = $this->getAuthMechMock();
+        $authMech->method('validateStorage')
+            ->willReturn(true);
+        $authMech->method('isVisibleFor')
+            ->willReturn(true);
+        $backend = $this->getBackendMock();
+        $backend->method('validateStorage')
+            ->willReturn(true);
+        $backend->method('isVisibleFor')
+            ->willReturn(true);
+
+        $storageConfig = new StorageConfig(1);
+        $storageConfig->setMountPoint('mount');
+        $storageConfig->setBackend($backend);
+        $storageConfig->setAuthMechanism($authMech);
+        $storageConfig->setBackendOptions([]);
+
+        $this->service->expects($this->once())
+            ->method('createStorage')
+            ->willReturn($storageConfig);
+        $this->service->expects($this->once())
+            ->method('updateStorage')
+            ->willReturn($storageConfig);
+
+        $response = $this->controller->update(
+            1,
+            'mount',
+            \OCA\Files_External\Lib\Storage\SMB::class,
+            NullMechanism::class,
+            [],
+            [],
+            [],
+            [],
+            null
+        );
+
+        $data = $response->getData();
+        $this->assertEquals(Http::STATUS_OK, $response->getStatus());
+        $this->assertEquals($storageConfig->jsonSerialize(), $data);
+    }
+
+    public static function mountPointNamesProvider(): array {
+        return [
+            [''],
+            ['/'],
+            ['//'],
+        ];
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('mountPointNamesProvider')]
+    public function testAddOrUpdateStorageInvalidMountPoint($mountPoint): void {
+        $storageConfig = new StorageConfig(1);
+        $storageConfig->setMountPoint($mountPoint);
+        $storageConfig->setBackend($this->getBackendMock());
+        $storageConfig->setAuthMechanism($this->getAuthMechMock());
+        $storageConfig->setBackendOptions([]);
+
+        $this->service->expects($this->exactly(2))
+            ->method('createStorage')
+            ->willReturn($storageConfig);
+        $this->service->expects($this->never())
+            ->method('addStorage');
+        $this->service->expects($this->never())
+            ->method('updateStorage');
+
+        $response = $this->controller->create(
+            $mountPoint,
+            \OCA\Files_External\Lib\Storage\SMB::class,
+            NullMechanism::class,
+            [],
+            [],
+            [],
+            [],
+            null
+        );
+
+        $this->assertEquals(Http::STATUS_UNPROCESSABLE_ENTITY, $response->getStatus());
+
+        $response = $this->controller->update(
+            1,
+            $mountPoint,
+            \OCA\Files_External\Lib\Storage\SMB::class,
+            NullMechanism::class,
+            [],
+            [],
+            [],
+            [],
+            null
+        );
+
+        $this->assertEquals(Http::STATUS_UNPROCESSABLE_ENTITY, $response->getStatus());
+    }
+
+    public function testAddOrUpdateStorageInvalidBackend(): void {
+        $this->service->expects($this->exactly(2))
+            ->method('createStorage')
+            ->willThrowException(new \InvalidArgumentException());
+        $this->service->expects($this->never())
+            ->method('addStorage');
+        $this->service->expects($this->never())
+            ->method('updateStorage');
+
+        $response = $this->controller->create(
+            'mount',
+            '\OC\Files\Storage\InvalidStorage',
+            NullMechanism::class,
+            [],
+            [],
+            [],
+            [],
+            null
+        );
+
+        $this->assertEquals(Http::STATUS_UNPROCESSABLE_ENTITY, $response->getStatus());
+
+        $response = $this->controller->update(
+            1,
+            'mount',
+            '\OC\Files\Storage\InvalidStorage',
+            NullMechanism::class,
+            [],
+            [],
+            [],
+            [],
+            null
+        );
+
+        $this->assertEquals(Http::STATUS_UNPROCESSABLE_ENTITY, $response->getStatus());
+    }
+
+    public function testUpdateStorageNonExisting(): void {
+        $authMech = $this->getAuthMechMock();
+        $authMech->method('validateStorage')
+            ->willReturn(true);
+        $authMech->method('isVisibleFor')
+            ->willReturn(true);
+        $backend = $this->getBackendMock();
+        $backend->method('validateStorage')
+            ->willReturn(true);
+        $backend->method('isVisibleFor')
+            ->willReturn(true);
+
+        $storageConfig = new StorageConfig(255);
+        $storageConfig->setMountPoint('mount');
+        $storageConfig->setBackend($backend);
+        $storageConfig->setAuthMechanism($authMech);
+        $storageConfig->setBackendOptions([]);
+
+        $this->service->expects($this->once())
+            ->method('createStorage')
+            ->willReturn($storageConfig);
+        $this->service->expects($this->once())
+            ->method('updateStorage')
+            ->willThrowException(new NotFoundException());
+
+        $response = $this->controller->update(
+            255,
+            'mount',
+            \OCA\Files_External\Lib\Storage\SMB::class,
+            NullMechanism::class,
+            [],
+            [],
+            [],
+            [],
+            null
+        );
+
+        $this->assertEquals(Http::STATUS_NOT_FOUND, $response->getStatus());
+    }
+
+    public function testDeleteStorage(): void {
+        $this->service->expects($this->once())
+            ->method('removeStorage');
+
+        $response = $this->controller->destroy(1);
+        $this->assertEquals(Http::STATUS_NO_CONTENT, $response->getStatus());
+    }
+
+    public function testDeleteStorageNonExisting(): void {
+        $this->service->expects($this->once())
+            ->method('removeStorage')
+            ->willThrowException(new NotFoundException());
+
+        $response = $this->controller->destroy(255);
+        $this->assertEquals(Http::STATUS_NOT_FOUND, $response->getStatus());
+    }
+
+    public function testGetStorage(): void {
+        $backend = $this->getBackendMock();
+        $authMech = $this->getAuthMechMock();
+        $storageConfig = new StorageConfig(1);
+        $storageConfig->setMountPoint('test');
+        $storageConfig->setBackend($backend);
+        $storageConfig->setAuthMechanism($authMech);
+        $storageConfig->setBackendOptions(['user' => 'test', 'password', 'password123']);
+        $storageConfig->setMountOptions(['priority' => false]);
+
+        $this->service->expects($this->once())
+            ->method('getStorage')
+            ->with(1)
+            ->willReturn($storageConfig);
+        $response = $this->controller->show(1);
+
+        $this->assertEquals(Http::STATUS_OK, $response->getStatus());
+        $expected = $storageConfig->jsonSerialize();
+        $expected['can_edit'] = false;
+        $this->assertEquals($expected, $response->getData());
+    }
+
+    public static function validateStorageProvider(): array {
+        return [
+            [true, true, true],
+            [false, true, false],
+            [true, false, false],
+            [false, false, false]
+        ];
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('validateStorageProvider')]
+    public function testValidateStorage(bool $backendValidate, bool $authMechValidate, bool $expectSuccess): void {
+        $backend = $this->getBackendMock();
+        $backend->method('validateStorage')
+            ->willReturn($backendValidate);
+        $backend->method('isVisibleFor')
+            ->willReturn(true);
+
+        $authMech = $this->getAuthMechMock();
+        $authMech->method('validateStorage')
+            ->willReturn($authMechValidate);
+        $authMech->method('isVisibleFor')
+            ->willReturn(true);
+
+        $storageConfig = new StorageConfig();
+        $storageConfig->setMountPoint('mount');
+        $storageConfig->setBackend($backend);
+        $storageConfig->setAuthMechanism($authMech);
+        $storageConfig->setBackendOptions([]);
+
+        $this->service->expects($this->once())
+            ->method('createStorage')
+            ->willReturn($storageConfig);
+
+        if ($expectSuccess) {
+            $this->service->expects($this->once())
+                ->method('addStorage')
+                ->with($storageConfig)
+                ->willReturn($storageConfig);
+        } else {
+            $this->service->expects($this->never())
+                ->method('addStorage');
+        }
+
+        $response = $this->controller->create(
+            'mount',
+            \OCA\Files_External\Lib\Storage\SMB::class,
+            NullMechanism::class,
+            [],
+            [],
+            [],
+            [],
+            null
+        );
+
+        if ($expectSuccess) {
+            $this->assertEquals(Http::STATUS_CREATED, $response->getStatus());
+        } else {
+            $this->assertEquals(Http::STATUS_UNPROCESSABLE_ENTITY, $response->getStatus());
+        }
+    }
 }

apps/files_external/tests/Service/UserGlobalStoragesServiceTest.php

Indentation +311 added lines, -311 removed lines

@@ -24,315 +24,315 @@
  * @group DB
  */
 class UserGlobalStoragesServiceTest extends GlobalStoragesServiceTest {
-	use UserTrait;
-
-	protected IGroupManager&MockObject $groupManager;
-	protected StoragesService $globalStoragesService;
-	protected User $user;
-
-	public const USER_ID = 'test_user';
-	public const GROUP_ID = 'test_group';
-	public const GROUP_ID2 = 'test_group2';
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->globalStoragesService = $this->service;
-
-		$this->user = new User(self::USER_ID, null, Server::get(IEventDispatcher::class));
-		/** @var IUserSession&MockObject $userSession */
-		$userSession = $this->createMock(IUserSession::class);
-		$userSession
-			->expects($this->any())
-			->method('getUser')
-			->willReturn($this->user);
-
-		$this->groupManager = $this->createMock(IGroupManager::class);
-		$this->groupManager->method('isInGroup')
-			->willReturnCallback(function ($userId, $groupId) {
-				if ($userId === self::USER_ID) {
-					switch ($groupId) {
-						case self::GROUP_ID:
-						case self::GROUP_ID2:
-							return true;
-					}
-				}
-				return false;
-			});
-		$this->groupManager->method('getUserGroupIds')
-			->willReturnCallback(function (IUser $user) {
-				if ($user->getUID() === self::USER_ID) {
-					return [self::GROUP_ID, self::GROUP_ID2];
-				} else {
-					return [];
-				}
-			});
-
-		$this->service = new UserGlobalStoragesService(
-			$this->backendService,
-			$this->dbConfig,
-			$userSession,
-			$this->groupManager,
-			$this->mountCache,
-			$this->eventDispatcher,
-		);
-	}
-
-	public static function applicableStorageProvider(): array {
-		return [
-			[[], [], true],
-
-			// not applicable cases
-			[['user1'], [], false],
-			[[], ['group1'], false],
-			[['user1'], ['group1'], false],
-
-			// applicable cases
-			[[self::USER_ID], [], true],
-			[[], [self::GROUP_ID], true],
-			[[self::USER_ID], ['group1'], true],
-			[['user1'], [self::GROUP_ID], true],
-
-			// sanity checks
-			[['user1', 'user2', self::USER_ID, 'user3'], [], true],
-		];
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('applicableStorageProvider')]
-	public function testGetStorageWithApplicable($applicableUsers, $applicableGroups, $isVisible): void {
-		$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($applicableUsers);
-		$storage->setApplicableGroups($applicableGroups);
-
-		$newStorage = $this->globalStoragesService->addStorage($storage);
-
-		$storages = $this->service->getAllStorages();
-		if ($isVisible) {
-			$this->assertEquals(1, count($storages));
-			$retrievedStorage = $this->service->getStorage($newStorage->getId());
-			$this->assertEquals('/mountpoint', $retrievedStorage->getMountPoint());
-		} else {
-			$this->assertEquals(0, count($storages));
-
-			try {
-				$this->service->getStorage($newStorage->getId());
-				$this->fail('Failed asserting that storage can\'t be accessed by id');
-			} catch (NotFoundException $e) {
-			}
-		}
-	}
-
-
-	public function testAddStorage($storageParams = null): void {
-		$this->expectException(\DomainException::class);
-
-		$backend = $this->backendService->getBackend('identifier:\OCA\Files_External\Lib\Backend\SMB');
-		$authMechanism = $this->backendService->getAuthMechanism('identifier:\Auth\Mechanism');
-
-		$storage = new StorageConfig(255);
-		$storage->setMountPoint('mountpoint');
-		$storage->setBackend($backend);
-		$storage->setAuthMechanism($authMechanism);
-		$storage->setBackendOptions(['password' => 'testPassword']);
-
-		$this->service->addStorage($storage);
-	}
-
-
-	public function testUpdateStorage($storageParams = null): void {
-		$this->expectException(\DomainException::class);
-
-		$backend = $this->backendService->getBackend('identifier:\OCA\Files_External\Lib\Backend\SMB');
-		$authMechanism = $this->backendService->getAuthMechanism('identifier:\Auth\Mechanism');
-
-		$storage = new StorageConfig(255);
-		$storage->setMountPoint('mountpoint');
-		$storage->setBackend($backend);
-		$storage->setAuthMechanism($authMechanism);
-		$storage->setBackendOptions(['password' => 'testPassword']);
-
-		$newStorage = $this->globalStoragesService->addStorage($storage);
-
-		$retrievedStorage = $this->service->getStorage($newStorage->getId());
-		$retrievedStorage->setMountPoint('abc');
-		$this->service->updateStorage($retrievedStorage);
-	}
-
-
-	public function testNonExistingStorage(): void {
-		$this->expectException(\DomainException::class);
-
-		$this->ActualNonExistingStorageTest();
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('deleteStorageDataProvider')]
-	public function testDeleteStorage($backendOptions, $rustyStorageId): void {
-		$this->expectException(\DomainException::class);
-
-		$backend = $this->backendService->getBackend('identifier:\OCA\Files_External\Lib\Backend\SMB');
-		$authMechanism = $this->backendService->getAuthMechanism('identifier:\Auth\Mechanism');
-
-		$storage = new StorageConfig(255);
-		$storage->setMountPoint('mountpoint');
-		$storage->setBackend($backend);
-		$storage->setAuthMechanism($authMechanism);
-		$storage->setBackendOptions($backendOptions);
-
-		$newStorage = $this->globalStoragesService->addStorage($storage);
-		$id = $newStorage->getId();
-
-		$this->service->removeStorage($id);
-	}
-
-
-	public function testDeleteUnexistingStorage(): void {
-		$this->expectException(\DomainException::class);
-
-		$this->actualDeletedUnexistingStorageTest();
-	}
-
-	public static function getUniqueStoragesProvider(): array {
-		return [
-			// 'all' vs group
-			[100, [], [], 100, [], [self::GROUP_ID], 2],
-			[100, [], [self::GROUP_ID], 100, [], [], 1],
-
-			// 'all' vs user
-			[100, [], [], 100, [self::USER_ID], [], 2],
-			[100, [self::USER_ID], [], 100, [], [], 1],
-
-			// group vs user
-			[100, [], [self::GROUP_ID], 100, [self::USER_ID], [], 2],
-			[100, [self::USER_ID], [], 100, [], [self::GROUP_ID], 1],
-
-			// group+user vs group
-			[100, [], [self::GROUP_ID2], 100, [self::USER_ID], [self::GROUP_ID], 2],
-			[100, [self::USER_ID], [self::GROUP_ID], 100, [], [self::GROUP_ID2], 1],
-
-			// user vs 'all' (higher priority)
-			[200, [], [], 100, [self::USER_ID], [], 2],
-			[100, [self::USER_ID], [], 200, [], [], 1],
-
-			// group vs group (higher priority)
-			[100, [], [self::GROUP_ID2], 200, [], [self::GROUP_ID], 2],
-			[200, [], [self::GROUP_ID], 100, [], [self::GROUP_ID2], 1],
-		];
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('getUniqueStoragesProvider')]
-	public function testGetUniqueStorages(
-		$priority1, $applicableUsers1, $applicableGroups1,
-		$priority2, $applicableUsers2, $applicableGroups2,
-		$expectedPrecedence,
-	): void {
-		$backend = $this->backendService->getBackend('identifier:\OCA\Files_External\Lib\Backend\SMB');
-		$backend->method('isVisibleFor')
-			->willReturn(true);
-		$authMechanism = $this->backendService->getAuthMechanism('identifier:\Auth\Mechanism');
-		$authMechanism->method('isVisibleFor')
-			->willReturn(true);
-
-		$storage1 = new StorageConfig();
-		$storage1->setMountPoint('mountpoint');
-		$storage1->setBackend($backend);
-		$storage1->setAuthMechanism($authMechanism);
-		$storage1->setBackendOptions(['password' => 'testPassword']);
-		$storage1->setPriority($priority1);
-		$storage1->setApplicableUsers($applicableUsers1);
-		$storage1->setApplicableGroups($applicableGroups1);
-
-		$storage1 = $this->globalStoragesService->addStorage($storage1);
-
-		$storage2 = new StorageConfig();
-		$storage2->setMountPoint('mountpoint');
-		$storage2->setBackend($backend);
-		$storage2->setAuthMechanism($authMechanism);
-		$storage2->setBackendOptions(['password' => 'testPassword']);
-		$storage2->setPriority($priority2);
-		$storage2->setApplicableUsers($applicableUsers2);
-		$storage2->setApplicableGroups($applicableGroups2);
-
-		$storage2 = $this->globalStoragesService->addStorage($storage2);
-
-		$storages = $this->service->getUniqueStorages();
-		$this->assertCount(1, $storages);
-
-		if ($expectedPrecedence === 1) {
-			$this->assertArrayHasKey($storage1->getID(), $storages);
-		} elseif ($expectedPrecedence === 2) {
-			$this->assertArrayHasKey($storage2->getID(), $storages);
-		}
-	}
-
-	public function testGetStoragesBackendNotVisible(): void {
-		// we don't test this here
-		$this->addToAssertionCount(1);
-	}
-
-	public function testGetStoragesAuthMechanismNotVisible(): void {
-		// we don't test this here
-		$this->addToAssertionCount(1);
-	}
-
-	public function testHooksAddStorage($a = null, $b = null, $c = null): void {
-		// we don't test this here
-		$this->addToAssertionCount(1);
-	}
-
-	public function testHooksUpdateStorage($a = null, $b = null, $c = null, $d = null, $e = null): void {
-		// we don't test this here
-		$this->addToAssertionCount(1);
-	}
-
-	public function testHooksRenameMountPoint(): void {
-		// we don't test this here
-		$this->addToAssertionCount(1);
-	}
-
-	public function testHooksDeleteStorage($a = null, $b = null, $c = null): void {
-		// we don't test this here
-		$this->addToAssertionCount(1);
-	}
-
-	public function testLegacyConfigConversionApplicableAll(): void {
-		// we don't test this here
-		$this->addToAssertionCount(1);
-	}
-
-	public function testLegacyConfigConversionApplicableUserAndGroup(): void {
-		// we don't test this here
-		$this->addToAssertionCount(1);
-	}
-
-	public function testReadLegacyConfigAndGenerateConfigId(): void {
-		// we don't test this here
-		$this->addToAssertionCount(1);
-	}
-
-	public function testReadLegacyConfigNoAuthMechanism(): void {
-		// we don't test this here
-		$this->addToAssertionCount(1);
-	}
-
-	public function testReadLegacyConfigClass(): void {
-		// we don't test this here
-		$this->addToAssertionCount(1);
-	}
-
-	public function testReadEmptyMountPoint(): void {
-		// we don't test this here
-		$this->addToAssertionCount(1);
-	}
-
-	public function testUpdateStorageMountPoint(): void {
-		// we don't test this here
-		$this->addToAssertionCount(1);
-	}
+    use UserTrait;
+
+    protected IGroupManager&MockObject $groupManager;
+    protected StoragesService $globalStoragesService;
+    protected User $user;
+
+    public const USER_ID = 'test_user';
+    public const GROUP_ID = 'test_group';
+    public const GROUP_ID2 = 'test_group2';
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->globalStoragesService = $this->service;
+
+        $this->user = new User(self::USER_ID, null, Server::get(IEventDispatcher::class));
+        /** @var IUserSession&MockObject $userSession */
+        $userSession = $this->createMock(IUserSession::class);
+        $userSession
+            ->expects($this->any())
+            ->method('getUser')
+            ->willReturn($this->user);
+
+        $this->groupManager = $this->createMock(IGroupManager::class);
+        $this->groupManager->method('isInGroup')
+            ->willReturnCallback(function ($userId, $groupId) {
+                if ($userId === self::USER_ID) {
+                    switch ($groupId) {
+                        case self::GROUP_ID:
+                        case self::GROUP_ID2:
+                            return true;
+                    }
+                }
+                return false;
+            });
+        $this->groupManager->method('getUserGroupIds')
+            ->willReturnCallback(function (IUser $user) {
+                if ($user->getUID() === self::USER_ID) {
+                    return [self::GROUP_ID, self::GROUP_ID2];
+                } else {
+                    return [];
+                }
+            });
+
+        $this->service = new UserGlobalStoragesService(
+            $this->backendService,
+            $this->dbConfig,
+            $userSession,
+            $this->groupManager,
+            $this->mountCache,
+            $this->eventDispatcher,
+        );
+    }
+
+    public static function applicableStorageProvider(): array {
+        return [
+            [[], [], true],
+
+            // not applicable cases
+            [['user1'], [], false],
+            [[], ['group1'], false],
+            [['user1'], ['group1'], false],
+
+            // applicable cases
+            [[self::USER_ID], [], true],
+            [[], [self::GROUP_ID], true],
+            [[self::USER_ID], ['group1'], true],
+            [['user1'], [self::GROUP_ID], true],
+
+            // sanity checks
+            [['user1', 'user2', self::USER_ID, 'user3'], [], true],
+        ];
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('applicableStorageProvider')]
+    public function testGetStorageWithApplicable($applicableUsers, $applicableGroups, $isVisible): void {
+        $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($applicableUsers);
+        $storage->setApplicableGroups($applicableGroups);
+
+        $newStorage = $this->globalStoragesService->addStorage($storage);
+
+        $storages = $this->service->getAllStorages();
+        if ($isVisible) {
+            $this->assertEquals(1, count($storages));
+            $retrievedStorage = $this->service->getStorage($newStorage->getId());
+            $this->assertEquals('/mountpoint', $retrievedStorage->getMountPoint());
+        } else {
+            $this->assertEquals(0, count($storages));
+
+            try {
+                $this->service->getStorage($newStorage->getId());
+                $this->fail('Failed asserting that storage can\'t be accessed by id');
+            } catch (NotFoundException $e) {
+            }
+        }
+    }
+
+
+    public function testAddStorage($storageParams = null): void {
+        $this->expectException(\DomainException::class);
+
+        $backend = $this->backendService->getBackend('identifier:\OCA\Files_External\Lib\Backend\SMB');
+        $authMechanism = $this->backendService->getAuthMechanism('identifier:\Auth\Mechanism');
+
+        $storage = new StorageConfig(255);
+        $storage->setMountPoint('mountpoint');
+        $storage->setBackend($backend);
+        $storage->setAuthMechanism($authMechanism);
+        $storage->setBackendOptions(['password' => 'testPassword']);
+
+        $this->service->addStorage($storage);
+    }
+
+
+    public function testUpdateStorage($storageParams = null): void {
+        $this->expectException(\DomainException::class);
+
+        $backend = $this->backendService->getBackend('identifier:\OCA\Files_External\Lib\Backend\SMB');
+        $authMechanism = $this->backendService->getAuthMechanism('identifier:\Auth\Mechanism');
+
+        $storage = new StorageConfig(255);
+        $storage->setMountPoint('mountpoint');
+        $storage->setBackend($backend);
+        $storage->setAuthMechanism($authMechanism);
+        $storage->setBackendOptions(['password' => 'testPassword']);
+
+        $newStorage = $this->globalStoragesService->addStorage($storage);
+
+        $retrievedStorage = $this->service->getStorage($newStorage->getId());
+        $retrievedStorage->setMountPoint('abc');
+        $this->service->updateStorage($retrievedStorage);
+    }
+
+
+    public function testNonExistingStorage(): void {
+        $this->expectException(\DomainException::class);
+
+        $this->ActualNonExistingStorageTest();
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('deleteStorageDataProvider')]
+    public function testDeleteStorage($backendOptions, $rustyStorageId): void {
+        $this->expectException(\DomainException::class);
+
+        $backend = $this->backendService->getBackend('identifier:\OCA\Files_External\Lib\Backend\SMB');
+        $authMechanism = $this->backendService->getAuthMechanism('identifier:\Auth\Mechanism');
+
+        $storage = new StorageConfig(255);
+        $storage->setMountPoint('mountpoint');
+        $storage->setBackend($backend);
+        $storage->setAuthMechanism($authMechanism);
+        $storage->setBackendOptions($backendOptions);
+
+        $newStorage = $this->globalStoragesService->addStorage($storage);
+        $id = $newStorage->getId();
+
+        $this->service->removeStorage($id);
+    }
+
+
+    public function testDeleteUnexistingStorage(): void {
+        $this->expectException(\DomainException::class);
+
+        $this->actualDeletedUnexistingStorageTest();
+    }
+
+    public static function getUniqueStoragesProvider(): array {
+        return [
+            // 'all' vs group
+            [100, [], [], 100, [], [self::GROUP_ID], 2],
+            [100, [], [self::GROUP_ID], 100, [], [], 1],
+
+            // 'all' vs user
+            [100, [], [], 100, [self::USER_ID], [], 2],
+            [100, [self::USER_ID], [], 100, [], [], 1],
+
+            // group vs user
+            [100, [], [self::GROUP_ID], 100, [self::USER_ID], [], 2],
+            [100, [self::USER_ID], [], 100, [], [self::GROUP_ID], 1],
+
+            // group+user vs group
+            [100, [], [self::GROUP_ID2], 100, [self::USER_ID], [self::GROUP_ID], 2],
+            [100, [self::USER_ID], [self::GROUP_ID], 100, [], [self::GROUP_ID2], 1],
+
+            // user vs 'all' (higher priority)
+            [200, [], [], 100, [self::USER_ID], [], 2],
+            [100, [self::USER_ID], [], 200, [], [], 1],
+
+            // group vs group (higher priority)
+            [100, [], [self::GROUP_ID2], 200, [], [self::GROUP_ID], 2],
+            [200, [], [self::GROUP_ID], 100, [], [self::GROUP_ID2], 1],
+        ];
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('getUniqueStoragesProvider')]
+    public function testGetUniqueStorages(
+        $priority1, $applicableUsers1, $applicableGroups1,
+        $priority2, $applicableUsers2, $applicableGroups2,
+        $expectedPrecedence,
+    ): void {
+        $backend = $this->backendService->getBackend('identifier:\OCA\Files_External\Lib\Backend\SMB');
+        $backend->method('isVisibleFor')
+            ->willReturn(true);
+        $authMechanism = $this->backendService->getAuthMechanism('identifier:\Auth\Mechanism');
+        $authMechanism->method('isVisibleFor')
+            ->willReturn(true);
+
+        $storage1 = new StorageConfig();
+        $storage1->setMountPoint('mountpoint');
+        $storage1->setBackend($backend);
+        $storage1->setAuthMechanism($authMechanism);
+        $storage1->setBackendOptions(['password' => 'testPassword']);
+        $storage1->setPriority($priority1);
+        $storage1->setApplicableUsers($applicableUsers1);
+        $storage1->setApplicableGroups($applicableGroups1);
+
+        $storage1 = $this->globalStoragesService->addStorage($storage1);
+
+        $storage2 = new StorageConfig();
+        $storage2->setMountPoint('mountpoint');
+        $storage2->setBackend($backend);
+        $storage2->setAuthMechanism($authMechanism);
+        $storage2->setBackendOptions(['password' => 'testPassword']);
+        $storage2->setPriority($priority2);
+        $storage2->setApplicableUsers($applicableUsers2);
+        $storage2->setApplicableGroups($applicableGroups2);
+
+        $storage2 = $this->globalStoragesService->addStorage($storage2);
+
+        $storages = $this->service->getUniqueStorages();
+        $this->assertCount(1, $storages);
+
+        if ($expectedPrecedence === 1) {
+            $this->assertArrayHasKey($storage1->getID(), $storages);
+        } elseif ($expectedPrecedence === 2) {
+            $this->assertArrayHasKey($storage2->getID(), $storages);
+        }
+    }
+
+    public function testGetStoragesBackendNotVisible(): void {
+        // we don't test this here
+        $this->addToAssertionCount(1);
+    }
+
+    public function testGetStoragesAuthMechanismNotVisible(): void {
+        // we don't test this here
+        $this->addToAssertionCount(1);
+    }
+
+    public function testHooksAddStorage($a = null, $b = null, $c = null): void {
+        // we don't test this here
+        $this->addToAssertionCount(1);
+    }
+
+    public function testHooksUpdateStorage($a = null, $b = null, $c = null, $d = null, $e = null): void {
+        // we don't test this here
+        $this->addToAssertionCount(1);
+    }
+
+    public function testHooksRenameMountPoint(): void {
+        // we don't test this here
+        $this->addToAssertionCount(1);
+    }
+
+    public function testHooksDeleteStorage($a = null, $b = null, $c = null): void {
+        // we don't test this here
+        $this->addToAssertionCount(1);
+    }
+
+    public function testLegacyConfigConversionApplicableAll(): void {
+        // we don't test this here
+        $this->addToAssertionCount(1);
+    }
+
+    public function testLegacyConfigConversionApplicableUserAndGroup(): void {
+        // we don't test this here
+        $this->addToAssertionCount(1);
+    }
+
+    public function testReadLegacyConfigAndGenerateConfigId(): void {
+        // we don't test this here
+        $this->addToAssertionCount(1);
+    }
+
+    public function testReadLegacyConfigNoAuthMechanism(): void {
+        // we don't test this here
+        $this->addToAssertionCount(1);
+    }
+
+    public function testReadLegacyConfigClass(): void {
+        // we don't test this here
+        $this->addToAssertionCount(1);
+    }
+
+    public function testReadEmptyMountPoint(): void {
+        // we don't test this here
+        $this->addToAssertionCount(1);
+    }
+
+    public function testUpdateStorageMountPoint(): void {
+        // we don't test this here
+        $this->addToAssertionCount(1);
+    }
 }

apps/files_external/tests/Service/GlobalStoragesServiceTest.php

Indentation +582 added lines, -582 removed lines

@@ -17,586 +17,586 @@
  * @group DB
  */
 class GlobalStoragesServiceTest extends StoragesServiceTestCase {
-	protected function setUp(): void {
-		parent::setUp();
-		$this->service = new GlobalStoragesService($this->backendService, $this->dbConfig, $this->mountCache, $this->eventDispatcher);
-	}
-
-	protected function tearDown(): void {
-		@unlink($this->dataDir . '/mount.json');
-		parent::tearDown();
-	}
-
-	protected 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',
-			],
-			'applicableUsers' => [],
-			'applicableGroups' => [],
-			'priority' => 15,
-			'mountOptions' => [
-				'preview' => false,
-			]
-		]);
-	}
-
-	public static function storageDataProvider(): array {
-		return [
-			// all users
-			[
-				[
-					'mountPoint' => 'mountpoint',
-					'backendIdentifier' => 'identifier:\OCA\Files_External\Lib\Backend\SMB',
-					'authMechanismIdentifier' => 'identifier:\Auth\Mechanism',
-					'backendOptions' => [
-						'option1' => 'value1',
-						'option2' => 'value2',
-						'password' => 'testPassword',
-					],
-					'applicableUsers' => [],
-					'applicableGroups' => [],
-					'priority' => 15,
-				],
-			],
-			// some users
-			[
-				[
-					'mountPoint' => 'mountpoint',
-					'backendIdentifier' => 'identifier:\OCA\Files_External\Lib\Backend\SMB',
-					'authMechanismIdentifier' => 'identifier:\Auth\Mechanism',
-					'backendOptions' => [
-						'option1' => 'value1',
-						'option2' => 'value2',
-						'password' => 'testPassword',
-					],
-					'applicableUsers' => ['user1', 'user2'],
-					'applicableGroups' => [],
-					'priority' => 15,
-				],
-			],
-			// some groups
-			[
-				[
-					'mountPoint' => 'mountpoint',
-					'backendIdentifier' => 'identifier:\OCA\Files_External\Lib\Backend\SMB',
-					'authMechanismIdentifier' => 'identifier:\Auth\Mechanism',
-					'backendOptions' => [
-						'option1' => 'value1',
-						'option2' => 'value2',
-						'password' => 'testPassword',
-					],
-					'applicableUsers' => [],
-					'applicableGroups' => ['group1', 'group2'],
-					'priority' => 15,
-				],
-			],
-			// both users and groups
-			[
-				[
-					'mountPoint' => 'mountpoint',
-					'backendIdentifier' => 'identifier:\OCA\Files_External\Lib\Backend\SMB',
-					'authMechanismIdentifier' => 'identifier:\Auth\Mechanism',
-					'backendOptions' => [
-						'option1' => 'value1',
-						'option2' => 'value2',
-						'password' => 'testPassword',
-					],
-					'applicableUsers' => ['user1', 'user2'],
-					'applicableGroups' => ['group1', 'group2'],
-					'priority' => 15,
-				],
-			],
-		];
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('storageDataProvider')]
-	public function testAddStorage($storageParams): void {
-		$storage = $this->makeStorageConfig($storageParams);
-		$newStorage = $this->service->addStorage($storage);
-
-		$baseId = $newStorage->getId();
-
-		$newStorage = $this->service->getStorage($baseId);
-
-		$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($storage->getApplicableUsers(), $newStorage->getApplicableUsers());
-		$this->assertEquals($storage->getApplicableGroups(), $newStorage->getApplicableGroups());
-		$this->assertEquals($storage->getPriority(), $newStorage->getPriority());
-		$this->assertEquals(0, $newStorage->getStatus());
-
-		$nextStorage = $this->service->addStorage($storage);
-		$this->assertEquals($baseId + 1, $nextStorage->getId());
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('storageDataProvider')]
-	public function testUpdateStorage($updatedStorageParams): void {
-		$updatedStorage = $this->makeStorageConfig($updatedStorageParams);
-		$storage = $this->makeStorageConfig([
-			'mountPoint' => 'mountpoint',
-			'backendIdentifier' => 'identifier:\OCA\Files_External\Lib\Backend\SMB',
-			'authMechanismIdentifier' => 'identifier:\Auth\Mechanism',
-			'backendOptions' => [
-				'option1' => 'value1',
-				'option2' => 'value2',
-				'password' => 'testPassword',
-			],
-			'applicableUsers' => [],
-			'applicableGroups' => [],
-			'priority' => 15,
-		]);
-
-		$newStorage = $this->service->addStorage($storage);
-		$id = $newStorage->getId();
-
-		$updatedStorage->setId($id);
-
-		$this->service->updateStorage($updatedStorage);
-		$newStorage = $this->service->getStorage($id);
-
-		$this->assertEquals($updatedStorage->getMountPoint(), $newStorage->getMountPoint());
-		$this->assertEquals($updatedStorage->getBackendOptions()['password'], $newStorage->getBackendOptions()['password']);
-		$this->assertEqualsCanonicalizing($updatedStorage->getApplicableUsers(), $newStorage->getApplicableUsers());
-		$this->assertEquals($updatedStorage->getApplicableGroups(), $newStorage->getApplicableGroups());
-		$this->assertEquals($updatedStorage->getPriority(), $newStorage->getPriority());
-		$this->assertEquals(0, $newStorage->getStatus());
-	}
-
-	public static function hooksAddStorageDataProvider(): array {
-		return [
-			// applicable all
-			[
-				[],
-				[],
-				// expected hook calls
-				[
-					[
-						Filesystem::signal_create_mount,
-						MountConfig::MOUNT_TYPE_USER,
-						'all'
-					],
-				],
-			],
-			// single user
-			[
-				['user1'],
-				[],
-				// expected hook calls
-				[
-					[
-						Filesystem::signal_create_mount,
-						MountConfig::MOUNT_TYPE_USER,
-						'user1',
-					],
-				],
-			],
-			// single group
-			[
-				[],
-				['group1'],
-				// expected hook calls
-				[
-					[
-						Filesystem::signal_create_mount,
-						MountConfig::MOUNT_TYPE_GROUP,
-						'group1',
-					],
-				],
-			],
-			// multiple users
-			[
-				['user1', 'user2'],
-				[],
-				[
-					[
-						Filesystem::signal_create_mount,
-						MountConfig::MOUNT_TYPE_USER,
-						'user1',
-					],
-					[
-						Filesystem::signal_create_mount,
-						MountConfig::MOUNT_TYPE_USER,
-						'user2',
-					],
-				],
-			],
-			// multiple groups
-			[
-				[],
-				['group1', 'group2'],
-				// expected hook calls
-				[
-					[
-						Filesystem::signal_create_mount,
-						MountConfig::MOUNT_TYPE_GROUP,
-						'group1'
-					],
-					[
-						Filesystem::signal_create_mount,
-						MountConfig::MOUNT_TYPE_GROUP,
-						'group2'
-					],
-				],
-			],
-			// mixed groups and users
-			[
-				['user1', 'user2'],
-				['group1', 'group2'],
-				// expected hook calls
-				[
-					[
-						Filesystem::signal_create_mount,
-						MountConfig::MOUNT_TYPE_USER,
-						'user1',
-					],
-					[
-						Filesystem::signal_create_mount,
-						MountConfig::MOUNT_TYPE_USER,
-						'user2',
-					],
-					[
-						Filesystem::signal_create_mount,
-						MountConfig::MOUNT_TYPE_GROUP,
-						'group1'
-					],
-					[
-						Filesystem::signal_create_mount,
-						MountConfig::MOUNT_TYPE_GROUP,
-						'group2'
-					],
-				],
-			],
-		];
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('hooksAddStorageDataProvider')]
-	public function testHooksAddStorage($applicableUsers, $applicableGroups, $expectedCalls): void {
-		$storage = $this->makeTestStorageData();
-		$storage->setApplicableUsers($applicableUsers);
-		$storage->setApplicableGroups($applicableGroups);
-		$this->service->addStorage($storage);
-
-		$this->assertCount(count($expectedCalls), self::$hookCalls);
-
-		foreach ($expectedCalls as $index => $call) {
-			$this->assertHookCall(
-				self::$hookCalls[$index],
-				$call[0],
-				$storage->getMountPoint(),
-				$call[1],
-				$call[2]
-			);
-		}
-	}
-
-	public static function hooksUpdateStorageDataProvider(): array {
-		return [
-			[
-				// nothing to multiple users and groups
-				[],
-				[],
-				['user1', 'user2'],
-				['group1', 'group2'],
-				// expected hook calls
-				[
-					// delete the "all entry"
-					[
-						Filesystem::signal_delete_mount,
-						MountConfig::MOUNT_TYPE_USER,
-						'all',
-					],
-					[
-						Filesystem::signal_create_mount,
-						MountConfig::MOUNT_TYPE_USER,
-						'user1',
-					],
-					[
-						Filesystem::signal_create_mount,
-						MountConfig::MOUNT_TYPE_USER,
-						'user2',
-					],
-					[
-						Filesystem::signal_create_mount,
-						MountConfig::MOUNT_TYPE_GROUP,
-						'group1'
-					],
-					[
-						Filesystem::signal_create_mount,
-						MountConfig::MOUNT_TYPE_GROUP,
-						'group2'
-					],
-				],
-			],
-			[
-				// adding a user and a group
-				['user1'],
-				['group1'],
-				['user1', 'user2'],
-				['group1', 'group2'],
-				// expected hook calls
-				[
-					[
-						Filesystem::signal_create_mount,
-						MountConfig::MOUNT_TYPE_USER,
-						'user2',
-					],
-					[
-						Filesystem::signal_create_mount,
-						MountConfig::MOUNT_TYPE_GROUP,
-						'group2'
-					],
-				],
-			],
-			[
-				// removing a user and a group
-				['user1', 'user2'],
-				['group1', 'group2'],
-				['user1'],
-				['group1'],
-				// expected hook calls
-				[
-					[
-						Filesystem::signal_delete_mount,
-						MountConfig::MOUNT_TYPE_USER,
-						'user2',
-					],
-					[
-						Filesystem::signal_delete_mount,
-						MountConfig::MOUNT_TYPE_GROUP,
-						'group2'
-					],
-				],
-			],
-			[
-				// removing all
-				['user1'],
-				['group1'],
-				[],
-				[],
-				// expected hook calls
-				[
-					[
-						Filesystem::signal_delete_mount,
-						MountConfig::MOUNT_TYPE_USER,
-						'user1',
-					],
-					[
-						Filesystem::signal_delete_mount,
-						MountConfig::MOUNT_TYPE_GROUP,
-						'group1'
-					],
-					// create the "all" entry
-					[
-						Filesystem::signal_create_mount,
-						MountConfig::MOUNT_TYPE_USER,
-						'all'
-					],
-				],
-			],
-			[
-				// no changes
-				['user1'],
-				['group1'],
-				['user1'],
-				['group1'],
-				// no hook calls
-				[]
-			]
-		];
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('hooksUpdateStorageDataProvider')]
-	public function testHooksUpdateStorage(
-		array $sourceApplicableUsers,
-		array $sourceApplicableGroups,
-		array $updatedApplicableUsers,
-		array $updatedApplicableGroups,
-		array $expectedCalls,
-	): void {
-		$storage = $this->makeTestStorageData();
-		$storage->setApplicableUsers($sourceApplicableUsers);
-		$storage->setApplicableGroups($sourceApplicableGroups);
-		$storage = $this->service->addStorage($storage);
-
-		$storage->setApplicableUsers($updatedApplicableUsers);
-		$storage->setApplicableGroups($updatedApplicableGroups);
-
-		// reset calls
-		self::$hookCalls = [];
-
-		$this->service->updateStorage($storage);
-
-		$this->assertCount(count($expectedCalls), self::$hookCalls);
-
-		foreach ($expectedCalls as $index => $call) {
-			$this->assertHookCall(
-				self::$hookCalls[$index],
-				$call[0],
-				'/mountpoint',
-				$call[1],
-				$call[2]
-			);
-		}
-	}
-
-
-	public function testHooksRenameMountPoint(): void {
-		$storage = $this->makeTestStorageData();
-		$storage->setApplicableUsers(['user1', 'user2']);
-		$storage->setApplicableGroups(['group1', 'group2']);
-		$storage = $this->service->addStorage($storage);
-
-		$storage->setMountPoint('renamedMountpoint');
-
-		// reset calls
-		self::$hookCalls = [];
-
-		$this->service->updateStorage($storage);
-
-		$expectedCalls = [
-			// deletes old mount
-			[
-				Filesystem::signal_delete_mount,
-				'/mountpoint',
-				MountConfig::MOUNT_TYPE_USER,
-				'user1',
-			],
-			[
-				Filesystem::signal_delete_mount,
-				'/mountpoint',
-				MountConfig::MOUNT_TYPE_USER,
-				'user2',
-			],
-			[
-				Filesystem::signal_delete_mount,
-				'/mountpoint',
-				MountConfig::MOUNT_TYPE_GROUP,
-				'group1',
-			],
-			[
-				Filesystem::signal_delete_mount,
-				'/mountpoint',
-				MountConfig::MOUNT_TYPE_GROUP,
-				'group2',
-			],
-			// creates new one
-			[
-				Filesystem::signal_create_mount,
-				'/renamedMountpoint',
-				MountConfig::MOUNT_TYPE_USER,
-				'user1',
-			],
-			[
-				Filesystem::signal_create_mount,
-				'/renamedMountpoint',
-				MountConfig::MOUNT_TYPE_USER,
-				'user2',
-			],
-			[
-				Filesystem::signal_create_mount,
-				'/renamedMountpoint',
-				MountConfig::MOUNT_TYPE_GROUP,
-				'group1',
-			],
-			[
-				Filesystem::signal_create_mount,
-				'/renamedMountpoint',
-				MountConfig::MOUNT_TYPE_GROUP,
-				'group2',
-			],
-		];
-
-		$this->assertCount(count($expectedCalls), self::$hookCalls);
-
-		foreach ($expectedCalls as $index => $call) {
-			$this->assertHookCall(
-				self::$hookCalls[$index],
-				$call[0],
-				$call[1],
-				$call[2],
-				$call[3]
-			);
-		}
-	}
-
-	public static function hooksDeleteStorageDataProvider(): array {
-		return [
-			[
-				['user1', 'user2'],
-				['group1', 'group2'],
-				// expected hook calls
-				[
-					[
-						Filesystem::signal_delete_mount,
-						MountConfig::MOUNT_TYPE_USER,
-						'user1',
-					],
-					[
-						Filesystem::signal_delete_mount,
-						MountConfig::MOUNT_TYPE_USER,
-						'user2',
-					],
-					[
-						Filesystem::signal_delete_mount,
-						MountConfig::MOUNT_TYPE_GROUP,
-						'group1'
-					],
-					[
-						Filesystem::signal_delete_mount,
-						MountConfig::MOUNT_TYPE_GROUP,
-						'group2'
-					],
-				],
-			],
-			[
-				// deleting "all" entry
-				[],
-				[],
-				[
-					[
-						Filesystem::signal_delete_mount,
-						MountConfig::MOUNT_TYPE_USER,
-						'all',
-					],
-				],
-			],
-		];
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('hooksDeleteStorageDataProvider')]
-	public function testHooksDeleteStorage(
-		array $sourceApplicableUsers,
-		array $sourceApplicableGroups,
-		array $expectedCalls,
-	): void {
-		$storage = $this->makeTestStorageData();
-		$storage->setApplicableUsers($sourceApplicableUsers);
-		$storage->setApplicableGroups($sourceApplicableGroups);
-		$storage = $this->service->addStorage($storage);
-
-		// reset calls
-		self::$hookCalls = [];
-
-		$this->service->removeStorage($storage->getId());
-
-		$this->assertCount(count($expectedCalls), self::$hookCalls);
-
-		foreach ($expectedCalls as $index => $call) {
-			$this->assertHookCall(
-				self::$hookCalls[$index],
-				$call[0],
-				'/mountpoint',
-				$call[1],
-				$call[2]
-			);
-		}
-	}
+    protected function setUp(): void {
+        parent::setUp();
+        $this->service = new GlobalStoragesService($this->backendService, $this->dbConfig, $this->mountCache, $this->eventDispatcher);
+    }
+
+    protected function tearDown(): void {
+        @unlink($this->dataDir . '/mount.json');
+        parent::tearDown();
+    }
+
+    protected 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',
+            ],
+            'applicableUsers' => [],
+            'applicableGroups' => [],
+            'priority' => 15,
+            'mountOptions' => [
+                'preview' => false,
+            ]
+        ]);
+    }
+
+    public static function storageDataProvider(): array {
+        return [
+            // all users
+            [
+                [
+                    'mountPoint' => 'mountpoint',
+                    'backendIdentifier' => 'identifier:\OCA\Files_External\Lib\Backend\SMB',
+                    'authMechanismIdentifier' => 'identifier:\Auth\Mechanism',
+                    'backendOptions' => [
+                        'option1' => 'value1',
+                        'option2' => 'value2',
+                        'password' => 'testPassword',
+                    ],
+                    'applicableUsers' => [],
+                    'applicableGroups' => [],
+                    'priority' => 15,
+                ],
+            ],
+            // some users
+            [
+                [
+                    'mountPoint' => 'mountpoint',
+                    'backendIdentifier' => 'identifier:\OCA\Files_External\Lib\Backend\SMB',
+                    'authMechanismIdentifier' => 'identifier:\Auth\Mechanism',
+                    'backendOptions' => [
+                        'option1' => 'value1',
+                        'option2' => 'value2',
+                        'password' => 'testPassword',
+                    ],
+                    'applicableUsers' => ['user1', 'user2'],
+                    'applicableGroups' => [],
+                    'priority' => 15,
+                ],
+            ],
+            // some groups
+            [
+                [
+                    'mountPoint' => 'mountpoint',
+                    'backendIdentifier' => 'identifier:\OCA\Files_External\Lib\Backend\SMB',
+                    'authMechanismIdentifier' => 'identifier:\Auth\Mechanism',
+                    'backendOptions' => [
+                        'option1' => 'value1',
+                        'option2' => 'value2',
+                        'password' => 'testPassword',
+                    ],
+                    'applicableUsers' => [],
+                    'applicableGroups' => ['group1', 'group2'],
+                    'priority' => 15,
+                ],
+            ],
+            // both users and groups
+            [
+                [
+                    'mountPoint' => 'mountpoint',
+                    'backendIdentifier' => 'identifier:\OCA\Files_External\Lib\Backend\SMB',
+                    'authMechanismIdentifier' => 'identifier:\Auth\Mechanism',
+                    'backendOptions' => [
+                        'option1' => 'value1',
+                        'option2' => 'value2',
+                        'password' => 'testPassword',
+                    ],
+                    'applicableUsers' => ['user1', 'user2'],
+                    'applicableGroups' => ['group1', 'group2'],
+                    'priority' => 15,
+                ],
+            ],
+        ];
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('storageDataProvider')]
+    public function testAddStorage($storageParams): void {
+        $storage = $this->makeStorageConfig($storageParams);
+        $newStorage = $this->service->addStorage($storage);
+
+        $baseId = $newStorage->getId();
+
+        $newStorage = $this->service->getStorage($baseId);
+
+        $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($storage->getApplicableUsers(), $newStorage->getApplicableUsers());
+        $this->assertEquals($storage->getApplicableGroups(), $newStorage->getApplicableGroups());
+        $this->assertEquals($storage->getPriority(), $newStorage->getPriority());
+        $this->assertEquals(0, $newStorage->getStatus());
+
+        $nextStorage = $this->service->addStorage($storage);
+        $this->assertEquals($baseId + 1, $nextStorage->getId());
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('storageDataProvider')]
+    public function testUpdateStorage($updatedStorageParams): void {
+        $updatedStorage = $this->makeStorageConfig($updatedStorageParams);
+        $storage = $this->makeStorageConfig([
+            'mountPoint' => 'mountpoint',
+            'backendIdentifier' => 'identifier:\OCA\Files_External\Lib\Backend\SMB',
+            'authMechanismIdentifier' => 'identifier:\Auth\Mechanism',
+            'backendOptions' => [
+                'option1' => 'value1',
+                'option2' => 'value2',
+                'password' => 'testPassword',
+            ],
+            'applicableUsers' => [],
+            'applicableGroups' => [],
+            'priority' => 15,
+        ]);
+
+        $newStorage = $this->service->addStorage($storage);
+        $id = $newStorage->getId();
+
+        $updatedStorage->setId($id);
+
+        $this->service->updateStorage($updatedStorage);
+        $newStorage = $this->service->getStorage($id);
+
+        $this->assertEquals($updatedStorage->getMountPoint(), $newStorage->getMountPoint());
+        $this->assertEquals($updatedStorage->getBackendOptions()['password'], $newStorage->getBackendOptions()['password']);
+        $this->assertEqualsCanonicalizing($updatedStorage->getApplicableUsers(), $newStorage->getApplicableUsers());
+        $this->assertEquals($updatedStorage->getApplicableGroups(), $newStorage->getApplicableGroups());
+        $this->assertEquals($updatedStorage->getPriority(), $newStorage->getPriority());
+        $this->assertEquals(0, $newStorage->getStatus());
+    }
+
+    public static function hooksAddStorageDataProvider(): array {
+        return [
+            // applicable all
+            [
+                [],
+                [],
+                // expected hook calls
+                [
+                    [
+                        Filesystem::signal_create_mount,
+                        MountConfig::MOUNT_TYPE_USER,
+                        'all'
+                    ],
+                ],
+            ],
+            // single user
+            [
+                ['user1'],
+                [],
+                // expected hook calls
+                [
+                    [
+                        Filesystem::signal_create_mount,
+                        MountConfig::MOUNT_TYPE_USER,
+                        'user1',
+                    ],
+                ],
+            ],
+            // single group
+            [
+                [],
+                ['group1'],
+                // expected hook calls
+                [
+                    [
+                        Filesystem::signal_create_mount,
+                        MountConfig::MOUNT_TYPE_GROUP,
+                        'group1',
+                    ],
+                ],
+            ],
+            // multiple users
+            [
+                ['user1', 'user2'],
+                [],
+                [
+                    [
+                        Filesystem::signal_create_mount,
+                        MountConfig::MOUNT_TYPE_USER,
+                        'user1',
+                    ],
+                    [
+                        Filesystem::signal_create_mount,
+                        MountConfig::MOUNT_TYPE_USER,
+                        'user2',
+                    ],
+                ],
+            ],
+            // multiple groups
+            [
+                [],
+                ['group1', 'group2'],
+                // expected hook calls
+                [
+                    [
+                        Filesystem::signal_create_mount,
+                        MountConfig::MOUNT_TYPE_GROUP,
+                        'group1'
+                    ],
+                    [
+                        Filesystem::signal_create_mount,
+                        MountConfig::MOUNT_TYPE_GROUP,
+                        'group2'
+                    ],
+                ],
+            ],
+            // mixed groups and users
+            [
+                ['user1', 'user2'],
+                ['group1', 'group2'],
+                // expected hook calls
+                [
+                    [
+                        Filesystem::signal_create_mount,
+                        MountConfig::MOUNT_TYPE_USER,
+                        'user1',
+                    ],
+                    [
+                        Filesystem::signal_create_mount,
+                        MountConfig::MOUNT_TYPE_USER,
+                        'user2',
+                    ],
+                    [
+                        Filesystem::signal_create_mount,
+                        MountConfig::MOUNT_TYPE_GROUP,
+                        'group1'
+                    ],
+                    [
+                        Filesystem::signal_create_mount,
+                        MountConfig::MOUNT_TYPE_GROUP,
+                        'group2'
+                    ],
+                ],
+            ],
+        ];
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('hooksAddStorageDataProvider')]
+    public function testHooksAddStorage($applicableUsers, $applicableGroups, $expectedCalls): void {
+        $storage = $this->makeTestStorageData();
+        $storage->setApplicableUsers($applicableUsers);
+        $storage->setApplicableGroups($applicableGroups);
+        $this->service->addStorage($storage);
+
+        $this->assertCount(count($expectedCalls), self::$hookCalls);
+
+        foreach ($expectedCalls as $index => $call) {
+            $this->assertHookCall(
+                self::$hookCalls[$index],
+                $call[0],
+                $storage->getMountPoint(),
+                $call[1],
+                $call[2]
+            );
+        }
+    }
+
+    public static function hooksUpdateStorageDataProvider(): array {
+        return [
+            [
+                // nothing to multiple users and groups
+                [],
+                [],
+                ['user1', 'user2'],
+                ['group1', 'group2'],
+                // expected hook calls
+                [
+                    // delete the "all entry"
+                    [
+                        Filesystem::signal_delete_mount,
+                        MountConfig::MOUNT_TYPE_USER,
+                        'all',
+                    ],
+                    [
+                        Filesystem::signal_create_mount,
+                        MountConfig::MOUNT_TYPE_USER,
+                        'user1',
+                    ],
+                    [
+                        Filesystem::signal_create_mount,
+                        MountConfig::MOUNT_TYPE_USER,
+                        'user2',
+                    ],
+                    [
+                        Filesystem::signal_create_mount,
+                        MountConfig::MOUNT_TYPE_GROUP,
+                        'group1'
+                    ],
+                    [
+                        Filesystem::signal_create_mount,
+                        MountConfig::MOUNT_TYPE_GROUP,
+                        'group2'
+                    ],
+                ],
+            ],
+            [
+                // adding a user and a group
+                ['user1'],
+                ['group1'],
+                ['user1', 'user2'],
+                ['group1', 'group2'],
+                // expected hook calls
+                [
+                    [
+                        Filesystem::signal_create_mount,
+                        MountConfig::MOUNT_TYPE_USER,
+                        'user2',
+                    ],
+                    [
+                        Filesystem::signal_create_mount,
+                        MountConfig::MOUNT_TYPE_GROUP,
+                        'group2'
+                    ],
+                ],
+            ],
+            [
+                // removing a user and a group
+                ['user1', 'user2'],
+                ['group1', 'group2'],
+                ['user1'],
+                ['group1'],
+                // expected hook calls
+                [
+                    [
+                        Filesystem::signal_delete_mount,
+                        MountConfig::MOUNT_TYPE_USER,
+                        'user2',
+                    ],
+                    [
+                        Filesystem::signal_delete_mount,
+                        MountConfig::MOUNT_TYPE_GROUP,
+                        'group2'
+                    ],
+                ],
+            ],
+            [
+                // removing all
+                ['user1'],
+                ['group1'],
+                [],
+                [],
+                // expected hook calls
+                [
+                    [
+                        Filesystem::signal_delete_mount,
+                        MountConfig::MOUNT_TYPE_USER,
+                        'user1',
+                    ],
+                    [
+                        Filesystem::signal_delete_mount,
+                        MountConfig::MOUNT_TYPE_GROUP,
+                        'group1'
+                    ],
+                    // create the "all" entry
+                    [
+                        Filesystem::signal_create_mount,
+                        MountConfig::MOUNT_TYPE_USER,
+                        'all'
+                    ],
+                ],
+            ],
+            [
+                // no changes
+                ['user1'],
+                ['group1'],
+                ['user1'],
+                ['group1'],
+                // no hook calls
+                []
+            ]
+        ];
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('hooksUpdateStorageDataProvider')]
+    public function testHooksUpdateStorage(
+        array $sourceApplicableUsers,
+        array $sourceApplicableGroups,
+        array $updatedApplicableUsers,
+        array $updatedApplicableGroups,
+        array $expectedCalls,
+    ): void {
+        $storage = $this->makeTestStorageData();
+        $storage->setApplicableUsers($sourceApplicableUsers);
+        $storage->setApplicableGroups($sourceApplicableGroups);
+        $storage = $this->service->addStorage($storage);
+
+        $storage->setApplicableUsers($updatedApplicableUsers);
+        $storage->setApplicableGroups($updatedApplicableGroups);
+
+        // reset calls
+        self::$hookCalls = [];
+
+        $this->service->updateStorage($storage);
+
+        $this->assertCount(count($expectedCalls), self::$hookCalls);
+
+        foreach ($expectedCalls as $index => $call) {
+            $this->assertHookCall(
+                self::$hookCalls[$index],
+                $call[0],
+                '/mountpoint',
+                $call[1],
+                $call[2]
+            );
+        }
+    }
+
+
+    public function testHooksRenameMountPoint(): void {
+        $storage = $this->makeTestStorageData();
+        $storage->setApplicableUsers(['user1', 'user2']);
+        $storage->setApplicableGroups(['group1', 'group2']);
+        $storage = $this->service->addStorage($storage);
+
+        $storage->setMountPoint('renamedMountpoint');
+
+        // reset calls
+        self::$hookCalls = [];
+
+        $this->service->updateStorage($storage);
+
+        $expectedCalls = [
+            // deletes old mount
+            [
+                Filesystem::signal_delete_mount,
+                '/mountpoint',
+                MountConfig::MOUNT_TYPE_USER,
+                'user1',
+            ],
+            [
+                Filesystem::signal_delete_mount,
+                '/mountpoint',
+                MountConfig::MOUNT_TYPE_USER,
+                'user2',
+            ],
+            [
+                Filesystem::signal_delete_mount,
+                '/mountpoint',
+                MountConfig::MOUNT_TYPE_GROUP,
+                'group1',
+            ],
+            [
+                Filesystem::signal_delete_mount,
+                '/mountpoint',
+                MountConfig::MOUNT_TYPE_GROUP,
+                'group2',
+            ],
+            // creates new one
+            [
+                Filesystem::signal_create_mount,
+                '/renamedMountpoint',
+                MountConfig::MOUNT_TYPE_USER,
+                'user1',
+            ],
+            [
+                Filesystem::signal_create_mount,
+                '/renamedMountpoint',
+                MountConfig::MOUNT_TYPE_USER,
+                'user2',
+            ],
+            [
+                Filesystem::signal_create_mount,
+                '/renamedMountpoint',
+                MountConfig::MOUNT_TYPE_GROUP,
+                'group1',
+            ],
+            [
+                Filesystem::signal_create_mount,
+                '/renamedMountpoint',
+                MountConfig::MOUNT_TYPE_GROUP,
+                'group2',
+            ],
+        ];
+
+        $this->assertCount(count($expectedCalls), self::$hookCalls);
+
+        foreach ($expectedCalls as $index => $call) {
+            $this->assertHookCall(
+                self::$hookCalls[$index],
+                $call[0],
+                $call[1],
+                $call[2],
+                $call[3]
+            );
+        }
+    }
+
+    public static function hooksDeleteStorageDataProvider(): array {
+        return [
+            [
+                ['user1', 'user2'],
+                ['group1', 'group2'],
+                // expected hook calls
+                [
+                    [
+                        Filesystem::signal_delete_mount,
+                        MountConfig::MOUNT_TYPE_USER,
+                        'user1',
+                    ],
+                    [
+                        Filesystem::signal_delete_mount,
+                        MountConfig::MOUNT_TYPE_USER,
+                        'user2',
+                    ],
+                    [
+                        Filesystem::signal_delete_mount,
+                        MountConfig::MOUNT_TYPE_GROUP,
+                        'group1'
+                    ],
+                    [
+                        Filesystem::signal_delete_mount,
+                        MountConfig::MOUNT_TYPE_GROUP,
+                        'group2'
+                    ],
+                ],
+            ],
+            [
+                // deleting "all" entry
+                [],
+                [],
+                [
+                    [
+                        Filesystem::signal_delete_mount,
+                        MountConfig::MOUNT_TYPE_USER,
+                        'all',
+                    ],
+                ],
+            ],
+        ];
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('hooksDeleteStorageDataProvider')]
+    public function testHooksDeleteStorage(
+        array $sourceApplicableUsers,
+        array $sourceApplicableGroups,
+        array $expectedCalls,
+    ): void {
+        $storage = $this->makeTestStorageData();
+        $storage->setApplicableUsers($sourceApplicableUsers);
+        $storage->setApplicableGroups($sourceApplicableGroups);
+        $storage = $this->service->addStorage($storage);
+
+        // reset calls
+        self::$hookCalls = [];
+
+        $this->service->removeStorage($storage->getId());
+
+        $this->assertCount(count($expectedCalls), self::$hookCalls);
+
+        foreach ($expectedCalls as $index => $call) {
+            $this->assertHookCall(
+                self::$hookCalls[$index],
+                $call[0],
+                '/mountpoint',
+                $call[1],
+                $call[2]
+            );
+        }
+    }
 }