nextcloud / server

lib/private/Files/Cache/Storage.php

Indentation +208 added lines, -208 removed lines

@@ -24,212 +24,212 @@
  * @package OC\Files\Cache
  */
 class Storage {
-	/** @var StorageGlobal|null */
-	private static $globalCache = null;
-	private $storageId;
-	private $numericId;
-
-	/**
-	 * @return StorageGlobal
-	 */
-	public static function getGlobalCache() {
-		if (is_null(self::$globalCache)) {
-			self::$globalCache = new StorageGlobal(\OC::$server->getDatabaseConnection());
-		}
-		return self::$globalCache;
-	}
-
-	/**
-	 * @param \OC\Files\Storage\Storage|string $storage
-	 * @param bool $isAvailable
-	 * @throws \RuntimeException
-	 */
-	public function __construct($storage, $isAvailable, IDBConnection $connection) {
-		if ($storage instanceof IStorage) {
-			$this->storageId = $storage->getId();
-		} else {
-			$this->storageId = $storage;
-		}
-		$this->storageId = self::adjustStorageId($this->storageId);
-
-		if ($row = self::getStorageById($this->storageId)) {
-			$this->numericId = (int)$row['numeric_id'];
-		} else {
-			$available = $isAvailable ? 1 : 0;
-			if ($connection->insertIfNotExist('*PREFIX*storages', ['id' => $this->storageId, 'available' => $available])) {
-				$this->numericId = $connection->lastInsertId('*PREFIX*storages');
-			} else {
-				if ($row = self::getStorageById($this->storageId)) {
-					$this->numericId = (int)$row['numeric_id'];
-				} else {
-					throw new \RuntimeException('Storage could neither be inserted nor be selected from the database: ' . $this->storageId);
-				}
-			}
-		}
-	}
-
-	/**
-	 * @param string $storageId
-	 * @return array
-	 */
-	public static function getStorageById($storageId) {
-		return self::getGlobalCache()->getStorageInfo($storageId);
-	}
-
-	/**
-	 * Adjusts the storage id to use md5 if too long
-	 * @param string $storageId storage id
-	 * @return string unchanged $storageId if its length is less than 64 characters,
-	 *                else returns the md5 of $storageId
-	 */
-	public static function adjustStorageId($storageId) {
-		if (strlen($storageId) > 64) {
-			return md5($storageId);
-		}
-		return $storageId;
-	}
-
-	/**
-	 * Get the numeric id for the storage
-	 *
-	 * @return int
-	 */
-	public function getNumericId() {
-		return $this->numericId;
-	}
-
-	/**
-	 * Get the string id for the storage
-	 *
-	 * @param int $numericId
-	 * @return string|null either the storage id string or null if the numeric id is not known
-	 */
-	public static function getStorageId(int $numericId): ?string {
-		$storage = self::getGlobalCache()->getStorageInfoByNumericId($numericId);
-		return $storage['id'] ?? null;
-	}
-
-	/**
-	 * Get the numeric of the storage with the provided string id
-	 *
-	 * @param $storageId
-	 * @return int|null either the numeric storage id or null if the storage id is not known
-	 */
-	public static function getNumericStorageId($storageId) {
-		$storageId = self::adjustStorageId($storageId);
-
-		if ($row = self::getStorageById($storageId)) {
-			return (int)$row['numeric_id'];
-		} else {
-			return null;
-		}
-	}
-
-	/**
-	 * @return array [ available, last_checked ]
-	 */
-	public function getAvailability() {
-		if ($row = self::getStorageById($this->storageId)) {
-			return [
-				'available' => (int)$row['available'] === 1,
-				'last_checked' => $row['last_checked']
-			];
-		} else {
-			return [
-				'available' => true,
-				'last_checked' => time(),
-			];
-		}
-	}
-
-	/**
-	 * @param bool $isAvailable
-	 * @param int $delay amount of seconds to delay reconsidering that storage further
-	 */
-	public function setAvailability($isAvailable, int $delay = 0) {
-		$available = $isAvailable ? 1 : 0;
-		if (!$isAvailable) {
-			\OCP\Server::get(LoggerInterface::class)->info('Storage with ' . $this->storageId . ' marked as unavailable', ['app' => 'lib']);
-		}
-
-		$query = \OC::$server->getDatabaseConnection()->getQueryBuilder();
-		$query->update('storages')
-			->set('available', $query->createNamedParameter($available))
-			->set('last_checked', $query->createNamedParameter(time() + $delay))
-			->where($query->expr()->eq('id', $query->createNamedParameter($this->storageId)));
-		$query->executeStatement();
-	}
-
-	/**
-	 * Check if a string storage id is known
-	 *
-	 * @param string $storageId
-	 * @return bool
-	 */
-	public static function exists($storageId) {
-		return !is_null(self::getNumericStorageId($storageId));
-	}
-
-	/**
-	 * remove the entry for the storage
-	 *
-	 * @param string $storageId
-	 */
-	public static function remove($storageId) {
-		$storageId = self::adjustStorageId($storageId);
-		$numericId = self::getNumericStorageId($storageId);
-
-		$query = \OC::$server->getDatabaseConnection()->getQueryBuilder();
-		$query->delete('storages')
-			->where($query->expr()->eq('id', $query->createNamedParameter($storageId)));
-		$query->executeStatement();
-
-		if (!is_null($numericId)) {
-			$query = \OC::$server->getDatabaseConnection()->getQueryBuilder();
-			$query->delete('filecache')
-				->where($query->expr()->eq('storage', $query->createNamedParameter($numericId)));
-			$query->executeStatement();
-		}
-	}
-
-	/**
-	 * remove the entry for the storage by the mount id
-	 *
-	 * @param int $mountId
-	 */
-	public static function cleanByMountId(int $mountId) {
-		$db = \OC::$server->getDatabaseConnection();
-
-		try {
-			$db->beginTransaction();
-
-			$query = $db->getQueryBuilder();
-			$query->select('storage_id')
-				->from('mounts')
-				->where($query->expr()->eq('mount_id', $query->createNamedParameter($mountId, IQueryBuilder::PARAM_INT)));
-			$storageIds = $query->executeQuery()->fetchAll(\PDO::FETCH_COLUMN);
-			$storageIds = array_unique($storageIds);
-
-			$query = $db->getQueryBuilder();
-			$query->delete('filecache')
-				->where($query->expr()->in('storage', $query->createNamedParameter($storageIds, IQueryBuilder::PARAM_INT_ARRAY)));
-			$query->runAcrossAllShards();
-			$query->executeStatement();
-
-			$query = $db->getQueryBuilder();
-			$query->delete('storages')
-				->where($query->expr()->in('numeric_id', $query->createNamedParameter($storageIds, IQueryBuilder::PARAM_INT_ARRAY)));
-			$query->executeStatement();
-
-			$query = $db->getQueryBuilder();
-			$query->delete('mounts')
-				->where($query->expr()->eq('mount_id', $query->createNamedParameter($mountId, IQueryBuilder::PARAM_INT)));
-			$query->executeStatement();
-
-			$db->commit();
-		} catch (\Exception $e) {
-			$db->rollBack();
-			throw $e;
-		}
-	}
+    /** @var StorageGlobal|null */
+    private static $globalCache = null;
+    private $storageId;
+    private $numericId;
+
+    /**
+     * @return StorageGlobal
+     */
+    public static function getGlobalCache() {
+        if (is_null(self::$globalCache)) {
+            self::$globalCache = new StorageGlobal(\OC::$server->getDatabaseConnection());
+        }
+        return self::$globalCache;
+    }
+
+    /**
+     * @param \OC\Files\Storage\Storage|string $storage
+     * @param bool $isAvailable
+     * @throws \RuntimeException
+     */
+    public function __construct($storage, $isAvailable, IDBConnection $connection) {
+        if ($storage instanceof IStorage) {
+            $this->storageId = $storage->getId();
+        } else {
+            $this->storageId = $storage;
+        }
+        $this->storageId = self::adjustStorageId($this->storageId);
+
+        if ($row = self::getStorageById($this->storageId)) {
+            $this->numericId = (int)$row['numeric_id'];
+        } else {
+            $available = $isAvailable ? 1 : 0;
+            if ($connection->insertIfNotExist('*PREFIX*storages', ['id' => $this->storageId, 'available' => $available])) {
+                $this->numericId = $connection->lastInsertId('*PREFIX*storages');
+            } else {
+                if ($row = self::getStorageById($this->storageId)) {
+                    $this->numericId = (int)$row['numeric_id'];
+                } else {
+                    throw new \RuntimeException('Storage could neither be inserted nor be selected from the database: ' . $this->storageId);
+                }
+            }
+        }
+    }
+
+    /**
+     * @param string $storageId
+     * @return array
+     */
+    public static function getStorageById($storageId) {
+        return self::getGlobalCache()->getStorageInfo($storageId);
+    }
+
+    /**
+     * Adjusts the storage id to use md5 if too long
+     * @param string $storageId storage id
+     * @return string unchanged $storageId if its length is less than 64 characters,
+     *                else returns the md5 of $storageId
+     */
+    public static function adjustStorageId($storageId) {
+        if (strlen($storageId) > 64) {
+            return md5($storageId);
+        }
+        return $storageId;
+    }
+
+    /**
+     * Get the numeric id for the storage
+     *
+     * @return int
+     */
+    public function getNumericId() {
+        return $this->numericId;
+    }
+
+    /**
+     * Get the string id for the storage
+     *
+     * @param int $numericId
+     * @return string|null either the storage id string or null if the numeric id is not known
+     */
+    public static function getStorageId(int $numericId): ?string {
+        $storage = self::getGlobalCache()->getStorageInfoByNumericId($numericId);
+        return $storage['id'] ?? null;
+    }
+
+    /**
+     * Get the numeric of the storage with the provided string id
+     *
+     * @param $storageId
+     * @return int|null either the numeric storage id or null if the storage id is not known
+     */
+    public static function getNumericStorageId($storageId) {
+        $storageId = self::adjustStorageId($storageId);
+
+        if ($row = self::getStorageById($storageId)) {
+            return (int)$row['numeric_id'];
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * @return array [ available, last_checked ]
+     */
+    public function getAvailability() {
+        if ($row = self::getStorageById($this->storageId)) {
+            return [
+                'available' => (int)$row['available'] === 1,
+                'last_checked' => $row['last_checked']
+            ];
+        } else {
+            return [
+                'available' => true,
+                'last_checked' => time(),
+            ];
+        }
+    }
+
+    /**
+     * @param bool $isAvailable
+     * @param int $delay amount of seconds to delay reconsidering that storage further
+     */
+    public function setAvailability($isAvailable, int $delay = 0) {
+        $available = $isAvailable ? 1 : 0;
+        if (!$isAvailable) {
+            \OCP\Server::get(LoggerInterface::class)->info('Storage with ' . $this->storageId . ' marked as unavailable', ['app' => 'lib']);
+        }
+
+        $query = \OC::$server->getDatabaseConnection()->getQueryBuilder();
+        $query->update('storages')
+            ->set('available', $query->createNamedParameter($available))
+            ->set('last_checked', $query->createNamedParameter(time() + $delay))
+            ->where($query->expr()->eq('id', $query->createNamedParameter($this->storageId)));
+        $query->executeStatement();
+    }
+
+    /**
+     * Check if a string storage id is known
+     *
+     * @param string $storageId
+     * @return bool
+     */
+    public static function exists($storageId) {
+        return !is_null(self::getNumericStorageId($storageId));
+    }
+
+    /**
+     * remove the entry for the storage
+     *
+     * @param string $storageId
+     */
+    public static function remove($storageId) {
+        $storageId = self::adjustStorageId($storageId);
+        $numericId = self::getNumericStorageId($storageId);
+
+        $query = \OC::$server->getDatabaseConnection()->getQueryBuilder();
+        $query->delete('storages')
+            ->where($query->expr()->eq('id', $query->createNamedParameter($storageId)));
+        $query->executeStatement();
+
+        if (!is_null($numericId)) {
+            $query = \OC::$server->getDatabaseConnection()->getQueryBuilder();
+            $query->delete('filecache')
+                ->where($query->expr()->eq('storage', $query->createNamedParameter($numericId)));
+            $query->executeStatement();
+        }
+    }
+
+    /**
+     * remove the entry for the storage by the mount id
+     *
+     * @param int $mountId
+     */
+    public static function cleanByMountId(int $mountId) {
+        $db = \OC::$server->getDatabaseConnection();
+
+        try {
+            $db->beginTransaction();
+
+            $query = $db->getQueryBuilder();
+            $query->select('storage_id')
+                ->from('mounts')
+                ->where($query->expr()->eq('mount_id', $query->createNamedParameter($mountId, IQueryBuilder::PARAM_INT)));
+            $storageIds = $query->executeQuery()->fetchAll(\PDO::FETCH_COLUMN);
+            $storageIds = array_unique($storageIds);
+
+            $query = $db->getQueryBuilder();
+            $query->delete('filecache')
+                ->where($query->expr()->in('storage', $query->createNamedParameter($storageIds, IQueryBuilder::PARAM_INT_ARRAY)));
+            $query->runAcrossAllShards();
+            $query->executeStatement();
+
+            $query = $db->getQueryBuilder();
+            $query->delete('storages')
+                ->where($query->expr()->in('numeric_id', $query->createNamedParameter($storageIds, IQueryBuilder::PARAM_INT_ARRAY)));
+            $query->executeStatement();
+
+            $query = $db->getQueryBuilder();
+            $query->delete('mounts')
+                ->where($query->expr()->eq('mount_id', $query->createNamedParameter($mountId, IQueryBuilder::PARAM_INT)));
+            $query->executeStatement();
+
+            $db->commit();
+        } catch (\Exception $e) {
+            $db->rollBack();
+            throw $e;
+        }
+    }
 }

apps/files_external/tests/Service/GlobalStoragesServiceTest.php

Indentation +592 added lines, -592 removed lines

@@ -17,596 +17,596 @@
  * @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,
-				],
-			],
-		];
-	}
-
-	/**
-	 * @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());
-	}
-
-	/**
-	 * @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'
-					],
-				],
-			],
-		];
-	}
-
-	/**
-	 * @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
-				[]
-			]
-		];
-	}
-
-	/**
-	 * @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',
-					],
-				],
-			],
-		];
-	}
-
-	/**
-	 * @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,
+                ],
+            ],
+        ];
+    }
+
+    /**
+     * @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());
+    }
+
+    /**
+     * @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'
+                    ],
+                ],
+            ],
+        ];
+    }
+
+    /**
+     * @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
+                []
+            ]
+        ];
+    }
+
+    /**
+     * @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',
+                    ],
+                ],
+            ],
+        ];
+    }
+
+    /**
+     * @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]
+            );
+        }
+    }
 }

apps/files_external/tests/Service/DBConfigServiceTest.php

Indentation +243 added lines, -243 removed lines

@@ -18,259 +18,259 @@
  * @group DB
  */
 class DBConfigServiceTest extends TestCase {
-	private IDBConnection $connection;
-	private DBConfigService $dbConfig;
-
-	private array $mounts = [];
-
-	protected function setUp(): void {
-		parent::setUp();
-		$this->connection = Server::get(IDBConnection::class);
-		$this->dbConfig = new DBConfigService($this->connection, Server::get(ICrypto::class));
-	}
-
-	protected function tearDown(): void {
-		foreach ($this->mounts as $mount) {
-			$this->dbConfig->removeMount($mount);
-		}
-		$this->mounts = [];
-		parent::tearDown();
-	}
-
-	private function addMount(string $mountPoint, string $storageBackend, string $authBackend, int $priority, int $type) {
-		$id = $this->dbConfig->addMount($mountPoint, $storageBackend, $authBackend, $priority, $type);
-		$this->mounts[] = $id;
-		return $id;
-	}
-
-	public function testAddSimpleMount(): void {
-		$id = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
-
-		$mount = $this->dbConfig->getMountById($id);
-		$this->assertEquals('/test', $mount['mount_point']);
-		$this->assertEquals('foo', $mount['storage_backend']);
-		$this->assertEquals('bar', $mount['auth_backend']);
-		$this->assertEquals(100, $mount['priority']);
-		$this->assertEquals(DBConfigService::MOUNT_TYPE_ADMIN, $mount['type']);
-		$this->assertEquals([], $mount['applicable']);
-		$this->assertEquals([], $mount['config']);
-		$this->assertEquals([], $mount['options']);
-	}
-
-	public function testAddApplicable(): void {
-		$id = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
-		$this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_USER, 'test');
-
-		$mount = $this->dbConfig->getMountById($id);
-		$this->assertEquals([
-			['type' => DBConfigService::APPLICABLE_TYPE_USER, 'value' => 'test', 'mount_id' => $id]
-		], $mount['applicable']);
-
-		$this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_GROUP, 'bar');
-		$this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
-
-		$mount = $this->dbConfig->getMountById($id);
-		$this->assertEqualsCanonicalizing([
-			['type' => DBConfigService::APPLICABLE_TYPE_USER, 'value' => 'test', 'mount_id' => $id],
-			['type' => DBConfigService::APPLICABLE_TYPE_GROUP, 'value' => 'bar', 'mount_id' => $id],
-			['type' => DBConfigService::APPLICABLE_TYPE_GLOBAL, 'value' => null, 'mount_id' => $id]
-		], $mount['applicable']);
-	}
-
-	public function testAddApplicableDouble(): void {
-		$id = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
-		$this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_USER, 'test');
-		$this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_USER, 'test');
-
-		$mount = $this->dbConfig->getMountById($id);
-		$this->assertEquals([
-			['type' => DBConfigService::APPLICABLE_TYPE_USER, 'value' => 'test', 'mount_id' => $id]
-		], $mount['applicable']);
-	}
-
-	public function testDeleteMount(): void {
-		$id = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
-
-		$this->dbConfig->removeMount($id);
-
-		$mount = $this->dbConfig->getMountById($id);
-		$this->assertEquals(null, $mount);
-	}
-
-	public function testRemoveApplicable(): void {
-		$id = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
-		$this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_USER, 'test');
-		$this->dbConfig->removeApplicable($id, DBConfigService::APPLICABLE_TYPE_USER, 'test');
-
-		$mount = $this->dbConfig->getMountById($id);
-		$this->assertEquals([], $mount['applicable']);
-	}
-
-	public function testRemoveApplicableGlobal(): void {
-		$id = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
-		$this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
-		$this->dbConfig->removeApplicable($id, DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
-		$this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_USER, 'test');
-
-		$mount = $this->dbConfig->getMountById($id);
-		$this->assertEquals([
-			['type' => DBConfigService::APPLICABLE_TYPE_USER, 'value' => 'test', 'mount_id' => $id]
-		], $mount['applicable']);
-	}
-
-	public function testSetConfig(): void {
-		$id = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
-		$this->dbConfig->setConfig($id, 'foo', 'bar');
-
-		$mount = $this->dbConfig->getMountById($id);
-		$this->assertEquals(['foo' => 'bar'], $mount['config']);
-
-		$this->dbConfig->setConfig($id, 'foo2', 'bar2');
-
-		$mount = $this->dbConfig->getMountById($id);
-		$this->assertEquals(['foo' => 'bar', 'foo2' => 'bar2'], $mount['config']);
-	}
-
-	public function testSetConfigOverwrite(): void {
-		$id = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
-		$this->dbConfig->setConfig($id, 'foo', 'bar');
-		$this->dbConfig->setConfig($id, 'asd', '1');
-		$this->dbConfig->setConfig($id, 'foo', 'qwerty');
-
-		$mount = $this->dbConfig->getMountById($id);
-		$this->assertEquals(['foo' => 'qwerty', 'asd' => '1'], $mount['config']);
-	}
-
-	public function testSetOption(): void {
-		$id = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
-		$this->dbConfig->setOption($id, 'foo', 'bar');
-
-		$mount = $this->dbConfig->getMountById($id);
-		$this->assertEquals(['foo' => 'bar'], $mount['options']);
-
-		$this->dbConfig->setOption($id, 'foo2', 'bar2');
-
-		$mount = $this->dbConfig->getMountById($id);
-		$this->assertEquals(['foo' => 'bar', 'foo2' => 'bar2'], $mount['options']);
-	}
-
-	public function testSetOptionOverwrite(): void {
-		$id = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
-		$this->dbConfig->setOption($id, 'foo', 'bar');
-		$this->dbConfig->setOption($id, 'asd', '1');
-		$this->dbConfig->setOption($id, 'foo', 'qwerty');
-
-		$mount = $this->dbConfig->getMountById($id);
-		$this->assertEquals(['foo' => 'qwerty', 'asd' => '1'], $mount['options']);
-	}
-
-	public function testGetMountsFor(): void {
-		$mounts = $this->dbConfig->getMountsFor(DBConfigService::APPLICABLE_TYPE_USER, 'test');
-		$this->assertEquals([], $mounts);
-
-		$id = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
-		$this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_USER, 'test');
-
-		$mounts = $this->dbConfig->getMountsFor(DBConfigService::APPLICABLE_TYPE_USER, 'test');
-		$this->assertCount(1, $mounts);
-		$this->assertEquals($id, $mounts[0]['mount_id']);
-		$this->assertEquals([['type' => DBConfigService::APPLICABLE_TYPE_USER, 'value' => 'test', 'mount_id' => $id]], $mounts[0]['applicable']);
-	}
-
-	public function testGetAdminMounts(): void {
-		$id1 = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
-		$this->addMount('/test2', 'foo2', 'bar2', 100, DBConfigService::MOUNT_TYPE_PERSONAL);
-
-		$mounts = $this->dbConfig->getAdminMounts();
-		$this->assertCount(1, $mounts);
-		$this->assertEquals($id1, $mounts[0]['mount_id']);
-	}
-
-	public function testGetAdminMountsFor(): void {
-		$id1 = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
-		$this->addMount('/test2', 'foo2', 'bar2', 100, DBConfigService::MOUNT_TYPE_ADMIN);
-		$id3 = $this->addMount('/test3', 'foo3', 'bar3', 100, DBConfigService::MOUNT_TYPE_PERSONAL);
+    private IDBConnection $connection;
+    private DBConfigService $dbConfig;
+
+    private array $mounts = [];
+
+    protected function setUp(): void {
+        parent::setUp();
+        $this->connection = Server::get(IDBConnection::class);
+        $this->dbConfig = new DBConfigService($this->connection, Server::get(ICrypto::class));
+    }
+
+    protected function tearDown(): void {
+        foreach ($this->mounts as $mount) {
+            $this->dbConfig->removeMount($mount);
+        }
+        $this->mounts = [];
+        parent::tearDown();
+    }
+
+    private function addMount(string $mountPoint, string $storageBackend, string $authBackend, int $priority, int $type) {
+        $id = $this->dbConfig->addMount($mountPoint, $storageBackend, $authBackend, $priority, $type);
+        $this->mounts[] = $id;
+        return $id;
+    }
+
+    public function testAddSimpleMount(): void {
+        $id = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
+
+        $mount = $this->dbConfig->getMountById($id);
+        $this->assertEquals('/test', $mount['mount_point']);
+        $this->assertEquals('foo', $mount['storage_backend']);
+        $this->assertEquals('bar', $mount['auth_backend']);
+        $this->assertEquals(100, $mount['priority']);
+        $this->assertEquals(DBConfigService::MOUNT_TYPE_ADMIN, $mount['type']);
+        $this->assertEquals([], $mount['applicable']);
+        $this->assertEquals([], $mount['config']);
+        $this->assertEquals([], $mount['options']);
+    }
+
+    public function testAddApplicable(): void {
+        $id = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
+        $this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_USER, 'test');
+
+        $mount = $this->dbConfig->getMountById($id);
+        $this->assertEquals([
+            ['type' => DBConfigService::APPLICABLE_TYPE_USER, 'value' => 'test', 'mount_id' => $id]
+        ], $mount['applicable']);
+
+        $this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_GROUP, 'bar');
+        $this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
+
+        $mount = $this->dbConfig->getMountById($id);
+        $this->assertEqualsCanonicalizing([
+            ['type' => DBConfigService::APPLICABLE_TYPE_USER, 'value' => 'test', 'mount_id' => $id],
+            ['type' => DBConfigService::APPLICABLE_TYPE_GROUP, 'value' => 'bar', 'mount_id' => $id],
+            ['type' => DBConfigService::APPLICABLE_TYPE_GLOBAL, 'value' => null, 'mount_id' => $id]
+        ], $mount['applicable']);
+    }
+
+    public function testAddApplicableDouble(): void {
+        $id = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
+        $this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_USER, 'test');
+        $this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_USER, 'test');
+
+        $mount = $this->dbConfig->getMountById($id);
+        $this->assertEquals([
+            ['type' => DBConfigService::APPLICABLE_TYPE_USER, 'value' => 'test', 'mount_id' => $id]
+        ], $mount['applicable']);
+    }
+
+    public function testDeleteMount(): void {
+        $id = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
+
+        $this->dbConfig->removeMount($id);
+
+        $mount = $this->dbConfig->getMountById($id);
+        $this->assertEquals(null, $mount);
+    }
+
+    public function testRemoveApplicable(): void {
+        $id = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
+        $this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_USER, 'test');
+        $this->dbConfig->removeApplicable($id, DBConfigService::APPLICABLE_TYPE_USER, 'test');
+
+        $mount = $this->dbConfig->getMountById($id);
+        $this->assertEquals([], $mount['applicable']);
+    }
+
+    public function testRemoveApplicableGlobal(): void {
+        $id = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
+        $this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
+        $this->dbConfig->removeApplicable($id, DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
+        $this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_USER, 'test');
+
+        $mount = $this->dbConfig->getMountById($id);
+        $this->assertEquals([
+            ['type' => DBConfigService::APPLICABLE_TYPE_USER, 'value' => 'test', 'mount_id' => $id]
+        ], $mount['applicable']);
+    }
+
+    public function testSetConfig(): void {
+        $id = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
+        $this->dbConfig->setConfig($id, 'foo', 'bar');
+
+        $mount = $this->dbConfig->getMountById($id);
+        $this->assertEquals(['foo' => 'bar'], $mount['config']);
+
+        $this->dbConfig->setConfig($id, 'foo2', 'bar2');
+
+        $mount = $this->dbConfig->getMountById($id);
+        $this->assertEquals(['foo' => 'bar', 'foo2' => 'bar2'], $mount['config']);
+    }
+
+    public function testSetConfigOverwrite(): void {
+        $id = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
+        $this->dbConfig->setConfig($id, 'foo', 'bar');
+        $this->dbConfig->setConfig($id, 'asd', '1');
+        $this->dbConfig->setConfig($id, 'foo', 'qwerty');
+
+        $mount = $this->dbConfig->getMountById($id);
+        $this->assertEquals(['foo' => 'qwerty', 'asd' => '1'], $mount['config']);
+    }
+
+    public function testSetOption(): void {
+        $id = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
+        $this->dbConfig->setOption($id, 'foo', 'bar');
+
+        $mount = $this->dbConfig->getMountById($id);
+        $this->assertEquals(['foo' => 'bar'], $mount['options']);
+
+        $this->dbConfig->setOption($id, 'foo2', 'bar2');
+
+        $mount = $this->dbConfig->getMountById($id);
+        $this->assertEquals(['foo' => 'bar', 'foo2' => 'bar2'], $mount['options']);
+    }
+
+    public function testSetOptionOverwrite(): void {
+        $id = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
+        $this->dbConfig->setOption($id, 'foo', 'bar');
+        $this->dbConfig->setOption($id, 'asd', '1');
+        $this->dbConfig->setOption($id, 'foo', 'qwerty');
+
+        $mount = $this->dbConfig->getMountById($id);
+        $this->assertEquals(['foo' => 'qwerty', 'asd' => '1'], $mount['options']);
+    }
+
+    public function testGetMountsFor(): void {
+        $mounts = $this->dbConfig->getMountsFor(DBConfigService::APPLICABLE_TYPE_USER, 'test');
+        $this->assertEquals([], $mounts);
+
+        $id = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
+        $this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_USER, 'test');
+
+        $mounts = $this->dbConfig->getMountsFor(DBConfigService::APPLICABLE_TYPE_USER, 'test');
+        $this->assertCount(1, $mounts);
+        $this->assertEquals($id, $mounts[0]['mount_id']);
+        $this->assertEquals([['type' => DBConfigService::APPLICABLE_TYPE_USER, 'value' => 'test', 'mount_id' => $id]], $mounts[0]['applicable']);
+    }
+
+    public function testGetAdminMounts(): void {
+        $id1 = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
+        $this->addMount('/test2', 'foo2', 'bar2', 100, DBConfigService::MOUNT_TYPE_PERSONAL);
+
+        $mounts = $this->dbConfig->getAdminMounts();
+        $this->assertCount(1, $mounts);
+        $this->assertEquals($id1, $mounts[0]['mount_id']);
+    }
+
+    public function testGetAdminMountsFor(): void {
+        $id1 = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
+        $this->addMount('/test2', 'foo2', 'bar2', 100, DBConfigService::MOUNT_TYPE_ADMIN);
+        $id3 = $this->addMount('/test3', 'foo3', 'bar3', 100, DBConfigService::MOUNT_TYPE_PERSONAL);
 
-		$this->dbConfig->addApplicable($id1, DBConfigService::APPLICABLE_TYPE_USER, 'test');
-		$this->dbConfig->addApplicable($id3, DBConfigService::APPLICABLE_TYPE_USER, 'test');
-
-		$mounts = $this->dbConfig->getAdminMountsFor(DBConfigService::APPLICABLE_TYPE_USER, 'test');
-		$this->assertCount(1, $mounts);
-		$this->assertEquals($id1, $mounts[0]['mount_id']);
-		$this->assertEquals([['type' => DBConfigService::APPLICABLE_TYPE_USER, 'value' => 'test', 'mount_id' => $id1]], $mounts[0]['applicable']);
-	}
-
-	public function testGetUserMountsFor(): void {
-		$id1 = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
-		$this->addMount('/test2', 'foo2', 'bar2', 100, DBConfigService::MOUNT_TYPE_PERSONAL);
-		$id3 = $this->addMount('/test3', 'foo3', 'bar3', 100, DBConfigService::MOUNT_TYPE_PERSONAL);
-
-		$this->dbConfig->addApplicable($id1, DBConfigService::APPLICABLE_TYPE_USER, 'test');
-		$this->dbConfig->addApplicable($id3, DBConfigService::APPLICABLE_TYPE_USER, 'test');
-
-		$mounts = $this->dbConfig->getUserMountsFor(DBConfigService::APPLICABLE_TYPE_USER, 'test');
-		$this->assertCount(1, $mounts);
-		$this->assertEquals($id3, $mounts[0]['mount_id']);
-		$this->assertEquals([['type' => DBConfigService::APPLICABLE_TYPE_USER, 'value' => 'test', 'mount_id' => $id3]], $mounts[0]['applicable']);
-	}
-
-	public function testGetAdminMountsForGlobal(): void {
-		$id1 = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
+        $this->dbConfig->addApplicable($id1, DBConfigService::APPLICABLE_TYPE_USER, 'test');
+        $this->dbConfig->addApplicable($id3, DBConfigService::APPLICABLE_TYPE_USER, 'test');
+
+        $mounts = $this->dbConfig->getAdminMountsFor(DBConfigService::APPLICABLE_TYPE_USER, 'test');
+        $this->assertCount(1, $mounts);
+        $this->assertEquals($id1, $mounts[0]['mount_id']);
+        $this->assertEquals([['type' => DBConfigService::APPLICABLE_TYPE_USER, 'value' => 'test', 'mount_id' => $id1]], $mounts[0]['applicable']);
+    }
+
+    public function testGetUserMountsFor(): void {
+        $id1 = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
+        $this->addMount('/test2', 'foo2', 'bar2', 100, DBConfigService::MOUNT_TYPE_PERSONAL);
+        $id3 = $this->addMount('/test3', 'foo3', 'bar3', 100, DBConfigService::MOUNT_TYPE_PERSONAL);
+
+        $this->dbConfig->addApplicable($id1, DBConfigService::APPLICABLE_TYPE_USER, 'test');
+        $this->dbConfig->addApplicable($id3, DBConfigService::APPLICABLE_TYPE_USER, 'test');
+
+        $mounts = $this->dbConfig->getUserMountsFor(DBConfigService::APPLICABLE_TYPE_USER, 'test');
+        $this->assertCount(1, $mounts);
+        $this->assertEquals($id3, $mounts[0]['mount_id']);
+        $this->assertEquals([['type' => DBConfigService::APPLICABLE_TYPE_USER, 'value' => 'test', 'mount_id' => $id3]], $mounts[0]['applicable']);
+    }
+
+    public function testGetAdminMountsForGlobal(): void {
+        $id1 = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
 
-		$this->dbConfig->addApplicable($id1, DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
+        $this->dbConfig->addApplicable($id1, DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
 
-		$mounts = $this->dbConfig->getAdminMountsFor(DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
-		$this->assertCount(1, $mounts);
-		$this->assertEquals($id1, $mounts[0]['mount_id']);
-		$this->assertEquals([['type' => DBConfigService::APPLICABLE_TYPE_GLOBAL, 'value' => null, 'mount_id' => $id1]], $mounts[0]['applicable']);
-	}
+        $mounts = $this->dbConfig->getAdminMountsFor(DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
+        $this->assertCount(1, $mounts);
+        $this->assertEquals($id1, $mounts[0]['mount_id']);
+        $this->assertEquals([['type' => DBConfigService::APPLICABLE_TYPE_GLOBAL, 'value' => null, 'mount_id' => $id1]], $mounts[0]['applicable']);
+    }
 
-	public function testSetMountPoint(): void {
-		$id1 = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
-		$id2 = $this->addMount('/foo', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
-
-		$this->dbConfig->setMountPoint($id1, '/asd');
+    public function testSetMountPoint(): void {
+        $id1 = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
+        $id2 = $this->addMount('/foo', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
+
+        $this->dbConfig->setMountPoint($id1, '/asd');
 
-		$mount = $this->dbConfig->getMountById($id1);
-		$this->assertEquals('/asd', $mount['mount_point']);
-
-		// remains unchanged
-		$mount = $this->dbConfig->getMountById($id2);
-		$this->assertEquals('/foo', $mount['mount_point']);
-	}
+        $mount = $this->dbConfig->getMountById($id1);
+        $this->assertEquals('/asd', $mount['mount_point']);
+
+        // remains unchanged
+        $mount = $this->dbConfig->getMountById($id2);
+        $this->assertEquals('/foo', $mount['mount_point']);
+    }
 
-	public function testSetAuthBackend(): void {
-		$id1 = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
-		$id2 = $this->addMount('/foo', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
+    public function testSetAuthBackend(): void {
+        $id1 = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
+        $id2 = $this->addMount('/foo', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
 
-		$this->dbConfig->setAuthBackend($id1, 'none');
+        $this->dbConfig->setAuthBackend($id1, 'none');
 
-		$mount = $this->dbConfig->getMountById($id1);
-		$this->assertEquals('none', $mount['auth_backend']);
+        $mount = $this->dbConfig->getMountById($id1);
+        $this->assertEquals('none', $mount['auth_backend']);
 
-		// remains unchanged
-		$mount = $this->dbConfig->getMountById($id2);
-		$this->assertEquals('bar', $mount['auth_backend']);
-	}
-
-	public function testGetMountsForDuplicateByGroup(): void {
-		$id1 = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
-
-		$this->dbConfig->addApplicable($id1, DBConfigService::APPLICABLE_TYPE_GROUP, 'group1');
-		$this->dbConfig->addApplicable($id1, DBConfigService::APPLICABLE_TYPE_GROUP, 'group2');
+        // remains unchanged
+        $mount = $this->dbConfig->getMountById($id2);
+        $this->assertEquals('bar', $mount['auth_backend']);
+    }
+
+    public function testGetMountsForDuplicateByGroup(): void {
+        $id1 = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
+
+        $this->dbConfig->addApplicable($id1, DBConfigService::APPLICABLE_TYPE_GROUP, 'group1');
+        $this->dbConfig->addApplicable($id1, DBConfigService::APPLICABLE_TYPE_GROUP, 'group2');
 
-		$mounts = $this->dbConfig->getAdminMountsForMultiple(DBConfigService::APPLICABLE_TYPE_GROUP, ['group1', 'group2']);
-		$this->assertCount(1, $mounts);
-		$this->assertEquals($id1, $mounts[0]['mount_id']);
-	}
+        $mounts = $this->dbConfig->getAdminMountsForMultiple(DBConfigService::APPLICABLE_TYPE_GROUP, ['group1', 'group2']);
+        $this->assertCount(1, $mounts);
+        $this->assertEquals($id1, $mounts[0]['mount_id']);
+    }
 
-	public function testGetAllMounts(): void {
-		$id1 = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
-		$id2 = $this->addMount('/test2', 'foo2', 'bar2', 100, DBConfigService::MOUNT_TYPE_PERSONAL);
+    public function testGetAllMounts(): void {
+        $id1 = $this->addMount('/test', 'foo', 'bar', 100, DBConfigService::MOUNT_TYPE_ADMIN);
+        $id2 = $this->addMount('/test2', 'foo2', 'bar2', 100, DBConfigService::MOUNT_TYPE_PERSONAL);
 
-		$mounts = $this->dbConfig->getAllMounts();
-		$this->assertCount(2, $mounts);
-		$this->assertEquals($id1, $mounts[0]['mount_id']);
-		$this->assertEquals($id2, $mounts[1]['mount_id']);
-	}
+        $mounts = $this->dbConfig->getAllMounts();
+        $this->assertCount(2, $mounts);
+        $this->assertEquals($id1, $mounts[0]['mount_id']);
+        $this->assertEquals($id2, $mounts[1]['mount_id']);
+    }
 }

tests/lib/Files/Storage/Storage.php

Indentation +653 added lines, -653 removed lines

@@ -12,657 +12,657 @@
 use OCP\Files\Storage\IWriteStreamStorage;
 
 abstract class Storage extends \Test\TestCase {
-	/**
-	 * @var \OC\Files\Storage\Storage instance
-	 */
-	protected $instance;
-	protected $waitDelay = 0;
-
-	/**
-	 * Sleep for the number of seconds specified in the
-	 * $waitDelay attribute
-	 */
-	protected function wait() {
-		if ($this->waitDelay > 0) {
-			sleep($this->waitDelay);
-		}
-	}
-
-	/**
-	 * the root folder of the storage should always exist, be readable and be recognized as a directory
-	 */
-	public function testRoot(): void {
-		$this->assertTrue($this->instance->file_exists('/'), 'Root folder does not exist');
-		$this->assertTrue($this->instance->isReadable('/'), 'Root folder is not readable');
-		$this->assertTrue($this->instance->is_dir('/'), 'Root folder is not a directory');
-		$this->assertFalse($this->instance->is_file('/'), 'Root folder is a file');
-		$this->assertEquals('dir', $this->instance->filetype('/'));
-
-		//without this, any further testing would be useless, not an actual requirement for filestorage though
-		$this->assertTrue($this->instance->isUpdatable('/'), 'Root folder is not writable');
-	}
-
-	/**
-	 * Check that the test() function works
-	 */
-	public function testTestFunction(): void {
-		$this->assertTrue($this->instance->test());
-	}
-
-	/**
-	 * @dataProvider directoryProvider
-	 */
-	public function testDirectories($directory): void {
-		$this->assertFalse($this->instance->file_exists('/' . $directory));
-
-		$this->assertTrue($this->instance->mkdir('/' . $directory));
-
-		$this->assertTrue($this->instance->file_exists('/' . $directory));
-		$this->assertTrue($this->instance->is_dir('/' . $directory));
-		$this->assertFalse($this->instance->is_file('/' . $directory));
-		$this->assertEquals('dir', $this->instance->filetype('/' . $directory));
-		$this->assertEquals(0, $this->instance->filesize('/' . $directory));
-		$this->assertTrue($this->instance->isReadable('/' . $directory));
-		$this->assertTrue($this->instance->isUpdatable('/' . $directory));
-
-		$dh = $this->instance->opendir('/');
-		$content = [];
-		while (($file = readdir($dh)) !== false) {
-			if ($file != '.' and $file != '..') {
-				$content[] = $file;
-			}
-		}
-		$this->assertEquals([$directory], $content);
-
-		$content = iterator_to_array($this->instance->getDirectoryContent('/'));
-
-		$this->assertCount(1, $content);
-		$dirEntry = $content[0];
-		unset($dirEntry['scan_permissions']);
-		unset($dirEntry['etag']);
-		$this->assertLessThanOrEqual(1, abs($dirEntry['mtime'] - $this->instance->filemtime($directory)));
-		unset($dirEntry['mtime']);
-		unset($dirEntry['storage_mtime']);
-		$this->assertEquals([
-			'name' => $directory,
-			'mimetype' => $this->instance->getMimeType($directory),
-			'size' => -1,
-			'permissions' => $this->instance->getPermissions($directory),
-		], $dirEntry);
-
-		$this->assertFalse($this->instance->mkdir('/' . $directory)); //can't create existing folders
-		$this->assertTrue($this->instance->rmdir('/' . $directory));
-
-		$this->wait();
-		$this->assertFalse($this->instance->file_exists('/' . $directory));
-
-		$this->assertFalse($this->instance->rmdir('/' . $directory)); //can't remove non existing folders
-
-		$dh = $this->instance->opendir('/');
-		$content = [];
-		while (($file = readdir($dh)) !== false) {
-			if ($file != '.' and $file != '..') {
-				$content[] = $file;
-			}
-		}
-		$this->assertEquals([], $content);
-	}
-
-	public static function fileNameProvider(): array {
-		return [
-			['file.txt'],
-			[' file.txt'],
-			['folder .txt'],
-			['file with space.txt'],
-			['spéciäl fäile'],
-			['test single\'quote.txt'],
-		];
-	}
-
-	public static function directoryProvider(): array {
-		return [
-			['folder'],
-			[' folder'],
-			['folder '],
-			['folder with space'],
-			['spéciäl földer'],
-			['test single\'quote'],
-		];
-	}
-
-	public static function loremFileProvider(): array {
-		$root = \OC::$SERVERROOT . '/tests/data/';
-		return [
-			// small file
-			[$root . 'lorem.txt'],
-			// bigger file (> 8 KB which is the standard PHP block size)
-			[$root . 'lorem-big.txt']
-		];
-	}
-
-	/**
-	 * test the various uses of file_get_contents and file_put_contents
-	 *
-	 * @dataProvider loremFileProvider
-	 */
-	public function testGetPutContents($sourceFile): void {
-		$sourceText = file_get_contents($sourceFile);
-
-		//fill a file with string data
-		$this->instance->file_put_contents('/lorem.txt', $sourceText);
-		$this->assertFalse($this->instance->is_dir('/lorem.txt'));
-		$this->assertEquals($sourceText, $this->instance->file_get_contents('/lorem.txt'), 'data returned from file_get_contents is not equal to the source data');
-
-		//empty the file
-		$this->instance->file_put_contents('/lorem.txt', '');
-		$this->assertEquals('', $this->instance->file_get_contents('/lorem.txt'), 'file not emptied');
-	}
-
-	/**
-	 * test various known mimetypes
-	 */
-	public function testMimeType(): void {
-		$this->assertEquals('httpd/unix-directory', $this->instance->getMimeType('/'));
-		$this->assertEquals(false, $this->instance->getMimeType('/non/existing/file'));
-
-		$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
-		$this->instance->file_put_contents('/lorem.txt', file_get_contents($textFile, 'r'));
-		$this->assertEquals('text/plain', $this->instance->getMimeType('/lorem.txt'));
-
-		$pngFile = \OC::$SERVERROOT . '/tests/data/desktopapp.png';
-		$this->instance->file_put_contents('/desktopapp.png', file_get_contents($pngFile, 'r'));
-		$this->assertEquals('image/png', $this->instance->getMimeType('/desktopapp.png'));
-
-		$svgFile = \OC::$SERVERROOT . '/tests/data/desktopapp.svg';
-		$this->instance->file_put_contents('/desktopapp.svg', file_get_contents($svgFile, 'r'));
-		$this->assertEquals('image/svg+xml', $this->instance->getMimeType('/desktopapp.svg'));
-	}
-
-
-	public static function copyAndMoveProvider(): array {
-		return [
-			['/source.txt', '/target.txt'],
-			['/source.txt', '/target with space.txt'],
-			['/source with space.txt', '/target.txt'],
-			['/source with space.txt', '/target with space.txt'],
-			['/source.txt', '/tärgét.txt'],
-			['/sòurcē.txt', '/target.txt'],
-			['/sòurcē.txt', '/tärgét.txt'],
-			['/single \' quote.txt', '/tar\'get.txt'],
-		];
-	}
-
-	public function initSourceAndTarget($source, $target = null) {
-		$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
-		$this->instance->file_put_contents($source, file_get_contents($textFile));
-		if ($target) {
-			$testContents = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
-			$this->instance->file_put_contents($target, $testContents);
-		}
-	}
-
-	public function assertSameAsLorem($file) {
-		$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
-		$this->assertEquals(
-			file_get_contents($textFile),
-			$this->instance->file_get_contents($file),
-			'Expected ' . $file . ' to be a copy of ' . $textFile
-		);
-	}
-
-	/**
-	 * @dataProvider copyAndMoveProvider
-	 */
-	public function testCopy($source, $target): void {
-		$this->initSourceAndTarget($source);
-
-		$this->instance->copy($source, $target);
-
-		$this->assertTrue($this->instance->file_exists($target), $target . ' was not created');
-		$this->assertSameAsLorem($target);
-		$this->assertTrue($this->instance->file_exists($source), $source . ' was deleted');
-	}
-
-	/**
-	 * @dataProvider copyAndMoveProvider
-	 */
-	public function testMove($source, $target): void {
-		$this->initSourceAndTarget($source);
-
-		$this->instance->rename($source, $target);
-
-		$this->wait();
-		$this->assertTrue($this->instance->file_exists($target), $target . ' was not created');
-		$this->assertFalse($this->instance->file_exists($source), $source . ' still exists');
-		$this->assertSameAsLorem($target);
-	}
-
-	/**
-	 * @dataProvider copyAndMoveProvider
-	 */
-	public function testCopyOverwrite($source, $target): void {
-		$this->initSourceAndTarget($source, $target);
-
-		$this->instance->copy($source, $target);
-
-		$this->assertTrue($this->instance->file_exists($target), $target . ' was not created');
-		$this->assertTrue($this->instance->file_exists($source), $source . ' was deleted');
-		$this->assertSameAsLorem($target);
-		$this->assertSameAsLorem($source);
-	}
-
-	/**
-	 * @dataProvider copyAndMoveProvider
-	 */
-	public function testMoveOverwrite($source, $target): void {
-		$this->initSourceAndTarget($source, $target);
-
-		$this->instance->rename($source, $target);
-
-		$this->assertTrue($this->instance->file_exists($target), $target . ' was not created');
-		$this->assertFalse($this->instance->file_exists($source), $source . ' still exists');
-		$this->assertSameAsLorem($target);
-	}
-
-	public function testLocal(): void {
-		$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
-		$this->instance->file_put_contents('/lorem.txt', file_get_contents($textFile));
-		$localFile = $this->instance->getLocalFile('/lorem.txt');
-		$this->assertTrue(file_exists($localFile));
-		$this->assertEquals(file_get_contents($textFile), file_get_contents($localFile));
-
-		$this->instance->mkdir('/folder');
-		$this->instance->file_put_contents('/folder/lorem.txt', file_get_contents($textFile));
-		$this->instance->file_put_contents('/folder/bar.txt', 'asd');
-		$this->instance->mkdir('/folder/recursive');
-		$this->instance->file_put_contents('/folder/recursive/file.txt', 'foo');
-
-		// test below require to use instance->getLocalFile because the physical storage might be different
-		$localFile = $this->instance->getLocalFile('/folder/lorem.txt');
-		$this->assertTrue(file_exists($localFile));
-		$this->assertEquals(file_get_contents($localFile), file_get_contents($textFile));
-
-		$localFile = $this->instance->getLocalFile('/folder/bar.txt');
-		$this->assertTrue(file_exists($localFile));
-		$this->assertEquals(file_get_contents($localFile), 'asd');
-
-		$localFile = $this->instance->getLocalFile('/folder/recursive/file.txt');
-		$this->assertTrue(file_exists($localFile));
-		$this->assertEquals(file_get_contents($localFile), 'foo');
-	}
-
-	public function testStat(): void {
-		$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
-		$ctimeStart = time();
-		$this->instance->file_put_contents('/lorem.txt', file_get_contents($textFile));
-		$this->assertTrue($this->instance->isReadable('/lorem.txt'));
-		$ctimeEnd = time();
-		$mTime = $this->instance->filemtime('/lorem.txt');
-		$this->assertTrue($this->instance->hasUpdated('/lorem.txt', $ctimeStart - 5));
-		$this->assertTrue($this->instance->hasUpdated('/', $ctimeStart - 5));
-
-		// check that ($ctimeStart - 5) <= $mTime <= ($ctimeEnd + 1)
-		$this->assertGreaterThanOrEqual(($ctimeStart - 5), $mTime);
-		$this->assertLessThanOrEqual(($ctimeEnd + 1), $mTime);
-		$this->assertEquals(filesize($textFile), $this->instance->filesize('/lorem.txt'));
-
-		$stat = $this->instance->stat('/lorem.txt');
-		//only size and mtime are required in the result
-		$this->assertEquals($stat['size'], $this->instance->filesize('/lorem.txt'));
-		$this->assertEquals($stat['mtime'], $mTime);
-
-		if ($this->instance->touch('/lorem.txt', 100) !== false) {
-			$mTime = $this->instance->filemtime('/lorem.txt');
-			$this->assertEquals($mTime, 100);
-		}
-
-		$mtimeStart = time();
-
-		$this->instance->unlink('/lorem.txt');
-		$this->assertTrue($this->instance->hasUpdated('/', $mtimeStart - 5));
-	}
-
-	/**
-	 * Test whether checkUpdate properly returns false when there was
-	 * no change.
-	 */
-	public function testCheckUpdate(): void {
-		if ($this->instance instanceof \OC\Files\Storage\Wrapper\Wrapper) {
-			$this->markTestSkipped('Cannot test update check on wrappers');
-		}
-		$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
-		$watcher = $this->instance->getWatcher();
-		$watcher->setPolicy(Watcher::CHECK_ALWAYS);
-		$this->instance->file_put_contents('/lorem.txt', file_get_contents($textFile));
-		$this->assertTrue($watcher->checkUpdate('/lorem.txt'), 'Update detected');
-		$this->assertFalse($watcher->checkUpdate('/lorem.txt'), 'No update');
-	}
-
-	public function testUnlink(): void {
-		$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
-		$this->instance->file_put_contents('/lorem.txt', file_get_contents($textFile));
-
-		$this->assertTrue($this->instance->file_exists('/lorem.txt'));
-
-		$this->assertTrue($this->instance->unlink('/lorem.txt'));
-		$this->wait();
-
-		$this->assertFalse($this->instance->file_exists('/lorem.txt'));
-	}
-
-	/**
-	 * @dataProvider fileNameProvider
-	 */
-	public function testFOpen($fileName): void {
-		$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
-
-		$fh = @$this->instance->fopen($fileName, 'r');
-		if ($fh) {
-			fclose($fh);
-		}
-		$this->assertFalse($fh);
-		$this->assertFalse($this->instance->file_exists($fileName));
-
-		$fh = $this->instance->fopen($fileName, 'w');
-		fwrite($fh, file_get_contents($textFile));
-		fclose($fh);
-		$this->assertTrue($this->instance->file_exists($fileName));
-
-		$fh = $this->instance->fopen($fileName, 'r');
-		$content = stream_get_contents($fh);
-		$this->assertEquals(file_get_contents($textFile), $content);
-	}
-
-	public function testTouchCreateFile(): void {
-		$this->assertFalse($this->instance->file_exists('touch'));
-		// returns true on success
-		$this->assertTrue($this->instance->touch('touch'));
-		$this->assertTrue($this->instance->file_exists('touch'));
-	}
-
-	public function testRecursiveRmdir(): void {
-		$this->instance->mkdir('folder');
-		$this->instance->mkdir('folder/bar');
-		$this->wait();
-		$this->instance->file_put_contents('folder/asd.txt', 'foobar');
-		$this->instance->file_put_contents('folder/bar/foo.txt', 'asd');
-		$this->assertTrue($this->instance->rmdir('folder'));
-		$this->wait();
-		$this->assertFalse($this->instance->file_exists('folder/asd.txt'));
-		$this->assertFalse($this->instance->file_exists('folder/bar/foo.txt'));
-		$this->assertFalse($this->instance->file_exists('folder/bar'));
-		$this->assertFalse($this->instance->file_exists('folder'));
-	}
-
-	public function testRmdirEmptyFolder(): void {
-		$this->assertTrue($this->instance->mkdir('empty'));
-		$this->wait();
-		$this->assertTrue($this->instance->rmdir('empty'));
-		$this->assertFalse($this->instance->file_exists('empty'));
-	}
-
-	public function testRecursiveUnlink(): void {
-		$this->instance->mkdir('folder');
-		$this->instance->mkdir('folder/bar');
-		$this->instance->file_put_contents('folder/asd.txt', 'foobar');
-		$this->instance->file_put_contents('folder/bar/foo.txt', 'asd');
-		$this->assertTrue($this->instance->unlink('folder'));
-		$this->wait();
-		$this->assertFalse($this->instance->file_exists('folder/asd.txt'));
-		$this->assertFalse($this->instance->file_exists('folder/bar/foo.txt'));
-		$this->assertFalse($this->instance->file_exists('folder/bar'));
-		$this->assertFalse($this->instance->file_exists('folder'));
-	}
-
-	public static function hashProvider(): array {
-		return [
-			['Foobar', 'md5'],
-			['Foobar', 'sha1'],
-			['Foobar', 'sha256'],
-		];
-	}
-
-	/**
-	 * @dataProvider hashProvider
-	 */
-	public function testHash($data, $type): void {
-		$this->instance->file_put_contents('hash.txt', $data);
-		$this->assertEquals(hash($type, $data), $this->instance->hash($type, 'hash.txt'));
-		$this->assertEquals(hash($type, $data, true), $this->instance->hash($type, 'hash.txt', true));
-	}
-
-	public function testHashInFileName(): void {
-		$this->instance->file_put_contents('#test.txt', 'data');
-		$this->assertEquals('data', $this->instance->file_get_contents('#test.txt'));
-
-		$this->instance->mkdir('#foo');
-		$this->instance->file_put_contents('#foo/test.txt', 'data');
-		$this->assertEquals('data', $this->instance->file_get_contents('#foo/test.txt'));
-
-		$dh = $this->instance->opendir('#foo');
-		$content = [];
-		while ($file = readdir($dh)) {
-			if ($file != '.' and $file != '..') {
-				$content[] = $file;
-			}
-		}
-
-		$this->assertEquals(['test.txt'], $content);
-	}
-
-	public function testCopyOverWriteFile(): void {
-		$this->instance->file_put_contents('target.txt', 'foo');
-		$this->instance->file_put_contents('source.txt', 'bar');
-		$this->instance->copy('source.txt', 'target.txt');
-		$this->assertEquals('bar', $this->instance->file_get_contents('target.txt'));
-	}
-
-	public function testRenameOverWriteFile(): void {
-		$this->instance->file_put_contents('target.txt', 'foo');
-		$this->instance->file_put_contents('source.txt', 'bar');
-		$this->instance->rename('source.txt', 'target.txt');
-		$this->assertEquals('bar', $this->instance->file_get_contents('target.txt'));
-		$this->assertFalse($this->instance->file_exists('source.txt'));
-	}
-
-	public function testRenameDirectory(): void {
-		$this->instance->mkdir('source');
-		$this->instance->file_put_contents('source/test1.txt', 'foo');
-		$this->instance->file_put_contents('source/test2.txt', 'qwerty');
-		$this->instance->mkdir('source/subfolder');
-		$this->instance->file_put_contents('source/subfolder/test.txt', 'bar');
-		$this->instance->rename('source', 'target');
-
-		$this->assertFalse($this->instance->file_exists('source'));
-		$this->assertFalse($this->instance->file_exists('source/test1.txt'));
-		$this->assertFalse($this->instance->file_exists('source/test2.txt'));
-		$this->assertFalse($this->instance->file_exists('source/subfolder'));
-		$this->assertFalse($this->instance->file_exists('source/subfolder/test.txt'));
-
-		$this->assertTrue($this->instance->file_exists('target'));
-		$this->assertTrue($this->instance->file_exists('target/test1.txt'));
-		$this->assertTrue($this->instance->file_exists('target/test2.txt'));
-		$this->assertTrue($this->instance->file_exists('target/subfolder'));
-		$this->assertTrue($this->instance->file_exists('target/subfolder/test.txt'));
-
-		$contents = iterator_to_array($this->instance->getDirectoryContent(''));
-		$this->assertCount(1, $contents);
-
-		$this->assertEquals('foo', $this->instance->file_get_contents('target/test1.txt'));
-		$this->assertEquals('qwerty', $this->instance->file_get_contents('target/test2.txt'));
-		$this->assertEquals('bar', $this->instance->file_get_contents('target/subfolder/test.txt'));
-	}
-
-	public function testRenameOverWriteDirectory(): void {
-		$this->instance->mkdir('source');
-		$this->instance->file_put_contents('source/test1.txt', 'foo');
-
-		$this->instance->mkdir('target');
-		$this->instance->file_put_contents('target/test1.txt', 'bar');
-		$this->instance->file_put_contents('target/test2.txt', 'bar');
-
-		$this->assertTrue($this->instance->rename('source', 'target'), 'rename must return true on success');
-
-		$this->assertFalse($this->instance->file_exists('source'), 'source has not been removed');
-		$this->assertFalse($this->instance->file_exists('source/test1.txt'), 'source/test1.txt has not been removed');
-		$this->assertFalse($this->instance->file_exists('target/test2.txt'), 'target/test2.txt has not been removed');
-		$this->assertEquals('foo', $this->instance->file_get_contents('target/test1.txt'), 'target/test1.txt has not been overwritten');
-	}
-
-	public function testRenameOverWriteDirectoryOverFile(): void {
-		$this->instance->mkdir('source');
-		$this->instance->file_put_contents('source/test1.txt', 'foo');
-
-		$this->instance->file_put_contents('target', 'bar');
-
-		$this->assertTrue($this->instance->rename('source', 'target'), 'rename must return true on success');
-
-		$this->assertFalse($this->instance->file_exists('source'));
-		$this->assertFalse($this->instance->file_exists('source/test1.txt'));
-		$this->assertEquals('foo', $this->instance->file_get_contents('target/test1.txt'));
-	}
-
-	public function testCopyDirectory(): void {
-		$this->instance->mkdir('source');
-		$this->instance->file_put_contents('source/test1.txt', 'foo');
-		$this->instance->file_put_contents('source/test2.txt', 'qwerty');
-		$this->instance->mkdir('source/subfolder');
-		$this->instance->file_put_contents('source/subfolder/test.txt', 'bar');
-		$this->instance->copy('source', 'target');
-
-		$this->assertTrue($this->instance->file_exists('source'));
-		$this->assertTrue($this->instance->file_exists('source/test1.txt'));
-		$this->assertTrue($this->instance->file_exists('source/test2.txt'));
-		$this->assertTrue($this->instance->file_exists('source/subfolder'));
-		$this->assertTrue($this->instance->file_exists('source/subfolder/test.txt'));
-
-		$this->assertTrue($this->instance->file_exists('target'));
-		$this->assertTrue($this->instance->file_exists('target/test1.txt'));
-		$this->assertTrue($this->instance->file_exists('target/test2.txt'));
-		$this->assertTrue($this->instance->file_exists('target/subfolder'));
-		$this->assertTrue($this->instance->file_exists('target/subfolder/test.txt'));
-
-		$this->assertEquals('foo', $this->instance->file_get_contents('target/test1.txt'));
-		$this->assertEquals('qwerty', $this->instance->file_get_contents('target/test2.txt'));
-		$this->assertEquals('bar', $this->instance->file_get_contents('target/subfolder/test.txt'));
-	}
-
-	public function testCopyOverWriteDirectory(): void {
-		$this->instance->mkdir('source');
-		$this->instance->file_put_contents('source/test1.txt', 'foo');
-
-		$this->instance->mkdir('target');
-		$this->instance->file_put_contents('target/test1.txt', 'bar');
-		$this->instance->file_put_contents('target/test2.txt', 'bar');
-
-		$this->instance->copy('source', 'target');
-
-		$this->assertFalse($this->instance->file_exists('target/test2.txt'), 'File target/test2.txt should no longer exist, but does');
-		$this->assertEquals('foo', $this->instance->file_get_contents('target/test1.txt'));
-	}
-
-	public function testCopyOverWriteDirectoryOverFile(): void {
-		$this->instance->mkdir('source');
-		$this->instance->file_put_contents('source/test1.txt', 'foo');
-
-		$this->instance->file_put_contents('target', 'bar');
-
-		$this->instance->copy('source', 'target');
-
-		$this->assertEquals('foo', $this->instance->file_get_contents('target/test1.txt'));
-	}
-
-	public function testInstanceOfStorage(): void {
-		$this->assertTrue($this->instance->instanceOfStorage(IStorage::class));
-		$this->assertTrue($this->instance->instanceOfStorage(get_class($this->instance)));
-		$this->assertFalse($this->instance->instanceOfStorage('\OC'));
-	}
-
-	/**
-	 * @dataProvider copyAndMoveProvider
-	 */
-	public function testCopyFromSameStorage($source, $target): void {
-		$this->initSourceAndTarget($source);
-
-		$this->instance->copyFromStorage($this->instance, $source, $target);
-
-		$this->assertTrue($this->instance->file_exists($target), $target . ' was not created');
-		$this->assertSameAsLorem($target);
-		$this->assertTrue($this->instance->file_exists($source), $source . ' was deleted');
-	}
-
-	public function testIsCreatable(): void {
-		$this->instance->mkdir('source');
-		$this->assertTrue($this->instance->isCreatable('source'));
-	}
-
-	public function testIsReadable(): void {
-		$this->instance->mkdir('source');
-		$this->assertTrue($this->instance->isReadable('source'));
-	}
-
-	public function testIsUpdatable(): void {
-		$this->instance->mkdir('source');
-		$this->assertTrue($this->instance->isUpdatable('source'));
-	}
-
-	public function testIsDeletable(): void {
-		$this->instance->mkdir('source');
-		$this->assertTrue($this->instance->isDeletable('source'));
-	}
-
-	public function testIsShareable(): void {
-		$this->instance->mkdir('source');
-		$this->assertTrue($this->instance->isSharable('source'));
-	}
-
-	public function testStatAfterWrite(): void {
-		$this->instance->file_put_contents('foo.txt', 'bar');
-		$stat = $this->instance->stat('foo.txt');
-		$this->assertEquals(3, $stat['size']);
-
-		$fh = $this->instance->fopen('foo.txt', 'w');
-		fwrite($fh, 'qwerty');
-		fclose($fh);
-
-		$stat = $this->instance->stat('foo.txt');
-		$this->assertEquals(6, $stat['size']);
-	}
-
-	public function testPartFile(): void {
-		$this->instance->file_put_contents('bar.txt.part', 'bar');
-		$this->instance->rename('bar.txt.part', 'bar.txt');
-		$this->assertEquals('bar', $this->instance->file_get_contents('bar.txt'));
-	}
-
-	public function testWriteStream(): void {
-		$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
-
-		if (!$this->instance->instanceOfStorage(IWriteStreamStorage::class)) {
-			$this->markTestSkipped('Not a WriteSteamStorage');
-		}
-		/** @var IWriteStreamStorage $storage */
-		$storage = $this->instance;
-
-		$source = fopen($textFile, 'r');
-
-		$storage->writeStream('test.txt', $source);
-		$this->assertTrue($storage->file_exists('test.txt'));
-		$this->assertStringEqualsFile($textFile, $storage->file_get_contents('test.txt'));
-		$this->assertEquals('resource (closed)', gettype($source));
-	}
-
-	public function testFseekSize(): void {
-		$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
-		$this->instance->file_put_contents('bar.txt', file_get_contents($textFile));
-
-		$size = $this->instance->filesize('bar.txt');
-		$this->assertEquals(filesize($textFile), $size);
-		$fh = $this->instance->fopen('bar.txt', 'r');
-
-		fseek($fh, 0, SEEK_END);
-		$pos = ftell($fh);
-
-		$this->assertEquals($size, $pos);
-	}
+    /**
+     * @var \OC\Files\Storage\Storage instance
+     */
+    protected $instance;
+    protected $waitDelay = 0;
+
+    /**
+     * Sleep for the number of seconds specified in the
+     * $waitDelay attribute
+     */
+    protected function wait() {
+        if ($this->waitDelay > 0) {
+            sleep($this->waitDelay);
+        }
+    }
+
+    /**
+     * the root folder of the storage should always exist, be readable and be recognized as a directory
+     */
+    public function testRoot(): void {
+        $this->assertTrue($this->instance->file_exists('/'), 'Root folder does not exist');
+        $this->assertTrue($this->instance->isReadable('/'), 'Root folder is not readable');
+        $this->assertTrue($this->instance->is_dir('/'), 'Root folder is not a directory');
+        $this->assertFalse($this->instance->is_file('/'), 'Root folder is a file');
+        $this->assertEquals('dir', $this->instance->filetype('/'));
+
+        //without this, any further testing would be useless, not an actual requirement for filestorage though
+        $this->assertTrue($this->instance->isUpdatable('/'), 'Root folder is not writable');
+    }
+
+    /**
+     * Check that the test() function works
+     */
+    public function testTestFunction(): void {
+        $this->assertTrue($this->instance->test());
+    }
+
+    /**
+     * @dataProvider directoryProvider
+     */
+    public function testDirectories($directory): void {
+        $this->assertFalse($this->instance->file_exists('/' . $directory));
+
+        $this->assertTrue($this->instance->mkdir('/' . $directory));
+
+        $this->assertTrue($this->instance->file_exists('/' . $directory));
+        $this->assertTrue($this->instance->is_dir('/' . $directory));
+        $this->assertFalse($this->instance->is_file('/' . $directory));
+        $this->assertEquals('dir', $this->instance->filetype('/' . $directory));
+        $this->assertEquals(0, $this->instance->filesize('/' . $directory));
+        $this->assertTrue($this->instance->isReadable('/' . $directory));
+        $this->assertTrue($this->instance->isUpdatable('/' . $directory));
+
+        $dh = $this->instance->opendir('/');
+        $content = [];
+        while (($file = readdir($dh)) !== false) {
+            if ($file != '.' and $file != '..') {
+                $content[] = $file;
+            }
+        }
+        $this->assertEquals([$directory], $content);
+
+        $content = iterator_to_array($this->instance->getDirectoryContent('/'));
+
+        $this->assertCount(1, $content);
+        $dirEntry = $content[0];
+        unset($dirEntry['scan_permissions']);
+        unset($dirEntry['etag']);
+        $this->assertLessThanOrEqual(1, abs($dirEntry['mtime'] - $this->instance->filemtime($directory)));
+        unset($dirEntry['mtime']);
+        unset($dirEntry['storage_mtime']);
+        $this->assertEquals([
+            'name' => $directory,
+            'mimetype' => $this->instance->getMimeType($directory),
+            'size' => -1,
+            'permissions' => $this->instance->getPermissions($directory),
+        ], $dirEntry);
+
+        $this->assertFalse($this->instance->mkdir('/' . $directory)); //can't create existing folders
+        $this->assertTrue($this->instance->rmdir('/' . $directory));
+
+        $this->wait();
+        $this->assertFalse($this->instance->file_exists('/' . $directory));
+
+        $this->assertFalse($this->instance->rmdir('/' . $directory)); //can't remove non existing folders
+
+        $dh = $this->instance->opendir('/');
+        $content = [];
+        while (($file = readdir($dh)) !== false) {
+            if ($file != '.' and $file != '..') {
+                $content[] = $file;
+            }
+        }
+        $this->assertEquals([], $content);
+    }
+
+    public static function fileNameProvider(): array {
+        return [
+            ['file.txt'],
+            [' file.txt'],
+            ['folder .txt'],
+            ['file with space.txt'],
+            ['spéciäl fäile'],
+            ['test single\'quote.txt'],
+        ];
+    }
+
+    public static function directoryProvider(): array {
+        return [
+            ['folder'],
+            [' folder'],
+            ['folder '],
+            ['folder with space'],
+            ['spéciäl földer'],
+            ['test single\'quote'],
+        ];
+    }
+
+    public static function loremFileProvider(): array {
+        $root = \OC::$SERVERROOT . '/tests/data/';
+        return [
+            // small file
+            [$root . 'lorem.txt'],
+            // bigger file (> 8 KB which is the standard PHP block size)
+            [$root . 'lorem-big.txt']
+        ];
+    }
+
+    /**
+     * test the various uses of file_get_contents and file_put_contents
+     *
+     * @dataProvider loremFileProvider
+     */
+    public function testGetPutContents($sourceFile): void {
+        $sourceText = file_get_contents($sourceFile);
+
+        //fill a file with string data
+        $this->instance->file_put_contents('/lorem.txt', $sourceText);
+        $this->assertFalse($this->instance->is_dir('/lorem.txt'));
+        $this->assertEquals($sourceText, $this->instance->file_get_contents('/lorem.txt'), 'data returned from file_get_contents is not equal to the source data');
+
+        //empty the file
+        $this->instance->file_put_contents('/lorem.txt', '');
+        $this->assertEquals('', $this->instance->file_get_contents('/lorem.txt'), 'file not emptied');
+    }
+
+    /**
+     * test various known mimetypes
+     */
+    public function testMimeType(): void {
+        $this->assertEquals('httpd/unix-directory', $this->instance->getMimeType('/'));
+        $this->assertEquals(false, $this->instance->getMimeType('/non/existing/file'));
+
+        $textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+        $this->instance->file_put_contents('/lorem.txt', file_get_contents($textFile, 'r'));
+        $this->assertEquals('text/plain', $this->instance->getMimeType('/lorem.txt'));
+
+        $pngFile = \OC::$SERVERROOT . '/tests/data/desktopapp.png';
+        $this->instance->file_put_contents('/desktopapp.png', file_get_contents($pngFile, 'r'));
+        $this->assertEquals('image/png', $this->instance->getMimeType('/desktopapp.png'));
+
+        $svgFile = \OC::$SERVERROOT . '/tests/data/desktopapp.svg';
+        $this->instance->file_put_contents('/desktopapp.svg', file_get_contents($svgFile, 'r'));
+        $this->assertEquals('image/svg+xml', $this->instance->getMimeType('/desktopapp.svg'));
+    }
+
+
+    public static function copyAndMoveProvider(): array {
+        return [
+            ['/source.txt', '/target.txt'],
+            ['/source.txt', '/target with space.txt'],
+            ['/source with space.txt', '/target.txt'],
+            ['/source with space.txt', '/target with space.txt'],
+            ['/source.txt', '/tärgét.txt'],
+            ['/sòurcē.txt', '/target.txt'],
+            ['/sòurcē.txt', '/tärgét.txt'],
+            ['/single \' quote.txt', '/tar\'get.txt'],
+        ];
+    }
+
+    public function initSourceAndTarget($source, $target = null) {
+        $textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+        $this->instance->file_put_contents($source, file_get_contents($textFile));
+        if ($target) {
+            $testContents = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+            $this->instance->file_put_contents($target, $testContents);
+        }
+    }
+
+    public function assertSameAsLorem($file) {
+        $textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+        $this->assertEquals(
+            file_get_contents($textFile),
+            $this->instance->file_get_contents($file),
+            'Expected ' . $file . ' to be a copy of ' . $textFile
+        );
+    }
+
+    /**
+     * @dataProvider copyAndMoveProvider
+     */
+    public function testCopy($source, $target): void {
+        $this->initSourceAndTarget($source);
+
+        $this->instance->copy($source, $target);
+
+        $this->assertTrue($this->instance->file_exists($target), $target . ' was not created');
+        $this->assertSameAsLorem($target);
+        $this->assertTrue($this->instance->file_exists($source), $source . ' was deleted');
+    }
+
+    /**
+     * @dataProvider copyAndMoveProvider
+     */
+    public function testMove($source, $target): void {
+        $this->initSourceAndTarget($source);
+
+        $this->instance->rename($source, $target);
+
+        $this->wait();
+        $this->assertTrue($this->instance->file_exists($target), $target . ' was not created');
+        $this->assertFalse($this->instance->file_exists($source), $source . ' still exists');
+        $this->assertSameAsLorem($target);
+    }
+
+    /**
+     * @dataProvider copyAndMoveProvider
+     */
+    public function testCopyOverwrite($source, $target): void {
+        $this->initSourceAndTarget($source, $target);
+
+        $this->instance->copy($source, $target);
+
+        $this->assertTrue($this->instance->file_exists($target), $target . ' was not created');
+        $this->assertTrue($this->instance->file_exists($source), $source . ' was deleted');
+        $this->assertSameAsLorem($target);
+        $this->assertSameAsLorem($source);
+    }
+
+    /**
+     * @dataProvider copyAndMoveProvider
+     */
+    public function testMoveOverwrite($source, $target): void {
+        $this->initSourceAndTarget($source, $target);
+
+        $this->instance->rename($source, $target);
+
+        $this->assertTrue($this->instance->file_exists($target), $target . ' was not created');
+        $this->assertFalse($this->instance->file_exists($source), $source . ' still exists');
+        $this->assertSameAsLorem($target);
+    }
+
+    public function testLocal(): void {
+        $textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+        $this->instance->file_put_contents('/lorem.txt', file_get_contents($textFile));
+        $localFile = $this->instance->getLocalFile('/lorem.txt');
+        $this->assertTrue(file_exists($localFile));
+        $this->assertEquals(file_get_contents($textFile), file_get_contents($localFile));
+
+        $this->instance->mkdir('/folder');
+        $this->instance->file_put_contents('/folder/lorem.txt', file_get_contents($textFile));
+        $this->instance->file_put_contents('/folder/bar.txt', 'asd');
+        $this->instance->mkdir('/folder/recursive');
+        $this->instance->file_put_contents('/folder/recursive/file.txt', 'foo');
+
+        // test below require to use instance->getLocalFile because the physical storage might be different
+        $localFile = $this->instance->getLocalFile('/folder/lorem.txt');
+        $this->assertTrue(file_exists($localFile));
+        $this->assertEquals(file_get_contents($localFile), file_get_contents($textFile));
+
+        $localFile = $this->instance->getLocalFile('/folder/bar.txt');
+        $this->assertTrue(file_exists($localFile));
+        $this->assertEquals(file_get_contents($localFile), 'asd');
+
+        $localFile = $this->instance->getLocalFile('/folder/recursive/file.txt');
+        $this->assertTrue(file_exists($localFile));
+        $this->assertEquals(file_get_contents($localFile), 'foo');
+    }
+
+    public function testStat(): void {
+        $textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+        $ctimeStart = time();
+        $this->instance->file_put_contents('/lorem.txt', file_get_contents($textFile));
+        $this->assertTrue($this->instance->isReadable('/lorem.txt'));
+        $ctimeEnd = time();
+        $mTime = $this->instance->filemtime('/lorem.txt');
+        $this->assertTrue($this->instance->hasUpdated('/lorem.txt', $ctimeStart - 5));
+        $this->assertTrue($this->instance->hasUpdated('/', $ctimeStart - 5));
+
+        // check that ($ctimeStart - 5) <= $mTime <= ($ctimeEnd + 1)
+        $this->assertGreaterThanOrEqual(($ctimeStart - 5), $mTime);
+        $this->assertLessThanOrEqual(($ctimeEnd + 1), $mTime);
+        $this->assertEquals(filesize($textFile), $this->instance->filesize('/lorem.txt'));
+
+        $stat = $this->instance->stat('/lorem.txt');
+        //only size and mtime are required in the result
+        $this->assertEquals($stat['size'], $this->instance->filesize('/lorem.txt'));
+        $this->assertEquals($stat['mtime'], $mTime);
+
+        if ($this->instance->touch('/lorem.txt', 100) !== false) {
+            $mTime = $this->instance->filemtime('/lorem.txt');
+            $this->assertEquals($mTime, 100);
+        }
+
+        $mtimeStart = time();
+
+        $this->instance->unlink('/lorem.txt');
+        $this->assertTrue($this->instance->hasUpdated('/', $mtimeStart - 5));
+    }
+
+    /**
+     * Test whether checkUpdate properly returns false when there was
+     * no change.
+     */
+    public function testCheckUpdate(): void {
+        if ($this->instance instanceof \OC\Files\Storage\Wrapper\Wrapper) {
+            $this->markTestSkipped('Cannot test update check on wrappers');
+        }
+        $textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+        $watcher = $this->instance->getWatcher();
+        $watcher->setPolicy(Watcher::CHECK_ALWAYS);
+        $this->instance->file_put_contents('/lorem.txt', file_get_contents($textFile));
+        $this->assertTrue($watcher->checkUpdate('/lorem.txt'), 'Update detected');
+        $this->assertFalse($watcher->checkUpdate('/lorem.txt'), 'No update');
+    }
+
+    public function testUnlink(): void {
+        $textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+        $this->instance->file_put_contents('/lorem.txt', file_get_contents($textFile));
+
+        $this->assertTrue($this->instance->file_exists('/lorem.txt'));
+
+        $this->assertTrue($this->instance->unlink('/lorem.txt'));
+        $this->wait();
+
+        $this->assertFalse($this->instance->file_exists('/lorem.txt'));
+    }
+
+    /**
+     * @dataProvider fileNameProvider
+     */
+    public function testFOpen($fileName): void {
+        $textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+
+        $fh = @$this->instance->fopen($fileName, 'r');
+        if ($fh) {
+            fclose($fh);
+        }
+        $this->assertFalse($fh);
+        $this->assertFalse($this->instance->file_exists($fileName));
+
+        $fh = $this->instance->fopen($fileName, 'w');
+        fwrite($fh, file_get_contents($textFile));
+        fclose($fh);
+        $this->assertTrue($this->instance->file_exists($fileName));
+
+        $fh = $this->instance->fopen($fileName, 'r');
+        $content = stream_get_contents($fh);
+        $this->assertEquals(file_get_contents($textFile), $content);
+    }
+
+    public function testTouchCreateFile(): void {
+        $this->assertFalse($this->instance->file_exists('touch'));
+        // returns true on success
+        $this->assertTrue($this->instance->touch('touch'));
+        $this->assertTrue($this->instance->file_exists('touch'));
+    }
+
+    public function testRecursiveRmdir(): void {
+        $this->instance->mkdir('folder');
+        $this->instance->mkdir('folder/bar');
+        $this->wait();
+        $this->instance->file_put_contents('folder/asd.txt', 'foobar');
+        $this->instance->file_put_contents('folder/bar/foo.txt', 'asd');
+        $this->assertTrue($this->instance->rmdir('folder'));
+        $this->wait();
+        $this->assertFalse($this->instance->file_exists('folder/asd.txt'));
+        $this->assertFalse($this->instance->file_exists('folder/bar/foo.txt'));
+        $this->assertFalse($this->instance->file_exists('folder/bar'));
+        $this->assertFalse($this->instance->file_exists('folder'));
+    }
+
+    public function testRmdirEmptyFolder(): void {
+        $this->assertTrue($this->instance->mkdir('empty'));
+        $this->wait();
+        $this->assertTrue($this->instance->rmdir('empty'));
+        $this->assertFalse($this->instance->file_exists('empty'));
+    }
+
+    public function testRecursiveUnlink(): void {
+        $this->instance->mkdir('folder');
+        $this->instance->mkdir('folder/bar');
+        $this->instance->file_put_contents('folder/asd.txt', 'foobar');
+        $this->instance->file_put_contents('folder/bar/foo.txt', 'asd');
+        $this->assertTrue($this->instance->unlink('folder'));
+        $this->wait();
+        $this->assertFalse($this->instance->file_exists('folder/asd.txt'));
+        $this->assertFalse($this->instance->file_exists('folder/bar/foo.txt'));
+        $this->assertFalse($this->instance->file_exists('folder/bar'));
+        $this->assertFalse($this->instance->file_exists('folder'));
+    }
+
+    public static function hashProvider(): array {
+        return [
+            ['Foobar', 'md5'],
+            ['Foobar', 'sha1'],
+            ['Foobar', 'sha256'],
+        ];
+    }
+
+    /**
+     * @dataProvider hashProvider
+     */
+    public function testHash($data, $type): void {
+        $this->instance->file_put_contents('hash.txt', $data);
+        $this->assertEquals(hash($type, $data), $this->instance->hash($type, 'hash.txt'));
+        $this->assertEquals(hash($type, $data, true), $this->instance->hash($type, 'hash.txt', true));
+    }
+
+    public function testHashInFileName(): void {
+        $this->instance->file_put_contents('#test.txt', 'data');
+        $this->assertEquals('data', $this->instance->file_get_contents('#test.txt'));
+
+        $this->instance->mkdir('#foo');
+        $this->instance->file_put_contents('#foo/test.txt', 'data');
+        $this->assertEquals('data', $this->instance->file_get_contents('#foo/test.txt'));
+
+        $dh = $this->instance->opendir('#foo');
+        $content = [];
+        while ($file = readdir($dh)) {
+            if ($file != '.' and $file != '..') {
+                $content[] = $file;
+            }
+        }
+
+        $this->assertEquals(['test.txt'], $content);
+    }
+
+    public function testCopyOverWriteFile(): void {
+        $this->instance->file_put_contents('target.txt', 'foo');
+        $this->instance->file_put_contents('source.txt', 'bar');
+        $this->instance->copy('source.txt', 'target.txt');
+        $this->assertEquals('bar', $this->instance->file_get_contents('target.txt'));
+    }
+
+    public function testRenameOverWriteFile(): void {
+        $this->instance->file_put_contents('target.txt', 'foo');
+        $this->instance->file_put_contents('source.txt', 'bar');
+        $this->instance->rename('source.txt', 'target.txt');
+        $this->assertEquals('bar', $this->instance->file_get_contents('target.txt'));
+        $this->assertFalse($this->instance->file_exists('source.txt'));
+    }
+
+    public function testRenameDirectory(): void {
+        $this->instance->mkdir('source');
+        $this->instance->file_put_contents('source/test1.txt', 'foo');
+        $this->instance->file_put_contents('source/test2.txt', 'qwerty');
+        $this->instance->mkdir('source/subfolder');
+        $this->instance->file_put_contents('source/subfolder/test.txt', 'bar');
+        $this->instance->rename('source', 'target');
+
+        $this->assertFalse($this->instance->file_exists('source'));
+        $this->assertFalse($this->instance->file_exists('source/test1.txt'));
+        $this->assertFalse($this->instance->file_exists('source/test2.txt'));
+        $this->assertFalse($this->instance->file_exists('source/subfolder'));
+        $this->assertFalse($this->instance->file_exists('source/subfolder/test.txt'));
+
+        $this->assertTrue($this->instance->file_exists('target'));
+        $this->assertTrue($this->instance->file_exists('target/test1.txt'));
+        $this->assertTrue($this->instance->file_exists('target/test2.txt'));
+        $this->assertTrue($this->instance->file_exists('target/subfolder'));
+        $this->assertTrue($this->instance->file_exists('target/subfolder/test.txt'));
+
+        $contents = iterator_to_array($this->instance->getDirectoryContent(''));
+        $this->assertCount(1, $contents);
+
+        $this->assertEquals('foo', $this->instance->file_get_contents('target/test1.txt'));
+        $this->assertEquals('qwerty', $this->instance->file_get_contents('target/test2.txt'));
+        $this->assertEquals('bar', $this->instance->file_get_contents('target/subfolder/test.txt'));
+    }
+
+    public function testRenameOverWriteDirectory(): void {
+        $this->instance->mkdir('source');
+        $this->instance->file_put_contents('source/test1.txt', 'foo');
+
+        $this->instance->mkdir('target');
+        $this->instance->file_put_contents('target/test1.txt', 'bar');
+        $this->instance->file_put_contents('target/test2.txt', 'bar');
+
+        $this->assertTrue($this->instance->rename('source', 'target'), 'rename must return true on success');
+
+        $this->assertFalse($this->instance->file_exists('source'), 'source has not been removed');
+        $this->assertFalse($this->instance->file_exists('source/test1.txt'), 'source/test1.txt has not been removed');
+        $this->assertFalse($this->instance->file_exists('target/test2.txt'), 'target/test2.txt has not been removed');
+        $this->assertEquals('foo', $this->instance->file_get_contents('target/test1.txt'), 'target/test1.txt has not been overwritten');
+    }
+
+    public function testRenameOverWriteDirectoryOverFile(): void {
+        $this->instance->mkdir('source');
+        $this->instance->file_put_contents('source/test1.txt', 'foo');
+
+        $this->instance->file_put_contents('target', 'bar');
+
+        $this->assertTrue($this->instance->rename('source', 'target'), 'rename must return true on success');
+
+        $this->assertFalse($this->instance->file_exists('source'));
+        $this->assertFalse($this->instance->file_exists('source/test1.txt'));
+        $this->assertEquals('foo', $this->instance->file_get_contents('target/test1.txt'));
+    }
+
+    public function testCopyDirectory(): void {
+        $this->instance->mkdir('source');
+        $this->instance->file_put_contents('source/test1.txt', 'foo');
+        $this->instance->file_put_contents('source/test2.txt', 'qwerty');
+        $this->instance->mkdir('source/subfolder');
+        $this->instance->file_put_contents('source/subfolder/test.txt', 'bar');
+        $this->instance->copy('source', 'target');
+
+        $this->assertTrue($this->instance->file_exists('source'));
+        $this->assertTrue($this->instance->file_exists('source/test1.txt'));
+        $this->assertTrue($this->instance->file_exists('source/test2.txt'));
+        $this->assertTrue($this->instance->file_exists('source/subfolder'));
+        $this->assertTrue($this->instance->file_exists('source/subfolder/test.txt'));
+
+        $this->assertTrue($this->instance->file_exists('target'));
+        $this->assertTrue($this->instance->file_exists('target/test1.txt'));
+        $this->assertTrue($this->instance->file_exists('target/test2.txt'));
+        $this->assertTrue($this->instance->file_exists('target/subfolder'));
+        $this->assertTrue($this->instance->file_exists('target/subfolder/test.txt'));
+
+        $this->assertEquals('foo', $this->instance->file_get_contents('target/test1.txt'));
+        $this->assertEquals('qwerty', $this->instance->file_get_contents('target/test2.txt'));
+        $this->assertEquals('bar', $this->instance->file_get_contents('target/subfolder/test.txt'));
+    }
+
+    public function testCopyOverWriteDirectory(): void {
+        $this->instance->mkdir('source');
+        $this->instance->file_put_contents('source/test1.txt', 'foo');
+
+        $this->instance->mkdir('target');
+        $this->instance->file_put_contents('target/test1.txt', 'bar');
+        $this->instance->file_put_contents('target/test2.txt', 'bar');
+
+        $this->instance->copy('source', 'target');
+
+        $this->assertFalse($this->instance->file_exists('target/test2.txt'), 'File target/test2.txt should no longer exist, but does');
+        $this->assertEquals('foo', $this->instance->file_get_contents('target/test1.txt'));
+    }
+
+    public function testCopyOverWriteDirectoryOverFile(): void {
+        $this->instance->mkdir('source');
+        $this->instance->file_put_contents('source/test1.txt', 'foo');
+
+        $this->instance->file_put_contents('target', 'bar');
+
+        $this->instance->copy('source', 'target');
+
+        $this->assertEquals('foo', $this->instance->file_get_contents('target/test1.txt'));
+    }
+
+    public function testInstanceOfStorage(): void {
+        $this->assertTrue($this->instance->instanceOfStorage(IStorage::class));
+        $this->assertTrue($this->instance->instanceOfStorage(get_class($this->instance)));
+        $this->assertFalse($this->instance->instanceOfStorage('\OC'));
+    }
+
+    /**
+     * @dataProvider copyAndMoveProvider
+     */
+    public function testCopyFromSameStorage($source, $target): void {
+        $this->initSourceAndTarget($source);
+
+        $this->instance->copyFromStorage($this->instance, $source, $target);
+
+        $this->assertTrue($this->instance->file_exists($target), $target . ' was not created');
+        $this->assertSameAsLorem($target);
+        $this->assertTrue($this->instance->file_exists($source), $source . ' was deleted');
+    }
+
+    public function testIsCreatable(): void {
+        $this->instance->mkdir('source');
+        $this->assertTrue($this->instance->isCreatable('source'));
+    }
+
+    public function testIsReadable(): void {
+        $this->instance->mkdir('source');
+        $this->assertTrue($this->instance->isReadable('source'));
+    }
+
+    public function testIsUpdatable(): void {
+        $this->instance->mkdir('source');
+        $this->assertTrue($this->instance->isUpdatable('source'));
+    }
+
+    public function testIsDeletable(): void {
+        $this->instance->mkdir('source');
+        $this->assertTrue($this->instance->isDeletable('source'));
+    }
+
+    public function testIsShareable(): void {
+        $this->instance->mkdir('source');
+        $this->assertTrue($this->instance->isSharable('source'));
+    }
+
+    public function testStatAfterWrite(): void {
+        $this->instance->file_put_contents('foo.txt', 'bar');
+        $stat = $this->instance->stat('foo.txt');
+        $this->assertEquals(3, $stat['size']);
+
+        $fh = $this->instance->fopen('foo.txt', 'w');
+        fwrite($fh, 'qwerty');
+        fclose($fh);
+
+        $stat = $this->instance->stat('foo.txt');
+        $this->assertEquals(6, $stat['size']);
+    }
+
+    public function testPartFile(): void {
+        $this->instance->file_put_contents('bar.txt.part', 'bar');
+        $this->instance->rename('bar.txt.part', 'bar.txt');
+        $this->assertEquals('bar', $this->instance->file_get_contents('bar.txt'));
+    }
+
+    public function testWriteStream(): void {
+        $textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+
+        if (!$this->instance->instanceOfStorage(IWriteStreamStorage::class)) {
+            $this->markTestSkipped('Not a WriteSteamStorage');
+        }
+        /** @var IWriteStreamStorage $storage */
+        $storage = $this->instance;
+
+        $source = fopen($textFile, 'r');
+
+        $storage->writeStream('test.txt', $source);
+        $this->assertTrue($storage->file_exists('test.txt'));
+        $this->assertStringEqualsFile($textFile, $storage->file_get_contents('test.txt'));
+        $this->assertEquals('resource (closed)', gettype($source));
+    }
+
+    public function testFseekSize(): void {
+        $textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+        $this->instance->file_put_contents('bar.txt', file_get_contents($textFile));
+
+        $size = $this->instance->filesize('bar.txt');
+        $this->assertEquals(filesize($textFile), $size);
+        $fh = $this->instance->fopen('bar.txt', 'r');
+
+        fseek($fh, 0, SEEK_END);
+        $pos = ftell($fh);
+
+        $this->assertEquals($size, $pos);
+    }
 }

tests/enable_all.php

Indentation +11 added lines, -11 removed lines

@@ -8,18 +8,18 @@
 require_once __DIR__ . '/../lib/base.php';
 
 function enableApp($app) {
-	try {
-		(new \OC_App())->enable($app);
-	} catch (Exception $e) {
-		echo $e;
-	}
+    try {
+        (new \OC_App())->enable($app);
+    } catch (Exception $e) {
+        echo $e;
+    }
 }
 
 foreach (new \DirectoryIterator(__DIR__ . '/../apps/') as $file) {
-	if ($file->isDot()) {
-		continue;
-	}
-	if (!file_exists($file->getPathname() . '/.git')) {
-		enableApp($file->getFilename());
-	}
+    if ($file->isDot()) {
+        continue;
+    }
+    if (!file_exists($file->getPathname() . '/.git')) {
+        enableApp($file->getFilename());
+    }
 }

Spacing +3 added lines, -3 removed lines

@@ -5,7 +5,7 @@ 
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
-require_once __DIR__ . '/../lib/base.php';
+require_once __DIR__.'/../lib/base.php';
 
 function enableApp($app) {
 	try {
@@ -15,11 +15,11 @@ 
 	}
 }
 
-foreach (new \DirectoryIterator(__DIR__ . '/../apps/') as $file) {
+foreach (new \DirectoryIterator(__DIR__.'/../apps/') as $file) {
 	if ($file->isDot()) {
 		continue;
 	}
-	if (!file_exists($file->getPathname() . '/.git')) {
+	if (!file_exists($file->getPathname().'/.git')) {
 		enableApp($file->getFilename());
 	}
 }

tests/bootstrap.php

Indentation +8 added lines, -8 removed lines

@@ -8,7 +8,7 @@ 
 
 $configDir = getenv('CONFIG_DIR');
 if ($configDir) {
-	define('PHPUNIT_CONFIG_DIR', $configDir);
+    define('PHPUNIT_CONFIG_DIR', $configDir);
 }
 
 require_once __DIR__ . '/../lib/base.php';
@@ -18,16 +18,16 @@ 
 
 // load all apps
 foreach (new \DirectoryIterator(__DIR__ . '/../apps/') as $file) {
-	if ($file->isDot()) {
-		continue;
-	}
-	\OC_App::loadApp($file->getFilename());
+    if ($file->isDot()) {
+        continue;
+    }
+    \OC_App::loadApp($file->getFilename());
 }
 
 OC_Hook::clear();
 
 set_include_path(
-	get_include_path() . PATH_SEPARATOR
-	. '/usr/share/php' . PATH_SEPARATOR
-	. __DIR__ . '/..'
+    get_include_path() . PATH_SEPARATOR
+    . '/usr/share/php' . PATH_SEPARATOR
+    . __DIR__ . '/..'
 );

Spacing +7 added lines, -7 removed lines

@@ -11,13 +11,13 @@ 
 	define('PHPUNIT_CONFIG_DIR', $configDir);
 }
 
-require_once __DIR__ . '/../lib/base.php';
-require_once __DIR__ . '/autoload.php';
+require_once __DIR__.'/../lib/base.php';
+require_once __DIR__.'/autoload.php';
 
-\OC::$composerAutoloader->addPsr4('Tests\\', OC::$SERVERROOT . '/tests/', true);
+\OC::$composerAutoloader->addPsr4('Tests\\', OC::$SERVERROOT.'/tests/', true);
 
 // load all apps
-foreach (new \DirectoryIterator(__DIR__ . '/../apps/') as $file) {
+foreach (new \DirectoryIterator(__DIR__.'/../apps/') as $file) {
 	if ($file->isDot()) {
 		continue;
 	}
@@ -27,7 +27,7 @@ 
 OC_Hook::clear();
 
 set_include_path(
-	get_include_path() . PATH_SEPARATOR
-	. '/usr/share/php' . PATH_SEPARATOR
-	. __DIR__ . '/..'
+	get_include_path().PATH_SEPARATOR
+	. '/usr/share/php'.PATH_SEPARATOR
+	. __DIR__.'/..'
 );