nextcloud / server

tests/lib/Encryption/UpdateTest.php

Indentation +172 added lines, -172 removed lines

@@ -23,176 +23,176 @@
 use Test\TestCase;
 
 class UpdateTest extends TestCase {
-	private string $uid;
-	private View&MockObject $view;
-	private Util&MockObject $util;
-	private \OC\Encryption\Manager&MockObject $encryptionManager;
-	private IEncryptionModule&MockObject $encryptionModule;
-	private File&MockObject $fileHelper;
-	private LoggerInterface&MockObject $logger;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->view = $this->createMock(View::class);
-		$this->util = $this->createMock(Util::class);
-		$this->encryptionManager = $this->createMock(\OC\Encryption\Manager::class);
-		$this->fileHelper = $this->createMock(File::class);
-		$this->encryptionModule = $this->createMock(IEncryptionModule::class);
-		$this->logger = $this->createMock(LoggerInterface::class);
-
-		$this->uid = 'testUser1';
-	}
-
-	private function getUserMock(string $uid): IUser&MockObject {
-		$user = $this->createMock(IUser::class);
-		$user->expects(self::any())
-			->method('getUID')
-			->willReturn($uid);
-		return $user;
-	}
-
-	private function getFileMock(string $path, string $owner): OCPFile&MockObject {
-		$node = $this->createMock(OCPFile::class);
-		$node->expects(self::atLeastOnce())
-			->method('getPath')
-			->willReturn($path);
-		$node->expects(self::any())
-			->method('getOwner')
-			->willReturn($this->getUserMock($owner));
-
-		return $node;
-	}
-
-	private function getFolderMock(string $path, string $owner): Folder&MockObject {
-		$node = $this->createMock(Folder::class);
-		$node->expects(self::atLeastOnce())
-			->method('getPath')
-			->willReturn($path);
-		$node->expects(self::any())
-			->method('getOwner')
-			->willReturn($this->getUserMock($owner));
-
-		return $node;
-	}
-
-	/**
-	 * @dataProvider dataTestUpdate
-	 *
-	 * @param string $path
-	 * @param boolean $isDir
-	 * @param array $allFiles
-	 * @param integer $numberOfFiles
-	 */
-	public function testUpdate($path, $isDir, $allFiles, $numberOfFiles): void {
-		$updateMock = $this->getUpdateMock(['getOwnerPath']);
-		$updateMock->expects($this->once())->method('getOwnerPath')
-			->willReturnCallback(fn (OCPFile|Folder $node) => '/user/' . $node->getPath());
-
-		$this->encryptionManager->expects($this->once())
-			->method('getEncryptionModule')
-			->willReturn($this->encryptionModule);
-
-		if ($isDir) {
-			$this->util->expects($this->once())
-				->method('getAllFiles')
-				->willReturn($allFiles);
-			$node = $this->getFolderMock($path, 'user');
-		} else {
-			$node = $this->getFileMock($path, 'user');
-		}
-
-		$this->fileHelper->expects($this->exactly($numberOfFiles))
-			->method('getAccessList')
-			->willReturn(['users' => [], 'public' => false]);
-
-		$this->encryptionModule->expects($this->exactly($numberOfFiles))
-			->method('update')
-			->willReturn(true);
-
-		$updateMock->update($node);
-	}
-
-	/**
-	 * data provider for testUpdate()
-	 *
-	 * @return array
-	 */
-	public function dataTestUpdate() {
-		return [
-			['/user/files/foo', true, ['/user/files/foo/file1.txt', '/user/files/foo/file1.txt'], 2],
-			['/user/files/test.txt', false, [], 1],
-		];
-	}
-
-	/**
-	 * @dataProvider dataTestPostRename
-	 *
-	 * @param string $source
-	 * @param string $target
-	 */
-	public function testPostRename($source, $target): void {
-		$updateMock = $this->getUpdateMock(['update','getOwnerPath']);
-
-		$sourceNode = $this->getFileMock($source, 'user');
-		$targetNode = $this->getFileMock($target, 'user');
-
-		if (dirname($source) === dirname($target)) {
-			$updateMock->expects($this->never())->method('getOwnerPath');
-			$updateMock->expects($this->never())->method('update');
-		} else {
-			$updateMock->expects($this->once())->method('update')
-				->willReturnCallback(fn (OCPFile|Folder $node) => $this->assertSame(
-					$target,
-					$node->getPath(),
-					'update needs to be executed for the target destination'
-				));
-		}
-
-		$updateMock->postRename($sourceNode, $targetNode);
-	}
-
-	/**
-	 * test data for testPostRename()
-	 *
-	 * @return array
-	 */
-	public function dataTestPostRename() {
-		return [
-			['/test.txt', '/testNew.txt'],
-			['/folder/test.txt', '/testNew.txt'],
-			['/test.txt', '/folder/testNew.txt'],
-		];
-	}
-
-	public function testPostRestore(): void {
-		$updateMock = $this->getUpdateMock(['update']);
-
-		$updateMock->expects($this->once())->method('update')
-			->willReturnCallback(fn (OCPFile|Folder $node) => $this->assertSame(
-				'/folder/test.txt',
-				$node->getPath(),
-				'update needs to be executed for the target destination'
-			));
-
-		$updateMock->postRestore($this->getFileMock('/folder/test.txt', 'user'));
-	}
-
-	/**
-	 * create mock of the update method
-	 *
-	 * @param array $methods methods which should be set
-	 */
-	protected function getUpdateMock(array $methods): Update&MockObject {
-		return  $this->getMockBuilder(Update::class)
-			->setConstructorArgs(
-				[
-					$this->util,
-					$this->encryptionManager,
-					$this->fileHelper,
-					$this->logger,
-					$this->uid
-				]
-			)->setMethods($methods)->getMock();
-	}
+    private string $uid;
+    private View&MockObject $view;
+    private Util&MockObject $util;
+    private \OC\Encryption\Manager&MockObject $encryptionManager;
+    private IEncryptionModule&MockObject $encryptionModule;
+    private File&MockObject $fileHelper;
+    private LoggerInterface&MockObject $logger;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->view = $this->createMock(View::class);
+        $this->util = $this->createMock(Util::class);
+        $this->encryptionManager = $this->createMock(\OC\Encryption\Manager::class);
+        $this->fileHelper = $this->createMock(File::class);
+        $this->encryptionModule = $this->createMock(IEncryptionModule::class);
+        $this->logger = $this->createMock(LoggerInterface::class);
+
+        $this->uid = 'testUser1';
+    }
+
+    private function getUserMock(string $uid): IUser&MockObject {
+        $user = $this->createMock(IUser::class);
+        $user->expects(self::any())
+            ->method('getUID')
+            ->willReturn($uid);
+        return $user;
+    }
+
+    private function getFileMock(string $path, string $owner): OCPFile&MockObject {
+        $node = $this->createMock(OCPFile::class);
+        $node->expects(self::atLeastOnce())
+            ->method('getPath')
+            ->willReturn($path);
+        $node->expects(self::any())
+            ->method('getOwner')
+            ->willReturn($this->getUserMock($owner));
+
+        return $node;
+    }
+
+    private function getFolderMock(string $path, string $owner): Folder&MockObject {
+        $node = $this->createMock(Folder::class);
+        $node->expects(self::atLeastOnce())
+            ->method('getPath')
+            ->willReturn($path);
+        $node->expects(self::any())
+            ->method('getOwner')
+            ->willReturn($this->getUserMock($owner));
+
+        return $node;
+    }
+
+    /**
+     * @dataProvider dataTestUpdate
+     *
+     * @param string $path
+     * @param boolean $isDir
+     * @param array $allFiles
+     * @param integer $numberOfFiles
+     */
+    public function testUpdate($path, $isDir, $allFiles, $numberOfFiles): void {
+        $updateMock = $this->getUpdateMock(['getOwnerPath']);
+        $updateMock->expects($this->once())->method('getOwnerPath')
+            ->willReturnCallback(fn (OCPFile|Folder $node) => '/user/' . $node->getPath());
+
+        $this->encryptionManager->expects($this->once())
+            ->method('getEncryptionModule')
+            ->willReturn($this->encryptionModule);
+
+        if ($isDir) {
+            $this->util->expects($this->once())
+                ->method('getAllFiles')
+                ->willReturn($allFiles);
+            $node = $this->getFolderMock($path, 'user');
+        } else {
+            $node = $this->getFileMock($path, 'user');
+        }
+
+        $this->fileHelper->expects($this->exactly($numberOfFiles))
+            ->method('getAccessList')
+            ->willReturn(['users' => [], 'public' => false]);
+
+        $this->encryptionModule->expects($this->exactly($numberOfFiles))
+            ->method('update')
+            ->willReturn(true);
+
+        $updateMock->update($node);
+    }
+
+    /**
+     * data provider for testUpdate()
+     *
+     * @return array
+     */
+    public function dataTestUpdate() {
+        return [
+            ['/user/files/foo', true, ['/user/files/foo/file1.txt', '/user/files/foo/file1.txt'], 2],
+            ['/user/files/test.txt', false, [], 1],
+        ];
+    }
+
+    /**
+     * @dataProvider dataTestPostRename
+     *
+     * @param string $source
+     * @param string $target
+     */
+    public function testPostRename($source, $target): void {
+        $updateMock = $this->getUpdateMock(['update','getOwnerPath']);
+
+        $sourceNode = $this->getFileMock($source, 'user');
+        $targetNode = $this->getFileMock($target, 'user');
+
+        if (dirname($source) === dirname($target)) {
+            $updateMock->expects($this->never())->method('getOwnerPath');
+            $updateMock->expects($this->never())->method('update');
+        } else {
+            $updateMock->expects($this->once())->method('update')
+                ->willReturnCallback(fn (OCPFile|Folder $node) => $this->assertSame(
+                    $target,
+                    $node->getPath(),
+                    'update needs to be executed for the target destination'
+                ));
+        }
+
+        $updateMock->postRename($sourceNode, $targetNode);
+    }
+
+    /**
+     * test data for testPostRename()
+     *
+     * @return array
+     */
+    public function dataTestPostRename() {
+        return [
+            ['/test.txt', '/testNew.txt'],
+            ['/folder/test.txt', '/testNew.txt'],
+            ['/test.txt', '/folder/testNew.txt'],
+        ];
+    }
+
+    public function testPostRestore(): void {
+        $updateMock = $this->getUpdateMock(['update']);
+
+        $updateMock->expects($this->once())->method('update')
+            ->willReturnCallback(fn (OCPFile|Folder $node) => $this->assertSame(
+                '/folder/test.txt',
+                $node->getPath(),
+                'update needs to be executed for the target destination'
+            ));
+
+        $updateMock->postRestore($this->getFileMock('/folder/test.txt', 'user'));
+    }
+
+    /**
+     * create mock of the update method
+     *
+     * @param array $methods methods which should be set
+     */
+    protected function getUpdateMock(array $methods): Update&MockObject {
+        return  $this->getMockBuilder(Update::class)
+            ->setConstructorArgs(
+                [
+                    $this->util,
+                    $this->encryptionManager,
+                    $this->fileHelper,
+                    $this->logger,
+                    $this->uid
+                ]
+            )->setMethods($methods)->getMock();
+    }
 }

Spacing +4 added lines, -4 removed lines

@@ -87,7 +87,7 @@ 
 	public function testUpdate($path, $isDir, $allFiles, $numberOfFiles): void {
 		$updateMock = $this->getUpdateMock(['getOwnerPath']);
 		$updateMock->expects($this->once())->method('getOwnerPath')
-			->willReturnCallback(fn (OCPFile|Folder $node) => '/user/' . $node->getPath());
+			->willReturnCallback(fn (OCPFile | Folder $node) => '/user/'.$node->getPath());
 
 		$this->encryptionManager->expects($this->once())
 			->method('getEncryptionModule')
@@ -132,7 +132,7 @@ 
 	 * @param string $target
 	 */
 	public function testPostRename($source, $target): void {
-		$updateMock = $this->getUpdateMock(['update','getOwnerPath']);
+		$updateMock = $this->getUpdateMock(['update', 'getOwnerPath']);
 
 		$sourceNode = $this->getFileMock($source, 'user');
 		$targetNode = $this->getFileMock($target, 'user');
@@ -142,7 +142,7 @@ 
 			$updateMock->expects($this->never())->method('update');
 		} else {
 			$updateMock->expects($this->once())->method('update')
-				->willReturnCallback(fn (OCPFile|Folder $node) => $this->assertSame(
+				->willReturnCallback(fn (OCPFile | Folder $node) => $this->assertSame(
 					$target,
 					$node->getPath(),
 					'update needs to be executed for the target destination'
@@ -169,7 +169,7 @@ 
 		$updateMock = $this->getUpdateMock(['update']);
 
 		$updateMock->expects($this->once())->method('update')
-			->willReturnCallback(fn (OCPFile|Folder $node) => $this->assertSame(
+			->willReturnCallback(fn (OCPFile | Folder $node) => $this->assertSame(
 				'/folder/test.txt',
 				$node->getPath(),
 				'update needs to be executed for the target destination'

tests/lib/Files/Storage/Wrapper/EncryptionTest.php

Indentation +994 added lines, -994 removed lines

@@ -33,998 +33,998 @@
 use Test\Files\Storage\Storage;
 
 class EncryptionTest extends Storage {
-	/**
-	 * block size will always be 8192 for a PHP stream
-	 * @see https://bugs.php.net/bug.php?id=21641
-	 */
-	protected int $headerSize = 8192;
-	private Temporary $sourceStorage;
-	/** @var Encryption&MockObject */
-	protected $instance;
-	private \OC\Encryption\Keys\Storage&MockObject $keyStore;
-	private Util&MockObject $util;
-	private \OC\Encryption\Manager&MockObject $encryptionManager;
-	private IEncryptionModule&MockObject $encryptionModule;
-	private Cache&MockObject $cache;
-	private LoggerInterface&MockObject $logger;
-	private File&MockObject $file;
-	private MountPoint&MockObject $mount;
-	private \OC\Files\Mount\Manager&MockObject $mountManager;
-	private \OC\Group\Manager&MockObject $groupManager;
-	private IConfig&MockObject $config;
-	private ArrayCache&MockObject $arrayCache;
-	/** dummy unencrypted size */
-	private int $dummySize = -1;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$mockModule = $this->buildMockModule();
-		$this->encryptionManager = $this->getMockBuilder('\OC\Encryption\Manager')
-			->disableOriginalConstructor()
-			->setMethods(['getEncryptionModule', 'isEnabled'])
-			->getMock();
-		$this->encryptionManager->expects($this->any())
-			->method('getEncryptionModule')
-			->willReturn($mockModule);
-
-		$this->arrayCache = $this->createMock(ArrayCache::class);
-		$this->config = $this->getMockBuilder(IConfig::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$this->groupManager = $this->getMockBuilder('\OC\Group\Manager')
-			->disableOriginalConstructor()
-			->getMock();
-
-		$this->util = $this->getMockBuilder('\OC\Encryption\Util')
-			->setMethods(['getUidAndFilename', 'isFile', 'isExcluded', 'stripPartialFileExtension'])
-			->setConstructorArgs([new View(), new Manager(
-				$this->config,
-				$this->createMock(ICacheFactory::class),
-				$this->createMock(IEventDispatcher::class),
-				$this->createMock(LoggerInterface::class),
-			), $this->groupManager, $this->config, $this->arrayCache])
-			->getMock();
-		$this->util->expects($this->any())
-			->method('getUidAndFilename')
-			->willReturnCallback(function ($path) {
-				return ['user1', $path];
-			});
-		$this->util->expects($this->any())
-			->method('stripPartialFileExtension')
-			->willReturnCallback(function ($path) {
-				return $path;
-			});
-
-		$this->file = $this->getMockBuilder('\OC\Encryption\File')
-			->disableOriginalConstructor()
-			->setMethods(['getAccessList'])
-			->getMock();
-		$this->file->expects($this->any())->method('getAccessList')->willReturn([]);
-
-		$this->logger = $this->createMock(LoggerInterface::class);
-
-		$this->sourceStorage = new Temporary([]);
-
-		$this->keyStore = $this->getMockBuilder('\OC\Encryption\Keys\Storage')
-			->disableOriginalConstructor()->getMock();
-
-		$this->mount = $this->getMockBuilder('\OC\Files\Mount\MountPoint')
-			->disableOriginalConstructor()
-			->setMethods(['getOption'])
-			->getMock();
-		$this->mount->expects($this->any())->method('getOption')->willReturnCallback(function ($option, $default) {
-			if ($option === 'encrypt' && $default === true) {
-				global $mockedMountPointEncryptionEnabled;
-				if ($mockedMountPointEncryptionEnabled !== null) {
-					return $mockedMountPointEncryptionEnabled;
-				}
-			}
-			return true;
-		});
-
-		$this->cache = $this->getMockBuilder('\OC\Files\Cache\Cache')
-			->disableOriginalConstructor()->getMock();
-		$this->cache->expects($this->any())
-			->method('get')
-			->willReturnCallback(function ($path) {
-				return ['encrypted' => false, 'path' => $path];
-			});
-
-		$this->mountManager = $this->createMock(\OC\Files\Mount\Manager::class);
-		$this->mountManager->method('findByStorageId')
-			->willReturn([]);
-
-		$this->instance = $this->getMockBuilder(Encryption::class)
-			->setConstructorArgs(
-				[
-					[
-						'storage' => $this->sourceStorage,
-						'root' => 'foo',
-						'mountPoint' => '/',
-						'mount' => $this->mount
-					],
-					$this->encryptionManager,
-					$this->util,
-					$this->logger,
-					$this->file,
-					null,
-					$this->keyStore,
-					$this->mountManager,
-					$this->arrayCache
-				]
-			)
-			->setMethods(['getMetaData', 'getCache', 'getEncryptionModule'])
-			->getMock();
-
-		$this->instance->expects($this->any())
-			->method('getMetaData')
-			->willReturnCallback(function ($path) {
-				return ['encrypted' => true, 'size' => $this->dummySize, 'path' => $path];
-			});
-
-		$this->instance->expects($this->any())
-			->method('getCache')
-			->willReturn($this->cache);
-
-		$this->instance->expects($this->any())
-			->method('getEncryptionModule')
-			->willReturn($mockModule);
-	}
-
-	protected function buildMockModule(): IEncryptionModule&MockObject {
-		$this->encryptionModule = $this->getMockBuilder('\OCP\Encryption\IEncryptionModule')
-			->disableOriginalConstructor()
-			->setMethods(['getId', 'getDisplayName', 'begin', 'end', 'encrypt', 'decrypt', 'update', 'shouldEncrypt', 'getUnencryptedBlockSize', 'isReadable', 'encryptAll', 'prepareDecryptAll', 'isReadyForUser', 'needDetailedAccessList'])
-			->getMock();
-
-		$this->encryptionModule->expects($this->any())->method('getId')->willReturn('UNIT_TEST_MODULE');
-		$this->encryptionModule->expects($this->any())->method('getDisplayName')->willReturn('Unit test module');
-		$this->encryptionModule->expects($this->any())->method('begin')->willReturn([]);
-		$this->encryptionModule->expects($this->any())->method('end')->willReturn('');
-		$this->encryptionModule->expects($this->any())->method('encrypt')->willReturnArgument(0);
-		$this->encryptionModule->expects($this->any())->method('decrypt')->willReturnArgument(0);
-		$this->encryptionModule->expects($this->any())->method('update')->willReturn(true);
-		$this->encryptionModule->expects($this->any())->method('shouldEncrypt')->willReturn(true);
-		$this->encryptionModule->expects($this->any())->method('getUnencryptedBlockSize')->willReturn(8192);
-		$this->encryptionModule->expects($this->any())->method('isReadable')->willReturn(true);
-		$this->encryptionModule->expects($this->any())->method('needDetailedAccessList')->willReturn(false);
-		return $this->encryptionModule;
-	}
-
-	/**
-	 * @dataProvider dataTestGetMetaData
-	 *
-	 * @param string $path
-	 * @param array $metaData
-	 * @param bool $encrypted
-	 * @param bool $unencryptedSizeSet
-	 * @param int $storedUnencryptedSize
-	 * @param array $expected
-	 */
-	public function testGetMetaData($path, $metaData, $encrypted, $unencryptedSizeSet, $storedUnencryptedSize, $expected): void {
-		$sourceStorage = $this->getMockBuilder('\OC\Files\Storage\Storage')
-			->disableOriginalConstructor()->getMock();
-
-		$cache = $this->getMockBuilder('\OC\Files\Cache\Cache')
-			->disableOriginalConstructor()->getMock();
-		$cache->expects($this->any())
-			->method('get')
-			->willReturnCallback(
-				function ($path) use ($encrypted) {
-					return new CacheEntry(['encrypted' => $encrypted, 'path' => $path, 'size' => 0, 'fileid' => 1]);
-				}
-			);
-
-		$this->instance = $this->getMockBuilder(Encryption::class)
-			->setConstructorArgs(
-				[
-					[
-						'storage' => $sourceStorage,
-						'root' => 'foo',
-						'mountPoint' => '/',
-						'mount' => $this->mount
-					],
-					$this->encryptionManager,
-					$this->util,
-					$this->logger,
-					$this->file,
-					null,
-					$this->keyStore,
-					$this->mountManager,
-					$this->arrayCache,
-				]
-			)
-			->setMethods(['getCache', 'verifyUnencryptedSize'])
-			->getMock();
-
-		if ($unencryptedSizeSet) {
-			$this->invokePrivate($this->instance, 'unencryptedSize', [[$path => $storedUnencryptedSize]]);
-		}
-
-		$fileEntry = $this->getMockBuilder('\OC\Files\Cache\Cache')
-			->disableOriginalConstructor()->getMock();
-		$sourceStorage->expects($this->once())->method('getMetaData')->with($path)
-			->willReturn($metaData);
-		$sourceStorage->expects($this->any())
-			->method('getCache')
-			->with($path)
-			->willReturn($fileEntry);
-		if ($metaData !== null) {
-			$fileEntry->expects($this->any())
-				->method('get')
-				->with($metaData['fileid']);
-		}
-
-		$this->instance->expects($this->any())->method('getCache')->willReturn($cache);
-		if ($expected !== null) {
-			$this->instance->expects($this->any())->method('verifyUnencryptedSize')
-				->with($path, 0)->willReturn($expected['size']);
-		}
-
-		$result = $this->instance->getMetaData($path);
-		if (isset($expected['encrypted'])) {
-			$this->assertSame($expected['encrypted'], (bool)$result['encrypted']);
-
-			if (isset($expected['encryptedVersion'])) {
-				$this->assertSame($expected['encryptedVersion'], $result['encryptedVersion']);
-			}
-		}
-
-		if ($expected !== null) {
-			$this->assertSame($expected['size'], $result['size']);
-		} else {
-			$this->assertSame(null, $result);
-		}
-	}
-
-	public function dataTestGetMetaData() {
-		return [
-			['/test.txt', ['size' => 42, 'encrypted' => 2, 'encryptedVersion' => 2, 'fileid' => 1], true, true, 12, ['size' => 12, 'encrypted' => true, 'encryptedVersion' => 2]],
-			['/test.txt', null, true, true, 12, null],
-			['/test.txt', ['size' => 42, 'encrypted' => 0, 'fileid' => 1], false, false, 12, ['size' => 42, 'encrypted' => false]],
-			['/test.txt', ['size' => 42, 'encrypted' => false, 'fileid' => 1], true, false, 12, ['size' => 12, 'encrypted' => true]]
-		];
-	}
-
-	public function testFilesize(): void {
-		$cache = $this->getMockBuilder('\OC\Files\Cache\Cache')
-			->disableOriginalConstructor()->getMock();
-		$cache->expects($this->any())
-			->method('get')
-			->willReturn(new CacheEntry(['encrypted' => true, 'path' => '/test.txt', 'size' => 0, 'fileid' => 1]));
-
-		$this->instance = $this->getMockBuilder(Encryption::class)
-			->setConstructorArgs(
-				[
-					[
-						'storage' => $this->sourceStorage,
-						'root' => 'foo',
-						'mountPoint' => '/',
-						'mount' => $this->mount
-					],
-					$this->encryptionManager,
-					$this->util,
-					$this->logger,
-					$this->file,
-					null,
-					$this->keyStore,
-					$this->mountManager,
-					$this->arrayCache,
-				]
-			)
-			->setMethods(['getCache', 'verifyUnencryptedSize'])
-			->getMock();
-
-		$this->instance->expects($this->any())->method('getCache')->willReturn($cache);
-		$this->instance->expects($this->any())->method('verifyUnencryptedSize')
-			->willReturn(42);
-
-
-		$this->assertSame(42,
-			$this->instance->filesize('/test.txt')
-		);
-	}
-
-	/**
-	 * @dataProvider dataTestVerifyUnencryptedSize
-	 *
-	 * @param int $encryptedSize
-	 * @param int $unencryptedSize
-	 * @param bool $failure
-	 * @param int $expected
-	 */
-	public function testVerifyUnencryptedSize($encryptedSize, $unencryptedSize, $failure, $expected): void {
-		$sourceStorage = $this->getMockBuilder('\OC\Files\Storage\Storage')
-			->disableOriginalConstructor()->getMock();
-
-		$this->instance = $this->getMockBuilder(Encryption::class)
-			->setConstructorArgs(
-				[
-					[
-						'storage' => $sourceStorage,
-						'root' => 'foo',
-						'mountPoint' => '/',
-						'mount' => $this->mount
-					],
-					$this->encryptionManager,
-					$this->util,
-					$this->logger,
-					$this->file,
-					null,
-					$this->keyStore,
-					$this->mountManager,
-					$this->arrayCache,
-				]
-			)
-			->setMethods(['fixUnencryptedSize'])
-			->getMock();
-
-		$sourceStorage->expects($this->once())->method('filesize')->willReturn($encryptedSize);
-
-		$this->instance->expects($this->any())->method('fixUnencryptedSize')
-			->with('/test.txt', $encryptedSize, $unencryptedSize)
-			->willReturnCallback(
-				function () use ($failure, $expected) {
-					if ($failure) {
-						throw new Exception();
-					} else {
-						return $expected;
-					}
-				}
-			);
-
-		$this->assertSame(
-			$expected,
-			$this->invokePrivate($this->instance, 'verifyUnencryptedSize', ['/test.txt', $unencryptedSize])
-		);
-	}
-
-	public function dataTestVerifyUnencryptedSize() {
-		return [
-			[120, 80, false, 80],
-			[120, 120, false, 80],
-			[120, -1, false, 80],
-			[120, -1, true, -1]
-		];
-	}
-
-	/**
-	 * @dataProvider dataTestCopyAndRename
-	 *
-	 * @param string $source
-	 * @param string $target
-	 * @param $encryptionEnabled
-	 * @param boolean $renameKeysReturn
-	 */
-	public function testRename($source,
-		$target,
-		$encryptionEnabled,
-		$renameKeysReturn): void {
-		if ($encryptionEnabled) {
-			$this->keyStore
-				->expects($this->once())
-				->method('renameKeys')
-				->willReturn($renameKeysReturn);
-		} else {
-			$this->keyStore
-				->expects($this->never())->method('renameKeys');
-		}
-		$this->util->expects($this->any())
-			->method('isFile')->willReturn(true);
-		$this->encryptionManager->expects($this->once())
-			->method('isEnabled')->willReturn($encryptionEnabled);
-
-		$this->instance->mkdir($source);
-		$this->instance->mkdir(dirname($target));
-		$this->instance->rename($source, $target);
-	}
-
-	public function testCopyEncryption(): void {
-		$this->instance->file_put_contents('source.txt', 'bar');
-		$this->instance->copy('source.txt', 'target.txt');
-		$this->assertSame('bar', $this->instance->file_get_contents('target.txt'));
-		$targetMeta = $this->instance->getMetaData('target.txt');
-		$sourceMeta = $this->instance->getMetaData('source.txt');
-		$this->assertSame($sourceMeta['encrypted'], $targetMeta['encrypted']);
-		$this->assertSame($sourceMeta['size'], $targetMeta['size']);
-	}
-
-	/**
-	 * data provider for testCopyTesting() and dataTestCopyAndRename()
-	 *
-	 * @return array
-	 */
-	public function dataTestCopyAndRename() {
-		return [
-			['source', 'target', true, false, false],
-			['source', 'target', true, true, false],
-			['source', '/subFolder/target', true, false, false],
-			['source', '/subFolder/target', true, true, true],
-			['source', '/subFolder/target', false, true, false],
-		];
-	}
-
-	public function testIsLocal(): void {
-		$this->encryptionManager->expects($this->once())
-			->method('isEnabled')->willReturn(true);
-		$this->assertFalse($this->instance->isLocal());
-	}
-
-	/**
-	 * @dataProvider dataTestRmdir
-	 *
-	 * @param string $path
-	 * @param boolean $rmdirResult
-	 * @param boolean $isExcluded
-	 * @param boolean $encryptionEnabled
-	 */
-	public function testRmdir($path, $rmdirResult, $isExcluded, $encryptionEnabled): void {
-		$sourceStorage = $this->getMockBuilder('\OC\Files\Storage\Storage')
-			->disableOriginalConstructor()->getMock();
-
-		$util = $this->getMockBuilder('\OC\Encryption\Util')->disableOriginalConstructor()->getMock();
-
-		$sourceStorage->expects($this->once())->method('rmdir')->willReturn($rmdirResult);
-		$util->expects($this->any())->method('isExcluded')->willReturn($isExcluded);
-		$this->encryptionManager->expects($this->any())->method('isEnabled')->willReturn($encryptionEnabled);
-
-		$encryptionStorage = new Encryption(
-			[
-				'storage' => $sourceStorage,
-				'root' => 'foo',
-				'mountPoint' => '/mountPoint',
-				'mount' => $this->mount
-			],
-			$this->encryptionManager,
-			$util,
-			$this->logger,
-			$this->file,
-			null,
-			$this->keyStore,
-			$this->mountManager,
-			$this->arrayCache,
-		);
-
-
-		if ($rmdirResult === true && $isExcluded === false && $encryptionEnabled === true) {
-			$this->keyStore->expects($this->once())->method('deleteAllFileKeys')->with('/mountPoint' . $path);
-		} else {
-			$this->keyStore->expects($this->never())->method('deleteAllFileKeys');
-		}
-
-		$encryptionStorage->rmdir($path);
-	}
-
-	public function dataTestRmdir() {
-		return [
-			['/file.txt', true, true, true],
-			['/file.txt', false, true, true],
-			['/file.txt', true, false, true],
-			['/file.txt', false, false, true],
-			['/file.txt', true, true, false],
-			['/file.txt', false, true, false],
-			['/file.txt', true, false, false],
-			['/file.txt', false, false, false],
-		];
-	}
-
-	/**
-	 * @dataProvider dataTestCopyKeys
-	 *
-	 * @param boolean $excluded
-	 * @param boolean $expected
-	 */
-	public function testCopyKeys($excluded, $expected): void {
-		$this->util->expects($this->once())
-			->method('isExcluded')
-			->willReturn($excluded);
-
-		if ($excluded) {
-			$this->keyStore->expects($this->never())->method('copyKeys');
-		} else {
-			$this->keyStore->expects($this->once())->method('copyKeys')->willReturn(true);
-		}
-
-		$this->assertSame($expected,
-			self::invokePrivate($this->instance, 'copyKeys', ['/source', '/target'])
-		);
-	}
-
-	public function dataTestCopyKeys() {
-		return [
-			[true, false],
-			[false, true],
-		];
-	}
-
-	/**
-	 * @dataProvider dataTestGetHeader
-	 *
-	 * @param string $path
-	 * @param bool $strippedPathExists
-	 * @param string $strippedPath
-	 */
-	public function testGetHeader($path, $strippedPathExists, $strippedPath): void {
-		$sourceStorage = $this->getMockBuilder('\OC\Files\Storage\Storage')
-			->disableOriginalConstructor()->getMock();
-
-		$util = $this->getMockBuilder('\OC\Encryption\Util')
-			->setConstructorArgs(
-				[
-					new View(),
-					new Manager(
-						$this->config,
-						$this->createMock(ICacheFactory::class),
-						$this->createMock(IEventDispatcher::class),
-						$this->createMock(LoggerInterface::class),
-					),
-					$this->groupManager,
-					$this->config,
-					$this->arrayCache
-				]
-			)->getMock();
-
-		$cache = $this->getMockBuilder('\OC\Files\Cache\Cache')
-			->disableOriginalConstructor()->getMock();
-		$cache->expects($this->any())
-			->method('get')
-			->willReturnCallback(function ($path) {
-				return ['encrypted' => true, 'path' => $path];
-			});
-
-		$instance = $this->getMockBuilder(Encryption::class)
-			->setConstructorArgs(
-				[
-					[
-						'storage' => $sourceStorage,
-						'root' => 'foo',
-						'mountPoint' => '/',
-						'mount' => $this->mount
-					],
-					$this->encryptionManager,
-					$util,
-					$this->logger,
-					$this->file,
-					null,
-					$this->keyStore,
-					$this->mountManager,
-					$this->arrayCache,
-				]
-			)
-			->setMethods(['getCache', 'readFirstBlock'])
-			->getMock();
-
-		$instance->method('getCache')->willReturn($cache);
-
-		$util->method('parseRawHeader')
-			->willReturn([Util::HEADER_ENCRYPTION_MODULE_KEY => 'OC_DEFAULT_MODULE']);
-
-		if ($strippedPathExists) {
-			$instance->method('readFirstBlock')
-				->with($strippedPath)->willReturn('');
-		} else {
-			$instance->method('readFirstBlock')
-				->with($path)->willReturn('');
-		}
-
-		$util->expects($this->once())->method('stripPartialFileExtension')
-			->with($path)->willReturn($strippedPath);
-		$sourceStorage->expects($this->once())
-			->method('is_file')
-			->with($strippedPath)
-			->willReturn($strippedPathExists);
-
-		$this->invokePrivate($instance, 'getHeader', [$path]);
-	}
-
-	public function dataTestGetHeader() {
-		return [
-			['/foo/bar.txt', false, '/foo/bar.txt'],
-			['/foo/bar.txt.part', false, '/foo/bar.txt'],
-			['/foo/bar.txt.ocTransferId7437493.part', false, '/foo/bar.txt'],
-			['/foo/bar.txt.part', true, '/foo/bar.txt'],
-			['/foo/bar.txt.ocTransferId7437493.part', true, '/foo/bar.txt'],
-		];
-	}
-
-	/**
-	 * test if getHeader adds the default module correctly to the header for
-	 * legacy files
-	 *
-	 * @dataProvider dataTestGetHeaderAddLegacyModule
-	 */
-	public function testGetHeaderAddLegacyModule($header, $isEncrypted, $strippedPathExists, $expected): void {
-		$sourceStorage = $this->getMockBuilder('\OC\Files\Storage\Storage')
-			->disableOriginalConstructor()->getMock();
-
-		$sourceStorage->expects($this->once())
-			->method('is_file')
-			->with('test.txt')
-			->willReturn($strippedPathExists);
-
-		$util = $this->getMockBuilder('\OC\Encryption\Util')
-			->onlyMethods(['stripPartialFileExtension', 'parseRawHeader'])
-			->setConstructorArgs([new View(), new Manager(
-				$this->config,
-				$this->createMock(ICacheFactory::class),
-				$this->createMock(IEventDispatcher::class),
-				$this->createMock(LoggerInterface::class),
-			), $this->groupManager, $this->config, $this->arrayCache])
-			->getMock();
-		$util->expects($this->any())
-			->method('stripPartialFileExtension')
-			->willReturnCallback(function ($path) {
-				return $path;
-			});
-
-		$cache = $this->getMockBuilder('\OC\Files\Cache\Cache')
-			->disableOriginalConstructor()->getMock();
-		$cache->expects($this->any())
-			->method('get')
-			->willReturnCallback(function ($path) use ($isEncrypted) {
-				return ['encrypted' => $isEncrypted, 'path' => $path];
-			});
-
-		$instance = $this->getMockBuilder(Encryption::class)
-			->setConstructorArgs(
-				[
-					[
-						'storage' => $sourceStorage,
-						'root' => 'foo',
-						'mountPoint' => '/',
-						'mount' => $this->mount
-					],
-					$this->encryptionManager,
-					$util,
-					$this->logger,
-					$this->file,
-					null,
-					$this->keyStore,
-					$this->mountManager,
-					$this->arrayCache,
-				]
-			)
-			->setMethods(['readFirstBlock', 'getCache'])
-			->getMock();
-
-		$instance->method('readFirstBlock')->willReturn('');
-
-		$util->method(('parseRawHeader'))->willReturn($header);
-		$instance->method('getCache')->willReturn($cache);
-
-		$result = $this->invokePrivate($instance, 'getHeader', ['test.txt']);
-		$this->assertSameSize($expected, $result);
-		foreach ($result as $key => $value) {
-			$this->assertArrayHasKey($key, $expected);
-			$this->assertSame($expected[$key], $value);
-		}
-	}
-
-	public function dataTestGetHeaderAddLegacyModule() {
-		return [
-			[['cipher' => 'AES-128'], true, true, ['cipher' => 'AES-128', Util::HEADER_ENCRYPTION_MODULE_KEY => 'OC_DEFAULT_MODULE']],
-			[[], true, false, []],
-			[[], true, true, [Util::HEADER_ENCRYPTION_MODULE_KEY => 'OC_DEFAULT_MODULE']],
-			[[], false, true, []],
-		];
-	}
-
-	public function dataCopyBetweenStorage() {
-		return [
-			[true, true, true],
-			[true, false, false],
-			[false, true, false],
-			[false, false, false],
-		];
-	}
-
-	public function testCopyBetweenStorageMinimumEncryptedVersion(): void {
-		$storage2 = $this->createMock(\OC\Files\Storage\Storage::class);
-
-		$sourceInternalPath = $targetInternalPath = 'file.txt';
-		$preserveMtime = $isRename = false;
-
-		$storage2->expects($this->any())
-			->method('fopen')
-			->willReturnCallback(function ($path, $mode) {
-				$temp = OC::$server->getTempManager();
-				return fopen($temp->getTemporaryFile(), $mode);
-			});
-		$storage2->method('getId')
-			->willReturn('stroage2');
-		$cache = $this->createMock(ICache::class);
-		$cache->expects($this->once())
-			->method('get')
-			->with($sourceInternalPath)
-			->willReturn(['encryptedVersion' => 0]);
-		$storage2->expects($this->once())
-			->method('getCache')
-			->willReturn($cache);
-		$this->encryptionManager->expects($this->any())
-			->method('isEnabled')
-			->willReturn(true);
-		global $mockedMountPointEncryptionEnabled;
-		$mockedMountPointEncryptionEnabled = true;
-
-		$expectedCachePut = [
-			'encrypted' => true,
-		];
-		$expectedCachePut['encryptedVersion'] = 1;
-
-		$this->cache->expects($this->once())
-			->method('put')
-			->with($sourceInternalPath, $expectedCachePut);
-
-		$this->invokePrivate($this->instance, 'copyBetweenStorage', [$storage2, $sourceInternalPath, $targetInternalPath, $preserveMtime, $isRename]);
-
-		$this->assertFalse(false);
-	}
-
-	/**
-	 * @dataProvider dataCopyBetweenStorage
-	 *
-	 * @param bool $encryptionEnabled
-	 * @param bool $mountPointEncryptionEnabled
-	 * @param bool $expectedEncrypted
-	 */
-	public function testCopyBetweenStorage($encryptionEnabled, $mountPointEncryptionEnabled, $expectedEncrypted): void {
-		$storage2 = $this->createMock(\OC\Files\Storage\Storage::class);
-
-		$sourceInternalPath = $targetInternalPath = 'file.txt';
-		$preserveMtime = $isRename = false;
-
-		$storage2->expects($this->any())
-			->method('fopen')
-			->willReturnCallback(function ($path, $mode) {
-				$temp = OC::$server->getTempManager();
-				return fopen($temp->getTemporaryFile(), $mode);
-			});
-		$storage2->method('getId')
-			->willReturn('stroage2');
-		if ($expectedEncrypted) {
-			$cache = $this->createMock(ICache::class);
-			$cache->expects($this->once())
-				->method('get')
-				->with($sourceInternalPath)
-				->willReturn(['encryptedVersion' => 12345]);
-			$storage2->expects($this->once())
-				->method('getCache')
-				->willReturn($cache);
-		}
-		$this->encryptionManager->expects($this->any())
-			->method('isEnabled')
-			->willReturn($encryptionEnabled);
-		// FIXME can not overwrite the return after definition
-		//		$this->mount->expects($this->at(0))
-		//			->method('getOption')
-		//			->with('encrypt', true)
-		//			->willReturn($mountPointEncryptionEnabled);
-		global $mockedMountPointEncryptionEnabled;
-		$mockedMountPointEncryptionEnabled = $mountPointEncryptionEnabled;
-
-		$expectedCachePut = [
-			'encrypted' => $expectedEncrypted,
-		];
-		if ($expectedEncrypted === true) {
-			$expectedCachePut['encryptedVersion'] = 1;
-		}
-
-		$this->arrayCache->expects($this->never())->method('set');
-
-		$this->cache->expects($this->once())
-			->method('put')
-			->with($sourceInternalPath, $expectedCachePut);
-
-		$this->invokePrivate($this->instance, 'copyBetweenStorage', [$storage2, $sourceInternalPath, $targetInternalPath, $preserveMtime, $isRename]);
-
-		$this->assertFalse(false);
-	}
-
-	/**
-	 * @dataProvider dataTestCopyBetweenStorageVersions
-	 *
-	 * @param string $sourceInternalPath
-	 * @param string $targetInternalPath
-	 * @param bool $copyResult
-	 * @param bool $encrypted
-	 */
-	public function testCopyBetweenStorageVersions($sourceInternalPath, $targetInternalPath, $copyResult, $encrypted): void {
-		$sourceStorage = $this->createMock(\OC\Files\Storage\Storage::class);
-
-		$targetStorage = $this->createMock(\OC\Files\Storage\Storage::class);
-
-		$cache = $this->getMockBuilder('\OC\Files\Cache\Cache')
-			->disableOriginalConstructor()->getMock();
-
-		$mountPoint = '/mountPoint';
-
-		/** @var Encryption |MockObject $instance */
-		$instance = $this->getMockBuilder(Encryption::class)
-			->setConstructorArgs(
-				[
-					[
-						'storage' => $targetStorage,
-						'root' => 'foo',
-						'mountPoint' => $mountPoint,
-						'mount' => $this->mount
-					],
-					$this->encryptionManager,
-					$this->util,
-					$this->logger,
-					$this->file,
-					null,
-					$this->keyStore,
-					$this->mountManager,
-					$this->arrayCache
-				]
-			)
-			->setMethods(['updateUnencryptedSize', 'getCache'])
-			->getMock();
-
-		$targetStorage->expects($this->once())->method('copyFromStorage')
-			->with($sourceStorage, $sourceInternalPath, $targetInternalPath)
-			->willReturn($copyResult);
-
-		$instance->expects($this->any())->method('getCache')
-			->willReturn($cache);
-
-		$this->arrayCache->expects($this->once())->method('set')
-			->with('encryption_copy_version_' . $sourceInternalPath, true);
-
-		if ($copyResult) {
-			$cache->expects($this->once())->method('get')
-				->with($sourceInternalPath)
-				->willReturn(new CacheEntry(['encrypted' => $encrypted, 'size' => 42]));
-			if ($encrypted) {
-				$instance->expects($this->once())->method('updateUnencryptedSize')
-					->with($mountPoint . $targetInternalPath, 42);
-			} else {
-				$instance->expects($this->never())->method('updateUnencryptedSize');
-			}
-		} else {
-			$instance->expects($this->never())->method('updateUnencryptedSize');
-		}
-
-		$result = $this->invokePrivate(
-			$instance,
-			'copyBetweenStorage',
-			[
-				$sourceStorage,
-				$sourceInternalPath,
-				$targetInternalPath,
-				false,
-				false
-			]
-		);
-
-		$this->assertSame($copyResult, $result);
-	}
-
-	public function dataTestCopyBetweenStorageVersions() {
-		return [
-			['/files/foo.txt', '/files_versions/foo.txt.768743', true, true],
-			['/files/foo.txt', '/files_versions/foo.txt.768743', true, false],
-			['/files/foo.txt', '/files_versions/foo.txt.768743', false, true],
-			['/files/foo.txt', '/files_versions/foo.txt.768743', false, false],
-			['/files_versions/foo.txt.6487634', '/files/foo.txt', true, true],
-			['/files_versions/foo.txt.6487634', '/files/foo.txt', true, false],
-			['/files_versions/foo.txt.6487634', '/files/foo.txt', false, true],
-			['/files_versions/foo.txt.6487634', '/files/foo.txt', false, false],
-
-		];
-	}
-
-	/**
-	 * @dataProvider dataTestIsVersion
-	 * @param string $path
-	 * @param bool $expected
-	 */
-	public function testIsVersion($path, $expected): void {
-		$this->assertSame($expected,
-			$this->invokePrivate($this->instance, 'isVersion', [$path])
-		);
-	}
-
-	public function dataTestIsVersion() {
-		return [
-			['files_versions/foo', true],
-			['/files_versions/foo', true],
-			['//files_versions/foo', true],
-			['files/versions/foo', false],
-			['files/files_versions/foo', false],
-			['files_versions_test/foo', false],
-		];
-	}
-
-	/**
-	 * @dataProvider dataTestShouldEncrypt
-	 *
-	 * @param bool $encryptMountPoint
-	 * @param mixed $encryptionModule
-	 * @param bool $encryptionModuleShouldEncrypt
-	 * @param bool $expected
-	 */
-	public function testShouldEncrypt(
-		$encryptMountPoint,
-		$encryptionModule,
-		$encryptionModuleShouldEncrypt,
-		$expected,
-	): void {
-		$encryptionManager = $this->createMock(\OC\Encryption\Manager::class);
-		$util = $this->createMock(Util::class);
-		$fileHelper = $this->createMock(IFile::class);
-		$keyStorage = $this->createMock(IStorage::class);
-		$mountManager = $this->createMock(\OC\Files\Mount\Manager::class);
-		$mount = $this->createMock(IMountPoint::class);
-		$arrayCache = $this->createMock(ArrayCache::class);
-		$path = '/welcome.txt';
-		$fullPath = 'admin/files/welcome.txt';
-		$defaultEncryptionModule = $this->createMock(IEncryptionModule::class);
-
-		$wrapper = $this->getMockBuilder(Encryption::class)
-			->setConstructorArgs(
-				[
-					['mountPoint' => '', 'mount' => $mount, 'storage' => ''],
-					$encryptionManager,
-					$util,
-					$this->logger,
-					$fileHelper,
-					null,
-					$keyStorage,
-					$mountManager,
-					$arrayCache
-				]
-			)
-			->setMethods(['getFullPath', 'getEncryptionModule'])
-			->getMock();
-
-		if ($encryptionModule === true) {
-			/** @var IEncryptionModule|MockObject $encryptionModule */
-			$encryptionModule = $this->createMock(IEncryptionModule::class);
-		}
-
-		$wrapper->method('getFullPath')->with($path)->willReturn($fullPath);
-		$wrapper->expects($encryptMountPoint ? $this->once() : $this->never())
-			->method('getEncryptionModule')
-			->with($fullPath)
-			->willReturnCallback(
-				function () use ($encryptionModule) {
-					if ($encryptionModule === false) {
-						throw new ModuleDoesNotExistsException();
-					}
-					return $encryptionModule;
-				}
-			);
-		$mount->expects($this->once())->method('getOption')->with('encrypt', true)
-			->willReturn($encryptMountPoint);
-
-		if ($encryptionModule !== null && $encryptionModule !== false) {
-			$encryptionModule
-				->method('shouldEncrypt')
-				->with($fullPath)
-				->willReturn($encryptionModuleShouldEncrypt);
-		}
-
-		if ($encryptionModule === null) {
-			$encryptionManager->expects($this->once())
-				->method('getEncryptionModule')
-				->willReturn($defaultEncryptionModule);
-		}
-		$defaultEncryptionModule->method('shouldEncrypt')->willReturn(true);
-
-		$result = $this->invokePrivate($wrapper, 'shouldEncrypt', [$path]);
-
-		$this->assertSame($expected, $result);
-	}
-
-	public function dataTestShouldEncrypt() {
-		return [
-			[false, false, false, false],
-			[true, false, false, false],
-			[true, true, false, false],
-			[true, true, true, true],
-			[true, null, false, true],
-		];
-	}
+    /**
+     * block size will always be 8192 for a PHP stream
+     * @see https://bugs.php.net/bug.php?id=21641
+     */
+    protected int $headerSize = 8192;
+    private Temporary $sourceStorage;
+    /** @var Encryption&MockObject */
+    protected $instance;
+    private \OC\Encryption\Keys\Storage&MockObject $keyStore;
+    private Util&MockObject $util;
+    private \OC\Encryption\Manager&MockObject $encryptionManager;
+    private IEncryptionModule&MockObject $encryptionModule;
+    private Cache&MockObject $cache;
+    private LoggerInterface&MockObject $logger;
+    private File&MockObject $file;
+    private MountPoint&MockObject $mount;
+    private \OC\Files\Mount\Manager&MockObject $mountManager;
+    private \OC\Group\Manager&MockObject $groupManager;
+    private IConfig&MockObject $config;
+    private ArrayCache&MockObject $arrayCache;
+    /** dummy unencrypted size */
+    private int $dummySize = -1;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $mockModule = $this->buildMockModule();
+        $this->encryptionManager = $this->getMockBuilder('\OC\Encryption\Manager')
+            ->disableOriginalConstructor()
+            ->setMethods(['getEncryptionModule', 'isEnabled'])
+            ->getMock();
+        $this->encryptionManager->expects($this->any())
+            ->method('getEncryptionModule')
+            ->willReturn($mockModule);
+
+        $this->arrayCache = $this->createMock(ArrayCache::class);
+        $this->config = $this->getMockBuilder(IConfig::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $this->groupManager = $this->getMockBuilder('\OC\Group\Manager')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $this->util = $this->getMockBuilder('\OC\Encryption\Util')
+            ->setMethods(['getUidAndFilename', 'isFile', 'isExcluded', 'stripPartialFileExtension'])
+            ->setConstructorArgs([new View(), new Manager(
+                $this->config,
+                $this->createMock(ICacheFactory::class),
+                $this->createMock(IEventDispatcher::class),
+                $this->createMock(LoggerInterface::class),
+            ), $this->groupManager, $this->config, $this->arrayCache])
+            ->getMock();
+        $this->util->expects($this->any())
+            ->method('getUidAndFilename')
+            ->willReturnCallback(function ($path) {
+                return ['user1', $path];
+            });
+        $this->util->expects($this->any())
+            ->method('stripPartialFileExtension')
+            ->willReturnCallback(function ($path) {
+                return $path;
+            });
+
+        $this->file = $this->getMockBuilder('\OC\Encryption\File')
+            ->disableOriginalConstructor()
+            ->setMethods(['getAccessList'])
+            ->getMock();
+        $this->file->expects($this->any())->method('getAccessList')->willReturn([]);
+
+        $this->logger = $this->createMock(LoggerInterface::class);
+
+        $this->sourceStorage = new Temporary([]);
+
+        $this->keyStore = $this->getMockBuilder('\OC\Encryption\Keys\Storage')
+            ->disableOriginalConstructor()->getMock();
+
+        $this->mount = $this->getMockBuilder('\OC\Files\Mount\MountPoint')
+            ->disableOriginalConstructor()
+            ->setMethods(['getOption'])
+            ->getMock();
+        $this->mount->expects($this->any())->method('getOption')->willReturnCallback(function ($option, $default) {
+            if ($option === 'encrypt' && $default === true) {
+                global $mockedMountPointEncryptionEnabled;
+                if ($mockedMountPointEncryptionEnabled !== null) {
+                    return $mockedMountPointEncryptionEnabled;
+                }
+            }
+            return true;
+        });
+
+        $this->cache = $this->getMockBuilder('\OC\Files\Cache\Cache')
+            ->disableOriginalConstructor()->getMock();
+        $this->cache->expects($this->any())
+            ->method('get')
+            ->willReturnCallback(function ($path) {
+                return ['encrypted' => false, 'path' => $path];
+            });
+
+        $this->mountManager = $this->createMock(\OC\Files\Mount\Manager::class);
+        $this->mountManager->method('findByStorageId')
+            ->willReturn([]);
+
+        $this->instance = $this->getMockBuilder(Encryption::class)
+            ->setConstructorArgs(
+                [
+                    [
+                        'storage' => $this->sourceStorage,
+                        'root' => 'foo',
+                        'mountPoint' => '/',
+                        'mount' => $this->mount
+                    ],
+                    $this->encryptionManager,
+                    $this->util,
+                    $this->logger,
+                    $this->file,
+                    null,
+                    $this->keyStore,
+                    $this->mountManager,
+                    $this->arrayCache
+                ]
+            )
+            ->setMethods(['getMetaData', 'getCache', 'getEncryptionModule'])
+            ->getMock();
+
+        $this->instance->expects($this->any())
+            ->method('getMetaData')
+            ->willReturnCallback(function ($path) {
+                return ['encrypted' => true, 'size' => $this->dummySize, 'path' => $path];
+            });
+
+        $this->instance->expects($this->any())
+            ->method('getCache')
+            ->willReturn($this->cache);
+
+        $this->instance->expects($this->any())
+            ->method('getEncryptionModule')
+            ->willReturn($mockModule);
+    }
+
+    protected function buildMockModule(): IEncryptionModule&MockObject {
+        $this->encryptionModule = $this->getMockBuilder('\OCP\Encryption\IEncryptionModule')
+            ->disableOriginalConstructor()
+            ->setMethods(['getId', 'getDisplayName', 'begin', 'end', 'encrypt', 'decrypt', 'update', 'shouldEncrypt', 'getUnencryptedBlockSize', 'isReadable', 'encryptAll', 'prepareDecryptAll', 'isReadyForUser', 'needDetailedAccessList'])
+            ->getMock();
+
+        $this->encryptionModule->expects($this->any())->method('getId')->willReturn('UNIT_TEST_MODULE');
+        $this->encryptionModule->expects($this->any())->method('getDisplayName')->willReturn('Unit test module');
+        $this->encryptionModule->expects($this->any())->method('begin')->willReturn([]);
+        $this->encryptionModule->expects($this->any())->method('end')->willReturn('');
+        $this->encryptionModule->expects($this->any())->method('encrypt')->willReturnArgument(0);
+        $this->encryptionModule->expects($this->any())->method('decrypt')->willReturnArgument(0);
+        $this->encryptionModule->expects($this->any())->method('update')->willReturn(true);
+        $this->encryptionModule->expects($this->any())->method('shouldEncrypt')->willReturn(true);
+        $this->encryptionModule->expects($this->any())->method('getUnencryptedBlockSize')->willReturn(8192);
+        $this->encryptionModule->expects($this->any())->method('isReadable')->willReturn(true);
+        $this->encryptionModule->expects($this->any())->method('needDetailedAccessList')->willReturn(false);
+        return $this->encryptionModule;
+    }
+
+    /**
+     * @dataProvider dataTestGetMetaData
+     *
+     * @param string $path
+     * @param array $metaData
+     * @param bool $encrypted
+     * @param bool $unencryptedSizeSet
+     * @param int $storedUnencryptedSize
+     * @param array $expected
+     */
+    public function testGetMetaData($path, $metaData, $encrypted, $unencryptedSizeSet, $storedUnencryptedSize, $expected): void {
+        $sourceStorage = $this->getMockBuilder('\OC\Files\Storage\Storage')
+            ->disableOriginalConstructor()->getMock();
+
+        $cache = $this->getMockBuilder('\OC\Files\Cache\Cache')
+            ->disableOriginalConstructor()->getMock();
+        $cache->expects($this->any())
+            ->method('get')
+            ->willReturnCallback(
+                function ($path) use ($encrypted) {
+                    return new CacheEntry(['encrypted' => $encrypted, 'path' => $path, 'size' => 0, 'fileid' => 1]);
+                }
+            );
+
+        $this->instance = $this->getMockBuilder(Encryption::class)
+            ->setConstructorArgs(
+                [
+                    [
+                        'storage' => $sourceStorage,
+                        'root' => 'foo',
+                        'mountPoint' => '/',
+                        'mount' => $this->mount
+                    ],
+                    $this->encryptionManager,
+                    $this->util,
+                    $this->logger,
+                    $this->file,
+                    null,
+                    $this->keyStore,
+                    $this->mountManager,
+                    $this->arrayCache,
+                ]
+            )
+            ->setMethods(['getCache', 'verifyUnencryptedSize'])
+            ->getMock();
+
+        if ($unencryptedSizeSet) {
+            $this->invokePrivate($this->instance, 'unencryptedSize', [[$path => $storedUnencryptedSize]]);
+        }
+
+        $fileEntry = $this->getMockBuilder('\OC\Files\Cache\Cache')
+            ->disableOriginalConstructor()->getMock();
+        $sourceStorage->expects($this->once())->method('getMetaData')->with($path)
+            ->willReturn($metaData);
+        $sourceStorage->expects($this->any())
+            ->method('getCache')
+            ->with($path)
+            ->willReturn($fileEntry);
+        if ($metaData !== null) {
+            $fileEntry->expects($this->any())
+                ->method('get')
+                ->with($metaData['fileid']);
+        }
+
+        $this->instance->expects($this->any())->method('getCache')->willReturn($cache);
+        if ($expected !== null) {
+            $this->instance->expects($this->any())->method('verifyUnencryptedSize')
+                ->with($path, 0)->willReturn($expected['size']);
+        }
+
+        $result = $this->instance->getMetaData($path);
+        if (isset($expected['encrypted'])) {
+            $this->assertSame($expected['encrypted'], (bool)$result['encrypted']);
+
+            if (isset($expected['encryptedVersion'])) {
+                $this->assertSame($expected['encryptedVersion'], $result['encryptedVersion']);
+            }
+        }
+
+        if ($expected !== null) {
+            $this->assertSame($expected['size'], $result['size']);
+        } else {
+            $this->assertSame(null, $result);
+        }
+    }
+
+    public function dataTestGetMetaData() {
+        return [
+            ['/test.txt', ['size' => 42, 'encrypted' => 2, 'encryptedVersion' => 2, 'fileid' => 1], true, true, 12, ['size' => 12, 'encrypted' => true, 'encryptedVersion' => 2]],
+            ['/test.txt', null, true, true, 12, null],
+            ['/test.txt', ['size' => 42, 'encrypted' => 0, 'fileid' => 1], false, false, 12, ['size' => 42, 'encrypted' => false]],
+            ['/test.txt', ['size' => 42, 'encrypted' => false, 'fileid' => 1], true, false, 12, ['size' => 12, 'encrypted' => true]]
+        ];
+    }
+
+    public function testFilesize(): void {
+        $cache = $this->getMockBuilder('\OC\Files\Cache\Cache')
+            ->disableOriginalConstructor()->getMock();
+        $cache->expects($this->any())
+            ->method('get')
+            ->willReturn(new CacheEntry(['encrypted' => true, 'path' => '/test.txt', 'size' => 0, 'fileid' => 1]));
+
+        $this->instance = $this->getMockBuilder(Encryption::class)
+            ->setConstructorArgs(
+                [
+                    [
+                        'storage' => $this->sourceStorage,
+                        'root' => 'foo',
+                        'mountPoint' => '/',
+                        'mount' => $this->mount
+                    ],
+                    $this->encryptionManager,
+                    $this->util,
+                    $this->logger,
+                    $this->file,
+                    null,
+                    $this->keyStore,
+                    $this->mountManager,
+                    $this->arrayCache,
+                ]
+            )
+            ->setMethods(['getCache', 'verifyUnencryptedSize'])
+            ->getMock();
+
+        $this->instance->expects($this->any())->method('getCache')->willReturn($cache);
+        $this->instance->expects($this->any())->method('verifyUnencryptedSize')
+            ->willReturn(42);
+
+
+        $this->assertSame(42,
+            $this->instance->filesize('/test.txt')
+        );
+    }
+
+    /**
+     * @dataProvider dataTestVerifyUnencryptedSize
+     *
+     * @param int $encryptedSize
+     * @param int $unencryptedSize
+     * @param bool $failure
+     * @param int $expected
+     */
+    public function testVerifyUnencryptedSize($encryptedSize, $unencryptedSize, $failure, $expected): void {
+        $sourceStorage = $this->getMockBuilder('\OC\Files\Storage\Storage')
+            ->disableOriginalConstructor()->getMock();
+
+        $this->instance = $this->getMockBuilder(Encryption::class)
+            ->setConstructorArgs(
+                [
+                    [
+                        'storage' => $sourceStorage,
+                        'root' => 'foo',
+                        'mountPoint' => '/',
+                        'mount' => $this->mount
+                    ],
+                    $this->encryptionManager,
+                    $this->util,
+                    $this->logger,
+                    $this->file,
+                    null,
+                    $this->keyStore,
+                    $this->mountManager,
+                    $this->arrayCache,
+                ]
+            )
+            ->setMethods(['fixUnencryptedSize'])
+            ->getMock();
+
+        $sourceStorage->expects($this->once())->method('filesize')->willReturn($encryptedSize);
+
+        $this->instance->expects($this->any())->method('fixUnencryptedSize')
+            ->with('/test.txt', $encryptedSize, $unencryptedSize)
+            ->willReturnCallback(
+                function () use ($failure, $expected) {
+                    if ($failure) {
+                        throw new Exception();
+                    } else {
+                        return $expected;
+                    }
+                }
+            );
+
+        $this->assertSame(
+            $expected,
+            $this->invokePrivate($this->instance, 'verifyUnencryptedSize', ['/test.txt', $unencryptedSize])
+        );
+    }
+
+    public function dataTestVerifyUnencryptedSize() {
+        return [
+            [120, 80, false, 80],
+            [120, 120, false, 80],
+            [120, -1, false, 80],
+            [120, -1, true, -1]
+        ];
+    }
+
+    /**
+     * @dataProvider dataTestCopyAndRename
+     *
+     * @param string $source
+     * @param string $target
+     * @param $encryptionEnabled
+     * @param boolean $renameKeysReturn
+     */
+    public function testRename($source,
+        $target,
+        $encryptionEnabled,
+        $renameKeysReturn): void {
+        if ($encryptionEnabled) {
+            $this->keyStore
+                ->expects($this->once())
+                ->method('renameKeys')
+                ->willReturn($renameKeysReturn);
+        } else {
+            $this->keyStore
+                ->expects($this->never())->method('renameKeys');
+        }
+        $this->util->expects($this->any())
+            ->method('isFile')->willReturn(true);
+        $this->encryptionManager->expects($this->once())
+            ->method('isEnabled')->willReturn($encryptionEnabled);
+
+        $this->instance->mkdir($source);
+        $this->instance->mkdir(dirname($target));
+        $this->instance->rename($source, $target);
+    }
+
+    public function testCopyEncryption(): void {
+        $this->instance->file_put_contents('source.txt', 'bar');
+        $this->instance->copy('source.txt', 'target.txt');
+        $this->assertSame('bar', $this->instance->file_get_contents('target.txt'));
+        $targetMeta = $this->instance->getMetaData('target.txt');
+        $sourceMeta = $this->instance->getMetaData('source.txt');
+        $this->assertSame($sourceMeta['encrypted'], $targetMeta['encrypted']);
+        $this->assertSame($sourceMeta['size'], $targetMeta['size']);
+    }
+
+    /**
+     * data provider for testCopyTesting() and dataTestCopyAndRename()
+     *
+     * @return array
+     */
+    public function dataTestCopyAndRename() {
+        return [
+            ['source', 'target', true, false, false],
+            ['source', 'target', true, true, false],
+            ['source', '/subFolder/target', true, false, false],
+            ['source', '/subFolder/target', true, true, true],
+            ['source', '/subFolder/target', false, true, false],
+        ];
+    }
+
+    public function testIsLocal(): void {
+        $this->encryptionManager->expects($this->once())
+            ->method('isEnabled')->willReturn(true);
+        $this->assertFalse($this->instance->isLocal());
+    }
+
+    /**
+     * @dataProvider dataTestRmdir
+     *
+     * @param string $path
+     * @param boolean $rmdirResult
+     * @param boolean $isExcluded
+     * @param boolean $encryptionEnabled
+     */
+    public function testRmdir($path, $rmdirResult, $isExcluded, $encryptionEnabled): void {
+        $sourceStorage = $this->getMockBuilder('\OC\Files\Storage\Storage')
+            ->disableOriginalConstructor()->getMock();
+
+        $util = $this->getMockBuilder('\OC\Encryption\Util')->disableOriginalConstructor()->getMock();
+
+        $sourceStorage->expects($this->once())->method('rmdir')->willReturn($rmdirResult);
+        $util->expects($this->any())->method('isExcluded')->willReturn($isExcluded);
+        $this->encryptionManager->expects($this->any())->method('isEnabled')->willReturn($encryptionEnabled);
+
+        $encryptionStorage = new Encryption(
+            [
+                'storage' => $sourceStorage,
+                'root' => 'foo',
+                'mountPoint' => '/mountPoint',
+                'mount' => $this->mount
+            ],
+            $this->encryptionManager,
+            $util,
+            $this->logger,
+            $this->file,
+            null,
+            $this->keyStore,
+            $this->mountManager,
+            $this->arrayCache,
+        );
+
+
+        if ($rmdirResult === true && $isExcluded === false && $encryptionEnabled === true) {
+            $this->keyStore->expects($this->once())->method('deleteAllFileKeys')->with('/mountPoint' . $path);
+        } else {
+            $this->keyStore->expects($this->never())->method('deleteAllFileKeys');
+        }
+
+        $encryptionStorage->rmdir($path);
+    }
+
+    public function dataTestRmdir() {
+        return [
+            ['/file.txt', true, true, true],
+            ['/file.txt', false, true, true],
+            ['/file.txt', true, false, true],
+            ['/file.txt', false, false, true],
+            ['/file.txt', true, true, false],
+            ['/file.txt', false, true, false],
+            ['/file.txt', true, false, false],
+            ['/file.txt', false, false, false],
+        ];
+    }
+
+    /**
+     * @dataProvider dataTestCopyKeys
+     *
+     * @param boolean $excluded
+     * @param boolean $expected
+     */
+    public function testCopyKeys($excluded, $expected): void {
+        $this->util->expects($this->once())
+            ->method('isExcluded')
+            ->willReturn($excluded);
+
+        if ($excluded) {
+            $this->keyStore->expects($this->never())->method('copyKeys');
+        } else {
+            $this->keyStore->expects($this->once())->method('copyKeys')->willReturn(true);
+        }
+
+        $this->assertSame($expected,
+            self::invokePrivate($this->instance, 'copyKeys', ['/source', '/target'])
+        );
+    }
+
+    public function dataTestCopyKeys() {
+        return [
+            [true, false],
+            [false, true],
+        ];
+    }
+
+    /**
+     * @dataProvider dataTestGetHeader
+     *
+     * @param string $path
+     * @param bool $strippedPathExists
+     * @param string $strippedPath
+     */
+    public function testGetHeader($path, $strippedPathExists, $strippedPath): void {
+        $sourceStorage = $this->getMockBuilder('\OC\Files\Storage\Storage')
+            ->disableOriginalConstructor()->getMock();
+
+        $util = $this->getMockBuilder('\OC\Encryption\Util')
+            ->setConstructorArgs(
+                [
+                    new View(),
+                    new Manager(
+                        $this->config,
+                        $this->createMock(ICacheFactory::class),
+                        $this->createMock(IEventDispatcher::class),
+                        $this->createMock(LoggerInterface::class),
+                    ),
+                    $this->groupManager,
+                    $this->config,
+                    $this->arrayCache
+                ]
+            )->getMock();
+
+        $cache = $this->getMockBuilder('\OC\Files\Cache\Cache')
+            ->disableOriginalConstructor()->getMock();
+        $cache->expects($this->any())
+            ->method('get')
+            ->willReturnCallback(function ($path) {
+                return ['encrypted' => true, 'path' => $path];
+            });
+
+        $instance = $this->getMockBuilder(Encryption::class)
+            ->setConstructorArgs(
+                [
+                    [
+                        'storage' => $sourceStorage,
+                        'root' => 'foo',
+                        'mountPoint' => '/',
+                        'mount' => $this->mount
+                    ],
+                    $this->encryptionManager,
+                    $util,
+                    $this->logger,
+                    $this->file,
+                    null,
+                    $this->keyStore,
+                    $this->mountManager,
+                    $this->arrayCache,
+                ]
+            )
+            ->setMethods(['getCache', 'readFirstBlock'])
+            ->getMock();
+
+        $instance->method('getCache')->willReturn($cache);
+
+        $util->method('parseRawHeader')
+            ->willReturn([Util::HEADER_ENCRYPTION_MODULE_KEY => 'OC_DEFAULT_MODULE']);
+
+        if ($strippedPathExists) {
+            $instance->method('readFirstBlock')
+                ->with($strippedPath)->willReturn('');
+        } else {
+            $instance->method('readFirstBlock')
+                ->with($path)->willReturn('');
+        }
+
+        $util->expects($this->once())->method('stripPartialFileExtension')
+            ->with($path)->willReturn($strippedPath);
+        $sourceStorage->expects($this->once())
+            ->method('is_file')
+            ->with($strippedPath)
+            ->willReturn($strippedPathExists);
+
+        $this->invokePrivate($instance, 'getHeader', [$path]);
+    }
+
+    public function dataTestGetHeader() {
+        return [
+            ['/foo/bar.txt', false, '/foo/bar.txt'],
+            ['/foo/bar.txt.part', false, '/foo/bar.txt'],
+            ['/foo/bar.txt.ocTransferId7437493.part', false, '/foo/bar.txt'],
+            ['/foo/bar.txt.part', true, '/foo/bar.txt'],
+            ['/foo/bar.txt.ocTransferId7437493.part', true, '/foo/bar.txt'],
+        ];
+    }
+
+    /**
+     * test if getHeader adds the default module correctly to the header for
+     * legacy files
+     *
+     * @dataProvider dataTestGetHeaderAddLegacyModule
+     */
+    public function testGetHeaderAddLegacyModule($header, $isEncrypted, $strippedPathExists, $expected): void {
+        $sourceStorage = $this->getMockBuilder('\OC\Files\Storage\Storage')
+            ->disableOriginalConstructor()->getMock();
+
+        $sourceStorage->expects($this->once())
+            ->method('is_file')
+            ->with('test.txt')
+            ->willReturn($strippedPathExists);
+
+        $util = $this->getMockBuilder('\OC\Encryption\Util')
+            ->onlyMethods(['stripPartialFileExtension', 'parseRawHeader'])
+            ->setConstructorArgs([new View(), new Manager(
+                $this->config,
+                $this->createMock(ICacheFactory::class),
+                $this->createMock(IEventDispatcher::class),
+                $this->createMock(LoggerInterface::class),
+            ), $this->groupManager, $this->config, $this->arrayCache])
+            ->getMock();
+        $util->expects($this->any())
+            ->method('stripPartialFileExtension')
+            ->willReturnCallback(function ($path) {
+                return $path;
+            });
+
+        $cache = $this->getMockBuilder('\OC\Files\Cache\Cache')
+            ->disableOriginalConstructor()->getMock();
+        $cache->expects($this->any())
+            ->method('get')
+            ->willReturnCallback(function ($path) use ($isEncrypted) {
+                return ['encrypted' => $isEncrypted, 'path' => $path];
+            });
+
+        $instance = $this->getMockBuilder(Encryption::class)
+            ->setConstructorArgs(
+                [
+                    [
+                        'storage' => $sourceStorage,
+                        'root' => 'foo',
+                        'mountPoint' => '/',
+                        'mount' => $this->mount
+                    ],
+                    $this->encryptionManager,
+                    $util,
+                    $this->logger,
+                    $this->file,
+                    null,
+                    $this->keyStore,
+                    $this->mountManager,
+                    $this->arrayCache,
+                ]
+            )
+            ->setMethods(['readFirstBlock', 'getCache'])
+            ->getMock();
+
+        $instance->method('readFirstBlock')->willReturn('');
+
+        $util->method(('parseRawHeader'))->willReturn($header);
+        $instance->method('getCache')->willReturn($cache);
+
+        $result = $this->invokePrivate($instance, 'getHeader', ['test.txt']);
+        $this->assertSameSize($expected, $result);
+        foreach ($result as $key => $value) {
+            $this->assertArrayHasKey($key, $expected);
+            $this->assertSame($expected[$key], $value);
+        }
+    }
+
+    public function dataTestGetHeaderAddLegacyModule() {
+        return [
+            [['cipher' => 'AES-128'], true, true, ['cipher' => 'AES-128', Util::HEADER_ENCRYPTION_MODULE_KEY => 'OC_DEFAULT_MODULE']],
+            [[], true, false, []],
+            [[], true, true, [Util::HEADER_ENCRYPTION_MODULE_KEY => 'OC_DEFAULT_MODULE']],
+            [[], false, true, []],
+        ];
+    }
+
+    public function dataCopyBetweenStorage() {
+        return [
+            [true, true, true],
+            [true, false, false],
+            [false, true, false],
+            [false, false, false],
+        ];
+    }
+
+    public function testCopyBetweenStorageMinimumEncryptedVersion(): void {
+        $storage2 = $this->createMock(\OC\Files\Storage\Storage::class);
+
+        $sourceInternalPath = $targetInternalPath = 'file.txt';
+        $preserveMtime = $isRename = false;
+
+        $storage2->expects($this->any())
+            ->method('fopen')
+            ->willReturnCallback(function ($path, $mode) {
+                $temp = OC::$server->getTempManager();
+                return fopen($temp->getTemporaryFile(), $mode);
+            });
+        $storage2->method('getId')
+            ->willReturn('stroage2');
+        $cache = $this->createMock(ICache::class);
+        $cache->expects($this->once())
+            ->method('get')
+            ->with($sourceInternalPath)
+            ->willReturn(['encryptedVersion' => 0]);
+        $storage2->expects($this->once())
+            ->method('getCache')
+            ->willReturn($cache);
+        $this->encryptionManager->expects($this->any())
+            ->method('isEnabled')
+            ->willReturn(true);
+        global $mockedMountPointEncryptionEnabled;
+        $mockedMountPointEncryptionEnabled = true;
+
+        $expectedCachePut = [
+            'encrypted' => true,
+        ];
+        $expectedCachePut['encryptedVersion'] = 1;
+
+        $this->cache->expects($this->once())
+            ->method('put')
+            ->with($sourceInternalPath, $expectedCachePut);
+
+        $this->invokePrivate($this->instance, 'copyBetweenStorage', [$storage2, $sourceInternalPath, $targetInternalPath, $preserveMtime, $isRename]);
+
+        $this->assertFalse(false);
+    }
+
+    /**
+     * @dataProvider dataCopyBetweenStorage
+     *
+     * @param bool $encryptionEnabled
+     * @param bool $mountPointEncryptionEnabled
+     * @param bool $expectedEncrypted
+     */
+    public function testCopyBetweenStorage($encryptionEnabled, $mountPointEncryptionEnabled, $expectedEncrypted): void {
+        $storage2 = $this->createMock(\OC\Files\Storage\Storage::class);
+
+        $sourceInternalPath = $targetInternalPath = 'file.txt';
+        $preserveMtime = $isRename = false;
+
+        $storage2->expects($this->any())
+            ->method('fopen')
+            ->willReturnCallback(function ($path, $mode) {
+                $temp = OC::$server->getTempManager();
+                return fopen($temp->getTemporaryFile(), $mode);
+            });
+        $storage2->method('getId')
+            ->willReturn('stroage2');
+        if ($expectedEncrypted) {
+            $cache = $this->createMock(ICache::class);
+            $cache->expects($this->once())
+                ->method('get')
+                ->with($sourceInternalPath)
+                ->willReturn(['encryptedVersion' => 12345]);
+            $storage2->expects($this->once())
+                ->method('getCache')
+                ->willReturn($cache);
+        }
+        $this->encryptionManager->expects($this->any())
+            ->method('isEnabled')
+            ->willReturn($encryptionEnabled);
+        // FIXME can not overwrite the return after definition
+        //		$this->mount->expects($this->at(0))
+        //			->method('getOption')
+        //			->with('encrypt', true)
+        //			->willReturn($mountPointEncryptionEnabled);
+        global $mockedMountPointEncryptionEnabled;
+        $mockedMountPointEncryptionEnabled = $mountPointEncryptionEnabled;
+
+        $expectedCachePut = [
+            'encrypted' => $expectedEncrypted,
+        ];
+        if ($expectedEncrypted === true) {
+            $expectedCachePut['encryptedVersion'] = 1;
+        }
+
+        $this->arrayCache->expects($this->never())->method('set');
+
+        $this->cache->expects($this->once())
+            ->method('put')
+            ->with($sourceInternalPath, $expectedCachePut);
+
+        $this->invokePrivate($this->instance, 'copyBetweenStorage', [$storage2, $sourceInternalPath, $targetInternalPath, $preserveMtime, $isRename]);
+
+        $this->assertFalse(false);
+    }
+
+    /**
+     * @dataProvider dataTestCopyBetweenStorageVersions
+     *
+     * @param string $sourceInternalPath
+     * @param string $targetInternalPath
+     * @param bool $copyResult
+     * @param bool $encrypted
+     */
+    public function testCopyBetweenStorageVersions($sourceInternalPath, $targetInternalPath, $copyResult, $encrypted): void {
+        $sourceStorage = $this->createMock(\OC\Files\Storage\Storage::class);
+
+        $targetStorage = $this->createMock(\OC\Files\Storage\Storage::class);
+
+        $cache = $this->getMockBuilder('\OC\Files\Cache\Cache')
+            ->disableOriginalConstructor()->getMock();
+
+        $mountPoint = '/mountPoint';
+
+        /** @var Encryption |MockObject $instance */
+        $instance = $this->getMockBuilder(Encryption::class)
+            ->setConstructorArgs(
+                [
+                    [
+                        'storage' => $targetStorage,
+                        'root' => 'foo',
+                        'mountPoint' => $mountPoint,
+                        'mount' => $this->mount
+                    ],
+                    $this->encryptionManager,
+                    $this->util,
+                    $this->logger,
+                    $this->file,
+                    null,
+                    $this->keyStore,
+                    $this->mountManager,
+                    $this->arrayCache
+                ]
+            )
+            ->setMethods(['updateUnencryptedSize', 'getCache'])
+            ->getMock();
+
+        $targetStorage->expects($this->once())->method('copyFromStorage')
+            ->with($sourceStorage, $sourceInternalPath, $targetInternalPath)
+            ->willReturn($copyResult);
+
+        $instance->expects($this->any())->method('getCache')
+            ->willReturn($cache);
+
+        $this->arrayCache->expects($this->once())->method('set')
+            ->with('encryption_copy_version_' . $sourceInternalPath, true);
+
+        if ($copyResult) {
+            $cache->expects($this->once())->method('get')
+                ->with($sourceInternalPath)
+                ->willReturn(new CacheEntry(['encrypted' => $encrypted, 'size' => 42]));
+            if ($encrypted) {
+                $instance->expects($this->once())->method('updateUnencryptedSize')
+                    ->with($mountPoint . $targetInternalPath, 42);
+            } else {
+                $instance->expects($this->never())->method('updateUnencryptedSize');
+            }
+        } else {
+            $instance->expects($this->never())->method('updateUnencryptedSize');
+        }
+
+        $result = $this->invokePrivate(
+            $instance,
+            'copyBetweenStorage',
+            [
+                $sourceStorage,
+                $sourceInternalPath,
+                $targetInternalPath,
+                false,
+                false
+            ]
+        );
+
+        $this->assertSame($copyResult, $result);
+    }
+
+    public function dataTestCopyBetweenStorageVersions() {
+        return [
+            ['/files/foo.txt', '/files_versions/foo.txt.768743', true, true],
+            ['/files/foo.txt', '/files_versions/foo.txt.768743', true, false],
+            ['/files/foo.txt', '/files_versions/foo.txt.768743', false, true],
+            ['/files/foo.txt', '/files_versions/foo.txt.768743', false, false],
+            ['/files_versions/foo.txt.6487634', '/files/foo.txt', true, true],
+            ['/files_versions/foo.txt.6487634', '/files/foo.txt', true, false],
+            ['/files_versions/foo.txt.6487634', '/files/foo.txt', false, true],
+            ['/files_versions/foo.txt.6487634', '/files/foo.txt', false, false],
+
+        ];
+    }
+
+    /**
+     * @dataProvider dataTestIsVersion
+     * @param string $path
+     * @param bool $expected
+     */
+    public function testIsVersion($path, $expected): void {
+        $this->assertSame($expected,
+            $this->invokePrivate($this->instance, 'isVersion', [$path])
+        );
+    }
+
+    public function dataTestIsVersion() {
+        return [
+            ['files_versions/foo', true],
+            ['/files_versions/foo', true],
+            ['//files_versions/foo', true],
+            ['files/versions/foo', false],
+            ['files/files_versions/foo', false],
+            ['files_versions_test/foo', false],
+        ];
+    }
+
+    /**
+     * @dataProvider dataTestShouldEncrypt
+     *
+     * @param bool $encryptMountPoint
+     * @param mixed $encryptionModule
+     * @param bool $encryptionModuleShouldEncrypt
+     * @param bool $expected
+     */
+    public function testShouldEncrypt(
+        $encryptMountPoint,
+        $encryptionModule,
+        $encryptionModuleShouldEncrypt,
+        $expected,
+    ): void {
+        $encryptionManager = $this->createMock(\OC\Encryption\Manager::class);
+        $util = $this->createMock(Util::class);
+        $fileHelper = $this->createMock(IFile::class);
+        $keyStorage = $this->createMock(IStorage::class);
+        $mountManager = $this->createMock(\OC\Files\Mount\Manager::class);
+        $mount = $this->createMock(IMountPoint::class);
+        $arrayCache = $this->createMock(ArrayCache::class);
+        $path = '/welcome.txt';
+        $fullPath = 'admin/files/welcome.txt';
+        $defaultEncryptionModule = $this->createMock(IEncryptionModule::class);
+
+        $wrapper = $this->getMockBuilder(Encryption::class)
+            ->setConstructorArgs(
+                [
+                    ['mountPoint' => '', 'mount' => $mount, 'storage' => ''],
+                    $encryptionManager,
+                    $util,
+                    $this->logger,
+                    $fileHelper,
+                    null,
+                    $keyStorage,
+                    $mountManager,
+                    $arrayCache
+                ]
+            )
+            ->setMethods(['getFullPath', 'getEncryptionModule'])
+            ->getMock();
+
+        if ($encryptionModule === true) {
+            /** @var IEncryptionModule|MockObject $encryptionModule */
+            $encryptionModule = $this->createMock(IEncryptionModule::class);
+        }
+
+        $wrapper->method('getFullPath')->with($path)->willReturn($fullPath);
+        $wrapper->expects($encryptMountPoint ? $this->once() : $this->never())
+            ->method('getEncryptionModule')
+            ->with($fullPath)
+            ->willReturnCallback(
+                function () use ($encryptionModule) {
+                    if ($encryptionModule === false) {
+                        throw new ModuleDoesNotExistsException();
+                    }
+                    return $encryptionModule;
+                }
+            );
+        $mount->expects($this->once())->method('getOption')->with('encrypt', true)
+            ->willReturn($encryptMountPoint);
+
+        if ($encryptionModule !== null && $encryptionModule !== false) {
+            $encryptionModule
+                ->method('shouldEncrypt')
+                ->with($fullPath)
+                ->willReturn($encryptionModuleShouldEncrypt);
+        }
+
+        if ($encryptionModule === null) {
+            $encryptionManager->expects($this->once())
+                ->method('getEncryptionModule')
+                ->willReturn($defaultEncryptionModule);
+        }
+        $defaultEncryptionModule->method('shouldEncrypt')->willReturn(true);
+
+        $result = $this->invokePrivate($wrapper, 'shouldEncrypt', [$path]);
+
+        $this->assertSame($expected, $result);
+    }
+
+    public function dataTestShouldEncrypt() {
+        return [
+            [false, false, false, false],
+            [true, false, false, false],
+            [true, true, false, false],
+            [true, true, true, true],
+            [true, null, false, true],
+        ];
+    }
 }

tests/lib/Files/ViewTest.php

Indentation +2834 added lines, -2834 removed lines

@@ -40,40 +40,40 @@ 
 use Test\Traits\UserTrait;
 
 class TemporaryNoTouch extends Temporary {
-	public function touch(string $path, ?int $mtime = null): bool {
-		return false;
-	}
+    public function touch(string $path, ?int $mtime = null): bool {
+        return false;
+    }
 }
 
 class TemporaryNoCross extends Temporary {
-	public function copyFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath, bool $preserveMtime = false): bool {
-		return Common::copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime);
-	}
+    public function copyFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath, bool $preserveMtime = false): bool {
+        return Common::copyFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath, $preserveMtime);
+    }
 
-	public function moveFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath): bool {
-		return Common::moveFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
-	}
+    public function moveFromStorage(IStorage $sourceStorage, string $sourceInternalPath, string $targetInternalPath): bool {
+        return Common::moveFromStorage($sourceStorage, $sourceInternalPath, $targetInternalPath);
+    }
 }
 
 class TemporaryNoLocal extends Temporary {
-	public function instanceOfStorage(string $class): bool {
-		if ($class === '\OC\Files\Storage\Local') {
-			return false;
-		} else {
-			return parent::instanceOfStorage($class);
-		}
-	}
+    public function instanceOfStorage(string $class): bool {
+        if ($class === '\OC\Files\Storage\Local') {
+            return false;
+        } else {
+            return parent::instanceOfStorage($class);
+        }
+    }
 }
 
 class TestEventHandler {
-	public function umount() {
-	}
-	public function post_umount() {
-	}
-	public function preCallback() {
-	}
-	public function postCallback() {
-	}
+    public function umount() {
+    }
+    public function post_umount() {
+    }
+    public function preCallback() {
+    }
+    public function postCallback() {
+    }
 }
 
 /**
@@ -84,2817 +84,2817 @@ 
  * @package Test\Files
  */
 class ViewTest extends \Test\TestCase {
-	use UserTrait;
-
-	/**
-	 * @var \OC\Files\Storage\Storage[] $storages
-	 */
-	private $storages = [];
-
-	/**
-	 * @var string
-	 */
-	private $user;
-
-	/**
-	 * @var \OCP\IUser
-	 */
-	private $userObject;
-
-	/**
-	 * @var \OCP\IGroup
-	 */
-	private $groupObject;
-
-	/** @var \OC\Files\Storage\Storage */
-	private $tempStorage;
-
-	protected function setUp(): void {
-		parent::setUp();
-		\OC_Hook::clear();
-
-		Server::get(IUserManager::class)->clearBackends();
-		Server::get(IUserManager::class)->registerBackend(new \Test\Util\User\Dummy());
-
-		//login
-		$userManager = \OC::$server->getUserManager();
-		$groupManager = \OC::$server->getGroupManager();
-		$this->user = 'test';
-		$this->userObject = $userManager->createUser('test', 'test');
-
-		$this->groupObject = $groupManager->createGroup('group1');
-		$this->groupObject->addUser($this->userObject);
-
-		self::loginAsUser($this->user);
-
-		/** @var IMountManager $manager */
-		$manager = \OC::$server->get(IMountManager::class);
-		$manager->removeMount('/test');
-
-		$this->tempStorage = null;
-	}
-
-	protected function tearDown(): void {
-		\OC_User::setUserId($this->user);
-		foreach ($this->storages as $storage) {
-			$cache = $storage->getCache();
-			$ids = $cache->getAll();
-			$cache->clear();
-		}
-
-		if ($this->tempStorage) {
-			system('rm -rf ' . escapeshellarg($this->tempStorage->getDataDir()));
-		}
-
-		self::logout();
-
-		/** @var SetupManager $setupManager */
-		$setupManager = \OC::$server->get(SetupManager::class);
-		$setupManager->setupRoot();
-
-		$this->userObject->delete();
-		$this->groupObject->delete();
-
-		$mountProviderCollection = \OC::$server->getMountProviderCollection();
-		self::invokePrivate($mountProviderCollection, 'providers', [[]]);
-
-		parent::tearDown();
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testCacheAPI(): void {
-		$storage1 = $this->getTestStorage();
-		$storage2 = $this->getTestStorage();
-		$storage3 = $this->getTestStorage();
-		$root = self::getUniqueID('/');
-		Filesystem::mount($storage1, [], $root . '/');
-		Filesystem::mount($storage2, [], $root . '/substorage');
-		Filesystem::mount($storage3, [], $root . '/folder/anotherstorage');
-		$textSize = strlen("dummy file data\n");
-		$imageSize = filesize(\OC::$SERVERROOT . '/core/img/logo/logo.png');
-		$storageSize = $textSize * 2 + $imageSize;
-
-		$storageInfo = $storage3->getCache()->get('');
-		$this->assertEquals($storageSize, $storageInfo['size']);
-
-		$rootView = new View($root);
-
-		$cachedData = $rootView->getFileInfo('/foo.txt');
-		$this->assertEquals($textSize, $cachedData['size']);
-		$this->assertEquals('text/plain', $cachedData['mimetype']);
-		$this->assertNotEquals(-1, $cachedData['permissions']);
-
-		$cachedData = $rootView->getFileInfo('/');
-		$this->assertEquals($storageSize * 3, $cachedData['size']);
-		$this->assertEquals('httpd/unix-directory', $cachedData['mimetype']);
-
-		// get cached data excluding mount points
-		$cachedData = $rootView->getFileInfo('/', false);
-		$this->assertEquals($storageSize, $cachedData['size']);
-		$this->assertEquals('httpd/unix-directory', $cachedData['mimetype']);
-
-		$cachedData = $rootView->getFileInfo('/folder');
-		$this->assertEquals($storageSize + $textSize, $cachedData['size']);
-		$this->assertEquals('httpd/unix-directory', $cachedData['mimetype']);
-
-		$folderData = $rootView->getDirectoryContent('/');
-		/**
-		 * expected entries:
-		 * folder
-		 * foo.png
-		 * foo.txt
-		 * substorage
-		 */
-		$this->assertCount(4, $folderData);
-		$this->assertEquals('folder', $folderData[0]['name']);
-		$this->assertEquals('foo.png', $folderData[1]['name']);
-		$this->assertEquals('foo.txt', $folderData[2]['name']);
-		$this->assertEquals('substorage', $folderData[3]['name']);
-
-		$this->assertEquals($storageSize + $textSize, $folderData[0]['size']);
-		$this->assertEquals($imageSize, $folderData[1]['size']);
-		$this->assertEquals($textSize, $folderData[2]['size']);
-		$this->assertEquals($storageSize, $folderData[3]['size']);
-
-		$folderData = $rootView->getDirectoryContent('/substorage');
-		/**
-		 * expected entries:
-		 * folder
-		 * foo.png
-		 * foo.txt
-		 */
-		$this->assertCount(3, $folderData);
-		$this->assertEquals('folder', $folderData[0]['name']);
-		$this->assertEquals('foo.png', $folderData[1]['name']);
-		$this->assertEquals('foo.txt', $folderData[2]['name']);
-
-		$folderView = new View($root . '/folder');
-		$this->assertEquals($rootView->getFileInfo('/folder'), $folderView->getFileInfo('/'));
-
-		$cachedData = $rootView->getFileInfo('/foo.txt');
-		$this->assertFalse($cachedData['encrypted']);
-		$id = $rootView->putFileInfo('/foo.txt', ['encrypted' => true]);
-		$cachedData = $rootView->getFileInfo('/foo.txt');
-		$this->assertTrue($cachedData['encrypted']);
-		$this->assertEquals($cachedData['fileid'], $id);
-
-		$this->assertFalse($rootView->getFileInfo('/non/existing'));
-		$this->assertEquals([], $rootView->getDirectoryContent('/non/existing'));
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testGetPath(): void {
-		$storage1 = $this->getTestStorage();
-		$storage2 = $this->getTestStorage();
-		$storage3 = $this->getTestStorage();
-
-		Filesystem::mount($storage1, [], '/');
-		Filesystem::mount($storage2, [], '/substorage');
-		Filesystem::mount($storage3, [], '/folder/anotherstorage');
-
-		$rootView = new View('');
-
-
-		$cachedData = $rootView->getFileInfo('/foo.txt');
-		/** @var int $id1 */
-		$id1 = $cachedData['fileid'];
-		$this->assertEquals('/foo.txt', $rootView->getPath($id1));
-
-		$cachedData = $rootView->getFileInfo('/substorage/foo.txt');
-		/** @var int $id2 */
-		$id2 = $cachedData['fileid'];
-		$this->assertEquals('/substorage/foo.txt', $rootView->getPath($id2));
-
-		$folderView = new View('/substorage');
-		$this->assertEquals('/foo.txt', $folderView->getPath($id2));
-	}
-
-
-	public function testGetPathNotExisting(): void {
-		$this->expectException(\OCP\Files\NotFoundException::class);
-
-		$storage1 = $this->getTestStorage();
-		Filesystem::mount($storage1, [], '/');
-
-		$rootView = new View('');
-		$cachedData = $rootView->getFileInfo('/foo.txt');
-		/** @var int $id1 */
-		$id1 = $cachedData['fileid'];
-		$folderView = new View('/substorage');
-		$this->assertNull($folderView->getPath($id1));
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testMountPointOverwrite(): void {
-		$storage1 = $this->getTestStorage(false);
-		$storage2 = $this->getTestStorage();
-		$storage1->mkdir('substorage');
-		Filesystem::mount($storage1, [], '/');
-		Filesystem::mount($storage2, [], '/substorage');
-
-		$rootView = new View('');
-		$folderContent = $rootView->getDirectoryContent('/');
-		$this->assertCount(4, $folderContent);
-	}
-
-	public static function sharingDisabledPermissionProvider(): array {
-		return [
-			['no', '', true],
-			['yes', 'group1', false],
-		];
-	}
-
-	/**
-	 * @dataProvider sharingDisabledPermissionProvider
-	 */
-	public function testRemoveSharePermissionWhenSharingDisabledForUser($excludeGroups, $excludeGroupsList, $expectedShareable): void {
-		// Reset sharing disabled for users cache
-		self::invokePrivate(\OC::$server->get(ShareDisableChecker::class), 'sharingDisabledForUsersCache', [new CappedMemoryCache()]);
-
-		$config = \OC::$server->getConfig();
-		$oldExcludeGroupsFlag = $config->getAppValue('core', 'shareapi_exclude_groups', 'no');
-		$oldExcludeGroupsList = $config->getAppValue('core', 'shareapi_exclude_groups_list', '');
-		$config->setAppValue('core', 'shareapi_exclude_groups', $excludeGroups);
-		$config->setAppValue('core', 'shareapi_exclude_groups_list', $excludeGroupsList);
-
-		$storage1 = $this->getTestStorage();
-		$storage2 = $this->getTestStorage();
-		Filesystem::mount($storage1, [], '/');
-		Filesystem::mount($storage2, [], '/mount');
-
-		$view = new View('/');
-
-		$folderContent = $view->getDirectoryContent('');
-		$this->assertEquals($expectedShareable, $folderContent[0]->isShareable());
-
-		$folderContent = $view->getDirectoryContent('mount');
-		$this->assertEquals($expectedShareable, $folderContent[0]->isShareable());
-
-		$config->setAppValue('core', 'shareapi_exclude_groups', $oldExcludeGroupsFlag);
-		$config->setAppValue('core', 'shareapi_exclude_groups_list', $oldExcludeGroupsList);
-
-		// Reset sharing disabled for users cache
-		self::invokePrivate(\OC::$server->get(ShareDisableChecker::class), 'sharingDisabledForUsersCache', [new CappedMemoryCache()]);
-	}
-
-	public function testCacheIncompleteFolder(): void {
-		$storage1 = $this->getTestStorage(false);
-		Filesystem::mount($storage1, [], '/incomplete');
-		$rootView = new View('/incomplete');
-
-		$entries = $rootView->getDirectoryContent('/');
-		$this->assertCount(3, $entries);
-
-		// /folder will already be in the cache but not scanned
-		$entries = $rootView->getDirectoryContent('/folder');
-		$this->assertCount(1, $entries);
-	}
-
-	public function testAutoScan(): void {
-		$storage1 = $this->getTestStorage(false);
-		$storage2 = $this->getTestStorage(false);
-		Filesystem::mount($storage1, [], '/');
-		Filesystem::mount($storage2, [], '/substorage');
-		$textSize = strlen("dummy file data\n");
-
-		$rootView = new View('');
-
-		$cachedData = $rootView->getFileInfo('/');
-		$this->assertEquals('httpd/unix-directory', $cachedData['mimetype']);
-		$this->assertEquals(-1, $cachedData['size']);
-
-		$folderData = $rootView->getDirectoryContent('/substorage/folder');
-		$this->assertEquals('text/plain', $folderData[0]['mimetype']);
-		$this->assertEquals($textSize, $folderData[0]['size']);
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testSearch(): void {
-		$storage1 = $this->getTestStorage();
-		$storage2 = $this->getTestStorage();
-		$storage3 = $this->getTestStorage();
-		Filesystem::mount($storage1, [], '/');
-		Filesystem::mount($storage2, [], '/substorage');
-		Filesystem::mount($storage3, [], '/folder/anotherstorage');
-
-		$rootView = new View('');
-
-		$results = $rootView->search('foo');
-		$this->assertCount(6, $results);
-		$paths = [];
-		foreach ($results as $result) {
-			$this->assertEquals($result['path'], Filesystem::normalizePath($result['path']));
-			$paths[] = $result['path'];
-		}
-		$this->assertContains('/foo.txt', $paths);
-		$this->assertContains('/foo.png', $paths);
-		$this->assertContains('/substorage/foo.txt', $paths);
-		$this->assertContains('/substorage/foo.png', $paths);
-		$this->assertContains('/folder/anotherstorage/foo.txt', $paths);
-		$this->assertContains('/folder/anotherstorage/foo.png', $paths);
-
-		$folderView = new View('/folder');
-		$results = $folderView->search('bar');
-		$this->assertCount(2, $results);
-		$paths = [];
-		foreach ($results as $result) {
-			$paths[] = $result['path'];
-		}
-		$this->assertContains('/anotherstorage/folder/bar.txt', $paths);
-		$this->assertContains('/bar.txt', $paths);
-
-		$results = $folderView->search('foo');
-		$this->assertCount(2, $results);
-		$paths = [];
-		foreach ($results as $result) {
-			$paths[] = $result['path'];
-		}
-		$this->assertContains('/anotherstorage/foo.txt', $paths);
-		$this->assertContains('/anotherstorage/foo.png', $paths);
-
-		$this->assertCount(6, $rootView->searchByMime('text'));
-		$this->assertCount(3, $folderView->searchByMime('text'));
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testWatcher(): void {
-		$storage1 = $this->getTestStorage();
-		Filesystem::mount($storage1, [], '/');
-		$storage1->getWatcher()->setPolicy(Watcher::CHECK_ALWAYS);
-
-		$rootView = new View('');
-
-		$cachedData = $rootView->getFileInfo('foo.txt');
-		$this->assertEquals(16, $cachedData['size']);
-
-		$rootView->putFileInfo('foo.txt', ['storage_mtime' => 10]);
-		$storage1->file_put_contents('foo.txt', 'foo');
-		clearstatcache();
-
-		$cachedData = $rootView->getFileInfo('foo.txt');
-		$this->assertEquals(3, $cachedData['size']);
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testCopyBetweenStorageNoCross(): void {
-		$storage1 = $this->getTestStorage(true, TemporaryNoCross::class);
-		$storage2 = $this->getTestStorage(true, TemporaryNoCross::class);
-		$this->copyBetweenStorages($storage1, $storage2);
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testCopyBetweenStorageCross(): void {
-		$storage1 = $this->getTestStorage();
-		$storage2 = $this->getTestStorage();
-		$this->copyBetweenStorages($storage1, $storage2);
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testCopyBetweenStorageCrossNonLocal(): void {
-		$storage1 = $this->getTestStorage(true, TemporaryNoLocal::class);
-		$storage2 = $this->getTestStorage(true, TemporaryNoLocal::class);
-		$this->copyBetweenStorages($storage1, $storage2);
-	}
-
-	public function copyBetweenStorages($storage1, $storage2) {
-		Filesystem::mount($storage1, [], '/');
-		Filesystem::mount($storage2, [], '/substorage');
-
-		$rootView = new View('');
-		$rootView->mkdir('substorage/emptyfolder');
-		$rootView->copy('substorage', 'anotherfolder');
-		$this->assertTrue($rootView->is_dir('/anotherfolder'));
-		$this->assertTrue($rootView->is_dir('/substorage'));
-		$this->assertTrue($rootView->is_dir('/anotherfolder/emptyfolder'));
-		$this->assertTrue($rootView->is_dir('/substorage/emptyfolder'));
-		$this->assertTrue($rootView->file_exists('/anotherfolder/foo.txt'));
-		$this->assertTrue($rootView->file_exists('/anotherfolder/foo.png'));
-		$this->assertTrue($rootView->file_exists('/anotherfolder/folder/bar.txt'));
-		$this->assertTrue($rootView->file_exists('/substorage/foo.txt'));
-		$this->assertTrue($rootView->file_exists('/substorage/foo.png'));
-		$this->assertTrue($rootView->file_exists('/substorage/folder/bar.txt'));
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testMoveBetweenStorageNoCross(): void {
-		$storage1 = $this->getTestStorage(true, TemporaryNoCross::class);
-		$storage2 = $this->getTestStorage(true, TemporaryNoCross::class);
-		$this->moveBetweenStorages($storage1, $storage2);
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testMoveBetweenStorageCross(): void {
-		$storage1 = $this->getTestStorage();
-		$storage2 = $this->getTestStorage();
-		$this->moveBetweenStorages($storage1, $storage2);
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testMoveBetweenStorageCrossNonLocal(): void {
-		$storage1 = $this->getTestStorage(true, TemporaryNoLocal::class);
-		$storage2 = $this->getTestStorage(true, TemporaryNoLocal::class);
-		$this->moveBetweenStorages($storage1, $storage2);
-	}
-
-	public function moveBetweenStorages($storage1, $storage2) {
-		Filesystem::mount($storage1, [], '/' . $this->user . '/');
-		Filesystem::mount($storage2, [], '/' . $this->user . '/substorage');
-
-		$rootView = new View('/' . $this->user);
-		$rootView->rename('foo.txt', 'substorage/folder/foo.txt');
-		$this->assertFalse($rootView->file_exists('foo.txt'));
-		$this->assertTrue($rootView->file_exists('substorage/folder/foo.txt'));
-		$rootView->rename('substorage/folder', 'anotherfolder');
-		$this->assertFalse($rootView->is_dir('substorage/folder'));
-		$this->assertTrue($rootView->file_exists('anotherfolder/foo.txt'));
-		$this->assertTrue($rootView->file_exists('anotherfolder/bar.txt'));
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testUnlink(): void {
-		$storage1 = $this->getTestStorage();
-		$storage2 = $this->getTestStorage();
-		Filesystem::mount($storage1, [], '/');
-		Filesystem::mount($storage2, [], '/substorage');
-
-		$rootView = new View('');
-		$rootView->file_put_contents('/foo.txt', 'asd');
-		$rootView->file_put_contents('/substorage/bar.txt', 'asd');
-
-		$this->assertTrue($rootView->file_exists('foo.txt'));
-		$this->assertTrue($rootView->file_exists('substorage/bar.txt'));
-
-		$this->assertTrue($rootView->unlink('foo.txt'));
-		$this->assertTrue($rootView->unlink('substorage/bar.txt'));
-
-		$this->assertFalse($rootView->file_exists('foo.txt'));
-		$this->assertFalse($rootView->file_exists('substorage/bar.txt'));
-	}
-
-	public static function rmdirOrUnlinkDataProvider(): array {
-		return [['rmdir'], ['unlink']];
-	}
-
-	/**
-	 * @dataProvider rmdirOrUnlinkDataProvider
-	 */
-	public function testRmdir($method): void {
-		$storage1 = $this->getTestStorage();
-		Filesystem::mount($storage1, [], '/');
-
-		$rootView = new View('');
-		$rootView->mkdir('sub');
-		$rootView->mkdir('sub/deep');
-		$rootView->file_put_contents('/sub/deep/foo.txt', 'asd');
-
-		$this->assertTrue($rootView->file_exists('sub/deep/foo.txt'));
-
-		$this->assertTrue($rootView->$method('sub'));
-
-		$this->assertFalse($rootView->file_exists('sub'));
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testUnlinkRootMustFail(): void {
-		$storage1 = $this->getTestStorage();
-		$storage2 = $this->getTestStorage();
-		Filesystem::mount($storage1, [], '/');
-		Filesystem::mount($storage2, [], '/substorage');
-
-		$rootView = new View('');
-		$rootView->file_put_contents('/foo.txt', 'asd');
-		$rootView->file_put_contents('/substorage/bar.txt', 'asd');
-
-		$this->assertFalse($rootView->unlink(''));
-		$this->assertFalse($rootView->unlink('/'));
-		$this->assertFalse($rootView->unlink('substorage'));
-		$this->assertFalse($rootView->unlink('/substorage'));
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testTouch(): void {
-		$storage = $this->getTestStorage(true, TemporaryNoTouch::class);
-
-		Filesystem::mount($storage, [], '/');
-
-		$rootView = new View('');
-		$oldCachedData = $rootView->getFileInfo('foo.txt');
-
-		$rootView->touch('foo.txt', 500);
-
-		$cachedData = $rootView->getFileInfo('foo.txt');
-		$this->assertEquals(500, $cachedData['mtime']);
-		$this->assertEquals($oldCachedData['storage_mtime'], $cachedData['storage_mtime']);
-
-		$rootView->putFileInfo('foo.txt', ['storage_mtime' => 1000]); //make sure the watcher detects the change
-		$rootView->file_put_contents('foo.txt', 'asd');
-		$cachedData = $rootView->getFileInfo('foo.txt');
-		$this->assertGreaterThanOrEqual($oldCachedData['mtime'], $cachedData['mtime']);
-		$this->assertEquals($cachedData['storage_mtime'], $cachedData['mtime']);
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testTouchFloat(): void {
-		$storage = $this->getTestStorage(true, TemporaryNoTouch::class);
-
-		Filesystem::mount($storage, [], '/');
-
-		$rootView = new View('');
-		$oldCachedData = $rootView->getFileInfo('foo.txt');
-
-		$rootView->touch('foo.txt', 500.5);
-
-		$cachedData = $rootView->getFileInfo('foo.txt');
-		$this->assertEquals(500, $cachedData['mtime']);
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testViewHooks(): void {
-		$storage1 = $this->getTestStorage();
-		$storage2 = $this->getTestStorage();
-		$defaultRoot = Filesystem::getRoot();
-		Filesystem::mount($storage1, [], '/');
-		Filesystem::mount($storage2, [], $defaultRoot . '/substorage');
-		\OC_Hook::connect('OC_Filesystem', 'post_write', $this, 'dummyHook');
-
-		$rootView = new View('');
-		$subView = new View($defaultRoot . '/substorage');
-		$this->hookPath = null;
-
-		$rootView->file_put_contents('/foo.txt', 'asd');
-		$this->assertNull($this->hookPath);
-
-		$subView->file_put_contents('/foo.txt', 'asd');
-		$this->assertEquals('/substorage/foo.txt', $this->hookPath);
-	}
-
-	private $hookPath;
-
-	public function dummyHook($params) {
-		$this->hookPath = $params['path'];
-	}
-
-	public function testSearchNotOutsideView(): void {
-		$storage1 = $this->getTestStorage();
-		Filesystem::mount($storage1, [], '/');
-		$storage1->rename('folder', 'foo');
-		$scanner = $storage1->getScanner();
-		$scanner->scan('');
-
-		$view = new View('/foo');
-
-		$result = $view->search('.txt');
-		$this->assertCount(1, $result);
-	}
-
-	/**
-	 * @param bool $scan
-	 * @param string $class
-	 * @return \OC\Files\Storage\Storage
-	 */
-	private function getTestStorage($scan = true, $class = Temporary::class) {
-		/**
-		 * @var \OC\Files\Storage\Storage $storage
-		 */
-		$storage = new $class([]);
-		$textData = "dummy file data\n";
-		$imgData = file_get_contents(\OC::$SERVERROOT . '/core/img/logo/logo.png');
-		$storage->mkdir('folder');
-		$storage->file_put_contents('foo.txt', $textData);
-		$storage->file_put_contents('foo.png', $imgData);
-		$storage->file_put_contents('folder/bar.txt', $textData);
-
-		if ($scan) {
-			$scanner = $storage->getScanner();
-			$scanner->scan('');
-		}
-		$this->storages[] = $storage;
-		return $storage;
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testViewHooksIfRootStartsTheSame(): void {
-		$storage1 = $this->getTestStorage();
-		$storage2 = $this->getTestStorage();
-		$defaultRoot = Filesystem::getRoot();
-		Filesystem::mount($storage1, [], '/');
-		Filesystem::mount($storage2, [], $defaultRoot . '_substorage');
-		\OC_Hook::connect('OC_Filesystem', 'post_write', $this, 'dummyHook');
-
-		$subView = new View($defaultRoot . '_substorage');
-		$this->hookPath = null;
-
-		$subView->file_put_contents('/foo.txt', 'asd');
-		$this->assertNull($this->hookPath);
-	}
-
-	private $hookWritePath;
-	private $hookCreatePath;
-	private $hookUpdatePath;
-
-	public function dummyHookWrite($params) {
-		$this->hookWritePath = $params['path'];
-	}
-
-	public function dummyHookUpdate($params) {
-		$this->hookUpdatePath = $params['path'];
-	}
-
-	public function dummyHookCreate($params) {
-		$this->hookCreatePath = $params['path'];
-	}
-
-	public function testEditNoCreateHook(): void {
-		$storage1 = $this->getTestStorage();
-		$storage2 = $this->getTestStorage();
-		$defaultRoot = Filesystem::getRoot();
-		Filesystem::mount($storage1, [], '/');
-		Filesystem::mount($storage2, [], $defaultRoot);
-		\OC_Hook::connect('OC_Filesystem', 'post_create', $this, 'dummyHookCreate');
-		\OC_Hook::connect('OC_Filesystem', 'post_update', $this, 'dummyHookUpdate');
-		\OC_Hook::connect('OC_Filesystem', 'post_write', $this, 'dummyHookWrite');
-
-		$view = new View($defaultRoot);
-		$this->hookWritePath = $this->hookUpdatePath = $this->hookCreatePath = null;
-
-		$view->file_put_contents('/asd.txt', 'foo');
-		$this->assertEquals('/asd.txt', $this->hookCreatePath);
-		$this->assertNull($this->hookUpdatePath);
-		$this->assertEquals('/asd.txt', $this->hookWritePath);
-
-		$this->hookWritePath = $this->hookUpdatePath = $this->hookCreatePath = null;
-
-		$view->file_put_contents('/asd.txt', 'foo');
-		$this->assertNull($this->hookCreatePath);
-		$this->assertEquals('/asd.txt', $this->hookUpdatePath);
-		$this->assertEquals('/asd.txt', $this->hookWritePath);
-
-		\OC_Hook::clear('OC_Filesystem', 'post_create');
-		\OC_Hook::clear('OC_Filesystem', 'post_update');
-		\OC_Hook::clear('OC_Filesystem', 'post_write');
-	}
-
-	/**
-	 * @dataProvider resolvePathTestProvider
-	 */
-	public function testResolvePath($expected, $pathToTest): void {
-		$storage1 = $this->getTestStorage();
-		Filesystem::mount($storage1, [], '/');
-
-		$view = new View('');
-
-		$result = $view->resolvePath($pathToTest);
-		$this->assertEquals($expected, $result[1]);
-
-		$exists = $view->file_exists($pathToTest);
-		$this->assertTrue($exists);
-
-		$exists = $view->file_exists($result[1]);
-		$this->assertTrue($exists);
-	}
-
-	public static function resolvePathTestProvider(): array {
-		return [
-			['foo.txt', 'foo.txt'],
-			['foo.txt', '/foo.txt'],
-			['folder', 'folder'],
-			['folder', '/folder'],
-			['folder', 'folder/'],
-			['folder', '/folder/'],
-			['folder/bar.txt', 'folder/bar.txt'],
-			['folder/bar.txt', '/folder/bar.txt'],
-			['', ''],
-			['', '/'],
-		];
-	}
-
-	public function testUTF8Names(): void {
-		$names = ['虚', '和知しゃ和で', 'regular ascii', 'sɨˈrɪlɪk', 'ѨѬ', 'أنا أحب القراءة كثيرا'];
-
-		$storage = new Temporary([]);
-		Filesystem::mount($storage, [], '/');
-
-		$rootView = new View('');
-		foreach ($names as $name) {
-			$rootView->file_put_contents('/' . $name, 'dummy content');
-		}
-
-		$list = $rootView->getDirectoryContent('/');
-
-		$this->assertCount(count($names), $list);
-		foreach ($list as $item) {
-			$this->assertContains($item['name'], $names);
-		}
-
-		$cache = $storage->getCache();
-		$scanner = $storage->getScanner();
-		$scanner->scan('');
-
-		$list = $cache->getFolderContents('');
-
-		$this->assertCount(count($names), $list);
-		foreach ($list as $item) {
-			$this->assertContains($item['name'], $names);
-		}
-	}
-
-	public function xtestLongPath() {
-		$storage = new Temporary([]);
-		Filesystem::mount($storage, [], '/');
-
-		$rootView = new View('');
-
-		$longPath = '';
-		$ds = DIRECTORY_SEPARATOR;
-		/*
+    use UserTrait;
+
+    /**
+     * @var \OC\Files\Storage\Storage[] $storages
+     */
+    private $storages = [];
+
+    /**
+     * @var string
+     */
+    private $user;
+
+    /**
+     * @var \OCP\IUser
+     */
+    private $userObject;
+
+    /**
+     * @var \OCP\IGroup
+     */
+    private $groupObject;
+
+    /** @var \OC\Files\Storage\Storage */
+    private $tempStorage;
+
+    protected function setUp(): void {
+        parent::setUp();
+        \OC_Hook::clear();
+
+        Server::get(IUserManager::class)->clearBackends();
+        Server::get(IUserManager::class)->registerBackend(new \Test\Util\User\Dummy());
+
+        //login
+        $userManager = \OC::$server->getUserManager();
+        $groupManager = \OC::$server->getGroupManager();
+        $this->user = 'test';
+        $this->userObject = $userManager->createUser('test', 'test');
+
+        $this->groupObject = $groupManager->createGroup('group1');
+        $this->groupObject->addUser($this->userObject);
+
+        self::loginAsUser($this->user);
+
+        /** @var IMountManager $manager */
+        $manager = \OC::$server->get(IMountManager::class);
+        $manager->removeMount('/test');
+
+        $this->tempStorage = null;
+    }
+
+    protected function tearDown(): void {
+        \OC_User::setUserId($this->user);
+        foreach ($this->storages as $storage) {
+            $cache = $storage->getCache();
+            $ids = $cache->getAll();
+            $cache->clear();
+        }
+
+        if ($this->tempStorage) {
+            system('rm -rf ' . escapeshellarg($this->tempStorage->getDataDir()));
+        }
+
+        self::logout();
+
+        /** @var SetupManager $setupManager */
+        $setupManager = \OC::$server->get(SetupManager::class);
+        $setupManager->setupRoot();
+
+        $this->userObject->delete();
+        $this->groupObject->delete();
+
+        $mountProviderCollection = \OC::$server->getMountProviderCollection();
+        self::invokePrivate($mountProviderCollection, 'providers', [[]]);
+
+        parent::tearDown();
+    }
+
+    /**
+     * @medium
+     */
+    public function testCacheAPI(): void {
+        $storage1 = $this->getTestStorage();
+        $storage2 = $this->getTestStorage();
+        $storage3 = $this->getTestStorage();
+        $root = self::getUniqueID('/');
+        Filesystem::mount($storage1, [], $root . '/');
+        Filesystem::mount($storage2, [], $root . '/substorage');
+        Filesystem::mount($storage3, [], $root . '/folder/anotherstorage');
+        $textSize = strlen("dummy file data\n");
+        $imageSize = filesize(\OC::$SERVERROOT . '/core/img/logo/logo.png');
+        $storageSize = $textSize * 2 + $imageSize;
+
+        $storageInfo = $storage3->getCache()->get('');
+        $this->assertEquals($storageSize, $storageInfo['size']);
+
+        $rootView = new View($root);
+
+        $cachedData = $rootView->getFileInfo('/foo.txt');
+        $this->assertEquals($textSize, $cachedData['size']);
+        $this->assertEquals('text/plain', $cachedData['mimetype']);
+        $this->assertNotEquals(-1, $cachedData['permissions']);
+
+        $cachedData = $rootView->getFileInfo('/');
+        $this->assertEquals($storageSize * 3, $cachedData['size']);
+        $this->assertEquals('httpd/unix-directory', $cachedData['mimetype']);
+
+        // get cached data excluding mount points
+        $cachedData = $rootView->getFileInfo('/', false);
+        $this->assertEquals($storageSize, $cachedData['size']);
+        $this->assertEquals('httpd/unix-directory', $cachedData['mimetype']);
+
+        $cachedData = $rootView->getFileInfo('/folder');
+        $this->assertEquals($storageSize + $textSize, $cachedData['size']);
+        $this->assertEquals('httpd/unix-directory', $cachedData['mimetype']);
+
+        $folderData = $rootView->getDirectoryContent('/');
+        /**
+         * expected entries:
+         * folder
+         * foo.png
+         * foo.txt
+         * substorage
+         */
+        $this->assertCount(4, $folderData);
+        $this->assertEquals('folder', $folderData[0]['name']);
+        $this->assertEquals('foo.png', $folderData[1]['name']);
+        $this->assertEquals('foo.txt', $folderData[2]['name']);
+        $this->assertEquals('substorage', $folderData[3]['name']);
+
+        $this->assertEquals($storageSize + $textSize, $folderData[0]['size']);
+        $this->assertEquals($imageSize, $folderData[1]['size']);
+        $this->assertEquals($textSize, $folderData[2]['size']);
+        $this->assertEquals($storageSize, $folderData[3]['size']);
+
+        $folderData = $rootView->getDirectoryContent('/substorage');
+        /**
+         * expected entries:
+         * folder
+         * foo.png
+         * foo.txt
+         */
+        $this->assertCount(3, $folderData);
+        $this->assertEquals('folder', $folderData[0]['name']);
+        $this->assertEquals('foo.png', $folderData[1]['name']);
+        $this->assertEquals('foo.txt', $folderData[2]['name']);
+
+        $folderView = new View($root . '/folder');
+        $this->assertEquals($rootView->getFileInfo('/folder'), $folderView->getFileInfo('/'));
+
+        $cachedData = $rootView->getFileInfo('/foo.txt');
+        $this->assertFalse($cachedData['encrypted']);
+        $id = $rootView->putFileInfo('/foo.txt', ['encrypted' => true]);
+        $cachedData = $rootView->getFileInfo('/foo.txt');
+        $this->assertTrue($cachedData['encrypted']);
+        $this->assertEquals($cachedData['fileid'], $id);
+
+        $this->assertFalse($rootView->getFileInfo('/non/existing'));
+        $this->assertEquals([], $rootView->getDirectoryContent('/non/existing'));
+    }
+
+    /**
+     * @medium
+     */
+    public function testGetPath(): void {
+        $storage1 = $this->getTestStorage();
+        $storage2 = $this->getTestStorage();
+        $storage3 = $this->getTestStorage();
+
+        Filesystem::mount($storage1, [], '/');
+        Filesystem::mount($storage2, [], '/substorage');
+        Filesystem::mount($storage3, [], '/folder/anotherstorage');
+
+        $rootView = new View('');
+
+
+        $cachedData = $rootView->getFileInfo('/foo.txt');
+        /** @var int $id1 */
+        $id1 = $cachedData['fileid'];
+        $this->assertEquals('/foo.txt', $rootView->getPath($id1));
+
+        $cachedData = $rootView->getFileInfo('/substorage/foo.txt');
+        /** @var int $id2 */
+        $id2 = $cachedData['fileid'];
+        $this->assertEquals('/substorage/foo.txt', $rootView->getPath($id2));
+
+        $folderView = new View('/substorage');
+        $this->assertEquals('/foo.txt', $folderView->getPath($id2));
+    }
+
+
+    public function testGetPathNotExisting(): void {
+        $this->expectException(\OCP\Files\NotFoundException::class);
+
+        $storage1 = $this->getTestStorage();
+        Filesystem::mount($storage1, [], '/');
+
+        $rootView = new View('');
+        $cachedData = $rootView->getFileInfo('/foo.txt');
+        /** @var int $id1 */
+        $id1 = $cachedData['fileid'];
+        $folderView = new View('/substorage');
+        $this->assertNull($folderView->getPath($id1));
+    }
+
+    /**
+     * @medium
+     */
+    public function testMountPointOverwrite(): void {
+        $storage1 = $this->getTestStorage(false);
+        $storage2 = $this->getTestStorage();
+        $storage1->mkdir('substorage');
+        Filesystem::mount($storage1, [], '/');
+        Filesystem::mount($storage2, [], '/substorage');
+
+        $rootView = new View('');
+        $folderContent = $rootView->getDirectoryContent('/');
+        $this->assertCount(4, $folderContent);
+    }
+
+    public static function sharingDisabledPermissionProvider(): array {
+        return [
+            ['no', '', true],
+            ['yes', 'group1', false],
+        ];
+    }
+
+    /**
+     * @dataProvider sharingDisabledPermissionProvider
+     */
+    public function testRemoveSharePermissionWhenSharingDisabledForUser($excludeGroups, $excludeGroupsList, $expectedShareable): void {
+        // Reset sharing disabled for users cache
+        self::invokePrivate(\OC::$server->get(ShareDisableChecker::class), 'sharingDisabledForUsersCache', [new CappedMemoryCache()]);
+
+        $config = \OC::$server->getConfig();
+        $oldExcludeGroupsFlag = $config->getAppValue('core', 'shareapi_exclude_groups', 'no');
+        $oldExcludeGroupsList = $config->getAppValue('core', 'shareapi_exclude_groups_list', '');
+        $config->setAppValue('core', 'shareapi_exclude_groups', $excludeGroups);
+        $config->setAppValue('core', 'shareapi_exclude_groups_list', $excludeGroupsList);
+
+        $storage1 = $this->getTestStorage();
+        $storage2 = $this->getTestStorage();
+        Filesystem::mount($storage1, [], '/');
+        Filesystem::mount($storage2, [], '/mount');
+
+        $view = new View('/');
+
+        $folderContent = $view->getDirectoryContent('');
+        $this->assertEquals($expectedShareable, $folderContent[0]->isShareable());
+
+        $folderContent = $view->getDirectoryContent('mount');
+        $this->assertEquals($expectedShareable, $folderContent[0]->isShareable());
+
+        $config->setAppValue('core', 'shareapi_exclude_groups', $oldExcludeGroupsFlag);
+        $config->setAppValue('core', 'shareapi_exclude_groups_list', $oldExcludeGroupsList);
+
+        // Reset sharing disabled for users cache
+        self::invokePrivate(\OC::$server->get(ShareDisableChecker::class), 'sharingDisabledForUsersCache', [new CappedMemoryCache()]);
+    }
+
+    public function testCacheIncompleteFolder(): void {
+        $storage1 = $this->getTestStorage(false);
+        Filesystem::mount($storage1, [], '/incomplete');
+        $rootView = new View('/incomplete');
+
+        $entries = $rootView->getDirectoryContent('/');
+        $this->assertCount(3, $entries);
+
+        // /folder will already be in the cache but not scanned
+        $entries = $rootView->getDirectoryContent('/folder');
+        $this->assertCount(1, $entries);
+    }
+
+    public function testAutoScan(): void {
+        $storage1 = $this->getTestStorage(false);
+        $storage2 = $this->getTestStorage(false);
+        Filesystem::mount($storage1, [], '/');
+        Filesystem::mount($storage2, [], '/substorage');
+        $textSize = strlen("dummy file data\n");
+
+        $rootView = new View('');
+
+        $cachedData = $rootView->getFileInfo('/');
+        $this->assertEquals('httpd/unix-directory', $cachedData['mimetype']);
+        $this->assertEquals(-1, $cachedData['size']);
+
+        $folderData = $rootView->getDirectoryContent('/substorage/folder');
+        $this->assertEquals('text/plain', $folderData[0]['mimetype']);
+        $this->assertEquals($textSize, $folderData[0]['size']);
+    }
+
+    /**
+     * @medium
+     */
+    public function testSearch(): void {
+        $storage1 = $this->getTestStorage();
+        $storage2 = $this->getTestStorage();
+        $storage3 = $this->getTestStorage();
+        Filesystem::mount($storage1, [], '/');
+        Filesystem::mount($storage2, [], '/substorage');
+        Filesystem::mount($storage3, [], '/folder/anotherstorage');
+
+        $rootView = new View('');
+
+        $results = $rootView->search('foo');
+        $this->assertCount(6, $results);
+        $paths = [];
+        foreach ($results as $result) {
+            $this->assertEquals($result['path'], Filesystem::normalizePath($result['path']));
+            $paths[] = $result['path'];
+        }
+        $this->assertContains('/foo.txt', $paths);
+        $this->assertContains('/foo.png', $paths);
+        $this->assertContains('/substorage/foo.txt', $paths);
+        $this->assertContains('/substorage/foo.png', $paths);
+        $this->assertContains('/folder/anotherstorage/foo.txt', $paths);
+        $this->assertContains('/folder/anotherstorage/foo.png', $paths);
+
+        $folderView = new View('/folder');
+        $results = $folderView->search('bar');
+        $this->assertCount(2, $results);
+        $paths = [];
+        foreach ($results as $result) {
+            $paths[] = $result['path'];
+        }
+        $this->assertContains('/anotherstorage/folder/bar.txt', $paths);
+        $this->assertContains('/bar.txt', $paths);
+
+        $results = $folderView->search('foo');
+        $this->assertCount(2, $results);
+        $paths = [];
+        foreach ($results as $result) {
+            $paths[] = $result['path'];
+        }
+        $this->assertContains('/anotherstorage/foo.txt', $paths);
+        $this->assertContains('/anotherstorage/foo.png', $paths);
+
+        $this->assertCount(6, $rootView->searchByMime('text'));
+        $this->assertCount(3, $folderView->searchByMime('text'));
+    }
+
+    /**
+     * @medium
+     */
+    public function testWatcher(): void {
+        $storage1 = $this->getTestStorage();
+        Filesystem::mount($storage1, [], '/');
+        $storage1->getWatcher()->setPolicy(Watcher::CHECK_ALWAYS);
+
+        $rootView = new View('');
+
+        $cachedData = $rootView->getFileInfo('foo.txt');
+        $this->assertEquals(16, $cachedData['size']);
+
+        $rootView->putFileInfo('foo.txt', ['storage_mtime' => 10]);
+        $storage1->file_put_contents('foo.txt', 'foo');
+        clearstatcache();
+
+        $cachedData = $rootView->getFileInfo('foo.txt');
+        $this->assertEquals(3, $cachedData['size']);
+    }
+
+    /**
+     * @medium
+     */
+    public function testCopyBetweenStorageNoCross(): void {
+        $storage1 = $this->getTestStorage(true, TemporaryNoCross::class);
+        $storage2 = $this->getTestStorage(true, TemporaryNoCross::class);
+        $this->copyBetweenStorages($storage1, $storage2);
+    }
+
+    /**
+     * @medium
+     */
+    public function testCopyBetweenStorageCross(): void {
+        $storage1 = $this->getTestStorage();
+        $storage2 = $this->getTestStorage();
+        $this->copyBetweenStorages($storage1, $storage2);
+    }
+
+    /**
+     * @medium
+     */
+    public function testCopyBetweenStorageCrossNonLocal(): void {
+        $storage1 = $this->getTestStorage(true, TemporaryNoLocal::class);
+        $storage2 = $this->getTestStorage(true, TemporaryNoLocal::class);
+        $this->copyBetweenStorages($storage1, $storage2);
+    }
+
+    public function copyBetweenStorages($storage1, $storage2) {
+        Filesystem::mount($storage1, [], '/');
+        Filesystem::mount($storage2, [], '/substorage');
+
+        $rootView = new View('');
+        $rootView->mkdir('substorage/emptyfolder');
+        $rootView->copy('substorage', 'anotherfolder');
+        $this->assertTrue($rootView->is_dir('/anotherfolder'));
+        $this->assertTrue($rootView->is_dir('/substorage'));
+        $this->assertTrue($rootView->is_dir('/anotherfolder/emptyfolder'));
+        $this->assertTrue($rootView->is_dir('/substorage/emptyfolder'));
+        $this->assertTrue($rootView->file_exists('/anotherfolder/foo.txt'));
+        $this->assertTrue($rootView->file_exists('/anotherfolder/foo.png'));
+        $this->assertTrue($rootView->file_exists('/anotherfolder/folder/bar.txt'));
+        $this->assertTrue($rootView->file_exists('/substorage/foo.txt'));
+        $this->assertTrue($rootView->file_exists('/substorage/foo.png'));
+        $this->assertTrue($rootView->file_exists('/substorage/folder/bar.txt'));
+    }
+
+    /**
+     * @medium
+     */
+    public function testMoveBetweenStorageNoCross(): void {
+        $storage1 = $this->getTestStorage(true, TemporaryNoCross::class);
+        $storage2 = $this->getTestStorage(true, TemporaryNoCross::class);
+        $this->moveBetweenStorages($storage1, $storage2);
+    }
+
+    /**
+     * @medium
+     */
+    public function testMoveBetweenStorageCross(): void {
+        $storage1 = $this->getTestStorage();
+        $storage2 = $this->getTestStorage();
+        $this->moveBetweenStorages($storage1, $storage2);
+    }
+
+    /**
+     * @medium
+     */
+    public function testMoveBetweenStorageCrossNonLocal(): void {
+        $storage1 = $this->getTestStorage(true, TemporaryNoLocal::class);
+        $storage2 = $this->getTestStorage(true, TemporaryNoLocal::class);
+        $this->moveBetweenStorages($storage1, $storage2);
+    }
+
+    public function moveBetweenStorages($storage1, $storage2) {
+        Filesystem::mount($storage1, [], '/' . $this->user . '/');
+        Filesystem::mount($storage2, [], '/' . $this->user . '/substorage');
+
+        $rootView = new View('/' . $this->user);
+        $rootView->rename('foo.txt', 'substorage/folder/foo.txt');
+        $this->assertFalse($rootView->file_exists('foo.txt'));
+        $this->assertTrue($rootView->file_exists('substorage/folder/foo.txt'));
+        $rootView->rename('substorage/folder', 'anotherfolder');
+        $this->assertFalse($rootView->is_dir('substorage/folder'));
+        $this->assertTrue($rootView->file_exists('anotherfolder/foo.txt'));
+        $this->assertTrue($rootView->file_exists('anotherfolder/bar.txt'));
+    }
+
+    /**
+     * @medium
+     */
+    public function testUnlink(): void {
+        $storage1 = $this->getTestStorage();
+        $storage2 = $this->getTestStorage();
+        Filesystem::mount($storage1, [], '/');
+        Filesystem::mount($storage2, [], '/substorage');
+
+        $rootView = new View('');
+        $rootView->file_put_contents('/foo.txt', 'asd');
+        $rootView->file_put_contents('/substorage/bar.txt', 'asd');
+
+        $this->assertTrue($rootView->file_exists('foo.txt'));
+        $this->assertTrue($rootView->file_exists('substorage/bar.txt'));
+
+        $this->assertTrue($rootView->unlink('foo.txt'));
+        $this->assertTrue($rootView->unlink('substorage/bar.txt'));
+
+        $this->assertFalse($rootView->file_exists('foo.txt'));
+        $this->assertFalse($rootView->file_exists('substorage/bar.txt'));
+    }
+
+    public static function rmdirOrUnlinkDataProvider(): array {
+        return [['rmdir'], ['unlink']];
+    }
+
+    /**
+     * @dataProvider rmdirOrUnlinkDataProvider
+     */
+    public function testRmdir($method): void {
+        $storage1 = $this->getTestStorage();
+        Filesystem::mount($storage1, [], '/');
+
+        $rootView = new View('');
+        $rootView->mkdir('sub');
+        $rootView->mkdir('sub/deep');
+        $rootView->file_put_contents('/sub/deep/foo.txt', 'asd');
+
+        $this->assertTrue($rootView->file_exists('sub/deep/foo.txt'));
+
+        $this->assertTrue($rootView->$method('sub'));
+
+        $this->assertFalse($rootView->file_exists('sub'));
+    }
+
+    /**
+     * @medium
+     */
+    public function testUnlinkRootMustFail(): void {
+        $storage1 = $this->getTestStorage();
+        $storage2 = $this->getTestStorage();
+        Filesystem::mount($storage1, [], '/');
+        Filesystem::mount($storage2, [], '/substorage');
+
+        $rootView = new View('');
+        $rootView->file_put_contents('/foo.txt', 'asd');
+        $rootView->file_put_contents('/substorage/bar.txt', 'asd');
+
+        $this->assertFalse($rootView->unlink(''));
+        $this->assertFalse($rootView->unlink('/'));
+        $this->assertFalse($rootView->unlink('substorage'));
+        $this->assertFalse($rootView->unlink('/substorage'));
+    }
+
+    /**
+     * @medium
+     */
+    public function testTouch(): void {
+        $storage = $this->getTestStorage(true, TemporaryNoTouch::class);
+
+        Filesystem::mount($storage, [], '/');
+
+        $rootView = new View('');
+        $oldCachedData = $rootView->getFileInfo('foo.txt');
+
+        $rootView->touch('foo.txt', 500);
+
+        $cachedData = $rootView->getFileInfo('foo.txt');
+        $this->assertEquals(500, $cachedData['mtime']);
+        $this->assertEquals($oldCachedData['storage_mtime'], $cachedData['storage_mtime']);
+
+        $rootView->putFileInfo('foo.txt', ['storage_mtime' => 1000]); //make sure the watcher detects the change
+        $rootView->file_put_contents('foo.txt', 'asd');
+        $cachedData = $rootView->getFileInfo('foo.txt');
+        $this->assertGreaterThanOrEqual($oldCachedData['mtime'], $cachedData['mtime']);
+        $this->assertEquals($cachedData['storage_mtime'], $cachedData['mtime']);
+    }
+
+    /**
+     * @medium
+     */
+    public function testTouchFloat(): void {
+        $storage = $this->getTestStorage(true, TemporaryNoTouch::class);
+
+        Filesystem::mount($storage, [], '/');
+
+        $rootView = new View('');
+        $oldCachedData = $rootView->getFileInfo('foo.txt');
+
+        $rootView->touch('foo.txt', 500.5);
+
+        $cachedData = $rootView->getFileInfo('foo.txt');
+        $this->assertEquals(500, $cachedData['mtime']);
+    }
+
+    /**
+     * @medium
+     */
+    public function testViewHooks(): void {
+        $storage1 = $this->getTestStorage();
+        $storage2 = $this->getTestStorage();
+        $defaultRoot = Filesystem::getRoot();
+        Filesystem::mount($storage1, [], '/');
+        Filesystem::mount($storage2, [], $defaultRoot . '/substorage');
+        \OC_Hook::connect('OC_Filesystem', 'post_write', $this, 'dummyHook');
+
+        $rootView = new View('');
+        $subView = new View($defaultRoot . '/substorage');
+        $this->hookPath = null;
+
+        $rootView->file_put_contents('/foo.txt', 'asd');
+        $this->assertNull($this->hookPath);
+
+        $subView->file_put_contents('/foo.txt', 'asd');
+        $this->assertEquals('/substorage/foo.txt', $this->hookPath);
+    }
+
+    private $hookPath;
+
+    public function dummyHook($params) {
+        $this->hookPath = $params['path'];
+    }
+
+    public function testSearchNotOutsideView(): void {
+        $storage1 = $this->getTestStorage();
+        Filesystem::mount($storage1, [], '/');
+        $storage1->rename('folder', 'foo');
+        $scanner = $storage1->getScanner();
+        $scanner->scan('');
+
+        $view = new View('/foo');
+
+        $result = $view->search('.txt');
+        $this->assertCount(1, $result);
+    }
+
+    /**
+     * @param bool $scan
+     * @param string $class
+     * @return \OC\Files\Storage\Storage
+     */
+    private function getTestStorage($scan = true, $class = Temporary::class) {
+        /**
+         * @var \OC\Files\Storage\Storage $storage
+         */
+        $storage = new $class([]);
+        $textData = "dummy file data\n";
+        $imgData = file_get_contents(\OC::$SERVERROOT . '/core/img/logo/logo.png');
+        $storage->mkdir('folder');
+        $storage->file_put_contents('foo.txt', $textData);
+        $storage->file_put_contents('foo.png', $imgData);
+        $storage->file_put_contents('folder/bar.txt', $textData);
+
+        if ($scan) {
+            $scanner = $storage->getScanner();
+            $scanner->scan('');
+        }
+        $this->storages[] = $storage;
+        return $storage;
+    }
+
+    /**
+     * @medium
+     */
+    public function testViewHooksIfRootStartsTheSame(): void {
+        $storage1 = $this->getTestStorage();
+        $storage2 = $this->getTestStorage();
+        $defaultRoot = Filesystem::getRoot();
+        Filesystem::mount($storage1, [], '/');
+        Filesystem::mount($storage2, [], $defaultRoot . '_substorage');
+        \OC_Hook::connect('OC_Filesystem', 'post_write', $this, 'dummyHook');
+
+        $subView = new View($defaultRoot . '_substorage');
+        $this->hookPath = null;
+
+        $subView->file_put_contents('/foo.txt', 'asd');
+        $this->assertNull($this->hookPath);
+    }
+
+    private $hookWritePath;
+    private $hookCreatePath;
+    private $hookUpdatePath;
+
+    public function dummyHookWrite($params) {
+        $this->hookWritePath = $params['path'];
+    }
+
+    public function dummyHookUpdate($params) {
+        $this->hookUpdatePath = $params['path'];
+    }
+
+    public function dummyHookCreate($params) {
+        $this->hookCreatePath = $params['path'];
+    }
+
+    public function testEditNoCreateHook(): void {
+        $storage1 = $this->getTestStorage();
+        $storage2 = $this->getTestStorage();
+        $defaultRoot = Filesystem::getRoot();
+        Filesystem::mount($storage1, [], '/');
+        Filesystem::mount($storage2, [], $defaultRoot);
+        \OC_Hook::connect('OC_Filesystem', 'post_create', $this, 'dummyHookCreate');
+        \OC_Hook::connect('OC_Filesystem', 'post_update', $this, 'dummyHookUpdate');
+        \OC_Hook::connect('OC_Filesystem', 'post_write', $this, 'dummyHookWrite');
+
+        $view = new View($defaultRoot);
+        $this->hookWritePath = $this->hookUpdatePath = $this->hookCreatePath = null;
+
+        $view->file_put_contents('/asd.txt', 'foo');
+        $this->assertEquals('/asd.txt', $this->hookCreatePath);
+        $this->assertNull($this->hookUpdatePath);
+        $this->assertEquals('/asd.txt', $this->hookWritePath);
+
+        $this->hookWritePath = $this->hookUpdatePath = $this->hookCreatePath = null;
+
+        $view->file_put_contents('/asd.txt', 'foo');
+        $this->assertNull($this->hookCreatePath);
+        $this->assertEquals('/asd.txt', $this->hookUpdatePath);
+        $this->assertEquals('/asd.txt', $this->hookWritePath);
+
+        \OC_Hook::clear('OC_Filesystem', 'post_create');
+        \OC_Hook::clear('OC_Filesystem', 'post_update');
+        \OC_Hook::clear('OC_Filesystem', 'post_write');
+    }
+
+    /**
+     * @dataProvider resolvePathTestProvider
+     */
+    public function testResolvePath($expected, $pathToTest): void {
+        $storage1 = $this->getTestStorage();
+        Filesystem::mount($storage1, [], '/');
+
+        $view = new View('');
+
+        $result = $view->resolvePath($pathToTest);
+        $this->assertEquals($expected, $result[1]);
+
+        $exists = $view->file_exists($pathToTest);
+        $this->assertTrue($exists);
+
+        $exists = $view->file_exists($result[1]);
+        $this->assertTrue($exists);
+    }
+
+    public static function resolvePathTestProvider(): array {
+        return [
+            ['foo.txt', 'foo.txt'],
+            ['foo.txt', '/foo.txt'],
+            ['folder', 'folder'],
+            ['folder', '/folder'],
+            ['folder', 'folder/'],
+            ['folder', '/folder/'],
+            ['folder/bar.txt', 'folder/bar.txt'],
+            ['folder/bar.txt', '/folder/bar.txt'],
+            ['', ''],
+            ['', '/'],
+        ];
+    }
+
+    public function testUTF8Names(): void {
+        $names = ['虚', '和知しゃ和で', 'regular ascii', 'sɨˈrɪlɪk', 'ѨѬ', 'أنا أحب القراءة كثيرا'];
+
+        $storage = new Temporary([]);
+        Filesystem::mount($storage, [], '/');
+
+        $rootView = new View('');
+        foreach ($names as $name) {
+            $rootView->file_put_contents('/' . $name, 'dummy content');
+        }
+
+        $list = $rootView->getDirectoryContent('/');
+
+        $this->assertCount(count($names), $list);
+        foreach ($list as $item) {
+            $this->assertContains($item['name'], $names);
+        }
+
+        $cache = $storage->getCache();
+        $scanner = $storage->getScanner();
+        $scanner->scan('');
+
+        $list = $cache->getFolderContents('');
+
+        $this->assertCount(count($names), $list);
+        foreach ($list as $item) {
+            $this->assertContains($item['name'], $names);
+        }
+    }
+
+    public function xtestLongPath() {
+        $storage = new Temporary([]);
+        Filesystem::mount($storage, [], '/');
+
+        $rootView = new View('');
+
+        $longPath = '';
+        $ds = DIRECTORY_SEPARATOR;
+        /*
 		 * 4096 is the maximum path length in file_cache.path in *nix
 		 * 1024 is the max path length in mac
 		 */
-		$folderName = 'abcdefghijklmnopqrstuvwxyz012345678901234567890123456789';
-		$tmpdirLength = strlen(\OC::$server->getTempManager()->getTemporaryFolder());
-		if (\OC_Util::runningOnMac()) {
-			$depth = ((1024 - $tmpdirLength) / 57);
-		} else {
-			$depth = ((4000 - $tmpdirLength) / 57);
-		}
-		foreach (range(0, $depth - 1) as $i) {
-			$longPath .= $ds . $folderName;
-			$result = $rootView->mkdir($longPath);
-			$this->assertTrue($result, "mkdir failed on $i - path length: " . strlen($longPath));
-
-			$result = $rootView->file_put_contents($longPath . "{$ds}test.txt", 'lorem');
-			$this->assertEquals(5, $result, "file_put_contents failed on $i");
-
-			$this->assertTrue($rootView->file_exists($longPath));
-			$this->assertTrue($rootView->file_exists($longPath . "{$ds}test.txt"));
-		}
-
-		$cache = $storage->getCache();
-		$scanner = $storage->getScanner();
-		$scanner->scan('');
-
-		$longPath = $folderName;
-		foreach (range(0, $depth - 1) as $i) {
-			$cachedFolder = $cache->get($longPath);
-			$this->assertTrue(is_array($cachedFolder), "No cache entry for folder at $i");
-			$this->assertEquals($folderName, $cachedFolder['name'], "Wrong cache entry for folder at $i");
-
-			$cachedFile = $cache->get($longPath . '/test.txt');
-			$this->assertTrue(is_array($cachedFile), "No cache entry for file at $i");
-			$this->assertEquals('test.txt', $cachedFile['name'], "Wrong cache entry for file at $i");
-
-			$longPath .= $ds . $folderName;
-		}
-	}
-
-	public function testTouchNotSupported(): void {
-		$storage = new TemporaryNoTouch([]);
-		$scanner = $storage->getScanner();
-		Filesystem::mount($storage, [], '/test/');
-		$past = time() - 100;
-		$storage->file_put_contents('test', 'foobar');
-		$scanner->scan('');
-		$view = new View('');
-		$info = $view->getFileInfo('/test/test');
-
-		$view->touch('/test/test', $past);
-		$scanner->scanFile('test', \OC\Files\Cache\Scanner::REUSE_ETAG);
-
-		$info2 = $view->getFileInfo('/test/test');
-		$this->assertSame($info['etag'], $info2['etag']);
-	}
-
-	public function testWatcherEtagCrossStorage(): void {
-		$storage1 = new Temporary([]);
-		$storage2 = new Temporary([]);
-		$scanner1 = $storage1->getScanner();
-		$scanner2 = $storage2->getScanner();
-		$storage1->mkdir('sub');
-		Filesystem::mount($storage1, [], '/test/');
-		Filesystem::mount($storage2, [], '/test/sub/storage');
-
-		$past = time() - 100;
-		$storage2->file_put_contents('test.txt', 'foobar');
-		$scanner1->scan('');
-		$scanner2->scan('');
-		$view = new View('');
-
-		$storage2->getWatcher('')->setPolicy(Watcher::CHECK_ALWAYS);
-
-		$oldFileInfo = $view->getFileInfo('/test/sub/storage/test.txt');
-		$oldFolderInfo = $view->getFileInfo('/test');
-
-		$storage2->getCache()->update($oldFileInfo->getId(), [
-			'storage_mtime' => $past,
-		]);
-
-		$oldEtag = $oldFolderInfo->getEtag();
-
-		$view->getFileInfo('/test/sub/storage/test.txt');
-		$newFolderInfo = $view->getFileInfo('/test');
-
-		$this->assertNotEquals($newFolderInfo->getEtag(), $oldEtag);
-	}
-
-	/**
-	 * @dataProvider absolutePathProvider
-	 */
-	public function testGetAbsolutePath($expectedPath, $relativePath): void {
-		$view = new View('/files');
-		$this->assertEquals($expectedPath, $view->getAbsolutePath($relativePath));
-	}
-
-	public function testPartFileInfo(): void {
-		$storage = new Temporary([]);
-		$scanner = $storage->getScanner();
-		Filesystem::mount($storage, [], '/test/');
-		$sizeWritten = $storage->file_put_contents('test.part', 'foobar');
-		$scanner->scan('');
-		$view = new View('/test');
-		$info = $view->getFileInfo('test.part');
-
-		$this->assertInstanceOf('\OCP\Files\FileInfo', $info);
-		$this->assertNull($info->getId());
-		$this->assertEquals(6, $sizeWritten);
-		$this->assertEquals(6, $info->getSize());
-		$this->assertEquals('foobar', $view->file_get_contents('test.part'));
-	}
-
-	public static function absolutePathProvider(): array {
-		return [
-			['/files/', ''],
-			['/files/0', '0'],
-			['/files/false', 'false'],
-			['/files/true', 'true'],
-			['/files/', '/'],
-			['/files/test', 'test'],
-			['/files/test', '/test'],
-		];
-	}
-
-	/**
-	 * @dataProvider chrootRelativePathProvider
-	 */
-	public function testChrootGetRelativePath($root, $absolutePath, $expectedPath): void {
-		$view = new View('/files');
-		$view->chroot($root);
-		$this->assertEquals($expectedPath, $view->getRelativePath($absolutePath));
-	}
-
-	public static function chrootRelativePathProvider(): array {
-		return self::relativePathProvider('/');
-	}
-
-	/**
-	 * @dataProvider initRelativePathProvider
-	 */
-	public function testInitGetRelativePath($root, $absolutePath, $expectedPath): void {
-		$view = new View($root);
-		$this->assertEquals($expectedPath, $view->getRelativePath($absolutePath));
-	}
-
-	public static function initRelativePathProvider(): array {
-		return self::relativePathProvider(null);
-	}
-
-	public static function relativePathProvider($missingRootExpectedPath): array {
-		return [
-			// No root - returns the path
-			['', '/files', '/files'],
-			['', '/files/', '/files/'],
-
-			// Root equals path - /
-			['/files/', '/files/', '/'],
-			['/files/', '/files', '/'],
-			['/files', '/files/', '/'],
-			['/files', '/files', '/'],
-
-			// False negatives: chroot fixes those by adding the leading slash.
-			// But setting them up with this root (instead of chroot($root))
-			// will fail them, although they should be the same.
-			// TODO init should be fixed, so it also adds the leading slash
-			['files/', '/files/', $missingRootExpectedPath],
-			['files', '/files/', $missingRootExpectedPath],
-			['files/', '/files', $missingRootExpectedPath],
-			['files', '/files', $missingRootExpectedPath],
-
-			// False negatives: Paths provided to the method should have a leading slash
-			// TODO input should be checked to have a leading slash
-			['/files/', 'files/', null],
-			['/files', 'files/', null],
-			['/files/', 'files', null],
-			['/files', 'files', null],
-
-			// with trailing slashes
-			['/files/', '/files/0', '0'],
-			['/files/', '/files/false', 'false'],
-			['/files/', '/files/true', 'true'],
-			['/files/', '/files/test', 'test'],
-			['/files/', '/files/test/foo', 'test/foo'],
-
-			// without trailing slashes
-			// TODO false expectation: Should match "with trailing slashes"
-			['/files', '/files/0', '/0'],
-			['/files', '/files/false', '/false'],
-			['/files', '/files/true', '/true'],
-			['/files', '/files/test', '/test'],
-			['/files', '/files/test/foo', '/test/foo'],
-
-			// leading slashes
-			['/files/', '/files_trashbin/', null],
-			['/files', '/files_trashbin/', null],
-			['/files/', '/files_trashbin', null],
-			['/files', '/files_trashbin', null],
-
-			// no leading slashes
-			['files/', 'files_trashbin/', null],
-			['files', 'files_trashbin/', null],
-			['files/', 'files_trashbin', null],
-			['files', 'files_trashbin', null],
-
-			// mixed leading slashes
-			['files/', '/files_trashbin/', null],
-			['/files/', 'files_trashbin/', null],
-			['files', '/files_trashbin/', null],
-			['/files', 'files_trashbin/', null],
-			['files/', '/files_trashbin', null],
-			['/files/', 'files_trashbin', null],
-			['files', '/files_trashbin', null],
-			['/files', 'files_trashbin', null],
-
-			['files', 'files_trashbin/test', null],
-			['/files', '/files_trashbin/test', null],
-			['/files', 'files_trashbin/test', null],
-		];
-	}
-
-	public function testFileView(): void {
-		$storage = new Temporary([]);
-		$scanner = $storage->getScanner();
-		$storage->file_put_contents('foo.txt', 'bar');
-		Filesystem::mount($storage, [], '/test/');
-		$scanner->scan('');
-		$view = new View('/test/foo.txt');
-
-		$this->assertEquals('bar', $view->file_get_contents(''));
-		$fh = tmpfile();
-		fwrite($fh, 'foo');
-		rewind($fh);
-		$view->file_put_contents('', $fh);
-		$this->assertEquals('foo', $view->file_get_contents(''));
-	}
-
-	/**
-	 * @dataProvider tooLongPathDataProvider
-	 */
-	public function testTooLongPath($operation, $param0 = null): void {
-		$this->expectException(\OCP\Files\InvalidPathException::class);
-
-
-		$longPath = '';
-		// 4000 is the maximum path length in file_cache.path
-		$folderName = 'abcdefghijklmnopqrstuvwxyz012345678901234567890123456789';
-		$depth = (4000 / 57);
-		foreach (range(0, $depth + 1) as $i) {
-			$longPath .= '/' . $folderName;
-		}
-
-		$storage = new Temporary([]);
-		$this->tempStorage = $storage; // for later hard cleanup
-		Filesystem::mount($storage, [], '/');
-
-		$rootView = new View('');
-
-		if ($param0 === '@0') {
-			$param0 = $longPath;
-		}
-
-		if ($operation === 'hash') {
-			$param0 = $longPath;
-			$longPath = 'md5';
-		}
-
-		call_user_func([$rootView, $operation], $longPath, $param0);
-	}
-
-	public static function tooLongPathDataProvider(): array {
-		return [
-			['getAbsolutePath'],
-			['getRelativePath'],
-			['getMountPoint'],
-			['resolvePath'],
-			['getLocalFile'],
-			['mkdir'],
-			['rmdir'],
-			['opendir'],
-			['is_dir'],
-			['is_file'],
-			['stat'],
-			['filetype'],
-			['filesize'],
-			['readfile'],
-			['isCreatable'],
-			['isReadable'],
-			['isUpdatable'],
-			['isDeletable'],
-			['isSharable'],
-			['file_exists'],
-			['filemtime'],
-			['touch'],
-			['file_get_contents'],
-			['unlink'],
-			['deleteAll'],
-			['toTmpFile'],
-			['getMimeType'],
-			['free_space'],
-			['getFileInfo'],
-			['getDirectoryContent'],
-			['getOwner'],
-			['getETag'],
-			['file_put_contents', 'ipsum'],
-			['rename', '@0'],
-			['copy', '@0'],
-			['fopen', 'r'],
-			['fromTmpFile', '@0'],
-			['hash'],
-			['hasUpdated', 0],
-			['putFileInfo', []],
-		];
-	}
-
-	public function testRenameCrossStoragePreserveMtime(): void {
-		$storage1 = new Temporary([]);
-		$storage2 = new Temporary([]);
-		$storage1->mkdir('sub');
-		$storage1->mkdir('foo');
-		$storage1->file_put_contents('foo.txt', 'asd');
-		$storage1->file_put_contents('foo/bar.txt', 'asd');
-		Filesystem::mount($storage1, [], '/test/');
-		Filesystem::mount($storage2, [], '/test/sub/storage');
-
-		$view = new View('');
-		$time = time() - 200;
-		$view->touch('/test/foo.txt', $time);
-		$view->touch('/test/foo', $time);
-		$view->touch('/test/foo/bar.txt', $time);
-
-		$view->rename('/test/foo.txt', '/test/sub/storage/foo.txt');
-
-		$this->assertEquals($time, $view->filemtime('/test/sub/storage/foo.txt'));
-
-		$view->rename('/test/foo', '/test/sub/storage/foo');
-
-		$this->assertEquals($time, $view->filemtime('/test/sub/storage/foo/bar.txt'));
-	}
-
-	public function testRenameFailDeleteTargetKeepSource(): void {
-		$this->doTestCopyRenameFail('rename');
-	}
-
-	public function testCopyFailDeleteTargetKeepSource(): void {
-		$this->doTestCopyRenameFail('copy');
-	}
-
-	private function doTestCopyRenameFail($operation) {
-		$storage1 = new Temporary([]);
-		/** @var \PHPUnit\Framework\MockObject\MockObject|Temporary $storage2 */
-		$storage2 = $this->getMockBuilder(TemporaryNoCross::class)
-			->setConstructorArgs([[]])
-			->onlyMethods(['fopen', 'writeStream'])
-			->getMock();
-
-		$storage2->method('writeStream')
-			->willThrowException(new GenericFileException('Failed to copy stream'));
-
-		$storage1->mkdir('sub');
-		$storage1->file_put_contents('foo.txt', '0123456789ABCDEFGH');
-		$storage1->mkdir('dirtomove');
-		$storage1->file_put_contents('dirtomove/indir1.txt', '0123456'); // fits
-		$storage1->file_put_contents('dirtomove/indir2.txt', '0123456789ABCDEFGH'); // doesn't fit
-		$storage2->file_put_contents('existing.txt', '0123');
-		$storage1->getScanner()->scan('');
-		$storage2->getScanner()->scan('');
-		Filesystem::mount($storage1, [], '/test/');
-		Filesystem::mount($storage2, [], '/test/sub/storage');
-
-		// move file
-		$view = new View('');
-		$this->assertTrue($storage1->file_exists('foo.txt'));
-		$this->assertFalse($storage2->file_exists('foo.txt'));
-		$this->assertFalse($view->$operation('/test/foo.txt', '/test/sub/storage/foo.txt'));
-		$this->assertFalse($storage2->file_exists('foo.txt'));
-		$this->assertFalse($storage2->getCache()->get('foo.txt'));
-		$this->assertTrue($storage1->file_exists('foo.txt'));
-
-		// if target exists, it will be deleted too
-		$this->assertFalse($view->$operation('/test/foo.txt', '/test/sub/storage/existing.txt'));
-		$this->assertFalse($storage2->file_exists('existing.txt'));
-		$this->assertFalse($storage2->getCache()->get('existing.txt'));
-		$this->assertTrue($storage1->file_exists('foo.txt'));
-
-		// move folder
-		$this->assertFalse($view->$operation('/test/dirtomove/', '/test/sub/storage/dirtomove/'));
-		// since the move failed, the full source tree is kept
-		$this->assertTrue($storage1->file_exists('dirtomove/indir1.txt'));
-		$this->assertTrue($storage1->file_exists('dirtomove/indir2.txt'));
-		// second file not moved/copied
-		$this->assertFalse($storage2->file_exists('dirtomove/indir2.txt'));
-		$this->assertFalse($storage2->getCache()->get('dirtomove/indir2.txt'));
-	}
-
-	public function testDeleteFailKeepCache(): void {
-		/** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
-		$storage = $this->getMockBuilder(Temporary::class)
-			->setConstructorArgs([[]])
-			->onlyMethods(['unlink'])
-			->getMock();
-		$storage->expects($this->once())
-			->method('unlink')
-			->willReturn(false);
-		$scanner = $storage->getScanner();
-		$cache = $storage->getCache();
-		$storage->file_put_contents('foo.txt', 'asd');
-		$scanner->scan('');
-		Filesystem::mount($storage, [], '/test/');
-
-		$view = new View('/test');
-
-		$this->assertFalse($view->unlink('foo.txt'));
-		$this->assertTrue($cache->inCache('foo.txt'));
-	}
-
-	public static function directoryTraversalProvider(): array {
-		return [
-			['../test/'],
-			['..\\test\\my/../folder'],
-			['/test/my/../foo\\'],
-		];
-	}
-
-	/**
-	 * @dataProvider directoryTraversalProvider
-	 * @param string $root
-	 */
-	public function testConstructDirectoryTraversalException($root): void {
-		$this->expectException(\Exception::class);
-
-		new View($root);
-	}
-
-	public function testRenameOverWrite(): void {
-		$storage = new Temporary([]);
-		$scanner = $storage->getScanner();
-		$storage->mkdir('sub');
-		$storage->mkdir('foo');
-		$storage->file_put_contents('foo.txt', 'asd');
-		$storage->file_put_contents('foo/bar.txt', 'asd');
-		$scanner->scan('');
-		Filesystem::mount($storage, [], '/test/');
-		$view = new View('');
-		$this->assertTrue($view->rename('/test/foo.txt', '/test/foo/bar.txt'));
-	}
-
-	public function testSetMountOptionsInStorage(): void {
-		$mount = new MountPoint(Temporary::class, '/asd/', [[]], Filesystem::getLoader(), ['foo' => 'bar']);
-		Filesystem::getMountManager()->addMount($mount);
-		/** @var \OC\Files\Storage\Common $storage */
-		$storage = $mount->getStorage();
-		$this->assertEquals($storage->getMountOption('foo'), 'bar');
-	}
-
-	public function testSetMountOptionsWatcherPolicy(): void {
-		$mount = new MountPoint(Temporary::class, '/asd/', [[]], Filesystem::getLoader(), ['filesystem_check_changes' => Watcher::CHECK_NEVER]);
-		Filesystem::getMountManager()->addMount($mount);
-		/** @var \OC\Files\Storage\Common $storage */
-		$storage = $mount->getStorage();
-		$watcher = $storage->getWatcher();
-		$this->assertEquals(Watcher::CHECK_NEVER, $watcher->getPolicy());
-	}
-
-	public function testGetAbsolutePathOnNull(): void {
-		$view = new View();
-		$this->assertNull($view->getAbsolutePath(null));
-	}
-
-	public function testGetRelativePathOnNull(): void {
-		$view = new View();
-		$this->assertNull($view->getRelativePath(null));
-	}
-
-
-	public function testNullAsRoot(): void {
-		$this->expectException(\TypeError::class);
-
-		new View(null);
-	}
-
-	/**
-	 * e.g. reading from a folder that's being renamed
-	 *
-	 *
-	 * @dataProvider dataLockPaths
-	 *
-	 * @param string $rootPath
-	 * @param string $pathPrefix
-	 */
-	public function testReadFromWriteLockedPath($rootPath, $pathPrefix): void {
-		$this->expectException(\OCP\Lock\LockedException::class);
-
-		$rootPath = str_replace('{folder}', 'files', $rootPath);
-		$pathPrefix = str_replace('{folder}', 'files', $pathPrefix);
-
-		$view = new View($rootPath);
-		$storage = new Temporary([]);
-		Filesystem::mount($storage, [], '/');
-		$this->assertTrue($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_EXCLUSIVE));
-		$view->lockFile($pathPrefix . '/foo/bar/asd', ILockingProvider::LOCK_SHARED);
-	}
-
-	/**
-	 * Reading from a files_encryption folder that's being renamed
-	 *
-	 * @dataProvider dataLockPaths
-	 *
-	 * @param string $rootPath
-	 * @param string $pathPrefix
-	 */
-	public function testReadFromWriteUnlockablePath($rootPath, $pathPrefix): void {
-		$rootPath = str_replace('{folder}', 'files_encryption', $rootPath);
-		$pathPrefix = str_replace('{folder}', 'files_encryption', $pathPrefix);
-
-		$view = new View($rootPath);
-		$storage = new Temporary([]);
-		Filesystem::mount($storage, [], '/');
-		$this->assertFalse($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_EXCLUSIVE));
-		$this->assertFalse($view->lockFile($pathPrefix . '/foo/bar/asd', ILockingProvider::LOCK_SHARED));
-	}
-
-	/**
-	 * e.g. writing a file that's being downloaded
-	 *
-	 *
-	 * @dataProvider dataLockPaths
-	 *
-	 * @param string $rootPath
-	 * @param string $pathPrefix
-	 */
-	public function testWriteToReadLockedFile($rootPath, $pathPrefix): void {
-		$this->expectException(\OCP\Lock\LockedException::class);
-
-		$rootPath = str_replace('{folder}', 'files', $rootPath);
-		$pathPrefix = str_replace('{folder}', 'files', $pathPrefix);
-
-		$view = new View($rootPath);
-		$storage = new Temporary([]);
-		Filesystem::mount($storage, [], '/');
-		$this->assertTrue($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_SHARED));
-		$view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_EXCLUSIVE);
-	}
-
-	/**
-	 * Writing a file that's being downloaded
-	 *
-	 * @dataProvider dataLockPaths
-	 *
-	 * @param string $rootPath
-	 * @param string $pathPrefix
-	 */
-	public function testWriteToReadUnlockableFile($rootPath, $pathPrefix): void {
-		$rootPath = str_replace('{folder}', 'files_encryption', $rootPath);
-		$pathPrefix = str_replace('{folder}', 'files_encryption', $pathPrefix);
-
-		$view = new View($rootPath);
-		$storage = new Temporary([]);
-		Filesystem::mount($storage, [], '/');
-		$this->assertFalse($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_SHARED));
-		$this->assertFalse($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_EXCLUSIVE));
-	}
-
-	/**
-	 * Test that locks are on mount point paths instead of mount root
-	 */
-	public function testLockLocalMountPointPathInsteadOfStorageRoot(): void {
-		$lockingProvider = \OC::$server->get(ILockingProvider::class);
-		$view = new View('/testuser/files/');
-		$storage = new Temporary([]);
-		Filesystem::mount($storage, [], '/');
-		$mountedStorage = new Temporary([]);
-		Filesystem::mount($mountedStorage, [], '/testuser/files/mountpoint');
-
-		$this->assertTrue(
-			$view->lockFile('/mountpoint', ILockingProvider::LOCK_EXCLUSIVE, true),
-			'Can lock mount point'
-		);
-
-		// no exception here because storage root was not locked
-		$mountedStorage->acquireLock('', ILockingProvider::LOCK_EXCLUSIVE, $lockingProvider);
-
-		$thrown = false;
-		try {
-			$storage->acquireLock('/testuser/files/mountpoint', ILockingProvider::LOCK_EXCLUSIVE, $lockingProvider);
-		} catch (LockedException $e) {
-			$thrown = true;
-		}
-		$this->assertTrue($thrown, 'Mount point path was locked on root storage');
-
-		$lockingProvider->releaseAll();
-	}
-
-	/**
-	 * Test that locks are on mount point paths and also mount root when requested
-	 */
-	public function testLockStorageRootButNotLocalMountPoint(): void {
-		$lockingProvider = \OC::$server->get(ILockingProvider::class);
-		$view = new View('/testuser/files/');
-		$storage = new Temporary([]);
-		Filesystem::mount($storage, [], '/');
-		$mountedStorage = new Temporary([]);
-		Filesystem::mount($mountedStorage, [], '/testuser/files/mountpoint');
-
-		$this->assertTrue(
-			$view->lockFile('/mountpoint', ILockingProvider::LOCK_EXCLUSIVE, false),
-			'Can lock mount point'
-		);
-
-		$thrown = false;
-		try {
-			$mountedStorage->acquireLock('', ILockingProvider::LOCK_EXCLUSIVE, $lockingProvider);
-		} catch (LockedException $e) {
-			$thrown = true;
-		}
-		$this->assertTrue($thrown, 'Mount point storage root was locked on original storage');
-
-		// local mount point was not locked
-		$storage->acquireLock('/testuser/files/mountpoint', ILockingProvider::LOCK_EXCLUSIVE, $lockingProvider);
-
-		$lockingProvider->releaseAll();
-	}
-
-	/**
-	 * Test that locks are on mount point paths and also mount root when requested
-	 */
-	public function testLockMountPointPathFailReleasesBoth(): void {
-		$lockingProvider = \OC::$server->get(ILockingProvider::class);
-		$view = new View('/testuser/files/');
-		$storage = new Temporary([]);
-		Filesystem::mount($storage, [], '/');
-		$mountedStorage = new Temporary([]);
-		Filesystem::mount($mountedStorage, [], '/testuser/files/mountpoint.txt');
-
-		// this would happen if someone is writing on the mount point
-		$mountedStorage->acquireLock('', ILockingProvider::LOCK_EXCLUSIVE, $lockingProvider);
-
-		$thrown = false;
-		try {
-			// this actually acquires two locks, one on the mount point and one on the storage root,
-			// but the one on the storage root will fail
-			$view->lockFile('/mountpoint.txt', ILockingProvider::LOCK_SHARED);
-		} catch (LockedException $e) {
-			$thrown = true;
-		}
-		$this->assertTrue($thrown, 'Cannot acquire shared lock because storage root is already locked');
-
-		// from here we expect that the lock on the local mount point was released properly
-		// so acquiring an exclusive lock will succeed
-		$storage->acquireLock('/testuser/files/mountpoint.txt', ILockingProvider::LOCK_EXCLUSIVE, $lockingProvider);
-
-		$lockingProvider->releaseAll();
-	}
-
-	public static function dataLockPaths(): array {
-		return [
-			['/testuser/{folder}', ''],
-			['/testuser', '/{folder}'],
-			['', '/testuser/{folder}'],
-		];
-	}
-
-	public static function pathRelativeToFilesProvider(): array {
-		return [
-			['admin/files', ''],
-			['admin/files/x', 'x'],
-			['/admin/files', ''],
-			['/admin/files/sub', 'sub'],
-			['/admin/files/sub/', 'sub'],
-			['/admin/files/sub/sub2', 'sub/sub2'],
-			['//admin//files/sub//sub2', 'sub/sub2'],
-		];
-	}
-
-	/**
-	 * @dataProvider pathRelativeToFilesProvider
-	 */
-	public function testGetPathRelativeToFiles($path, $expectedPath): void {
-		$view = new View();
-		$this->assertEquals($expectedPath, $view->getPathRelativeToFiles($path));
-	}
-
-	public static function pathRelativeToFilesProviderExceptionCases(): array {
-		return [
-			[''],
-			['x'],
-			['files'],
-			['/files'],
-			['/admin/files_versions/abc'],
-		];
-	}
-
-	/**
-	 * @dataProvider pathRelativeToFilesProviderExceptionCases
-	 * @param string $path
-	 */
-	public function testGetPathRelativeToFilesWithInvalidArgument($path): void {
-		$this->expectException(\InvalidArgumentException::class);
-		$this->expectExceptionMessage('$absolutePath must be relative to "files"');
-
-		$view = new View();
-		$view->getPathRelativeToFiles($path);
-	}
-
-	public function testChangeLock(): void {
-		$view = new View('/testuser/files/');
-		$storage = new Temporary([]);
-		Filesystem::mount($storage, [], '/');
-
-		$view->lockFile('/test/sub', ILockingProvider::LOCK_SHARED);
-		$this->assertTrue($this->isFileLocked($view, '/test//sub', ILockingProvider::LOCK_SHARED));
-		$this->assertFalse($this->isFileLocked($view, '/test//sub', ILockingProvider::LOCK_EXCLUSIVE));
-
-		$view->changeLock('//test/sub', ILockingProvider::LOCK_EXCLUSIVE);
-		$this->assertTrue($this->isFileLocked($view, '/test//sub', ILockingProvider::LOCK_EXCLUSIVE));
-
-		$view->changeLock('test/sub', ILockingProvider::LOCK_SHARED);
-		$this->assertTrue($this->isFileLocked($view, '/test//sub', ILockingProvider::LOCK_SHARED));
-
-		$view->unlockFile('/test/sub/', ILockingProvider::LOCK_SHARED);
-
-		$this->assertFalse($this->isFileLocked($view, '/test//sub', ILockingProvider::LOCK_SHARED));
-		$this->assertFalse($this->isFileLocked($view, '/test//sub', ILockingProvider::LOCK_EXCLUSIVE));
-	}
-
-	public static function hookPathProvider(): array {
-		return [
-			['/foo/files', '/foo', true],
-			['/foo/files/bar', '/foo', true],
-			['/foo', '/foo', false],
-			['/foo', '/files/foo', true],
-			['/foo', 'filesfoo', false],
-			['', '/foo/files', true],
-			['', '/foo/files/bar.txt', true],
-		];
-	}
-
-	/**
-	 * @dataProvider hookPathProvider
-	 * @param $root
-	 * @param $path
-	 * @param $shouldEmit
-	 */
-	public function testHookPaths($root, $path, $shouldEmit): void {
-		$filesystemReflection = new \ReflectionClass(Filesystem::class);
-		$defaultRootValue = $filesystemReflection->getProperty('defaultInstance');
-		$defaultRootValue->setAccessible(true);
-		$oldRoot = $defaultRootValue->getValue();
-		$defaultView = new View('/foo/files');
-		$defaultRootValue->setValue(null, $defaultView);
-		$view = new View($root);
-		$result = self::invokePrivate($view, 'shouldEmitHooks', [$path]);
-		$defaultRootValue->setValue(null, $oldRoot);
-		$this->assertEquals($shouldEmit, $result);
-	}
-
-	/**
-	 * Create test movable mount points
-	 *
-	 * @param array $mountPoints array of mount point locations
-	 * @return array array of MountPoint objects
-	 */
-	private function createTestMovableMountPoints($mountPoints) {
-		$mounts = [];
-		foreach ($mountPoints as $mountPoint) {
-			$storage = $this->getMockBuilder(Storage::class)
-				->onlyMethods([])
-				->getMock();
-			$storage->method('getId')->willReturn('non-null-id');
-			$storage->method('getStorageCache')->willReturnCallback(function () use ($storage) {
-				return new \OC\Files\Cache\Storage($storage, true, \OC::$server->get(IDBConnection::class));
-			});
-
-			$mounts[] = $this->getMockBuilder(TestMoveableMountPoint::class)
-				->onlyMethods(['moveMount'])
-				->setConstructorArgs([$storage, $mountPoint])
-				->getMock();
-		}
-
-		/** @var IMountProvider|\PHPUnit\Framework\MockObject\MockObject $mountProvider */
-		$mountProvider = $this->createMock(IMountProvider::class);
-		$mountProvider->expects($this->any())
-			->method('getMountsForUser')
-			->willReturn($mounts);
-
-		$mountProviderCollection = \OC::$server->getMountProviderCollection();
-		$mountProviderCollection->registerProvider($mountProvider);
-
-		return $mounts;
-	}
-
-	/**
-	 * Test mount point move
-	 */
-	public function testMountPointMove(): void {
-		self::loginAsUser($this->user);
-
-		[$mount1, $mount2] = $this->createTestMovableMountPoints([
-			$this->user . '/files/mount1',
-			$this->user . '/files/mount2',
-		]);
-		$mount1->expects($this->once())
-			->method('moveMount')
-			->willReturn(true);
-
-		$mount2->expects($this->once())
-			->method('moveMount')
-			->willReturn(true);
-
-		$view = new View('/' . $this->user . '/files/');
-		$view->mkdir('sub');
-
-		$this->assertTrue($view->rename('mount1', 'renamed_mount'), 'Can rename mount point');
-		$this->assertTrue($view->rename('mount2', 'sub/moved_mount'), 'Can move a mount point into a subdirectory');
-	}
-
-	public function testMoveMountPointOverwrite(): void {
-		self::loginAsUser($this->user);
-
-		[$mount1, $mount2] = $this->createTestMovableMountPoints([
-			$this->user . '/files/mount1',
-			$this->user . '/files/mount2',
-		]);
-
-		$mount1->expects($this->never())
-			->method('moveMount');
-
-		$mount2->expects($this->never())
-			->method('moveMount');
-
-		$view = new View('/' . $this->user . '/files/');
-
-		$this->expectException(ForbiddenException::class);
-		$view->rename('mount1', 'mount2');
-	}
-
-	public function testMoveMountPointIntoMount(): void {
-		self::loginAsUser($this->user);
-
-		[$mount1, $mount2] = $this->createTestMovableMountPoints([
-			$this->user . '/files/mount1',
-			$this->user . '/files/mount2',
-		]);
-
-		$mount1->expects($this->never())
-			->method('moveMount');
-
-		$mount2->expects($this->never())
-			->method('moveMount');
-
-		$view = new View('/' . $this->user . '/files/');
-
-		$this->expectException(ForbiddenException::class);
-		$view->rename('mount1', 'mount2/sub');
-	}
-
-	/**
-	 * Test that moving a mount point into a shared folder is forbidden
-	 */
-	public function testMoveMountPointIntoSharedFolder(): void {
-		self::loginAsUser($this->user);
-
-		[$mount1, $mount2] = $this->createTestMovableMountPoints([
-			$this->user . '/files/mount1',
-			$this->user . '/files/mount2',
-		]);
-
-		$mount1->expects($this->never())
-			->method('moveMount');
-
-		$mount2->expects($this->once())
-			->method('moveMount')
-			->willReturn(true);
-
-		$view = new View('/' . $this->user . '/files/');
-		$view->mkdir('shareddir');
-		$view->mkdir('shareddir/sub');
-		$view->mkdir('shareddir/sub2');
-		// Create a similar named but non-shared folder
-		$view->mkdir('shareddir notshared');
-
-		$fileId = $view->getFileInfo('shareddir')->getId();
-		$userObject = \OC::$server->getUserManager()->createUser('test2', 'IHateNonMockableStaticClasses');
-
-		$userFolder = \OC::$server->getUserFolder($this->user);
-		$shareDir = $userFolder->get('shareddir');
-		$shareManager = \OC::$server->get(IShareManager::class);
-		$share = $shareManager->newShare();
-		$share->setSharedWith('test2')
-			->setSharedBy($this->user)
-			->setShareType(IShare::TYPE_USER)
-			->setPermissions(\OCP\Constants::PERMISSION_READ)
-			->setNode($shareDir);
-		$shareManager->createShare($share);
-
-		try {
-			$view->rename('mount1', 'shareddir');
-			$this->fail('Cannot overwrite shared folder');
-		} catch (ForbiddenException $e) {
-
-		}
-		try {
-			$view->rename('mount1', 'shareddir/sub');
-			$this->fail('Cannot move mount point into shared folder');
-		} catch (ForbiddenException $e) {
-
-		}
-		try {
-			$view->rename('mount1', 'shareddir/sub/sub2');
-			$this->fail('Cannot move mount point into shared subfolder');
-		} catch (ForbiddenException $e) {
-
-		}
-		$this->assertTrue($view->rename('mount2', 'shareddir notshared/sub'), 'Can move mount point into a similarly named but non-shared folder');
-
-		$shareManager->deleteShare($share);
-		$userObject->delete();
-	}
-
-	public static function basicOperationProviderForLocks(): array {
-		return [
-			// --- write hook ----
-			[
-				'touch',
-				['touch-create.txt'],
-				'touch-create.txt',
-				'create',
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_EXCLUSIVE,
-				ILockingProvider::LOCK_SHARED,
-			],
-			[
-				'fopen',
-				['test-write.txt', 'w'],
-				'test-write.txt',
-				'write',
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_EXCLUSIVE,
-				null,
-				// exclusive lock stays until fclose
-				ILockingProvider::LOCK_EXCLUSIVE,
-			],
-			[
-				'mkdir',
-				['newdir'],
-				'newdir',
-				'write',
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_EXCLUSIVE,
-				ILockingProvider::LOCK_SHARED,
-			],
-			[
-				'file_put_contents',
-				['file_put_contents.txt', 'blah'],
-				'file_put_contents.txt',
-				'write',
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_EXCLUSIVE,
-				ILockingProvider::LOCK_SHARED,
-				null,
-				0,
-			],
-
-			// ---- delete hook ----
-			[
-				'rmdir',
-				['dir'],
-				'dir',
-				'delete',
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_EXCLUSIVE,
-				ILockingProvider::LOCK_SHARED,
-			],
-			[
-				'unlink',
-				['test.txt'],
-				'test.txt',
-				'delete',
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_EXCLUSIVE,
-				ILockingProvider::LOCK_SHARED,
-			],
-
-			// ---- read hook (no post hooks) ----
-			[
-				'file_get_contents',
-				['test.txt'],
-				'test.txt',
-				'read',
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_SHARED,
-				null,
-				null,
-				false,
-			],
-			[
-				'fopen',
-				['test.txt', 'r'],
-				'test.txt',
-				'read',
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_SHARED,
-				null,
-			],
-			[
-				'opendir',
-				['dir'],
-				'dir',
-				'read',
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_SHARED,
-				null,
-			],
-
-			// ---- no lock, touch hook ---
-			['touch', ['test.txt'], 'test.txt', 'touch', null, null, null],
-
-			// ---- no hooks, no locks ---
-			['is_dir', ['dir'], 'dir', null],
-			['is_file', ['dir'], 'dir', null],
-			[
-				'stat',
-				['dir'],
-				'dir',
-				null,
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_SHARED,
-				null,
-				false,
-			],
-			[
-				'filetype',
-				['dir'],
-				'dir',
-				null,
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_SHARED,
-				null,
-				false,
-			],
-			[
-				'filesize',
-				['dir'],
-				'dir',
-				null,
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_SHARED,
-				null,
-				/* Return an int */
-				100
-			],
-			['isCreatable', ['dir'], 'dir', null],
-			['isReadable', ['dir'], 'dir', null],
-			['isUpdatable', ['dir'], 'dir', null],
-			['isDeletable', ['dir'], 'dir', null],
-			['isSharable', ['dir'], 'dir', null],
-			['file_exists', ['dir'], 'dir', null],
-			[
-				'filemtime',
-				['dir'],
-				'dir',
-				null,
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_SHARED,
-				ILockingProvider::LOCK_SHARED,
-				null,
-				false,
-			],
-		];
-	}
-
-	/**
-	 * Test whether locks are set before and after the operation
-	 *
-	 * @dataProvider basicOperationProviderForLocks
-	 *
-	 * @param string $operation operation name on the view
-	 * @param array $operationArgs arguments for the operation
-	 * @param string $lockedPath path of the locked item to check
-	 * @param string $hookType hook type
-	 * @param int $expectedLockBefore expected lock during pre hooks
-	 * @param int $expectedLockDuring expected lock during operation
-	 * @param int $expectedLockAfter expected lock during post hooks
-	 * @param int $expectedStrayLock expected lock after returning, should
-	 *                               be null (unlock) for most operations
-	 */
-	public function testLockBasicOperation(
-		$operation,
-		$operationArgs,
-		$lockedPath,
-		$hookType,
-		$expectedLockBefore = ILockingProvider::LOCK_SHARED,
-		$expectedLockDuring = ILockingProvider::LOCK_SHARED,
-		$expectedLockAfter = ILockingProvider::LOCK_SHARED,
-		$expectedStrayLock = null,
-		$returnValue = true,
-	): void {
-		$view = new View('/' . $this->user . '/files/');
-
-		/** @var Temporary&MockObject $storage */
-		$storage = $this->getMockBuilder(Temporary::class)
-			->onlyMethods([$operation])
-			->getMock();
-
-		/* Pause trash to avoid the trashbin intercepting rmdir and unlink calls */
-		Server::get(ITrashManager::class)->pauseTrash();
-		/* Same thing with encryption wrapper */
-		Server::get(IStorageFactory::class)->removeStorageWrapper('oc_encryption');
-
-		Filesystem::mount($storage, [], $this->user . '/');
-
-		// work directly on disk because mkdir might be mocked
-		$realPath = $storage->getSourcePath('');
-		mkdir($realPath . '/files');
-		mkdir($realPath . '/files/dir');
-		file_put_contents($realPath . '/files/test.txt', 'blah');
-		$storage->getScanner()->scan('files');
-
-		$storage->expects($this->once())
-			->method($operation)
-			->willReturnCallback(
-				function () use ($view, $lockedPath, &$lockTypeDuring, $returnValue) {
-					$lockTypeDuring = $this->getFileLockType($view, $lockedPath);
-
-					return $returnValue;
-				}
-			);
-
-		$this->assertNull($this->getFileLockType($view, $lockedPath), 'File not locked before operation');
-
-		$this->connectMockHooks($hookType, $view, $lockedPath, $lockTypePre, $lockTypePost);
-
-		// do operation
-		call_user_func_array([$view, $operation], $operationArgs);
-
-		if ($hookType !== null) {
-			$this->assertEquals($expectedLockBefore, $lockTypePre, 'File locked properly during pre-hook');
-			$this->assertEquals($expectedLockAfter, $lockTypePost, 'File locked properly during post-hook');
-			$this->assertEquals($expectedLockDuring, $lockTypeDuring, 'File locked properly during operation');
-		} else {
-			$this->assertNull($lockTypeDuring, 'File not locked during operation');
-		}
-
-		$this->assertEquals($expectedStrayLock, $this->getFileLockType($view, $lockedPath));
-
-		/* Resume trash to avoid side effects */
-		Server::get(ITrashManager::class)->resumeTrash();
-	}
-
-	/**
-	 * Test locks for file_put_content with stream.
-	 * This code path uses $storage->fopen instead
-	 */
-	public function testLockFilePutContentWithStream(): void {
-		$view = new View('/' . $this->user . '/files/');
-
-		$path = 'test_file_put_contents.txt';
-		/** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
-		$storage = $this->getMockBuilder(Temporary::class)
-			->onlyMethods(['fopen'])
-			->getMock();
-
-		Filesystem::mount($storage, [], $this->user . '/');
-		$storage->mkdir('files');
-
-		$storage->expects($this->once())
-			->method('fopen')
-			->willReturnCallback(
-				function () use ($view, $path, &$lockTypeDuring) {
-					$lockTypeDuring = $this->getFileLockType($view, $path);
-
-					return fopen('php://temp', 'r+');
-				}
-			);
-
-		$this->connectMockHooks('write', $view, $path, $lockTypePre, $lockTypePost);
-
-		$this->assertNull($this->getFileLockType($view, $path), 'File not locked before operation');
-
-		// do operation
-		$view->file_put_contents($path, fopen('php://temp', 'r+'));
-
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypePre, 'File locked properly during pre-hook');
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypePost, 'File locked properly during post-hook');
-		$this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $lockTypeDuring, 'File locked properly during operation');
-
-		$this->assertNull($this->getFileLockType($view, $path));
-	}
-
-	/**
-	 * Test locks for fopen with fclose at the end
-	 */
-	public function testLockFopen(): void {
-		$view = new View('/' . $this->user . '/files/');
-
-		$path = 'test_file_put_contents.txt';
-		/** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
-		$storage = $this->getMockBuilder(Temporary::class)
-			->onlyMethods(['fopen'])
-			->getMock();
-
-		Filesystem::mount($storage, [], $this->user . '/');
-		$storage->mkdir('files');
-
-		$storage->expects($this->once())
-			->method('fopen')
-			->willReturnCallback(
-				function () use ($view, $path, &$lockTypeDuring) {
-					$lockTypeDuring = $this->getFileLockType($view, $path);
-
-					return fopen('php://temp', 'r+');
-				}
-			);
-
-		$this->connectMockHooks('write', $view, $path, $lockTypePre, $lockTypePost);
-
-		$this->assertNull($this->getFileLockType($view, $path), 'File not locked before operation');
-
-		// do operation
-		$res = $view->fopen($path, 'w');
-
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypePre, 'File locked properly during pre-hook');
-		$this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $lockTypeDuring, 'File locked properly during operation');
-		$this->assertNull($lockTypePost, 'No post hook, no lock check possible');
-
-		$this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $lockTypeDuring, 'File still locked after fopen');
-
-		fclose($res);
-
-		$this->assertNull($this->getFileLockType($view, $path), 'File unlocked after fclose');
-	}
-
-	/**
-	 * Test locks for fopen with fclose at the end
-	 *
-	 * @dataProvider basicOperationProviderForLocks
-	 *
-	 * @param string $operation operation name on the view
-	 * @param array $operationArgs arguments for the operation
-	 * @param string $path path of the locked item to check
-	 */
-	public function testLockBasicOperationUnlocksAfterException(
-		$operation,
-		$operationArgs,
-		$path,
-	): void {
-		if ($operation === 'touch') {
-			$this->markTestSkipped('touch handles storage exceptions internally');
-		}
-		$view = new View('/' . $this->user . '/files/');
-
-		/** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
-		$storage = $this->getMockBuilder(Temporary::class)
-			->onlyMethods([$operation])
-			->getMock();
-
-		/* Pause trash to avoid the trashbin intercepting rmdir and unlink calls */
-		Server::get(ITrashManager::class)->pauseTrash();
-		/* Same thing with encryption wrapper */
-		Server::get(IStorageFactory::class)->removeStorageWrapper('oc_encryption');
-
-		Filesystem::mount($storage, [], $this->user . '/');
-
-		// work directly on disk because mkdir might be mocked
-		$realPath = $storage->getSourcePath('');
-		mkdir($realPath . '/files');
-		mkdir($realPath . '/files/dir');
-		file_put_contents($realPath . '/files/test.txt', 'blah');
-		$storage->getScanner()->scan('files');
-
-		$storage->expects($this->once())
-			->method($operation)
-			->willReturnCallback(
-				function () {
-					throw new \Exception('Simulated exception');
-				}
-			);
-
-		$thrown = false;
-		try {
-			call_user_func_array([$view, $operation], $operationArgs);
-		} catch (\Exception $e) {
-			$thrown = true;
-			$this->assertEquals('Simulated exception', $e->getMessage());
-		}
-		$this->assertTrue($thrown, 'Exception was rethrown');
-		$this->assertNull($this->getFileLockType($view, $path), 'File got unlocked after exception');
-
-		/* Resume trash to avoid side effects */
-		Server::get(ITrashManager::class)->resumeTrash();
-	}
-
-	public function testLockBasicOperationUnlocksAfterLockException(): void {
-		$view = new View('/' . $this->user . '/files/');
-
-		$storage = new Temporary([]);
-
-		Filesystem::mount($storage, [], $this->user . '/');
-
-		$storage->mkdir('files');
-		$storage->mkdir('files/dir');
-		$storage->file_put_contents('files/test.txt', 'blah');
-		$storage->getScanner()->scan('files');
-
-		// get a shared lock
-		$handle = $view->fopen('test.txt', 'r');
-
-		$thrown = false;
-		try {
-			// try (and fail) to get a write lock
-			$view->unlink('test.txt');
-		} catch (\Exception $e) {
-			$thrown = true;
-			$this->assertInstanceOf(LockedException::class, $e);
-		}
-		$this->assertTrue($thrown, 'Exception was rethrown');
-
-		// clean shared lock
-		fclose($handle);
-
-		$this->assertNull($this->getFileLockType($view, 'test.txt'), 'File got unlocked');
-	}
-
-	/**
-	 * Test locks for fopen with fclose at the end
-	 *
-	 * @dataProvider basicOperationProviderForLocks
-	 *
-	 * @param string $operation operation name on the view
-	 * @param array $operationArgs arguments for the operation
-	 * @param string $path path of the locked item to check
-	 * @param string $hookType hook type
-	 */
-	public function testLockBasicOperationUnlocksAfterCancelledHook(
-		$operation,
-		$operationArgs,
-		$path,
-		$hookType,
-	): void {
-		$view = new View('/' . $this->user . '/files/');
-
-		/** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
-		$storage = $this->getMockBuilder(Temporary::class)
-			->onlyMethods([$operation])
-			->getMock();
-
-		Filesystem::mount($storage, [], $this->user . '/');
-		$storage->mkdir('files');
-
-		Util::connectHook(
-			Filesystem::CLASSNAME,
-			$hookType,
-			HookHelper::class,
-			'cancellingCallback'
-		);
-
-		call_user_func_array([$view, $operation], $operationArgs);
-
-		$this->assertNull($this->getFileLockType($view, $path), 'File got unlocked after exception');
-	}
-
-	public static function lockFileRenameOrCopyDataProvider(): array {
-		return [
-			['rename', ILockingProvider::LOCK_EXCLUSIVE],
-			['copy', ILockingProvider::LOCK_SHARED],
-		];
-	}
-
-	/**
-	 * Test locks for rename or copy operation
-	 *
-	 * @dataProvider lockFileRenameOrCopyDataProvider
-	 *
-	 * @param string $operation operation to be done on the view
-	 * @param int $expectedLockTypeSourceDuring expected lock type on source file during
-	 *                                          the operation
-	 */
-	public function testLockFileRename($operation, $expectedLockTypeSourceDuring): void {
-		$view = new View('/' . $this->user . '/files/');
-
-		/** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
-		$storage = $this->getMockBuilder(Temporary::class)
-			->onlyMethods([$operation, 'getMetaData', 'filemtime'])
-			->getMock();
-
-		$storage->expects($this->any())
-			->method('getMetaData')
-			->will($this->returnValue([
-				'mtime' => 1885434487,
-				'etag' => '',
-				'mimetype' => 'text/plain',
-				'permissions' => Constants::PERMISSION_ALL,
-				'size' => 3
-			]));
-		$storage->expects($this->any())
-			->method('filemtime')
-			->willReturn(123456789);
-
-		$sourcePath = 'original.txt';
-		$targetPath = 'target.txt';
-
-		/* Disable encryption wrapper to avoid it intercepting mocked call */
-		Server::get(IStorageFactory::class)->removeStorageWrapper('oc_encryption');
-
-		Filesystem::mount($storage, [], $this->user . '/');
-		$storage->mkdir('files');
-		$view->file_put_contents($sourcePath, 'meh');
-
-		$storage->expects($this->once())
-			->method($operation)
-			->willReturnCallback(
-				function () use ($view, $sourcePath, $targetPath, &$lockTypeSourceDuring, &$lockTypeTargetDuring) {
-					$lockTypeSourceDuring = $this->getFileLockType($view, $sourcePath);
-					$lockTypeTargetDuring = $this->getFileLockType($view, $targetPath);
-
-					return true;
-				}
-			);
-
-		$this->connectMockHooks($operation, $view, $sourcePath, $lockTypeSourcePre, $lockTypeSourcePost);
-		$this->connectMockHooks($operation, $view, $targetPath, $lockTypeTargetPre, $lockTypeTargetPost);
-
-		$this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked before operation');
-		$this->assertNull($this->getFileLockType($view, $targetPath), 'Target file not locked before operation');
-
-		$view->$operation($sourcePath, $targetPath);
-
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeSourcePre, 'Source file locked properly during pre-hook');
-		$this->assertEquals($expectedLockTypeSourceDuring, $lockTypeSourceDuring, 'Source file locked properly during operation');
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeSourcePost, 'Source file locked properly during post-hook');
-
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeTargetPre, 'Target file locked properly during pre-hook');
-		$this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $lockTypeTargetDuring, 'Target file locked properly during operation');
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeTargetPost, 'Target file locked properly during post-hook');
-
-		$this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked after operation');
-		$this->assertNull($this->getFileLockType($view, $targetPath), 'Target file not locked after operation');
-	}
-
-	/**
-	 * simulate a failed copy operation.
-	 * We expect that we catch the exception, free the lock and re-throw it.
-	 *
-	 */
-	public function testLockFileCopyException(): void {
-		$this->expectException(\Exception::class);
-
-		$view = new View('/' . $this->user . '/files/');
-
-		/** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
-		$storage = $this->getMockBuilder(Temporary::class)
-			->onlyMethods(['copy'])
-			->getMock();
-
-		$sourcePath = 'original.txt';
-		$targetPath = 'target.txt';
-
-		/* Disable encryption wrapper to avoid it intercepting mocked call */
-		Server::get(IStorageFactory::class)->removeStorageWrapper('oc_encryption');
-
-		Filesystem::mount($storage, [], $this->user . '/');
-		$storage->mkdir('files');
-		$view->file_put_contents($sourcePath, 'meh');
-
-		$storage->expects($this->once())
-			->method('copy')
-			->willReturnCallback(
-				function () {
-					throw new \Exception();
-				}
-			);
-
-		$this->connectMockHooks('copy', $view, $sourcePath, $lockTypeSourcePre, $lockTypeSourcePost);
-		$this->connectMockHooks('copy', $view, $targetPath, $lockTypeTargetPre, $lockTypeTargetPost);
-
-		$this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked before operation');
-		$this->assertNull($this->getFileLockType($view, $targetPath), 'Target file not locked before operation');
-
-		try {
-			$view->copy($sourcePath, $targetPath);
-		} catch (\Exception $e) {
-			$this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked after operation');
-			$this->assertNull($this->getFileLockType($view, $targetPath), 'Target file not locked after operation');
-			throw $e;
-		}
-	}
-
-	/**
-	 * Test rename operation: unlock first path when second path was locked
-	 */
-	public function testLockFileRenameUnlockOnException(): void {
-		self::loginAsUser('test');
-
-		$view = new View('/' . $this->user . '/files/');
-
-		$sourcePath = 'original.txt';
-		$targetPath = 'target.txt';
-		$view->file_put_contents($sourcePath, 'meh');
-
-		// simulate that the target path is already locked
-		$view->lockFile($targetPath, ILockingProvider::LOCK_EXCLUSIVE);
-
-		$this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked before operation');
-		$this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $this->getFileLockType($view, $targetPath), 'Target file is locked before operation');
-
-		$thrown = false;
-		try {
-			$view->rename($sourcePath, $targetPath);
-		} catch (LockedException $e) {
-			$thrown = true;
-		}
-
-		$this->assertTrue($thrown, 'LockedException thrown');
-
-		$this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked after operation');
-		$this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $this->getFileLockType($view, $targetPath), 'Target file still locked after operation');
-
-		$view->unlockFile($targetPath, ILockingProvider::LOCK_EXCLUSIVE);
-	}
-
-	/**
-	 * Test rename operation: unlock first path when second path was locked
-	 */
-	public function testGetOwner(): void {
-		self::loginAsUser('test');
-
-		$view = new View('/test/files/');
-
-		$path = 'foo.txt';
-		$view->file_put_contents($path, 'meh');
-
-		$this->assertEquals('test', $view->getFileInfo($path)->getOwner()->getUID());
-
-		$folderInfo = $view->getDirectoryContent('');
-		$folderInfo = array_values(array_filter($folderInfo, function (FileInfo $info) {
-			return $info->getName() === 'foo.txt';
-		}));
-
-		$this->assertEquals('test', $folderInfo[0]->getOwner()->getUID());
-
-		$subStorage = new Temporary();
-		Filesystem::mount($subStorage, [], '/test/files/asd');
-
-		$folderInfo = $view->getDirectoryContent('');
-		$folderInfo = array_values(array_filter($folderInfo, function (FileInfo $info) {
-			return $info->getName() === 'asd';
-		}));
-
-		$this->assertEquals('test', $folderInfo[0]->getOwner()->getUID());
-	}
-
-	public static function lockFileRenameOrCopyCrossStorageDataProvider(): array {
-		return [
-			['rename', 'moveFromStorage', ILockingProvider::LOCK_EXCLUSIVE],
-			['copy', 'copyFromStorage', ILockingProvider::LOCK_SHARED],
-		];
-	}
-
-	/**
-	 * Test locks for rename or copy operation cross-storage
-	 *
-	 * @dataProvider lockFileRenameOrCopyCrossStorageDataProvider
-	 *
-	 * @param string $viewOperation operation to be done on the view
-	 * @param string $storageOperation operation to be mocked on the storage
-	 * @param int $expectedLockTypeSourceDuring expected lock type on source file during
-	 *                                          the operation
-	 */
-	public function testLockFileRenameCrossStorage($viewOperation, $storageOperation, $expectedLockTypeSourceDuring): void {
-		$view = new View('/' . $this->user . '/files/');
-
-		/** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
-		$storage = $this->getMockBuilder(Temporary::class)
-			->onlyMethods([$storageOperation])
-			->getMock();
-		/** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage2 */
-		$storage2 = $this->getMockBuilder(Temporary::class)
-			->onlyMethods([$storageOperation, 'getMetaData', 'filemtime'])
-			->getMock();
-
-		$storage2->expects($this->any())
-			->method('getMetaData')
-			->will($this->returnValue([
-				'mtime' => 1885434487,
-				'etag' => '',
-				'mimetype' => 'text/plain',
-				'permissions' => Constants::PERMISSION_ALL,
-				'size' => 3
-			]));
-		$storage2->expects($this->any())
-			->method('filemtime')
-			->willReturn(123456789);
-
-		$sourcePath = 'original.txt';
-		$targetPath = 'substorage/target.txt';
-
-		/* Disable encryption wrapper to avoid it intercepting mocked call */
-		Server::get(IStorageFactory::class)->removeStorageWrapper('oc_encryption');
-
-		Filesystem::mount($storage, [], $this->user . '/');
-		Filesystem::mount($storage2, [], $this->user . '/files/substorage');
-		$storage->mkdir('files');
-		$view->file_put_contents($sourcePath, 'meh');
-		$storage2->getUpdater()->update('');
-
-		$storage->expects($this->never())
-			->method($storageOperation);
-		$storage2->expects($this->once())
-			->method($storageOperation)
-			->willReturnCallback(
-				function () use ($view, $sourcePath, $targetPath, &$lockTypeSourceDuring, &$lockTypeTargetDuring) {
-					$lockTypeSourceDuring = $this->getFileLockType($view, $sourcePath);
-					$lockTypeTargetDuring = $this->getFileLockType($view, $targetPath);
-
-					return true;
-				}
-			);
-
-		$this->connectMockHooks($viewOperation, $view, $sourcePath, $lockTypeSourcePre, $lockTypeSourcePost);
-		$this->connectMockHooks($viewOperation, $view, $targetPath, $lockTypeTargetPre, $lockTypeTargetPost);
-
-		$this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked before operation');
-		$this->assertNull($this->getFileLockType($view, $targetPath), 'Target file not locked before operation');
-
-		$view->$viewOperation($sourcePath, $targetPath);
-
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeSourcePre, 'Source file locked properly during pre-hook');
-		$this->assertEquals($expectedLockTypeSourceDuring, $lockTypeSourceDuring, 'Source file locked properly during operation');
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeSourcePost, 'Source file locked properly during post-hook');
-
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeTargetPre, 'Target file locked properly during pre-hook');
-		$this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $lockTypeTargetDuring, 'Target file locked properly during operation');
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeTargetPost, 'Target file locked properly during post-hook');
-
-		$this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked after operation');
-		$this->assertNull($this->getFileLockType($view, $targetPath), 'Target file not locked after operation');
-	}
-
-	/**
-	 * Test locks when moving a mount point
-	 */
-	public function testLockMoveMountPoint(): void {
-		self::loginAsUser('test');
-
-		[$mount] = $this->createTestMovableMountPoints([
-			$this->user . '/files/substorage',
-		]);
-
-		$view = new View('/' . $this->user . '/files/');
-		$view->mkdir('subdir');
-
-		$sourcePath = 'substorage';
-		$targetPath = 'subdir/substorage_moved';
-
-		$mount->expects($this->once())
-			->method('moveMount')
-			->willReturnCallback(
-				function ($target) use ($mount, $view, $sourcePath, $targetPath, &$lockTypeSourceDuring, &$lockTypeTargetDuring, &$lockTypeSharedRootDuring) {
-					$lockTypeSourceDuring = $this->getFileLockType($view, $sourcePath, true);
-					$lockTypeTargetDuring = $this->getFileLockType($view, $targetPath, true);
-
-					$lockTypeSharedRootDuring = $this->getFileLockType($view, $sourcePath, false);
-
-					$mount->setMountPoint($target);
-
-					return true;
-				}
-			);
-
-		$this->connectMockHooks('rename', $view, $sourcePath, $lockTypeSourcePre, $lockTypeSourcePost, true);
-		$this->connectMockHooks('rename', $view, $targetPath, $lockTypeTargetPre, $lockTypeTargetPost, true);
-		// in pre-hook, mount point is still on $sourcePath
-		$this->connectMockHooks('rename', $view, $sourcePath, $lockTypeSharedRootPre, $dummy, false);
-		// in post-hook, mount point is now on $targetPath
-		$this->connectMockHooks('rename', $view, $targetPath, $dummy, $lockTypeSharedRootPost, false);
-
-		$this->assertNull($this->getFileLockType($view, $sourcePath, false), 'Shared storage root not locked before operation');
-		$this->assertNull($this->getFileLockType($view, $sourcePath, true), 'Source path not locked before operation');
-		$this->assertNull($this->getFileLockType($view, $targetPath, true), 'Target path not locked before operation');
-
-		$view->rename($sourcePath, $targetPath);
-
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeSourcePre, 'Source path locked properly during pre-hook');
-		$this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $lockTypeSourceDuring, 'Source path locked properly during operation');
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeSourcePost, 'Source path locked properly during post-hook');
-
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeTargetPre, 'Target path locked properly during pre-hook');
-		$this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $lockTypeTargetDuring, 'Target path locked properly during operation');
-		$this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeTargetPost, 'Target path locked properly during post-hook');
-
-		$this->assertNull($lockTypeSharedRootPre, 'Shared storage root not locked during pre-hook');
-		$this->assertNull($lockTypeSharedRootDuring, 'Shared storage root not locked during move');
-		$this->assertNull($lockTypeSharedRootPost, 'Shared storage root not locked during post-hook');
-
-		$this->assertNull($this->getFileLockType($view, $sourcePath, false), 'Shared storage root not locked after operation');
-		$this->assertNull($this->getFileLockType($view, $sourcePath, true), 'Source path not locked after operation');
-		$this->assertNull($this->getFileLockType($view, $targetPath, true), 'Target path not locked after operation');
-	}
-
-	/**
-	 * Connect hook callbacks for hook type
-	 *
-	 * @param string $hookType hook type or null for none
-	 * @param View $view view to check the lock on
-	 * @param string $path path for which to check the lock
-	 * @param int $lockTypePre variable to receive lock type that was active in the pre-hook
-	 * @param int $lockTypePost variable to receive lock type that was active in the post-hook
-	 * @param bool $onMountPoint true to check the mount point instead of the
-	 *                           mounted storage
-	 */
-	private function connectMockHooks($hookType, $view, $path, &$lockTypePre, &$lockTypePost, $onMountPoint = false) {
-		if ($hookType === null) {
-			return;
-		}
-
-		$eventHandler = $this->getMockBuilder(TestEventHandler::class)
-			->onlyMethods(['preCallback', 'postCallback'])
-			->getMock();
-
-		$eventHandler->expects($this->any())
-			->method('preCallback')
-			->willReturnCallback(
-				function () use ($view, $path, $onMountPoint, &$lockTypePre) {
-					$lockTypePre = $this->getFileLockType($view, $path, $onMountPoint);
-				}
-			);
-		$eventHandler->expects($this->any())
-			->method('postCallback')
-			->willReturnCallback(
-				function () use ($view, $path, $onMountPoint, &$lockTypePost) {
-					$lockTypePost = $this->getFileLockType($view, $path, $onMountPoint);
-				}
-			);
-
-		if ($hookType !== null) {
-			Util::connectHook(
-				Filesystem::CLASSNAME,
-				$hookType,
-				$eventHandler,
-				'preCallback'
-			);
-			Util::connectHook(
-				Filesystem::CLASSNAME,
-				'post_' . $hookType,
-				$eventHandler,
-				'postCallback'
-			);
-		}
-	}
-
-	/**
-	 * Returns the file lock type
-	 *
-	 * @param View $view view
-	 * @param string $path path
-	 * @param bool $onMountPoint true to check the mount point instead of the
-	 *                           mounted storage
-	 *
-	 * @return int lock type or null if file was not locked
-	 */
-	private function getFileLockType(View $view, $path, $onMountPoint = false) {
-		if ($this->isFileLocked($view, $path, ILockingProvider::LOCK_EXCLUSIVE, $onMountPoint)) {
-			return ILockingProvider::LOCK_EXCLUSIVE;
-		} elseif ($this->isFileLocked($view, $path, ILockingProvider::LOCK_SHARED, $onMountPoint)) {
-			return ILockingProvider::LOCK_SHARED;
-		}
-		return null;
-	}
-
-
-	public function testRemoveMoveableMountPoint(): void {
-		$mountPoint = '/' . $this->user . '/files/mount/';
-
-		// Mock the mount point
-		/** @var TestMoveableMountPoint|\PHPUnit\Framework\MockObject\MockObject $mount */
-		$mount = $this->createMock(TestMoveableMountPoint::class);
-		$mount->expects($this->once())
-			->method('getMountPoint')
-			->willReturn($mountPoint);
-		$mount->expects($this->once())
-			->method('removeMount')
-			->willReturn('foo');
-		$mount->expects($this->any())
-			->method('getInternalPath')
-			->willReturn('');
-
-		// Register mount
-		Filesystem::getMountManager()->addMount($mount);
-
-		// Listen for events
-		$eventHandler = $this->getMockBuilder(TestEventHandler::class)
-			->onlyMethods(['umount', 'post_umount'])
-			->getMock();
-		$eventHandler->expects($this->once())
-			->method('umount')
-			->with([Filesystem::signal_param_path => '/mount']);
-		$eventHandler->expects($this->once())
-			->method('post_umount')
-			->with([Filesystem::signal_param_path => '/mount']);
-		Util::connectHook(
-			Filesystem::CLASSNAME,
-			'umount',
-			$eventHandler,
-			'umount'
-		);
-		Util::connectHook(
-			Filesystem::CLASSNAME,
-			'post_umount',
-			$eventHandler,
-			'post_umount'
-		);
-
-		//Delete the mountpoint
-		$view = new View('/' . $this->user . '/files');
-		$this->assertEquals('foo', $view->rmdir('mount'));
-	}
-
-	public static function mimeFilterProvider(): array {
-		return [
-			[null, ['test1.txt', 'test2.txt', 'test3.md', 'test4.png']],
-			['text/plain', ['test1.txt', 'test2.txt']],
-			['text/markdown', ['test3.md']],
-			['text', ['test1.txt', 'test2.txt', 'test3.md']],
-		];
-	}
-
-	/**
-	 * @param string $filter
-	 * @param string[] $expected
-	 * @dataProvider mimeFilterProvider
-	 */
-	public function testGetDirectoryContentMimeFilter($filter, $expected): void {
-		$storage1 = new Temporary();
-		$root = self::getUniqueID('/');
-		Filesystem::mount($storage1, [], $root . '/');
-		$view = new View($root);
-
-		$view->file_put_contents('test1.txt', 'asd');
-		$view->file_put_contents('test2.txt', 'asd');
-		$view->file_put_contents('test3.md', 'asd');
-		$view->file_put_contents('test4.png', '');
-
-		$content = $view->getDirectoryContent('', $filter);
-
-		$files = array_map(function (FileInfo $info) {
-			return $info->getName();
-		}, $content);
-		sort($files);
-
-		$this->assertEquals($expected, $files);
-	}
-
-	public function testFilePutContentsClearsChecksum(): void {
-		$storage = new Temporary([]);
-		$scanner = $storage->getScanner();
-		$storage->file_put_contents('foo.txt', 'bar');
-		Filesystem::mount($storage, [], '/test/');
-		$scanner->scan('');
-
-		$view = new View('/test/foo.txt');
-		$view->putFileInfo('.', ['checksum' => '42']);
-
-		$this->assertEquals('bar', $view->file_get_contents(''));
-		$fh = tmpfile();
-		fwrite($fh, 'fooo');
-		rewind($fh);
-		clearstatcache();
-		$view->file_put_contents('', $fh);
-		$this->assertEquals('fooo', $view->file_get_contents(''));
-		$data = $view->getFileInfo('.');
-		$this->assertEquals('', $data->getChecksum());
-	}
-
-	public function testDeleteGhostFile(): void {
-		$storage = new Temporary([]);
-		$scanner = $storage->getScanner();
-		$cache = $storage->getCache();
-		$storage->file_put_contents('foo.txt', 'bar');
-		Filesystem::mount($storage, [], '/test/');
-		$scanner->scan('');
-
-		$storage->unlink('foo.txt');
-
-		$this->assertTrue($cache->inCache('foo.txt'));
-
-		$view = new View('/test');
-		$rootInfo = $view->getFileInfo('');
-		$this->assertEquals(3, $rootInfo->getSize());
-		$view->unlink('foo.txt');
-		$newInfo = $view->getFileInfo('');
-
-		$this->assertFalse($cache->inCache('foo.txt'));
-		$this->assertNotEquals($rootInfo->getEtag(), $newInfo->getEtag());
-		$this->assertEquals(0, $newInfo->getSize());
-	}
-
-	public function testDeleteGhostFolder(): void {
-		$storage = new Temporary([]);
-		$scanner = $storage->getScanner();
-		$cache = $storage->getCache();
-		$storage->mkdir('foo');
-		$storage->file_put_contents('foo/foo.txt', 'bar');
-		Filesystem::mount($storage, [], '/test/');
-		$scanner->scan('');
-
-		$storage->rmdir('foo');
-
-		$this->assertTrue($cache->inCache('foo'));
-		$this->assertTrue($cache->inCache('foo/foo.txt'));
-
-		$view = new View('/test');
-		$rootInfo = $view->getFileInfo('');
-		$this->assertEquals(3, $rootInfo->getSize());
-		$view->rmdir('foo');
-		$newInfo = $view->getFileInfo('');
-
-		$this->assertFalse($cache->inCache('foo'));
-		$this->assertFalse($cache->inCache('foo/foo.txt'));
-		$this->assertNotEquals($rootInfo->getEtag(), $newInfo->getEtag());
-		$this->assertEquals(0, $newInfo->getSize());
-	}
-
-	public function testCreateParentDirectories(): void {
-		$view = $this->getMockBuilder(View::class)
-			->disableOriginalConstructor()
-			->onlyMethods([
-				'is_file',
-				'file_exists',
-				'mkdir',
-			])
-			->getMock();
-
-		$view->expects($this->exactly(3))
-			->method('is_file')
-			->willReturnMap([
-				['/new', false],
-				['/new/folder', false],
-				['/new/folder/structure', false],
-			]);
-		$view->expects($this->exactly(3))
-			->method('file_exists')
-			->willReturnMap([
-				['/new', true],
-				['/new/folder', false],
-				['/new/folder/structure', false],
-			]);
-
-		$calls = ['/new/folder', '/new/folder/structure'];
-		$view->expects($this->exactly(2))
-			->method('mkdir')
-			->willReturnCallback(function ($dir) use (&$calls) {
-				$expected = array_shift($calls);
-				$this->assertEquals($expected, $dir);
-			});
-
-		$this->assertTrue(self::invokePrivate($view, 'createParentDirectories', ['/new/folder/structure']));
-	}
-
-	public function testCreateParentDirectoriesWithExistingFile(): void {
-		$view = $this->getMockBuilder(View::class)
-			->disableOriginalConstructor()
-			->onlyMethods([
-				'is_file',
-				'file_exists',
-				'mkdir',
-			])
-			->getMock();
-
-		$view
-			->expects($this->once())
-			->method('is_file')
-			->with('/file.txt')
-			->willReturn(true);
-		$this->assertFalse(self::invokePrivate($view, 'createParentDirectories', ['/file.txt/folder/structure']));
-	}
-
-	public function testCacheExtension(): void {
-		$storage = new Temporary([]);
-		$scanner = $storage->getScanner();
-		$storage->file_put_contents('foo.txt', 'bar');
-		$scanner->scan('');
-
-		Filesystem::mount($storage, [], '/test/');
-		$view = new View('/test');
-
-		$info = $view->getFileInfo('/foo.txt');
-		$this->assertEquals(0, $info->getUploadTime());
-		$this->assertEquals(0, $info->getCreationTime());
-
-		$view->putFileInfo('/foo.txt', ['upload_time' => 25]);
-
-		$info = $view->getFileInfo('/foo.txt');
-		$this->assertEquals(25, $info->getUploadTime());
-		$this->assertEquals(0, $info->getCreationTime());
-	}
-
-	public function testFopenGone(): void {
-		$storage = new Temporary([]);
-		$scanner = $storage->getScanner();
-		$storage->file_put_contents('foo.txt', 'bar');
-		$scanner->scan('');
-		$cache = $storage->getCache();
-
-		Filesystem::mount($storage, [], '/test/');
-		$view = new View('/test');
-
-		$storage->unlink('foo.txt');
-
-		$this->assertTrue($cache->inCache('foo.txt'));
-
-		$this->assertFalse($view->fopen('foo.txt', 'r'));
-
-		$this->assertFalse($cache->inCache('foo.txt'));
-	}
-
-	public function testMountpointParentsCreated(): void {
-		$storage1 = $this->getTestStorage();
-		Filesystem::mount($storage1, [], '/');
-
-		$storage2 = $this->getTestStorage();
-		Filesystem::mount($storage2, [], '/A/B/C');
-
-		$rootView = new View('');
-
-		$folderData = $rootView->getDirectoryContent('/');
-		$this->assertCount(4, $folderData);
-		$this->assertEquals('folder', $folderData[0]['name']);
-		$this->assertEquals('foo.png', $folderData[1]['name']);
-		$this->assertEquals('foo.txt', $folderData[2]['name']);
-		$this->assertEquals('A', $folderData[3]['name']);
-
-		$folderData = $rootView->getDirectoryContent('/A');
-		$this->assertCount(1, $folderData);
-		$this->assertEquals('B', $folderData[0]['name']);
-
-		$folderData = $rootView->getDirectoryContent('/A/B');
-		$this->assertCount(1, $folderData);
-		$this->assertEquals('C', $folderData[0]['name']);
-
-		$folderData = $rootView->getDirectoryContent('/A/B/C');
-		$this->assertCount(3, $folderData);
-		$this->assertEquals('folder', $folderData[0]['name']);
-		$this->assertEquals('foo.png', $folderData[1]['name']);
-		$this->assertEquals('foo.txt', $folderData[2]['name']);
-	}
-
-	public function testCopyPreservesContent() {
-		$viewUser1 = new View('/' . 'userId' . '/files');
-		$viewUser1->mkdir('');
-		$viewUser1->file_put_contents('foo.txt', 'foo');
-		$viewUser1->copy('foo.txt', 'bar.txt');
-		$this->assertEquals('foo', $viewUser1->file_get_contents('bar.txt'));
-	}
+        $folderName = 'abcdefghijklmnopqrstuvwxyz012345678901234567890123456789';
+        $tmpdirLength = strlen(\OC::$server->getTempManager()->getTemporaryFolder());
+        if (\OC_Util::runningOnMac()) {
+            $depth = ((1024 - $tmpdirLength) / 57);
+        } else {
+            $depth = ((4000 - $tmpdirLength) / 57);
+        }
+        foreach (range(0, $depth - 1) as $i) {
+            $longPath .= $ds . $folderName;
+            $result = $rootView->mkdir($longPath);
+            $this->assertTrue($result, "mkdir failed on $i - path length: " . strlen($longPath));
+
+            $result = $rootView->file_put_contents($longPath . "{$ds}test.txt", 'lorem');
+            $this->assertEquals(5, $result, "file_put_contents failed on $i");
+
+            $this->assertTrue($rootView->file_exists($longPath));
+            $this->assertTrue($rootView->file_exists($longPath . "{$ds}test.txt"));
+        }
+
+        $cache = $storage->getCache();
+        $scanner = $storage->getScanner();
+        $scanner->scan('');
+
+        $longPath = $folderName;
+        foreach (range(0, $depth - 1) as $i) {
+            $cachedFolder = $cache->get($longPath);
+            $this->assertTrue(is_array($cachedFolder), "No cache entry for folder at $i");
+            $this->assertEquals($folderName, $cachedFolder['name'], "Wrong cache entry for folder at $i");
+
+            $cachedFile = $cache->get($longPath . '/test.txt');
+            $this->assertTrue(is_array($cachedFile), "No cache entry for file at $i");
+            $this->assertEquals('test.txt', $cachedFile['name'], "Wrong cache entry for file at $i");
+
+            $longPath .= $ds . $folderName;
+        }
+    }
+
+    public function testTouchNotSupported(): void {
+        $storage = new TemporaryNoTouch([]);
+        $scanner = $storage->getScanner();
+        Filesystem::mount($storage, [], '/test/');
+        $past = time() - 100;
+        $storage->file_put_contents('test', 'foobar');
+        $scanner->scan('');
+        $view = new View('');
+        $info = $view->getFileInfo('/test/test');
+
+        $view->touch('/test/test', $past);
+        $scanner->scanFile('test', \OC\Files\Cache\Scanner::REUSE_ETAG);
+
+        $info2 = $view->getFileInfo('/test/test');
+        $this->assertSame($info['etag'], $info2['etag']);
+    }
+
+    public function testWatcherEtagCrossStorage(): void {
+        $storage1 = new Temporary([]);
+        $storage2 = new Temporary([]);
+        $scanner1 = $storage1->getScanner();
+        $scanner2 = $storage2->getScanner();
+        $storage1->mkdir('sub');
+        Filesystem::mount($storage1, [], '/test/');
+        Filesystem::mount($storage2, [], '/test/sub/storage');
+
+        $past = time() - 100;
+        $storage2->file_put_contents('test.txt', 'foobar');
+        $scanner1->scan('');
+        $scanner2->scan('');
+        $view = new View('');
+
+        $storage2->getWatcher('')->setPolicy(Watcher::CHECK_ALWAYS);
+
+        $oldFileInfo = $view->getFileInfo('/test/sub/storage/test.txt');
+        $oldFolderInfo = $view->getFileInfo('/test');
+
+        $storage2->getCache()->update($oldFileInfo->getId(), [
+            'storage_mtime' => $past,
+        ]);
+
+        $oldEtag = $oldFolderInfo->getEtag();
+
+        $view->getFileInfo('/test/sub/storage/test.txt');
+        $newFolderInfo = $view->getFileInfo('/test');
+
+        $this->assertNotEquals($newFolderInfo->getEtag(), $oldEtag);
+    }
+
+    /**
+     * @dataProvider absolutePathProvider
+     */
+    public function testGetAbsolutePath($expectedPath, $relativePath): void {
+        $view = new View('/files');
+        $this->assertEquals($expectedPath, $view->getAbsolutePath($relativePath));
+    }
+
+    public function testPartFileInfo(): void {
+        $storage = new Temporary([]);
+        $scanner = $storage->getScanner();
+        Filesystem::mount($storage, [], '/test/');
+        $sizeWritten = $storage->file_put_contents('test.part', 'foobar');
+        $scanner->scan('');
+        $view = new View('/test');
+        $info = $view->getFileInfo('test.part');
+
+        $this->assertInstanceOf('\OCP\Files\FileInfo', $info);
+        $this->assertNull($info->getId());
+        $this->assertEquals(6, $sizeWritten);
+        $this->assertEquals(6, $info->getSize());
+        $this->assertEquals('foobar', $view->file_get_contents('test.part'));
+    }
+
+    public static function absolutePathProvider(): array {
+        return [
+            ['/files/', ''],
+            ['/files/0', '0'],
+            ['/files/false', 'false'],
+            ['/files/true', 'true'],
+            ['/files/', '/'],
+            ['/files/test', 'test'],
+            ['/files/test', '/test'],
+        ];
+    }
+
+    /**
+     * @dataProvider chrootRelativePathProvider
+     */
+    public function testChrootGetRelativePath($root, $absolutePath, $expectedPath): void {
+        $view = new View('/files');
+        $view->chroot($root);
+        $this->assertEquals($expectedPath, $view->getRelativePath($absolutePath));
+    }
+
+    public static function chrootRelativePathProvider(): array {
+        return self::relativePathProvider('/');
+    }
+
+    /**
+     * @dataProvider initRelativePathProvider
+     */
+    public function testInitGetRelativePath($root, $absolutePath, $expectedPath): void {
+        $view = new View($root);
+        $this->assertEquals($expectedPath, $view->getRelativePath($absolutePath));
+    }
+
+    public static function initRelativePathProvider(): array {
+        return self::relativePathProvider(null);
+    }
+
+    public static function relativePathProvider($missingRootExpectedPath): array {
+        return [
+            // No root - returns the path
+            ['', '/files', '/files'],
+            ['', '/files/', '/files/'],
+
+            // Root equals path - /
+            ['/files/', '/files/', '/'],
+            ['/files/', '/files', '/'],
+            ['/files', '/files/', '/'],
+            ['/files', '/files', '/'],
+
+            // False negatives: chroot fixes those by adding the leading slash.
+            // But setting them up with this root (instead of chroot($root))
+            // will fail them, although they should be the same.
+            // TODO init should be fixed, so it also adds the leading slash
+            ['files/', '/files/', $missingRootExpectedPath],
+            ['files', '/files/', $missingRootExpectedPath],
+            ['files/', '/files', $missingRootExpectedPath],
+            ['files', '/files', $missingRootExpectedPath],
+
+            // False negatives: Paths provided to the method should have a leading slash
+            // TODO input should be checked to have a leading slash
+            ['/files/', 'files/', null],
+            ['/files', 'files/', null],
+            ['/files/', 'files', null],
+            ['/files', 'files', null],
+
+            // with trailing slashes
+            ['/files/', '/files/0', '0'],
+            ['/files/', '/files/false', 'false'],
+            ['/files/', '/files/true', 'true'],
+            ['/files/', '/files/test', 'test'],
+            ['/files/', '/files/test/foo', 'test/foo'],
+
+            // without trailing slashes
+            // TODO false expectation: Should match "with trailing slashes"
+            ['/files', '/files/0', '/0'],
+            ['/files', '/files/false', '/false'],
+            ['/files', '/files/true', '/true'],
+            ['/files', '/files/test', '/test'],
+            ['/files', '/files/test/foo', '/test/foo'],
+
+            // leading slashes
+            ['/files/', '/files_trashbin/', null],
+            ['/files', '/files_trashbin/', null],
+            ['/files/', '/files_trashbin', null],
+            ['/files', '/files_trashbin', null],
+
+            // no leading slashes
+            ['files/', 'files_trashbin/', null],
+            ['files', 'files_trashbin/', null],
+            ['files/', 'files_trashbin', null],
+            ['files', 'files_trashbin', null],
+
+            // mixed leading slashes
+            ['files/', '/files_trashbin/', null],
+            ['/files/', 'files_trashbin/', null],
+            ['files', '/files_trashbin/', null],
+            ['/files', 'files_trashbin/', null],
+            ['files/', '/files_trashbin', null],
+            ['/files/', 'files_trashbin', null],
+            ['files', '/files_trashbin', null],
+            ['/files', 'files_trashbin', null],
+
+            ['files', 'files_trashbin/test', null],
+            ['/files', '/files_trashbin/test', null],
+            ['/files', 'files_trashbin/test', null],
+        ];
+    }
+
+    public function testFileView(): void {
+        $storage = new Temporary([]);
+        $scanner = $storage->getScanner();
+        $storage->file_put_contents('foo.txt', 'bar');
+        Filesystem::mount($storage, [], '/test/');
+        $scanner->scan('');
+        $view = new View('/test/foo.txt');
+
+        $this->assertEquals('bar', $view->file_get_contents(''));
+        $fh = tmpfile();
+        fwrite($fh, 'foo');
+        rewind($fh);
+        $view->file_put_contents('', $fh);
+        $this->assertEquals('foo', $view->file_get_contents(''));
+    }
+
+    /**
+     * @dataProvider tooLongPathDataProvider
+     */
+    public function testTooLongPath($operation, $param0 = null): void {
+        $this->expectException(\OCP\Files\InvalidPathException::class);
+
+
+        $longPath = '';
+        // 4000 is the maximum path length in file_cache.path
+        $folderName = 'abcdefghijklmnopqrstuvwxyz012345678901234567890123456789';
+        $depth = (4000 / 57);
+        foreach (range(0, $depth + 1) as $i) {
+            $longPath .= '/' . $folderName;
+        }
+
+        $storage = new Temporary([]);
+        $this->tempStorage = $storage; // for later hard cleanup
+        Filesystem::mount($storage, [], '/');
+
+        $rootView = new View('');
+
+        if ($param0 === '@0') {
+            $param0 = $longPath;
+        }
+
+        if ($operation === 'hash') {
+            $param0 = $longPath;
+            $longPath = 'md5';
+        }
+
+        call_user_func([$rootView, $operation], $longPath, $param0);
+    }
+
+    public static function tooLongPathDataProvider(): array {
+        return [
+            ['getAbsolutePath'],
+            ['getRelativePath'],
+            ['getMountPoint'],
+            ['resolvePath'],
+            ['getLocalFile'],
+            ['mkdir'],
+            ['rmdir'],
+            ['opendir'],
+            ['is_dir'],
+            ['is_file'],
+            ['stat'],
+            ['filetype'],
+            ['filesize'],
+            ['readfile'],
+            ['isCreatable'],
+            ['isReadable'],
+            ['isUpdatable'],
+            ['isDeletable'],
+            ['isSharable'],
+            ['file_exists'],
+            ['filemtime'],
+            ['touch'],
+            ['file_get_contents'],
+            ['unlink'],
+            ['deleteAll'],
+            ['toTmpFile'],
+            ['getMimeType'],
+            ['free_space'],
+            ['getFileInfo'],
+            ['getDirectoryContent'],
+            ['getOwner'],
+            ['getETag'],
+            ['file_put_contents', 'ipsum'],
+            ['rename', '@0'],
+            ['copy', '@0'],
+            ['fopen', 'r'],
+            ['fromTmpFile', '@0'],
+            ['hash'],
+            ['hasUpdated', 0],
+            ['putFileInfo', []],
+        ];
+    }
+
+    public function testRenameCrossStoragePreserveMtime(): void {
+        $storage1 = new Temporary([]);
+        $storage2 = new Temporary([]);
+        $storage1->mkdir('sub');
+        $storage1->mkdir('foo');
+        $storage1->file_put_contents('foo.txt', 'asd');
+        $storage1->file_put_contents('foo/bar.txt', 'asd');
+        Filesystem::mount($storage1, [], '/test/');
+        Filesystem::mount($storage2, [], '/test/sub/storage');
+
+        $view = new View('');
+        $time = time() - 200;
+        $view->touch('/test/foo.txt', $time);
+        $view->touch('/test/foo', $time);
+        $view->touch('/test/foo/bar.txt', $time);
+
+        $view->rename('/test/foo.txt', '/test/sub/storage/foo.txt');
+
+        $this->assertEquals($time, $view->filemtime('/test/sub/storage/foo.txt'));
+
+        $view->rename('/test/foo', '/test/sub/storage/foo');
+
+        $this->assertEquals($time, $view->filemtime('/test/sub/storage/foo/bar.txt'));
+    }
+
+    public function testRenameFailDeleteTargetKeepSource(): void {
+        $this->doTestCopyRenameFail('rename');
+    }
+
+    public function testCopyFailDeleteTargetKeepSource(): void {
+        $this->doTestCopyRenameFail('copy');
+    }
+
+    private function doTestCopyRenameFail($operation) {
+        $storage1 = new Temporary([]);
+        /** @var \PHPUnit\Framework\MockObject\MockObject|Temporary $storage2 */
+        $storage2 = $this->getMockBuilder(TemporaryNoCross::class)
+            ->setConstructorArgs([[]])
+            ->onlyMethods(['fopen', 'writeStream'])
+            ->getMock();
+
+        $storage2->method('writeStream')
+            ->willThrowException(new GenericFileException('Failed to copy stream'));
+
+        $storage1->mkdir('sub');
+        $storage1->file_put_contents('foo.txt', '0123456789ABCDEFGH');
+        $storage1->mkdir('dirtomove');
+        $storage1->file_put_contents('dirtomove/indir1.txt', '0123456'); // fits
+        $storage1->file_put_contents('dirtomove/indir2.txt', '0123456789ABCDEFGH'); // doesn't fit
+        $storage2->file_put_contents('existing.txt', '0123');
+        $storage1->getScanner()->scan('');
+        $storage2->getScanner()->scan('');
+        Filesystem::mount($storage1, [], '/test/');
+        Filesystem::mount($storage2, [], '/test/sub/storage');
+
+        // move file
+        $view = new View('');
+        $this->assertTrue($storage1->file_exists('foo.txt'));
+        $this->assertFalse($storage2->file_exists('foo.txt'));
+        $this->assertFalse($view->$operation('/test/foo.txt', '/test/sub/storage/foo.txt'));
+        $this->assertFalse($storage2->file_exists('foo.txt'));
+        $this->assertFalse($storage2->getCache()->get('foo.txt'));
+        $this->assertTrue($storage1->file_exists('foo.txt'));
+
+        // if target exists, it will be deleted too
+        $this->assertFalse($view->$operation('/test/foo.txt', '/test/sub/storage/existing.txt'));
+        $this->assertFalse($storage2->file_exists('existing.txt'));
+        $this->assertFalse($storage2->getCache()->get('existing.txt'));
+        $this->assertTrue($storage1->file_exists('foo.txt'));
+
+        // move folder
+        $this->assertFalse($view->$operation('/test/dirtomove/', '/test/sub/storage/dirtomove/'));
+        // since the move failed, the full source tree is kept
+        $this->assertTrue($storage1->file_exists('dirtomove/indir1.txt'));
+        $this->assertTrue($storage1->file_exists('dirtomove/indir2.txt'));
+        // second file not moved/copied
+        $this->assertFalse($storage2->file_exists('dirtomove/indir2.txt'));
+        $this->assertFalse($storage2->getCache()->get('dirtomove/indir2.txt'));
+    }
+
+    public function testDeleteFailKeepCache(): void {
+        /** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
+        $storage = $this->getMockBuilder(Temporary::class)
+            ->setConstructorArgs([[]])
+            ->onlyMethods(['unlink'])
+            ->getMock();
+        $storage->expects($this->once())
+            ->method('unlink')
+            ->willReturn(false);
+        $scanner = $storage->getScanner();
+        $cache = $storage->getCache();
+        $storage->file_put_contents('foo.txt', 'asd');
+        $scanner->scan('');
+        Filesystem::mount($storage, [], '/test/');
+
+        $view = new View('/test');
+
+        $this->assertFalse($view->unlink('foo.txt'));
+        $this->assertTrue($cache->inCache('foo.txt'));
+    }
+
+    public static function directoryTraversalProvider(): array {
+        return [
+            ['../test/'],
+            ['..\\test\\my/../folder'],
+            ['/test/my/../foo\\'],
+        ];
+    }
+
+    /**
+     * @dataProvider directoryTraversalProvider
+     * @param string $root
+     */
+    public function testConstructDirectoryTraversalException($root): void {
+        $this->expectException(\Exception::class);
+
+        new View($root);
+    }
+
+    public function testRenameOverWrite(): void {
+        $storage = new Temporary([]);
+        $scanner = $storage->getScanner();
+        $storage->mkdir('sub');
+        $storage->mkdir('foo');
+        $storage->file_put_contents('foo.txt', 'asd');
+        $storage->file_put_contents('foo/bar.txt', 'asd');
+        $scanner->scan('');
+        Filesystem::mount($storage, [], '/test/');
+        $view = new View('');
+        $this->assertTrue($view->rename('/test/foo.txt', '/test/foo/bar.txt'));
+    }
+
+    public function testSetMountOptionsInStorage(): void {
+        $mount = new MountPoint(Temporary::class, '/asd/', [[]], Filesystem::getLoader(), ['foo' => 'bar']);
+        Filesystem::getMountManager()->addMount($mount);
+        /** @var \OC\Files\Storage\Common $storage */
+        $storage = $mount->getStorage();
+        $this->assertEquals($storage->getMountOption('foo'), 'bar');
+    }
+
+    public function testSetMountOptionsWatcherPolicy(): void {
+        $mount = new MountPoint(Temporary::class, '/asd/', [[]], Filesystem::getLoader(), ['filesystem_check_changes' => Watcher::CHECK_NEVER]);
+        Filesystem::getMountManager()->addMount($mount);
+        /** @var \OC\Files\Storage\Common $storage */
+        $storage = $mount->getStorage();
+        $watcher = $storage->getWatcher();
+        $this->assertEquals(Watcher::CHECK_NEVER, $watcher->getPolicy());
+    }
+
+    public function testGetAbsolutePathOnNull(): void {
+        $view = new View();
+        $this->assertNull($view->getAbsolutePath(null));
+    }
+
+    public function testGetRelativePathOnNull(): void {
+        $view = new View();
+        $this->assertNull($view->getRelativePath(null));
+    }
+
+
+    public function testNullAsRoot(): void {
+        $this->expectException(\TypeError::class);
+
+        new View(null);
+    }
+
+    /**
+     * e.g. reading from a folder that's being renamed
+     *
+     *
+     * @dataProvider dataLockPaths
+     *
+     * @param string $rootPath
+     * @param string $pathPrefix
+     */
+    public function testReadFromWriteLockedPath($rootPath, $pathPrefix): void {
+        $this->expectException(\OCP\Lock\LockedException::class);
+
+        $rootPath = str_replace('{folder}', 'files', $rootPath);
+        $pathPrefix = str_replace('{folder}', 'files', $pathPrefix);
+
+        $view = new View($rootPath);
+        $storage = new Temporary([]);
+        Filesystem::mount($storage, [], '/');
+        $this->assertTrue($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_EXCLUSIVE));
+        $view->lockFile($pathPrefix . '/foo/bar/asd', ILockingProvider::LOCK_SHARED);
+    }
+
+    /**
+     * Reading from a files_encryption folder that's being renamed
+     *
+     * @dataProvider dataLockPaths
+     *
+     * @param string $rootPath
+     * @param string $pathPrefix
+     */
+    public function testReadFromWriteUnlockablePath($rootPath, $pathPrefix): void {
+        $rootPath = str_replace('{folder}', 'files_encryption', $rootPath);
+        $pathPrefix = str_replace('{folder}', 'files_encryption', $pathPrefix);
+
+        $view = new View($rootPath);
+        $storage = new Temporary([]);
+        Filesystem::mount($storage, [], '/');
+        $this->assertFalse($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_EXCLUSIVE));
+        $this->assertFalse($view->lockFile($pathPrefix . '/foo/bar/asd', ILockingProvider::LOCK_SHARED));
+    }
+
+    /**
+     * e.g. writing a file that's being downloaded
+     *
+     *
+     * @dataProvider dataLockPaths
+     *
+     * @param string $rootPath
+     * @param string $pathPrefix
+     */
+    public function testWriteToReadLockedFile($rootPath, $pathPrefix): void {
+        $this->expectException(\OCP\Lock\LockedException::class);
+
+        $rootPath = str_replace('{folder}', 'files', $rootPath);
+        $pathPrefix = str_replace('{folder}', 'files', $pathPrefix);
+
+        $view = new View($rootPath);
+        $storage = new Temporary([]);
+        Filesystem::mount($storage, [], '/');
+        $this->assertTrue($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_SHARED));
+        $view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_EXCLUSIVE);
+    }
+
+    /**
+     * Writing a file that's being downloaded
+     *
+     * @dataProvider dataLockPaths
+     *
+     * @param string $rootPath
+     * @param string $pathPrefix
+     */
+    public function testWriteToReadUnlockableFile($rootPath, $pathPrefix): void {
+        $rootPath = str_replace('{folder}', 'files_encryption', $rootPath);
+        $pathPrefix = str_replace('{folder}', 'files_encryption', $pathPrefix);
+
+        $view = new View($rootPath);
+        $storage = new Temporary([]);
+        Filesystem::mount($storage, [], '/');
+        $this->assertFalse($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_SHARED));
+        $this->assertFalse($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_EXCLUSIVE));
+    }
+
+    /**
+     * Test that locks are on mount point paths instead of mount root
+     */
+    public function testLockLocalMountPointPathInsteadOfStorageRoot(): void {
+        $lockingProvider = \OC::$server->get(ILockingProvider::class);
+        $view = new View('/testuser/files/');
+        $storage = new Temporary([]);
+        Filesystem::mount($storage, [], '/');
+        $mountedStorage = new Temporary([]);
+        Filesystem::mount($mountedStorage, [], '/testuser/files/mountpoint');
+
+        $this->assertTrue(
+            $view->lockFile('/mountpoint', ILockingProvider::LOCK_EXCLUSIVE, true),
+            'Can lock mount point'
+        );
+
+        // no exception here because storage root was not locked
+        $mountedStorage->acquireLock('', ILockingProvider::LOCK_EXCLUSIVE, $lockingProvider);
+
+        $thrown = false;
+        try {
+            $storage->acquireLock('/testuser/files/mountpoint', ILockingProvider::LOCK_EXCLUSIVE, $lockingProvider);
+        } catch (LockedException $e) {
+            $thrown = true;
+        }
+        $this->assertTrue($thrown, 'Mount point path was locked on root storage');
+
+        $lockingProvider->releaseAll();
+    }
+
+    /**
+     * Test that locks are on mount point paths and also mount root when requested
+     */
+    public function testLockStorageRootButNotLocalMountPoint(): void {
+        $lockingProvider = \OC::$server->get(ILockingProvider::class);
+        $view = new View('/testuser/files/');
+        $storage = new Temporary([]);
+        Filesystem::mount($storage, [], '/');
+        $mountedStorage = new Temporary([]);
+        Filesystem::mount($mountedStorage, [], '/testuser/files/mountpoint');
+
+        $this->assertTrue(
+            $view->lockFile('/mountpoint', ILockingProvider::LOCK_EXCLUSIVE, false),
+            'Can lock mount point'
+        );
+
+        $thrown = false;
+        try {
+            $mountedStorage->acquireLock('', ILockingProvider::LOCK_EXCLUSIVE, $lockingProvider);
+        } catch (LockedException $e) {
+            $thrown = true;
+        }
+        $this->assertTrue($thrown, 'Mount point storage root was locked on original storage');
+
+        // local mount point was not locked
+        $storage->acquireLock('/testuser/files/mountpoint', ILockingProvider::LOCK_EXCLUSIVE, $lockingProvider);
+
+        $lockingProvider->releaseAll();
+    }
+
+    /**
+     * Test that locks are on mount point paths and also mount root when requested
+     */
+    public function testLockMountPointPathFailReleasesBoth(): void {
+        $lockingProvider = \OC::$server->get(ILockingProvider::class);
+        $view = new View('/testuser/files/');
+        $storage = new Temporary([]);
+        Filesystem::mount($storage, [], '/');
+        $mountedStorage = new Temporary([]);
+        Filesystem::mount($mountedStorage, [], '/testuser/files/mountpoint.txt');
+
+        // this would happen if someone is writing on the mount point
+        $mountedStorage->acquireLock('', ILockingProvider::LOCK_EXCLUSIVE, $lockingProvider);
+
+        $thrown = false;
+        try {
+            // this actually acquires two locks, one on the mount point and one on the storage root,
+            // but the one on the storage root will fail
+            $view->lockFile('/mountpoint.txt', ILockingProvider::LOCK_SHARED);
+        } catch (LockedException $e) {
+            $thrown = true;
+        }
+        $this->assertTrue($thrown, 'Cannot acquire shared lock because storage root is already locked');
+
+        // from here we expect that the lock on the local mount point was released properly
+        // so acquiring an exclusive lock will succeed
+        $storage->acquireLock('/testuser/files/mountpoint.txt', ILockingProvider::LOCK_EXCLUSIVE, $lockingProvider);
+
+        $lockingProvider->releaseAll();
+    }
+
+    public static function dataLockPaths(): array {
+        return [
+            ['/testuser/{folder}', ''],
+            ['/testuser', '/{folder}'],
+            ['', '/testuser/{folder}'],
+        ];
+    }
+
+    public static function pathRelativeToFilesProvider(): array {
+        return [
+            ['admin/files', ''],
+            ['admin/files/x', 'x'],
+            ['/admin/files', ''],
+            ['/admin/files/sub', 'sub'],
+            ['/admin/files/sub/', 'sub'],
+            ['/admin/files/sub/sub2', 'sub/sub2'],
+            ['//admin//files/sub//sub2', 'sub/sub2'],
+        ];
+    }
+
+    /**
+     * @dataProvider pathRelativeToFilesProvider
+     */
+    public function testGetPathRelativeToFiles($path, $expectedPath): void {
+        $view = new View();
+        $this->assertEquals($expectedPath, $view->getPathRelativeToFiles($path));
+    }
+
+    public static function pathRelativeToFilesProviderExceptionCases(): array {
+        return [
+            [''],
+            ['x'],
+            ['files'],
+            ['/files'],
+            ['/admin/files_versions/abc'],
+        ];
+    }
+
+    /**
+     * @dataProvider pathRelativeToFilesProviderExceptionCases
+     * @param string $path
+     */
+    public function testGetPathRelativeToFilesWithInvalidArgument($path): void {
+        $this->expectException(\InvalidArgumentException::class);
+        $this->expectExceptionMessage('$absolutePath must be relative to "files"');
+
+        $view = new View();
+        $view->getPathRelativeToFiles($path);
+    }
+
+    public function testChangeLock(): void {
+        $view = new View('/testuser/files/');
+        $storage = new Temporary([]);
+        Filesystem::mount($storage, [], '/');
+
+        $view->lockFile('/test/sub', ILockingProvider::LOCK_SHARED);
+        $this->assertTrue($this->isFileLocked($view, '/test//sub', ILockingProvider::LOCK_SHARED));
+        $this->assertFalse($this->isFileLocked($view, '/test//sub', ILockingProvider::LOCK_EXCLUSIVE));
+
+        $view->changeLock('//test/sub', ILockingProvider::LOCK_EXCLUSIVE);
+        $this->assertTrue($this->isFileLocked($view, '/test//sub', ILockingProvider::LOCK_EXCLUSIVE));
+
+        $view->changeLock('test/sub', ILockingProvider::LOCK_SHARED);
+        $this->assertTrue($this->isFileLocked($view, '/test//sub', ILockingProvider::LOCK_SHARED));
+
+        $view->unlockFile('/test/sub/', ILockingProvider::LOCK_SHARED);
+
+        $this->assertFalse($this->isFileLocked($view, '/test//sub', ILockingProvider::LOCK_SHARED));
+        $this->assertFalse($this->isFileLocked($view, '/test//sub', ILockingProvider::LOCK_EXCLUSIVE));
+    }
+
+    public static function hookPathProvider(): array {
+        return [
+            ['/foo/files', '/foo', true],
+            ['/foo/files/bar', '/foo', true],
+            ['/foo', '/foo', false],
+            ['/foo', '/files/foo', true],
+            ['/foo', 'filesfoo', false],
+            ['', '/foo/files', true],
+            ['', '/foo/files/bar.txt', true],
+        ];
+    }
+
+    /**
+     * @dataProvider hookPathProvider
+     * @param $root
+     * @param $path
+     * @param $shouldEmit
+     */
+    public function testHookPaths($root, $path, $shouldEmit): void {
+        $filesystemReflection = new \ReflectionClass(Filesystem::class);
+        $defaultRootValue = $filesystemReflection->getProperty('defaultInstance');
+        $defaultRootValue->setAccessible(true);
+        $oldRoot = $defaultRootValue->getValue();
+        $defaultView = new View('/foo/files');
+        $defaultRootValue->setValue(null, $defaultView);
+        $view = new View($root);
+        $result = self::invokePrivate($view, 'shouldEmitHooks', [$path]);
+        $defaultRootValue->setValue(null, $oldRoot);
+        $this->assertEquals($shouldEmit, $result);
+    }
+
+    /**
+     * Create test movable mount points
+     *
+     * @param array $mountPoints array of mount point locations
+     * @return array array of MountPoint objects
+     */
+    private function createTestMovableMountPoints($mountPoints) {
+        $mounts = [];
+        foreach ($mountPoints as $mountPoint) {
+            $storage = $this->getMockBuilder(Storage::class)
+                ->onlyMethods([])
+                ->getMock();
+            $storage->method('getId')->willReturn('non-null-id');
+            $storage->method('getStorageCache')->willReturnCallback(function () use ($storage) {
+                return new \OC\Files\Cache\Storage($storage, true, \OC::$server->get(IDBConnection::class));
+            });
+
+            $mounts[] = $this->getMockBuilder(TestMoveableMountPoint::class)
+                ->onlyMethods(['moveMount'])
+                ->setConstructorArgs([$storage, $mountPoint])
+                ->getMock();
+        }
+
+        /** @var IMountProvider|\PHPUnit\Framework\MockObject\MockObject $mountProvider */
+        $mountProvider = $this->createMock(IMountProvider::class);
+        $mountProvider->expects($this->any())
+            ->method('getMountsForUser')
+            ->willReturn($mounts);
+
+        $mountProviderCollection = \OC::$server->getMountProviderCollection();
+        $mountProviderCollection->registerProvider($mountProvider);
+
+        return $mounts;
+    }
+
+    /**
+     * Test mount point move
+     */
+    public function testMountPointMove(): void {
+        self::loginAsUser($this->user);
+
+        [$mount1, $mount2] = $this->createTestMovableMountPoints([
+            $this->user . '/files/mount1',
+            $this->user . '/files/mount2',
+        ]);
+        $mount1->expects($this->once())
+            ->method('moveMount')
+            ->willReturn(true);
+
+        $mount2->expects($this->once())
+            ->method('moveMount')
+            ->willReturn(true);
+
+        $view = new View('/' . $this->user . '/files/');
+        $view->mkdir('sub');
+
+        $this->assertTrue($view->rename('mount1', 'renamed_mount'), 'Can rename mount point');
+        $this->assertTrue($view->rename('mount2', 'sub/moved_mount'), 'Can move a mount point into a subdirectory');
+    }
+
+    public function testMoveMountPointOverwrite(): void {
+        self::loginAsUser($this->user);
+
+        [$mount1, $mount2] = $this->createTestMovableMountPoints([
+            $this->user . '/files/mount1',
+            $this->user . '/files/mount2',
+        ]);
+
+        $mount1->expects($this->never())
+            ->method('moveMount');
+
+        $mount2->expects($this->never())
+            ->method('moveMount');
+
+        $view = new View('/' . $this->user . '/files/');
+
+        $this->expectException(ForbiddenException::class);
+        $view->rename('mount1', 'mount2');
+    }
+
+    public function testMoveMountPointIntoMount(): void {
+        self::loginAsUser($this->user);
+
+        [$mount1, $mount2] = $this->createTestMovableMountPoints([
+            $this->user . '/files/mount1',
+            $this->user . '/files/mount2',
+        ]);
+
+        $mount1->expects($this->never())
+            ->method('moveMount');
+
+        $mount2->expects($this->never())
+            ->method('moveMount');
+
+        $view = new View('/' . $this->user . '/files/');
+
+        $this->expectException(ForbiddenException::class);
+        $view->rename('mount1', 'mount2/sub');
+    }
+
+    /**
+     * Test that moving a mount point into a shared folder is forbidden
+     */
+    public function testMoveMountPointIntoSharedFolder(): void {
+        self::loginAsUser($this->user);
+
+        [$mount1, $mount2] = $this->createTestMovableMountPoints([
+            $this->user . '/files/mount1',
+            $this->user . '/files/mount2',
+        ]);
+
+        $mount1->expects($this->never())
+            ->method('moveMount');
+
+        $mount2->expects($this->once())
+            ->method('moveMount')
+            ->willReturn(true);
+
+        $view = new View('/' . $this->user . '/files/');
+        $view->mkdir('shareddir');
+        $view->mkdir('shareddir/sub');
+        $view->mkdir('shareddir/sub2');
+        // Create a similar named but non-shared folder
+        $view->mkdir('shareddir notshared');
+
+        $fileId = $view->getFileInfo('shareddir')->getId();
+        $userObject = \OC::$server->getUserManager()->createUser('test2', 'IHateNonMockableStaticClasses');
+
+        $userFolder = \OC::$server->getUserFolder($this->user);
+        $shareDir = $userFolder->get('shareddir');
+        $shareManager = \OC::$server->get(IShareManager::class);
+        $share = $shareManager->newShare();
+        $share->setSharedWith('test2')
+            ->setSharedBy($this->user)
+            ->setShareType(IShare::TYPE_USER)
+            ->setPermissions(\OCP\Constants::PERMISSION_READ)
+            ->setNode($shareDir);
+        $shareManager->createShare($share);
+
+        try {
+            $view->rename('mount1', 'shareddir');
+            $this->fail('Cannot overwrite shared folder');
+        } catch (ForbiddenException $e) {
+
+        }
+        try {
+            $view->rename('mount1', 'shareddir/sub');
+            $this->fail('Cannot move mount point into shared folder');
+        } catch (ForbiddenException $e) {
+
+        }
+        try {
+            $view->rename('mount1', 'shareddir/sub/sub2');
+            $this->fail('Cannot move mount point into shared subfolder');
+        } catch (ForbiddenException $e) {
+
+        }
+        $this->assertTrue($view->rename('mount2', 'shareddir notshared/sub'), 'Can move mount point into a similarly named but non-shared folder');
+
+        $shareManager->deleteShare($share);
+        $userObject->delete();
+    }
+
+    public static function basicOperationProviderForLocks(): array {
+        return [
+            // --- write hook ----
+            [
+                'touch',
+                ['touch-create.txt'],
+                'touch-create.txt',
+                'create',
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_EXCLUSIVE,
+                ILockingProvider::LOCK_SHARED,
+            ],
+            [
+                'fopen',
+                ['test-write.txt', 'w'],
+                'test-write.txt',
+                'write',
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_EXCLUSIVE,
+                null,
+                // exclusive lock stays until fclose
+                ILockingProvider::LOCK_EXCLUSIVE,
+            ],
+            [
+                'mkdir',
+                ['newdir'],
+                'newdir',
+                'write',
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_EXCLUSIVE,
+                ILockingProvider::LOCK_SHARED,
+            ],
+            [
+                'file_put_contents',
+                ['file_put_contents.txt', 'blah'],
+                'file_put_contents.txt',
+                'write',
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_EXCLUSIVE,
+                ILockingProvider::LOCK_SHARED,
+                null,
+                0,
+            ],
+
+            // ---- delete hook ----
+            [
+                'rmdir',
+                ['dir'],
+                'dir',
+                'delete',
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_EXCLUSIVE,
+                ILockingProvider::LOCK_SHARED,
+            ],
+            [
+                'unlink',
+                ['test.txt'],
+                'test.txt',
+                'delete',
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_EXCLUSIVE,
+                ILockingProvider::LOCK_SHARED,
+            ],
+
+            // ---- read hook (no post hooks) ----
+            [
+                'file_get_contents',
+                ['test.txt'],
+                'test.txt',
+                'read',
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_SHARED,
+                null,
+                null,
+                false,
+            ],
+            [
+                'fopen',
+                ['test.txt', 'r'],
+                'test.txt',
+                'read',
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_SHARED,
+                null,
+            ],
+            [
+                'opendir',
+                ['dir'],
+                'dir',
+                'read',
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_SHARED,
+                null,
+            ],
+
+            // ---- no lock, touch hook ---
+            ['touch', ['test.txt'], 'test.txt', 'touch', null, null, null],
+
+            // ---- no hooks, no locks ---
+            ['is_dir', ['dir'], 'dir', null],
+            ['is_file', ['dir'], 'dir', null],
+            [
+                'stat',
+                ['dir'],
+                'dir',
+                null,
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_SHARED,
+                null,
+                false,
+            ],
+            [
+                'filetype',
+                ['dir'],
+                'dir',
+                null,
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_SHARED,
+                null,
+                false,
+            ],
+            [
+                'filesize',
+                ['dir'],
+                'dir',
+                null,
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_SHARED,
+                null,
+                /* Return an int */
+                100
+            ],
+            ['isCreatable', ['dir'], 'dir', null],
+            ['isReadable', ['dir'], 'dir', null],
+            ['isUpdatable', ['dir'], 'dir', null],
+            ['isDeletable', ['dir'], 'dir', null],
+            ['isSharable', ['dir'], 'dir', null],
+            ['file_exists', ['dir'], 'dir', null],
+            [
+                'filemtime',
+                ['dir'],
+                'dir',
+                null,
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_SHARED,
+                ILockingProvider::LOCK_SHARED,
+                null,
+                false,
+            ],
+        ];
+    }
+
+    /**
+     * Test whether locks are set before and after the operation
+     *
+     * @dataProvider basicOperationProviderForLocks
+     *
+     * @param string $operation operation name on the view
+     * @param array $operationArgs arguments for the operation
+     * @param string $lockedPath path of the locked item to check
+     * @param string $hookType hook type
+     * @param int $expectedLockBefore expected lock during pre hooks
+     * @param int $expectedLockDuring expected lock during operation
+     * @param int $expectedLockAfter expected lock during post hooks
+     * @param int $expectedStrayLock expected lock after returning, should
+     *                               be null (unlock) for most operations
+     */
+    public function testLockBasicOperation(
+        $operation,
+        $operationArgs,
+        $lockedPath,
+        $hookType,
+        $expectedLockBefore = ILockingProvider::LOCK_SHARED,
+        $expectedLockDuring = ILockingProvider::LOCK_SHARED,
+        $expectedLockAfter = ILockingProvider::LOCK_SHARED,
+        $expectedStrayLock = null,
+        $returnValue = true,
+    ): void {
+        $view = new View('/' . $this->user . '/files/');
+
+        /** @var Temporary&MockObject $storage */
+        $storage = $this->getMockBuilder(Temporary::class)
+            ->onlyMethods([$operation])
+            ->getMock();
+
+        /* Pause trash to avoid the trashbin intercepting rmdir and unlink calls */
+        Server::get(ITrashManager::class)->pauseTrash();
+        /* Same thing with encryption wrapper */
+        Server::get(IStorageFactory::class)->removeStorageWrapper('oc_encryption');
+
+        Filesystem::mount($storage, [], $this->user . '/');
+
+        // work directly on disk because mkdir might be mocked
+        $realPath = $storage->getSourcePath('');
+        mkdir($realPath . '/files');
+        mkdir($realPath . '/files/dir');
+        file_put_contents($realPath . '/files/test.txt', 'blah');
+        $storage->getScanner()->scan('files');
+
+        $storage->expects($this->once())
+            ->method($operation)
+            ->willReturnCallback(
+                function () use ($view, $lockedPath, &$lockTypeDuring, $returnValue) {
+                    $lockTypeDuring = $this->getFileLockType($view, $lockedPath);
+
+                    return $returnValue;
+                }
+            );
+
+        $this->assertNull($this->getFileLockType($view, $lockedPath), 'File not locked before operation');
+
+        $this->connectMockHooks($hookType, $view, $lockedPath, $lockTypePre, $lockTypePost);
+
+        // do operation
+        call_user_func_array([$view, $operation], $operationArgs);
+
+        if ($hookType !== null) {
+            $this->assertEquals($expectedLockBefore, $lockTypePre, 'File locked properly during pre-hook');
+            $this->assertEquals($expectedLockAfter, $lockTypePost, 'File locked properly during post-hook');
+            $this->assertEquals($expectedLockDuring, $lockTypeDuring, 'File locked properly during operation');
+        } else {
+            $this->assertNull($lockTypeDuring, 'File not locked during operation');
+        }
+
+        $this->assertEquals($expectedStrayLock, $this->getFileLockType($view, $lockedPath));
+
+        /* Resume trash to avoid side effects */
+        Server::get(ITrashManager::class)->resumeTrash();
+    }
+
+    /**
+     * Test locks for file_put_content with stream.
+     * This code path uses $storage->fopen instead
+     */
+    public function testLockFilePutContentWithStream(): void {
+        $view = new View('/' . $this->user . '/files/');
+
+        $path = 'test_file_put_contents.txt';
+        /** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
+        $storage = $this->getMockBuilder(Temporary::class)
+            ->onlyMethods(['fopen'])
+            ->getMock();
+
+        Filesystem::mount($storage, [], $this->user . '/');
+        $storage->mkdir('files');
+
+        $storage->expects($this->once())
+            ->method('fopen')
+            ->willReturnCallback(
+                function () use ($view, $path, &$lockTypeDuring) {
+                    $lockTypeDuring = $this->getFileLockType($view, $path);
+
+                    return fopen('php://temp', 'r+');
+                }
+            );
+
+        $this->connectMockHooks('write', $view, $path, $lockTypePre, $lockTypePost);
+
+        $this->assertNull($this->getFileLockType($view, $path), 'File not locked before operation');
+
+        // do operation
+        $view->file_put_contents($path, fopen('php://temp', 'r+'));
+
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypePre, 'File locked properly during pre-hook');
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypePost, 'File locked properly during post-hook');
+        $this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $lockTypeDuring, 'File locked properly during operation');
+
+        $this->assertNull($this->getFileLockType($view, $path));
+    }
+
+    /**
+     * Test locks for fopen with fclose at the end
+     */
+    public function testLockFopen(): void {
+        $view = new View('/' . $this->user . '/files/');
+
+        $path = 'test_file_put_contents.txt';
+        /** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
+        $storage = $this->getMockBuilder(Temporary::class)
+            ->onlyMethods(['fopen'])
+            ->getMock();
+
+        Filesystem::mount($storage, [], $this->user . '/');
+        $storage->mkdir('files');
+
+        $storage->expects($this->once())
+            ->method('fopen')
+            ->willReturnCallback(
+                function () use ($view, $path, &$lockTypeDuring) {
+                    $lockTypeDuring = $this->getFileLockType($view, $path);
+
+                    return fopen('php://temp', 'r+');
+                }
+            );
+
+        $this->connectMockHooks('write', $view, $path, $lockTypePre, $lockTypePost);
+
+        $this->assertNull($this->getFileLockType($view, $path), 'File not locked before operation');
+
+        // do operation
+        $res = $view->fopen($path, 'w');
+
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypePre, 'File locked properly during pre-hook');
+        $this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $lockTypeDuring, 'File locked properly during operation');
+        $this->assertNull($lockTypePost, 'No post hook, no lock check possible');
+
+        $this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $lockTypeDuring, 'File still locked after fopen');
+
+        fclose($res);
+
+        $this->assertNull($this->getFileLockType($view, $path), 'File unlocked after fclose');
+    }
+
+    /**
+     * Test locks for fopen with fclose at the end
+     *
+     * @dataProvider basicOperationProviderForLocks
+     *
+     * @param string $operation operation name on the view
+     * @param array $operationArgs arguments for the operation
+     * @param string $path path of the locked item to check
+     */
+    public function testLockBasicOperationUnlocksAfterException(
+        $operation,
+        $operationArgs,
+        $path,
+    ): void {
+        if ($operation === 'touch') {
+            $this->markTestSkipped('touch handles storage exceptions internally');
+        }
+        $view = new View('/' . $this->user . '/files/');
+
+        /** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
+        $storage = $this->getMockBuilder(Temporary::class)
+            ->onlyMethods([$operation])
+            ->getMock();
+
+        /* Pause trash to avoid the trashbin intercepting rmdir and unlink calls */
+        Server::get(ITrashManager::class)->pauseTrash();
+        /* Same thing with encryption wrapper */
+        Server::get(IStorageFactory::class)->removeStorageWrapper('oc_encryption');
+
+        Filesystem::mount($storage, [], $this->user . '/');
+
+        // work directly on disk because mkdir might be mocked
+        $realPath = $storage->getSourcePath('');
+        mkdir($realPath . '/files');
+        mkdir($realPath . '/files/dir');
+        file_put_contents($realPath . '/files/test.txt', 'blah');
+        $storage->getScanner()->scan('files');
+
+        $storage->expects($this->once())
+            ->method($operation)
+            ->willReturnCallback(
+                function () {
+                    throw new \Exception('Simulated exception');
+                }
+            );
+
+        $thrown = false;
+        try {
+            call_user_func_array([$view, $operation], $operationArgs);
+        } catch (\Exception $e) {
+            $thrown = true;
+            $this->assertEquals('Simulated exception', $e->getMessage());
+        }
+        $this->assertTrue($thrown, 'Exception was rethrown');
+        $this->assertNull($this->getFileLockType($view, $path), 'File got unlocked after exception');
+
+        /* Resume trash to avoid side effects */
+        Server::get(ITrashManager::class)->resumeTrash();
+    }
+
+    public function testLockBasicOperationUnlocksAfterLockException(): void {
+        $view = new View('/' . $this->user . '/files/');
+
+        $storage = new Temporary([]);
+
+        Filesystem::mount($storage, [], $this->user . '/');
+
+        $storage->mkdir('files');
+        $storage->mkdir('files/dir');
+        $storage->file_put_contents('files/test.txt', 'blah');
+        $storage->getScanner()->scan('files');
+
+        // get a shared lock
+        $handle = $view->fopen('test.txt', 'r');
+
+        $thrown = false;
+        try {
+            // try (and fail) to get a write lock
+            $view->unlink('test.txt');
+        } catch (\Exception $e) {
+            $thrown = true;
+            $this->assertInstanceOf(LockedException::class, $e);
+        }
+        $this->assertTrue($thrown, 'Exception was rethrown');
+
+        // clean shared lock
+        fclose($handle);
+
+        $this->assertNull($this->getFileLockType($view, 'test.txt'), 'File got unlocked');
+    }
+
+    /**
+     * Test locks for fopen with fclose at the end
+     *
+     * @dataProvider basicOperationProviderForLocks
+     *
+     * @param string $operation operation name on the view
+     * @param array $operationArgs arguments for the operation
+     * @param string $path path of the locked item to check
+     * @param string $hookType hook type
+     */
+    public function testLockBasicOperationUnlocksAfterCancelledHook(
+        $operation,
+        $operationArgs,
+        $path,
+        $hookType,
+    ): void {
+        $view = new View('/' . $this->user . '/files/');
+
+        /** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
+        $storage = $this->getMockBuilder(Temporary::class)
+            ->onlyMethods([$operation])
+            ->getMock();
+
+        Filesystem::mount($storage, [], $this->user . '/');
+        $storage->mkdir('files');
+
+        Util::connectHook(
+            Filesystem::CLASSNAME,
+            $hookType,
+            HookHelper::class,
+            'cancellingCallback'
+        );
+
+        call_user_func_array([$view, $operation], $operationArgs);
+
+        $this->assertNull($this->getFileLockType($view, $path), 'File got unlocked after exception');
+    }
+
+    public static function lockFileRenameOrCopyDataProvider(): array {
+        return [
+            ['rename', ILockingProvider::LOCK_EXCLUSIVE],
+            ['copy', ILockingProvider::LOCK_SHARED],
+        ];
+    }
+
+    /**
+     * Test locks for rename or copy operation
+     *
+     * @dataProvider lockFileRenameOrCopyDataProvider
+     *
+     * @param string $operation operation to be done on the view
+     * @param int $expectedLockTypeSourceDuring expected lock type on source file during
+     *                                          the operation
+     */
+    public function testLockFileRename($operation, $expectedLockTypeSourceDuring): void {
+        $view = new View('/' . $this->user . '/files/');
+
+        /** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
+        $storage = $this->getMockBuilder(Temporary::class)
+            ->onlyMethods([$operation, 'getMetaData', 'filemtime'])
+            ->getMock();
+
+        $storage->expects($this->any())
+            ->method('getMetaData')
+            ->will($this->returnValue([
+                'mtime' => 1885434487,
+                'etag' => '',
+                'mimetype' => 'text/plain',
+                'permissions' => Constants::PERMISSION_ALL,
+                'size' => 3
+            ]));
+        $storage->expects($this->any())
+            ->method('filemtime')
+            ->willReturn(123456789);
+
+        $sourcePath = 'original.txt';
+        $targetPath = 'target.txt';
+
+        /* Disable encryption wrapper to avoid it intercepting mocked call */
+        Server::get(IStorageFactory::class)->removeStorageWrapper('oc_encryption');
+
+        Filesystem::mount($storage, [], $this->user . '/');
+        $storage->mkdir('files');
+        $view->file_put_contents($sourcePath, 'meh');
+
+        $storage->expects($this->once())
+            ->method($operation)
+            ->willReturnCallback(
+                function () use ($view, $sourcePath, $targetPath, &$lockTypeSourceDuring, &$lockTypeTargetDuring) {
+                    $lockTypeSourceDuring = $this->getFileLockType($view, $sourcePath);
+                    $lockTypeTargetDuring = $this->getFileLockType($view, $targetPath);
+
+                    return true;
+                }
+            );
+
+        $this->connectMockHooks($operation, $view, $sourcePath, $lockTypeSourcePre, $lockTypeSourcePost);
+        $this->connectMockHooks($operation, $view, $targetPath, $lockTypeTargetPre, $lockTypeTargetPost);
+
+        $this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked before operation');
+        $this->assertNull($this->getFileLockType($view, $targetPath), 'Target file not locked before operation');
+
+        $view->$operation($sourcePath, $targetPath);
+
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeSourcePre, 'Source file locked properly during pre-hook');
+        $this->assertEquals($expectedLockTypeSourceDuring, $lockTypeSourceDuring, 'Source file locked properly during operation');
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeSourcePost, 'Source file locked properly during post-hook');
+
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeTargetPre, 'Target file locked properly during pre-hook');
+        $this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $lockTypeTargetDuring, 'Target file locked properly during operation');
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeTargetPost, 'Target file locked properly during post-hook');
+
+        $this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked after operation');
+        $this->assertNull($this->getFileLockType($view, $targetPath), 'Target file not locked after operation');
+    }
+
+    /**
+     * simulate a failed copy operation.
+     * We expect that we catch the exception, free the lock and re-throw it.
+     *
+     */
+    public function testLockFileCopyException(): void {
+        $this->expectException(\Exception::class);
+
+        $view = new View('/' . $this->user . '/files/');
+
+        /** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
+        $storage = $this->getMockBuilder(Temporary::class)
+            ->onlyMethods(['copy'])
+            ->getMock();
+
+        $sourcePath = 'original.txt';
+        $targetPath = 'target.txt';
+
+        /* Disable encryption wrapper to avoid it intercepting mocked call */
+        Server::get(IStorageFactory::class)->removeStorageWrapper('oc_encryption');
+
+        Filesystem::mount($storage, [], $this->user . '/');
+        $storage->mkdir('files');
+        $view->file_put_contents($sourcePath, 'meh');
+
+        $storage->expects($this->once())
+            ->method('copy')
+            ->willReturnCallback(
+                function () {
+                    throw new \Exception();
+                }
+            );
+
+        $this->connectMockHooks('copy', $view, $sourcePath, $lockTypeSourcePre, $lockTypeSourcePost);
+        $this->connectMockHooks('copy', $view, $targetPath, $lockTypeTargetPre, $lockTypeTargetPost);
+
+        $this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked before operation');
+        $this->assertNull($this->getFileLockType($view, $targetPath), 'Target file not locked before operation');
+
+        try {
+            $view->copy($sourcePath, $targetPath);
+        } catch (\Exception $e) {
+            $this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked after operation');
+            $this->assertNull($this->getFileLockType($view, $targetPath), 'Target file not locked after operation');
+            throw $e;
+        }
+    }
+
+    /**
+     * Test rename operation: unlock first path when second path was locked
+     */
+    public function testLockFileRenameUnlockOnException(): void {
+        self::loginAsUser('test');
+
+        $view = new View('/' . $this->user . '/files/');
+
+        $sourcePath = 'original.txt';
+        $targetPath = 'target.txt';
+        $view->file_put_contents($sourcePath, 'meh');
+
+        // simulate that the target path is already locked
+        $view->lockFile($targetPath, ILockingProvider::LOCK_EXCLUSIVE);
+
+        $this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked before operation');
+        $this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $this->getFileLockType($view, $targetPath), 'Target file is locked before operation');
+
+        $thrown = false;
+        try {
+            $view->rename($sourcePath, $targetPath);
+        } catch (LockedException $e) {
+            $thrown = true;
+        }
+
+        $this->assertTrue($thrown, 'LockedException thrown');
+
+        $this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked after operation');
+        $this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $this->getFileLockType($view, $targetPath), 'Target file still locked after operation');
+
+        $view->unlockFile($targetPath, ILockingProvider::LOCK_EXCLUSIVE);
+    }
+
+    /**
+     * Test rename operation: unlock first path when second path was locked
+     */
+    public function testGetOwner(): void {
+        self::loginAsUser('test');
+
+        $view = new View('/test/files/');
+
+        $path = 'foo.txt';
+        $view->file_put_contents($path, 'meh');
+
+        $this->assertEquals('test', $view->getFileInfo($path)->getOwner()->getUID());
+
+        $folderInfo = $view->getDirectoryContent('');
+        $folderInfo = array_values(array_filter($folderInfo, function (FileInfo $info) {
+            return $info->getName() === 'foo.txt';
+        }));
+
+        $this->assertEquals('test', $folderInfo[0]->getOwner()->getUID());
+
+        $subStorage = new Temporary();
+        Filesystem::mount($subStorage, [], '/test/files/asd');
+
+        $folderInfo = $view->getDirectoryContent('');
+        $folderInfo = array_values(array_filter($folderInfo, function (FileInfo $info) {
+            return $info->getName() === 'asd';
+        }));
+
+        $this->assertEquals('test', $folderInfo[0]->getOwner()->getUID());
+    }
+
+    public static function lockFileRenameOrCopyCrossStorageDataProvider(): array {
+        return [
+            ['rename', 'moveFromStorage', ILockingProvider::LOCK_EXCLUSIVE],
+            ['copy', 'copyFromStorage', ILockingProvider::LOCK_SHARED],
+        ];
+    }
+
+    /**
+     * Test locks for rename or copy operation cross-storage
+     *
+     * @dataProvider lockFileRenameOrCopyCrossStorageDataProvider
+     *
+     * @param string $viewOperation operation to be done on the view
+     * @param string $storageOperation operation to be mocked on the storage
+     * @param int $expectedLockTypeSourceDuring expected lock type on source file during
+     *                                          the operation
+     */
+    public function testLockFileRenameCrossStorage($viewOperation, $storageOperation, $expectedLockTypeSourceDuring): void {
+        $view = new View('/' . $this->user . '/files/');
+
+        /** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
+        $storage = $this->getMockBuilder(Temporary::class)
+            ->onlyMethods([$storageOperation])
+            ->getMock();
+        /** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage2 */
+        $storage2 = $this->getMockBuilder(Temporary::class)
+            ->onlyMethods([$storageOperation, 'getMetaData', 'filemtime'])
+            ->getMock();
+
+        $storage2->expects($this->any())
+            ->method('getMetaData')
+            ->will($this->returnValue([
+                'mtime' => 1885434487,
+                'etag' => '',
+                'mimetype' => 'text/plain',
+                'permissions' => Constants::PERMISSION_ALL,
+                'size' => 3
+            ]));
+        $storage2->expects($this->any())
+            ->method('filemtime')
+            ->willReturn(123456789);
+
+        $sourcePath = 'original.txt';
+        $targetPath = 'substorage/target.txt';
+
+        /* Disable encryption wrapper to avoid it intercepting mocked call */
+        Server::get(IStorageFactory::class)->removeStorageWrapper('oc_encryption');
+
+        Filesystem::mount($storage, [], $this->user . '/');
+        Filesystem::mount($storage2, [], $this->user . '/files/substorage');
+        $storage->mkdir('files');
+        $view->file_put_contents($sourcePath, 'meh');
+        $storage2->getUpdater()->update('');
+
+        $storage->expects($this->never())
+            ->method($storageOperation);
+        $storage2->expects($this->once())
+            ->method($storageOperation)
+            ->willReturnCallback(
+                function () use ($view, $sourcePath, $targetPath, &$lockTypeSourceDuring, &$lockTypeTargetDuring) {
+                    $lockTypeSourceDuring = $this->getFileLockType($view, $sourcePath);
+                    $lockTypeTargetDuring = $this->getFileLockType($view, $targetPath);
+
+                    return true;
+                }
+            );
+
+        $this->connectMockHooks($viewOperation, $view, $sourcePath, $lockTypeSourcePre, $lockTypeSourcePost);
+        $this->connectMockHooks($viewOperation, $view, $targetPath, $lockTypeTargetPre, $lockTypeTargetPost);
+
+        $this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked before operation');
+        $this->assertNull($this->getFileLockType($view, $targetPath), 'Target file not locked before operation');
+
+        $view->$viewOperation($sourcePath, $targetPath);
+
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeSourcePre, 'Source file locked properly during pre-hook');
+        $this->assertEquals($expectedLockTypeSourceDuring, $lockTypeSourceDuring, 'Source file locked properly during operation');
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeSourcePost, 'Source file locked properly during post-hook');
+
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeTargetPre, 'Target file locked properly during pre-hook');
+        $this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $lockTypeTargetDuring, 'Target file locked properly during operation');
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeTargetPost, 'Target file locked properly during post-hook');
+
+        $this->assertNull($this->getFileLockType($view, $sourcePath), 'Source file not locked after operation');
+        $this->assertNull($this->getFileLockType($view, $targetPath), 'Target file not locked after operation');
+    }
+
+    /**
+     * Test locks when moving a mount point
+     */
+    public function testLockMoveMountPoint(): void {
+        self::loginAsUser('test');
+
+        [$mount] = $this->createTestMovableMountPoints([
+            $this->user . '/files/substorage',
+        ]);
+
+        $view = new View('/' . $this->user . '/files/');
+        $view->mkdir('subdir');
+
+        $sourcePath = 'substorage';
+        $targetPath = 'subdir/substorage_moved';
+
+        $mount->expects($this->once())
+            ->method('moveMount')
+            ->willReturnCallback(
+                function ($target) use ($mount, $view, $sourcePath, $targetPath, &$lockTypeSourceDuring, &$lockTypeTargetDuring, &$lockTypeSharedRootDuring) {
+                    $lockTypeSourceDuring = $this->getFileLockType($view, $sourcePath, true);
+                    $lockTypeTargetDuring = $this->getFileLockType($view, $targetPath, true);
+
+                    $lockTypeSharedRootDuring = $this->getFileLockType($view, $sourcePath, false);
+
+                    $mount->setMountPoint($target);
+
+                    return true;
+                }
+            );
+
+        $this->connectMockHooks('rename', $view, $sourcePath, $lockTypeSourcePre, $lockTypeSourcePost, true);
+        $this->connectMockHooks('rename', $view, $targetPath, $lockTypeTargetPre, $lockTypeTargetPost, true);
+        // in pre-hook, mount point is still on $sourcePath
+        $this->connectMockHooks('rename', $view, $sourcePath, $lockTypeSharedRootPre, $dummy, false);
+        // in post-hook, mount point is now on $targetPath
+        $this->connectMockHooks('rename', $view, $targetPath, $dummy, $lockTypeSharedRootPost, false);
+
+        $this->assertNull($this->getFileLockType($view, $sourcePath, false), 'Shared storage root not locked before operation');
+        $this->assertNull($this->getFileLockType($view, $sourcePath, true), 'Source path not locked before operation');
+        $this->assertNull($this->getFileLockType($view, $targetPath, true), 'Target path not locked before operation');
+
+        $view->rename($sourcePath, $targetPath);
+
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeSourcePre, 'Source path locked properly during pre-hook');
+        $this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $lockTypeSourceDuring, 'Source path locked properly during operation');
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeSourcePost, 'Source path locked properly during post-hook');
+
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeTargetPre, 'Target path locked properly during pre-hook');
+        $this->assertEquals(ILockingProvider::LOCK_EXCLUSIVE, $lockTypeTargetDuring, 'Target path locked properly during operation');
+        $this->assertEquals(ILockingProvider::LOCK_SHARED, $lockTypeTargetPost, 'Target path locked properly during post-hook');
+
+        $this->assertNull($lockTypeSharedRootPre, 'Shared storage root not locked during pre-hook');
+        $this->assertNull($lockTypeSharedRootDuring, 'Shared storage root not locked during move');
+        $this->assertNull($lockTypeSharedRootPost, 'Shared storage root not locked during post-hook');
+
+        $this->assertNull($this->getFileLockType($view, $sourcePath, false), 'Shared storage root not locked after operation');
+        $this->assertNull($this->getFileLockType($view, $sourcePath, true), 'Source path not locked after operation');
+        $this->assertNull($this->getFileLockType($view, $targetPath, true), 'Target path not locked after operation');
+    }
+
+    /**
+     * Connect hook callbacks for hook type
+     *
+     * @param string $hookType hook type or null for none
+     * @param View $view view to check the lock on
+     * @param string $path path for which to check the lock
+     * @param int $lockTypePre variable to receive lock type that was active in the pre-hook
+     * @param int $lockTypePost variable to receive lock type that was active in the post-hook
+     * @param bool $onMountPoint true to check the mount point instead of the
+     *                           mounted storage
+     */
+    private function connectMockHooks($hookType, $view, $path, &$lockTypePre, &$lockTypePost, $onMountPoint = false) {
+        if ($hookType === null) {
+            return;
+        }
+
+        $eventHandler = $this->getMockBuilder(TestEventHandler::class)
+            ->onlyMethods(['preCallback', 'postCallback'])
+            ->getMock();
+
+        $eventHandler->expects($this->any())
+            ->method('preCallback')
+            ->willReturnCallback(
+                function () use ($view, $path, $onMountPoint, &$lockTypePre) {
+                    $lockTypePre = $this->getFileLockType($view, $path, $onMountPoint);
+                }
+            );
+        $eventHandler->expects($this->any())
+            ->method('postCallback')
+            ->willReturnCallback(
+                function () use ($view, $path, $onMountPoint, &$lockTypePost) {
+                    $lockTypePost = $this->getFileLockType($view, $path, $onMountPoint);
+                }
+            );
+
+        if ($hookType !== null) {
+            Util::connectHook(
+                Filesystem::CLASSNAME,
+                $hookType,
+                $eventHandler,
+                'preCallback'
+            );
+            Util::connectHook(
+                Filesystem::CLASSNAME,
+                'post_' . $hookType,
+                $eventHandler,
+                'postCallback'
+            );
+        }
+    }
+
+    /**
+     * Returns the file lock type
+     *
+     * @param View $view view
+     * @param string $path path
+     * @param bool $onMountPoint true to check the mount point instead of the
+     *                           mounted storage
+     *
+     * @return int lock type or null if file was not locked
+     */
+    private function getFileLockType(View $view, $path, $onMountPoint = false) {
+        if ($this->isFileLocked($view, $path, ILockingProvider::LOCK_EXCLUSIVE, $onMountPoint)) {
+            return ILockingProvider::LOCK_EXCLUSIVE;
+        } elseif ($this->isFileLocked($view, $path, ILockingProvider::LOCK_SHARED, $onMountPoint)) {
+            return ILockingProvider::LOCK_SHARED;
+        }
+        return null;
+    }
+
+
+    public function testRemoveMoveableMountPoint(): void {
+        $mountPoint = '/' . $this->user . '/files/mount/';
+
+        // Mock the mount point
+        /** @var TestMoveableMountPoint|\PHPUnit\Framework\MockObject\MockObject $mount */
+        $mount = $this->createMock(TestMoveableMountPoint::class);
+        $mount->expects($this->once())
+            ->method('getMountPoint')
+            ->willReturn($mountPoint);
+        $mount->expects($this->once())
+            ->method('removeMount')
+            ->willReturn('foo');
+        $mount->expects($this->any())
+            ->method('getInternalPath')
+            ->willReturn('');
+
+        // Register mount
+        Filesystem::getMountManager()->addMount($mount);
+
+        // Listen for events
+        $eventHandler = $this->getMockBuilder(TestEventHandler::class)
+            ->onlyMethods(['umount', 'post_umount'])
+            ->getMock();
+        $eventHandler->expects($this->once())
+            ->method('umount')
+            ->with([Filesystem::signal_param_path => '/mount']);
+        $eventHandler->expects($this->once())
+            ->method('post_umount')
+            ->with([Filesystem::signal_param_path => '/mount']);
+        Util::connectHook(
+            Filesystem::CLASSNAME,
+            'umount',
+            $eventHandler,
+            'umount'
+        );
+        Util::connectHook(
+            Filesystem::CLASSNAME,
+            'post_umount',
+            $eventHandler,
+            'post_umount'
+        );
+
+        //Delete the mountpoint
+        $view = new View('/' . $this->user . '/files');
+        $this->assertEquals('foo', $view->rmdir('mount'));
+    }
+
+    public static function mimeFilterProvider(): array {
+        return [
+            [null, ['test1.txt', 'test2.txt', 'test3.md', 'test4.png']],
+            ['text/plain', ['test1.txt', 'test2.txt']],
+            ['text/markdown', ['test3.md']],
+            ['text', ['test1.txt', 'test2.txt', 'test3.md']],
+        ];
+    }
+
+    /**
+     * @param string $filter
+     * @param string[] $expected
+     * @dataProvider mimeFilterProvider
+     */
+    public function testGetDirectoryContentMimeFilter($filter, $expected): void {
+        $storage1 = new Temporary();
+        $root = self::getUniqueID('/');
+        Filesystem::mount($storage1, [], $root . '/');
+        $view = new View($root);
+
+        $view->file_put_contents('test1.txt', 'asd');
+        $view->file_put_contents('test2.txt', 'asd');
+        $view->file_put_contents('test3.md', 'asd');
+        $view->file_put_contents('test4.png', '');
+
+        $content = $view->getDirectoryContent('', $filter);
+
+        $files = array_map(function (FileInfo $info) {
+            return $info->getName();
+        }, $content);
+        sort($files);
+
+        $this->assertEquals($expected, $files);
+    }
+
+    public function testFilePutContentsClearsChecksum(): void {
+        $storage = new Temporary([]);
+        $scanner = $storage->getScanner();
+        $storage->file_put_contents('foo.txt', 'bar');
+        Filesystem::mount($storage, [], '/test/');
+        $scanner->scan('');
+
+        $view = new View('/test/foo.txt');
+        $view->putFileInfo('.', ['checksum' => '42']);
+
+        $this->assertEquals('bar', $view->file_get_contents(''));
+        $fh = tmpfile();
+        fwrite($fh, 'fooo');
+        rewind($fh);
+        clearstatcache();
+        $view->file_put_contents('', $fh);
+        $this->assertEquals('fooo', $view->file_get_contents(''));
+        $data = $view->getFileInfo('.');
+        $this->assertEquals('', $data->getChecksum());
+    }
+
+    public function testDeleteGhostFile(): void {
+        $storage = new Temporary([]);
+        $scanner = $storage->getScanner();
+        $cache = $storage->getCache();
+        $storage->file_put_contents('foo.txt', 'bar');
+        Filesystem::mount($storage, [], '/test/');
+        $scanner->scan('');
+
+        $storage->unlink('foo.txt');
+
+        $this->assertTrue($cache->inCache('foo.txt'));
+
+        $view = new View('/test');
+        $rootInfo = $view->getFileInfo('');
+        $this->assertEquals(3, $rootInfo->getSize());
+        $view->unlink('foo.txt');
+        $newInfo = $view->getFileInfo('');
+
+        $this->assertFalse($cache->inCache('foo.txt'));
+        $this->assertNotEquals($rootInfo->getEtag(), $newInfo->getEtag());
+        $this->assertEquals(0, $newInfo->getSize());
+    }
+
+    public function testDeleteGhostFolder(): void {
+        $storage = new Temporary([]);
+        $scanner = $storage->getScanner();
+        $cache = $storage->getCache();
+        $storage->mkdir('foo');
+        $storage->file_put_contents('foo/foo.txt', 'bar');
+        Filesystem::mount($storage, [], '/test/');
+        $scanner->scan('');
+
+        $storage->rmdir('foo');
+
+        $this->assertTrue($cache->inCache('foo'));
+        $this->assertTrue($cache->inCache('foo/foo.txt'));
+
+        $view = new View('/test');
+        $rootInfo = $view->getFileInfo('');
+        $this->assertEquals(3, $rootInfo->getSize());
+        $view->rmdir('foo');
+        $newInfo = $view->getFileInfo('');
+
+        $this->assertFalse($cache->inCache('foo'));
+        $this->assertFalse($cache->inCache('foo/foo.txt'));
+        $this->assertNotEquals($rootInfo->getEtag(), $newInfo->getEtag());
+        $this->assertEquals(0, $newInfo->getSize());
+    }
+
+    public function testCreateParentDirectories(): void {
+        $view = $this->getMockBuilder(View::class)
+            ->disableOriginalConstructor()
+            ->onlyMethods([
+                'is_file',
+                'file_exists',
+                'mkdir',
+            ])
+            ->getMock();
+
+        $view->expects($this->exactly(3))
+            ->method('is_file')
+            ->willReturnMap([
+                ['/new', false],
+                ['/new/folder', false],
+                ['/new/folder/structure', false],
+            ]);
+        $view->expects($this->exactly(3))
+            ->method('file_exists')
+            ->willReturnMap([
+                ['/new', true],
+                ['/new/folder', false],
+                ['/new/folder/structure', false],
+            ]);
+
+        $calls = ['/new/folder', '/new/folder/structure'];
+        $view->expects($this->exactly(2))
+            ->method('mkdir')
+            ->willReturnCallback(function ($dir) use (&$calls) {
+                $expected = array_shift($calls);
+                $this->assertEquals($expected, $dir);
+            });
+
+        $this->assertTrue(self::invokePrivate($view, 'createParentDirectories', ['/new/folder/structure']));
+    }
+
+    public function testCreateParentDirectoriesWithExistingFile(): void {
+        $view = $this->getMockBuilder(View::class)
+            ->disableOriginalConstructor()
+            ->onlyMethods([
+                'is_file',
+                'file_exists',
+                'mkdir',
+            ])
+            ->getMock();
+
+        $view
+            ->expects($this->once())
+            ->method('is_file')
+            ->with('/file.txt')
+            ->willReturn(true);
+        $this->assertFalse(self::invokePrivate($view, 'createParentDirectories', ['/file.txt/folder/structure']));
+    }
+
+    public function testCacheExtension(): void {
+        $storage = new Temporary([]);
+        $scanner = $storage->getScanner();
+        $storage->file_put_contents('foo.txt', 'bar');
+        $scanner->scan('');
+
+        Filesystem::mount($storage, [], '/test/');
+        $view = new View('/test');
+
+        $info = $view->getFileInfo('/foo.txt');
+        $this->assertEquals(0, $info->getUploadTime());
+        $this->assertEquals(0, $info->getCreationTime());
+
+        $view->putFileInfo('/foo.txt', ['upload_time' => 25]);
+
+        $info = $view->getFileInfo('/foo.txt');
+        $this->assertEquals(25, $info->getUploadTime());
+        $this->assertEquals(0, $info->getCreationTime());
+    }
+
+    public function testFopenGone(): void {
+        $storage = new Temporary([]);
+        $scanner = $storage->getScanner();
+        $storage->file_put_contents('foo.txt', 'bar');
+        $scanner->scan('');
+        $cache = $storage->getCache();
+
+        Filesystem::mount($storage, [], '/test/');
+        $view = new View('/test');
+
+        $storage->unlink('foo.txt');
+
+        $this->assertTrue($cache->inCache('foo.txt'));
+
+        $this->assertFalse($view->fopen('foo.txt', 'r'));
+
+        $this->assertFalse($cache->inCache('foo.txt'));
+    }
+
+    public function testMountpointParentsCreated(): void {
+        $storage1 = $this->getTestStorage();
+        Filesystem::mount($storage1, [], '/');
+
+        $storage2 = $this->getTestStorage();
+        Filesystem::mount($storage2, [], '/A/B/C');
+
+        $rootView = new View('');
+
+        $folderData = $rootView->getDirectoryContent('/');
+        $this->assertCount(4, $folderData);
+        $this->assertEquals('folder', $folderData[0]['name']);
+        $this->assertEquals('foo.png', $folderData[1]['name']);
+        $this->assertEquals('foo.txt', $folderData[2]['name']);
+        $this->assertEquals('A', $folderData[3]['name']);
+
+        $folderData = $rootView->getDirectoryContent('/A');
+        $this->assertCount(1, $folderData);
+        $this->assertEquals('B', $folderData[0]['name']);
+
+        $folderData = $rootView->getDirectoryContent('/A/B');
+        $this->assertCount(1, $folderData);
+        $this->assertEquals('C', $folderData[0]['name']);
+
+        $folderData = $rootView->getDirectoryContent('/A/B/C');
+        $this->assertCount(3, $folderData);
+        $this->assertEquals('folder', $folderData[0]['name']);
+        $this->assertEquals('foo.png', $folderData[1]['name']);
+        $this->assertEquals('foo.txt', $folderData[2]['name']);
+    }
+
+    public function testCopyPreservesContent() {
+        $viewUser1 = new View('/' . 'userId' . '/files');
+        $viewUser1->mkdir('');
+        $viewUser1->file_put_contents('foo.txt', 'foo');
+        $viewUser1->copy('foo.txt', 'bar.txt');
+        $this->assertEquals('foo', $viewUser1->file_get_contents('bar.txt'));
+    }
 }

Spacing +90 added lines, -90 removed lines

@@ -143,7 +143,7 @@ 
 		}
 
 		if ($this->tempStorage) {
-			system('rm -rf ' . escapeshellarg($this->tempStorage->getDataDir()));
+			system('rm -rf '.escapeshellarg($this->tempStorage->getDataDir()));
 		}
 
 		self::logout();
@@ -169,11 +169,11 @@ 
 		$storage2 = $this->getTestStorage();
 		$storage3 = $this->getTestStorage();
 		$root = self::getUniqueID('/');
-		Filesystem::mount($storage1, [], $root . '/');
-		Filesystem::mount($storage2, [], $root . '/substorage');
-		Filesystem::mount($storage3, [], $root . '/folder/anotherstorage');
+		Filesystem::mount($storage1, [], $root.'/');
+		Filesystem::mount($storage2, [], $root.'/substorage');
+		Filesystem::mount($storage3, [], $root.'/folder/anotherstorage');
 		$textSize = strlen("dummy file data\n");
-		$imageSize = filesize(\OC::$SERVERROOT . '/core/img/logo/logo.png');
+		$imageSize = filesize(\OC::$SERVERROOT.'/core/img/logo/logo.png');
 		$storageSize = $textSize * 2 + $imageSize;
 
 		$storageInfo = $storage3->getCache()->get('');
@@ -230,7 +230,7 @@ 
 		$this->assertEquals('foo.png', $folderData[1]['name']);
 		$this->assertEquals('foo.txt', $folderData[2]['name']);
 
-		$folderView = new View($root . '/folder');
+		$folderView = new View($root.'/folder');
 		$this->assertEquals($rootView->getFileInfo('/folder'), $folderView->getFileInfo('/'));
 
 		$cachedData = $rootView->getFileInfo('/foo.txt');
@@ -519,10 +519,10 @@ 
 	}
 
 	public function moveBetweenStorages($storage1, $storage2) {
-		Filesystem::mount($storage1, [], '/' . $this->user . '/');
-		Filesystem::mount($storage2, [], '/' . $this->user . '/substorage');
+		Filesystem::mount($storage1, [], '/'.$this->user.'/');
+		Filesystem::mount($storage2, [], '/'.$this->user.'/substorage');
 
-		$rootView = new View('/' . $this->user);
+		$rootView = new View('/'.$this->user);
 		$rootView->rename('foo.txt', 'substorage/folder/foo.txt');
 		$this->assertFalse($rootView->file_exists('foo.txt'));
 		$this->assertTrue($rootView->file_exists('substorage/folder/foo.txt'));
@@ -646,11 +646,11 @@ 
 		$storage2 = $this->getTestStorage();
 		$defaultRoot = Filesystem::getRoot();
 		Filesystem::mount($storage1, [], '/');
-		Filesystem::mount($storage2, [], $defaultRoot . '/substorage');
+		Filesystem::mount($storage2, [], $defaultRoot.'/substorage');
 		\OC_Hook::connect('OC_Filesystem', 'post_write', $this, 'dummyHook');
 
 		$rootView = new View('');
-		$subView = new View($defaultRoot . '/substorage');
+		$subView = new View($defaultRoot.'/substorage');
 		$this->hookPath = null;
 
 		$rootView->file_put_contents('/foo.txt', 'asd');
@@ -690,7 +690,7 @@ 
 		 */
 		$storage = new $class([]);
 		$textData = "dummy file data\n";
-		$imgData = file_get_contents(\OC::$SERVERROOT . '/core/img/logo/logo.png');
+		$imgData = file_get_contents(\OC::$SERVERROOT.'/core/img/logo/logo.png');
 		$storage->mkdir('folder');
 		$storage->file_put_contents('foo.txt', $textData);
 		$storage->file_put_contents('foo.png', $imgData);
@@ -712,10 +712,10 @@ 
 		$storage2 = $this->getTestStorage();
 		$defaultRoot = Filesystem::getRoot();
 		Filesystem::mount($storage1, [], '/');
-		Filesystem::mount($storage2, [], $defaultRoot . '_substorage');
+		Filesystem::mount($storage2, [], $defaultRoot.'_substorage');
 		\OC_Hook::connect('OC_Filesystem', 'post_write', $this, 'dummyHook');
 
-		$subView = new View($defaultRoot . '_substorage');
+		$subView = new View($defaultRoot.'_substorage');
 		$this->hookPath = null;
 
 		$subView->file_put_contents('/foo.txt', 'asd');
@@ -810,7 +810,7 @@ 
 
 		$rootView = new View('');
 		foreach ($names as $name) {
-			$rootView->file_put_contents('/' . $name, 'dummy content');
+			$rootView->file_put_contents('/'.$name, 'dummy content');
 		}
 
 		$list = $rootView->getDirectoryContent('/');
@@ -852,15 +852,15 @@ 
 			$depth = ((4000 - $tmpdirLength) / 57);
 		}
 		foreach (range(0, $depth - 1) as $i) {
-			$longPath .= $ds . $folderName;
+			$longPath .= $ds.$folderName;
 			$result = $rootView->mkdir($longPath);
-			$this->assertTrue($result, "mkdir failed on $i - path length: " . strlen($longPath));
+			$this->assertTrue($result, "mkdir failed on $i - path length: ".strlen($longPath));
 
-			$result = $rootView->file_put_contents($longPath . "{$ds}test.txt", 'lorem');
+			$result = $rootView->file_put_contents($longPath."{$ds}test.txt", 'lorem');
 			$this->assertEquals(5, $result, "file_put_contents failed on $i");
 
 			$this->assertTrue($rootView->file_exists($longPath));
-			$this->assertTrue($rootView->file_exists($longPath . "{$ds}test.txt"));
+			$this->assertTrue($rootView->file_exists($longPath."{$ds}test.txt"));
 		}
 
 		$cache = $storage->getCache();
@@ -873,11 +873,11 @@ 
 			$this->assertTrue(is_array($cachedFolder), "No cache entry for folder at $i");
 			$this->assertEquals($folderName, $cachedFolder['name'], "Wrong cache entry for folder at $i");
 
-			$cachedFile = $cache->get($longPath . '/test.txt');
+			$cachedFile = $cache->get($longPath.'/test.txt');
 			$this->assertTrue(is_array($cachedFile), "No cache entry for file at $i");
 			$this->assertEquals('test.txt', $cachedFile['name'], "Wrong cache entry for file at $i");
 
-			$longPath .= $ds . $folderName;
+			$longPath .= $ds.$folderName;
 		}
 	}
 
@@ -1090,7 +1090,7 @@ 
 		$folderName = 'abcdefghijklmnopqrstuvwxyz012345678901234567890123456789';
 		$depth = (4000 / 57);
 		foreach (range(0, $depth + 1) as $i) {
-			$longPath .= '/' . $folderName;
+			$longPath .= '/'.$folderName;
 		}
 
 		$storage = new Temporary([]);
@@ -1340,8 +1340,8 @@ 
 		$view = new View($rootPath);
 		$storage = new Temporary([]);
 		Filesystem::mount($storage, [], '/');
-		$this->assertTrue($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_EXCLUSIVE));
-		$view->lockFile($pathPrefix . '/foo/bar/asd', ILockingProvider::LOCK_SHARED);
+		$this->assertTrue($view->lockFile($pathPrefix.'/foo/bar', ILockingProvider::LOCK_EXCLUSIVE));
+		$view->lockFile($pathPrefix.'/foo/bar/asd', ILockingProvider::LOCK_SHARED);
 	}
 
 	/**
@@ -1359,8 +1359,8 @@ 
 		$view = new View($rootPath);
 		$storage = new Temporary([]);
 		Filesystem::mount($storage, [], '/');
-		$this->assertFalse($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_EXCLUSIVE));
-		$this->assertFalse($view->lockFile($pathPrefix . '/foo/bar/asd', ILockingProvider::LOCK_SHARED));
+		$this->assertFalse($view->lockFile($pathPrefix.'/foo/bar', ILockingProvider::LOCK_EXCLUSIVE));
+		$this->assertFalse($view->lockFile($pathPrefix.'/foo/bar/asd', ILockingProvider::LOCK_SHARED));
 	}
 
 	/**
@@ -1381,8 +1381,8 @@ 
 		$view = new View($rootPath);
 		$storage = new Temporary([]);
 		Filesystem::mount($storage, [], '/');
-		$this->assertTrue($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_SHARED));
-		$view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_EXCLUSIVE);
+		$this->assertTrue($view->lockFile($pathPrefix.'/foo/bar', ILockingProvider::LOCK_SHARED));
+		$view->lockFile($pathPrefix.'/foo/bar', ILockingProvider::LOCK_EXCLUSIVE);
 	}
 
 	/**
@@ -1400,8 +1400,8 @@ 
 		$view = new View($rootPath);
 		$storage = new Temporary([]);
 		Filesystem::mount($storage, [], '/');
-		$this->assertFalse($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_SHARED));
-		$this->assertFalse($view->lockFile($pathPrefix . '/foo/bar', ILockingProvider::LOCK_EXCLUSIVE));
+		$this->assertFalse($view->lockFile($pathPrefix.'/foo/bar', ILockingProvider::LOCK_SHARED));
+		$this->assertFalse($view->lockFile($pathPrefix.'/foo/bar', ILockingProvider::LOCK_EXCLUSIVE));
 	}
 
 	/**
@@ -1610,7 +1610,7 @@ 
 				->onlyMethods([])
 				->getMock();
 			$storage->method('getId')->willReturn('non-null-id');
-			$storage->method('getStorageCache')->willReturnCallback(function () use ($storage) {
+			$storage->method('getStorageCache')->willReturnCallback(function() use ($storage) {
 				return new \OC\Files\Cache\Storage($storage, true, \OC::$server->get(IDBConnection::class));
 			});
 
@@ -1639,8 +1639,8 @@ 
 		self::loginAsUser($this->user);
 
 		[$mount1, $mount2] = $this->createTestMovableMountPoints([
-			$this->user . '/files/mount1',
-			$this->user . '/files/mount2',
+			$this->user.'/files/mount1',
+			$this->user.'/files/mount2',
 		]);
 		$mount1->expects($this->once())
 			->method('moveMount')
@@ -1650,7 +1650,7 @@ 
 			->method('moveMount')
 			->willReturn(true);
 
-		$view = new View('/' . $this->user . '/files/');
+		$view = new View('/'.$this->user.'/files/');
 		$view->mkdir('sub');
 
 		$this->assertTrue($view->rename('mount1', 'renamed_mount'), 'Can rename mount point');
@@ -1661,8 +1661,8 @@ 
 		self::loginAsUser($this->user);
 
 		[$mount1, $mount2] = $this->createTestMovableMountPoints([
-			$this->user . '/files/mount1',
-			$this->user . '/files/mount2',
+			$this->user.'/files/mount1',
+			$this->user.'/files/mount2',
 		]);
 
 		$mount1->expects($this->never())
@@ -1671,7 +1671,7 @@ 
 		$mount2->expects($this->never())
 			->method('moveMount');
 
-		$view = new View('/' . $this->user . '/files/');
+		$view = new View('/'.$this->user.'/files/');
 
 		$this->expectException(ForbiddenException::class);
 		$view->rename('mount1', 'mount2');
@@ -1681,8 +1681,8 @@ 
 		self::loginAsUser($this->user);
 
 		[$mount1, $mount2] = $this->createTestMovableMountPoints([
-			$this->user . '/files/mount1',
-			$this->user . '/files/mount2',
+			$this->user.'/files/mount1',
+			$this->user.'/files/mount2',
 		]);
 
 		$mount1->expects($this->never())
@@ -1691,7 +1691,7 @@ 
 		$mount2->expects($this->never())
 			->method('moveMount');
 
-		$view = new View('/' . $this->user . '/files/');
+		$view = new View('/'.$this->user.'/files/');
 
 		$this->expectException(ForbiddenException::class);
 		$view->rename('mount1', 'mount2/sub');
@@ -1704,8 +1704,8 @@ 
 		self::loginAsUser($this->user);
 
 		[$mount1, $mount2] = $this->createTestMovableMountPoints([
-			$this->user . '/files/mount1',
-			$this->user . '/files/mount2',
+			$this->user.'/files/mount1',
+			$this->user.'/files/mount2',
 		]);
 
 		$mount1->expects($this->never())
@@ -1715,7 +1715,7 @@ 
 			->method('moveMount')
 			->willReturn(true);
 
-		$view = new View('/' . $this->user . '/files/');
+		$view = new View('/'.$this->user.'/files/');
 		$view->mkdir('shareddir');
 		$view->mkdir('shareddir/sub');
 		$view->mkdir('shareddir/sub2');
@@ -1941,7 +1941,7 @@ 
 		$expectedStrayLock = null,
 		$returnValue = true,
 	): void {
-		$view = new View('/' . $this->user . '/files/');
+		$view = new View('/'.$this->user.'/files/');
 
 		/** @var Temporary&MockObject $storage */
 		$storage = $this->getMockBuilder(Temporary::class)
@@ -1953,19 +1953,19 @@ 
 		/* Same thing with encryption wrapper */
 		Server::get(IStorageFactory::class)->removeStorageWrapper('oc_encryption');
 
-		Filesystem::mount($storage, [], $this->user . '/');
+		Filesystem::mount($storage, [], $this->user.'/');
 
 		// work directly on disk because mkdir might be mocked
 		$realPath = $storage->getSourcePath('');
-		mkdir($realPath . '/files');
-		mkdir($realPath . '/files/dir');
-		file_put_contents($realPath . '/files/test.txt', 'blah');
+		mkdir($realPath.'/files');
+		mkdir($realPath.'/files/dir');
+		file_put_contents($realPath.'/files/test.txt', 'blah');
 		$storage->getScanner()->scan('files');
 
 		$storage->expects($this->once())
 			->method($operation)
 			->willReturnCallback(
-				function () use ($view, $lockedPath, &$lockTypeDuring, $returnValue) {
+				function() use ($view, $lockedPath, &$lockTypeDuring, $returnValue) {
 					$lockTypeDuring = $this->getFileLockType($view, $lockedPath);
 
 					return $returnValue;
@@ -1998,7 +1998,7 @@ 
 	 * This code path uses $storage->fopen instead
 	 */
 	public function testLockFilePutContentWithStream(): void {
-		$view = new View('/' . $this->user . '/files/');
+		$view = new View('/'.$this->user.'/files/');
 
 		$path = 'test_file_put_contents.txt';
 		/** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
@@ -2006,13 +2006,13 @@ 
 			->onlyMethods(['fopen'])
 			->getMock();
 
-		Filesystem::mount($storage, [], $this->user . '/');
+		Filesystem::mount($storage, [], $this->user.'/');
 		$storage->mkdir('files');
 
 		$storage->expects($this->once())
 			->method('fopen')
 			->willReturnCallback(
-				function () use ($view, $path, &$lockTypeDuring) {
+				function() use ($view, $path, &$lockTypeDuring) {
 					$lockTypeDuring = $this->getFileLockType($view, $path);
 
 					return fopen('php://temp', 'r+');
@@ -2037,7 +2037,7 @@ 
 	 * Test locks for fopen with fclose at the end
 	 */
 	public function testLockFopen(): void {
-		$view = new View('/' . $this->user . '/files/');
+		$view = new View('/'.$this->user.'/files/');
 
 		$path = 'test_file_put_contents.txt';
 		/** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
@@ -2045,13 +2045,13 @@ 
 			->onlyMethods(['fopen'])
 			->getMock();
 
-		Filesystem::mount($storage, [], $this->user . '/');
+		Filesystem::mount($storage, [], $this->user.'/');
 		$storage->mkdir('files');
 
 		$storage->expects($this->once())
 			->method('fopen')
 			->willReturnCallback(
-				function () use ($view, $path, &$lockTypeDuring) {
+				function() use ($view, $path, &$lockTypeDuring) {
 					$lockTypeDuring = $this->getFileLockType($view, $path);
 
 					return fopen('php://temp', 'r+');
@@ -2093,7 +2093,7 @@ 
 		if ($operation === 'touch') {
 			$this->markTestSkipped('touch handles storage exceptions internally');
 		}
-		$view = new View('/' . $this->user . '/files/');
+		$view = new View('/'.$this->user.'/files/');
 
 		/** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
 		$storage = $this->getMockBuilder(Temporary::class)
@@ -2105,19 +2105,19 @@ 
 		/* Same thing with encryption wrapper */
 		Server::get(IStorageFactory::class)->removeStorageWrapper('oc_encryption');
 
-		Filesystem::mount($storage, [], $this->user . '/');
+		Filesystem::mount($storage, [], $this->user.'/');
 
 		// work directly on disk because mkdir might be mocked
 		$realPath = $storage->getSourcePath('');
-		mkdir($realPath . '/files');
-		mkdir($realPath . '/files/dir');
-		file_put_contents($realPath . '/files/test.txt', 'blah');
+		mkdir($realPath.'/files');
+		mkdir($realPath.'/files/dir');
+		file_put_contents($realPath.'/files/test.txt', 'blah');
 		$storage->getScanner()->scan('files');
 
 		$storage->expects($this->once())
 			->method($operation)
 			->willReturnCallback(
-				function () {
+				function() {
 					throw new \Exception('Simulated exception');
 				}
 			);
@@ -2137,11 +2137,11 @@ 
 	}
 
 	public function testLockBasicOperationUnlocksAfterLockException(): void {
-		$view = new View('/' . $this->user . '/files/');
+		$view = new View('/'.$this->user.'/files/');
 
 		$storage = new Temporary([]);
 
-		Filesystem::mount($storage, [], $this->user . '/');
+		Filesystem::mount($storage, [], $this->user.'/');
 
 		$storage->mkdir('files');
 		$storage->mkdir('files/dir');
@@ -2183,14 +2183,14 @@ 
 		$path,
 		$hookType,
 	): void {
-		$view = new View('/' . $this->user . '/files/');
+		$view = new View('/'.$this->user.'/files/');
 
 		/** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
 		$storage = $this->getMockBuilder(Temporary::class)
 			->onlyMethods([$operation])
 			->getMock();
 
-		Filesystem::mount($storage, [], $this->user . '/');
+		Filesystem::mount($storage, [], $this->user.'/');
 		$storage->mkdir('files');
 
 		Util::connectHook(
@@ -2222,7 +2222,7 @@ 
 	 *                                          the operation
 	 */
 	public function testLockFileRename($operation, $expectedLockTypeSourceDuring): void {
-		$view = new View('/' . $this->user . '/files/');
+		$view = new View('/'.$this->user.'/files/');
 
 		/** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
 		$storage = $this->getMockBuilder(Temporary::class)
@@ -2248,14 +2248,14 @@ 
 		/* Disable encryption wrapper to avoid it intercepting mocked call */
 		Server::get(IStorageFactory::class)->removeStorageWrapper('oc_encryption');
 
-		Filesystem::mount($storage, [], $this->user . '/');
+		Filesystem::mount($storage, [], $this->user.'/');
 		$storage->mkdir('files');
 		$view->file_put_contents($sourcePath, 'meh');
 
 		$storage->expects($this->once())
 			->method($operation)
 			->willReturnCallback(
-				function () use ($view, $sourcePath, $targetPath, &$lockTypeSourceDuring, &$lockTypeTargetDuring) {
+				function() use ($view, $sourcePath, $targetPath, &$lockTypeSourceDuring, &$lockTypeTargetDuring) {
 					$lockTypeSourceDuring = $this->getFileLockType($view, $sourcePath);
 					$lockTypeTargetDuring = $this->getFileLockType($view, $targetPath);
 
@@ -2291,7 +2291,7 @@ 
 	public function testLockFileCopyException(): void {
 		$this->expectException(\Exception::class);
 
-		$view = new View('/' . $this->user . '/files/');
+		$view = new View('/'.$this->user.'/files/');
 
 		/** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
 		$storage = $this->getMockBuilder(Temporary::class)
@@ -2304,14 +2304,14 @@ 
 		/* Disable encryption wrapper to avoid it intercepting mocked call */
 		Server::get(IStorageFactory::class)->removeStorageWrapper('oc_encryption');
 
-		Filesystem::mount($storage, [], $this->user . '/');
+		Filesystem::mount($storage, [], $this->user.'/');
 		$storage->mkdir('files');
 		$view->file_put_contents($sourcePath, 'meh');
 
 		$storage->expects($this->once())
 			->method('copy')
 			->willReturnCallback(
-				function () {
+				function() {
 					throw new \Exception();
 				}
 			);
@@ -2337,7 +2337,7 @@ 
 	public function testLockFileRenameUnlockOnException(): void {
 		self::loginAsUser('test');
 
-		$view = new View('/' . $this->user . '/files/');
+		$view = new View('/'.$this->user.'/files/');
 
 		$sourcePath = 'original.txt';
 		$targetPath = 'target.txt';
@@ -2378,7 +2378,7 @@ 
 		$this->assertEquals('test', $view->getFileInfo($path)->getOwner()->getUID());
 
 		$folderInfo = $view->getDirectoryContent('');
-		$folderInfo = array_values(array_filter($folderInfo, function (FileInfo $info) {
+		$folderInfo = array_values(array_filter($folderInfo, function(FileInfo $info) {
 			return $info->getName() === 'foo.txt';
 		}));
 
@@ -2388,7 +2388,7 @@ 
 		Filesystem::mount($subStorage, [], '/test/files/asd');
 
 		$folderInfo = $view->getDirectoryContent('');
-		$folderInfo = array_values(array_filter($folderInfo, function (FileInfo $info) {
+		$folderInfo = array_values(array_filter($folderInfo, function(FileInfo $info) {
 			return $info->getName() === 'asd';
 		}));
 
@@ -2413,7 +2413,7 @@ 
 	 *                                          the operation
 	 */
 	public function testLockFileRenameCrossStorage($viewOperation, $storageOperation, $expectedLockTypeSourceDuring): void {
-		$view = new View('/' . $this->user . '/files/');
+		$view = new View('/'.$this->user.'/files/');
 
 		/** @var Temporary|\PHPUnit\Framework\MockObject\MockObject $storage */
 		$storage = $this->getMockBuilder(Temporary::class)
@@ -2443,8 +2443,8 @@ 
 		/* Disable encryption wrapper to avoid it intercepting mocked call */
 		Server::get(IStorageFactory::class)->removeStorageWrapper('oc_encryption');
 
-		Filesystem::mount($storage, [], $this->user . '/');
-		Filesystem::mount($storage2, [], $this->user . '/files/substorage');
+		Filesystem::mount($storage, [], $this->user.'/');
+		Filesystem::mount($storage2, [], $this->user.'/files/substorage');
 		$storage->mkdir('files');
 		$view->file_put_contents($sourcePath, 'meh');
 		$storage2->getUpdater()->update('');
@@ -2454,7 +2454,7 @@ 
 		$storage2->expects($this->once())
 			->method($storageOperation)
 			->willReturnCallback(
-				function () use ($view, $sourcePath, $targetPath, &$lockTypeSourceDuring, &$lockTypeTargetDuring) {
+				function() use ($view, $sourcePath, $targetPath, &$lockTypeSourceDuring, &$lockTypeTargetDuring) {
 					$lockTypeSourceDuring = $this->getFileLockType($view, $sourcePath);
 					$lockTypeTargetDuring = $this->getFileLockType($view, $targetPath);
 
@@ -2489,10 +2489,10 @@ 
 		self::loginAsUser('test');
 
 		[$mount] = $this->createTestMovableMountPoints([
-			$this->user . '/files/substorage',
+			$this->user.'/files/substorage',
 		]);
 
-		$view = new View('/' . $this->user . '/files/');
+		$view = new View('/'.$this->user.'/files/');
 		$view->mkdir('subdir');
 
 		$sourcePath = 'substorage';
@@ -2501,7 +2501,7 @@ 
 		$mount->expects($this->once())
 			->method('moveMount')
 			->willReturnCallback(
-				function ($target) use ($mount, $view, $sourcePath, $targetPath, &$lockTypeSourceDuring, &$lockTypeTargetDuring, &$lockTypeSharedRootDuring) {
+				function($target) use ($mount, $view, $sourcePath, $targetPath, &$lockTypeSourceDuring, &$lockTypeTargetDuring, &$lockTypeSharedRootDuring) {
 					$lockTypeSourceDuring = $this->getFileLockType($view, $sourcePath, true);
 					$lockTypeTargetDuring = $this->getFileLockType($view, $targetPath, true);
 
@@ -2566,14 +2566,14 @@ 
 		$eventHandler->expects($this->any())
 			->method('preCallback')
 			->willReturnCallback(
-				function () use ($view, $path, $onMountPoint, &$lockTypePre) {
+				function() use ($view, $path, $onMountPoint, &$lockTypePre) {
 					$lockTypePre = $this->getFileLockType($view, $path, $onMountPoint);
 				}
 			);
 		$eventHandler->expects($this->any())
 			->method('postCallback')
 			->willReturnCallback(
-				function () use ($view, $path, $onMountPoint, &$lockTypePost) {
+				function() use ($view, $path, $onMountPoint, &$lockTypePost) {
 					$lockTypePost = $this->getFileLockType($view, $path, $onMountPoint);
 				}
 			);
@@ -2587,7 +2587,7 @@ 
 			);
 			Util::connectHook(
 				Filesystem::CLASSNAME,
-				'post_' . $hookType,
+				'post_'.$hookType,
 				$eventHandler,
 				'postCallback'
 			);
@@ -2615,7 +2615,7 @@ 
 
 
 	public function testRemoveMoveableMountPoint(): void {
-		$mountPoint = '/' . $this->user . '/files/mount/';
+		$mountPoint = '/'.$this->user.'/files/mount/';
 
 		// Mock the mount point
 		/** @var TestMoveableMountPoint|\PHPUnit\Framework\MockObject\MockObject $mount */
@@ -2657,7 +2657,7 @@ 
 		);
 
 		//Delete the mountpoint
-		$view = new View('/' . $this->user . '/files');
+		$view = new View('/'.$this->user.'/files');
 		$this->assertEquals('foo', $view->rmdir('mount'));
 	}
 
@@ -2678,7 +2678,7 @@ 
 	public function testGetDirectoryContentMimeFilter($filter, $expected): void {
 		$storage1 = new Temporary();
 		$root = self::getUniqueID('/');
-		Filesystem::mount($storage1, [], $root . '/');
+		Filesystem::mount($storage1, [], $root.'/');
 		$view = new View($root);
 
 		$view->file_put_contents('test1.txt', 'asd');
@@ -2688,7 +2688,7 @@ 
 
 		$content = $view->getDirectoryContent('', $filter);
 
-		$files = array_map(function (FileInfo $info) {
+		$files = array_map(function(FileInfo $info) {
 			return $info->getName();
 		}, $content);
 		sort($files);
@@ -2794,7 +2794,7 @@ 
 		$calls = ['/new/folder', '/new/folder/structure'];
 		$view->expects($this->exactly(2))
 			->method('mkdir')
-			->willReturnCallback(function ($dir) use (&$calls) {
+			->willReturnCallback(function($dir) use (&$calls) {
 				$expected = array_shift($calls);
 				$this->assertEquals($expected, $dir);
 			});
@@ -2891,7 +2891,7 @@ 
 	}
 
 	public function testCopyPreservesContent() {
-		$viewUser1 = new View('/' . 'userId' . '/files');
+		$viewUser1 = new View('/'.'userId'.'/files');
 		$viewUser1->mkdir('');
 		$viewUser1->file_put_contents('foo.txt', 'foo');
 		$viewUser1->copy('foo.txt', 'bar.txt');

apps/files_trashbin/tests/TrashbinTest.php

Indentation +654 added lines, -654 removed lines

@@ -34,674 +34,674 @@
  * @group DB
  */
 class TrashbinTest extends \Test\TestCase {
-	public const TEST_TRASHBIN_USER1 = 'test-trashbin-user1';
-	public const TEST_TRASHBIN_USER2 = 'test-trashbin-user2';
-
-	private $trashRoot1;
-	private $trashRoot2;
-
-	private static $rememberRetentionObligation;
-
-	/**
-	 * @var bool
-	 */
-	private static $trashBinStatus;
-
-	/**
-	 * @var View
-	 */
-	private $rootView;
-
-	public static function setUpBeforeClass(): void {
-		parent::setUpBeforeClass();
-
-		$appManager = Server::get(IAppManager::class);
-		self::$trashBinStatus = $appManager->isEnabledForUser('files_trashbin');
-
-		// reset backend
-		Server::get(IUserManager::class)->clearBackends();
-		Server::get(IUserManager::class)->registerBackend(new Database());
-
-		// clear share hooks
-		\OC_Hook::clear('OCP\\Share');
-		\OC::registerShareHooks(Server::get(SystemConfig::class));
-
-		// init files sharing
-		new Application();
-
-		//disable encryption
-		Server::get(IAppManager::class)->disableApp('encryption');
-
-		$config = Server::get(IConfig::class);
-		//configure trashbin
-		self::$rememberRetentionObligation = $config->getSystemValue('trashbin_retention_obligation', Expiration::DEFAULT_RETENTION_OBLIGATION);
-		/** @var Expiration $expiration */
-		$expiration = Server::get(Expiration::class);
-		$expiration->setRetentionObligation('auto, 2');
-
-		// register trashbin hooks
-		$trashbinApp = new TrashbinApplication();
-		$trashbinApp->boot(new BootContext(new DIContainer('', [], \OC::$server)));
-
-		// create test user
-		self::loginHelper(self::TEST_TRASHBIN_USER2, true);
-		self::loginHelper(self::TEST_TRASHBIN_USER1, true);
-	}
-
-
-	public static function tearDownAfterClass(): void {
-		// cleanup test user
-		$user = Server::get(IUserManager::class)->get(self::TEST_TRASHBIN_USER1);
-		if ($user !== null) {
-			$user->delete();
-		}
-
-		/** @var Expiration $expiration */
-		$expiration = Server::get(Expiration::class);
-		$expiration->setRetentionObligation(self::$rememberRetentionObligation);
-
-		\OC_Hook::clear();
-
-		Filesystem::getLoader()->removeStorageWrapper('oc_trashbin');
-
-		if (self::$trashBinStatus) {
-			Server::get(IAppManager::class)->enableApp('files_trashbin');
-		}
-
-		parent::tearDownAfterClass();
-	}
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		Server::get(IAppManager::class)->enableApp('files_trashbin');
-		$config = Server::get(IConfig::class);
-		$mockConfig = $this->getMockBuilder(AllConfig::class)
-			->onlyMethods(['getSystemValue'])
-			->setConstructorArgs([Server::get(\OC\SystemConfig::class)])
-			->getMock();
-		$mockConfig->expects($this->any())
-			->method('getSystemValue')
-			->willReturnCallback(static function ($key, $default) use ($config) {
-				if ($key === 'filesystem_check_changes') {
-					return Watcher::CHECK_ONCE;
-				} else {
-					return $config->getSystemValue($key, $default);
-				}
-			});
-		$this->overwriteService(AllConfig::class, $mockConfig);
-
-		$this->trashRoot1 = '/' . self::TEST_TRASHBIN_USER1 . '/files_trashbin';
-		$this->trashRoot2 = '/' . self::TEST_TRASHBIN_USER2 . '/files_trashbin';
-		$this->rootView = new View();
-		self::loginHelper(self::TEST_TRASHBIN_USER1);
-	}
-
-	protected function tearDown(): void {
-		$this->restoreService(AllConfig::class);
-		// disable trashbin to be able to properly clean up
-		Server::get(IAppManager::class)->disableApp('files_trashbin');
-
-		$this->rootView->deleteAll('/' . self::TEST_TRASHBIN_USER1 . '/files');
-		$this->rootView->deleteAll('/' . self::TEST_TRASHBIN_USER2 . '/files');
-		$this->rootView->deleteAll($this->trashRoot1);
-		$this->rootView->deleteAll($this->trashRoot2);
-
-		// clear trash table
-		$connection = Server::get(IDBConnection::class);
-		$connection->executeUpdate('DELETE FROM `*PREFIX*files_trash`');
-
-		parent::tearDown();
-	}
-
-	/**
-	 * test expiration of files older then the max storage time defined for the trash
-	 */
-	public function testExpireOldFiles(): void {
-
-		/** @var ITimeFactory $time */
-		$time = Server::get(ITimeFactory::class);
-		$currentTime = $time->getTime();
-		$expireAt = $currentTime - 2 * 24 * 60 * 60;
-		$expiredDate = $currentTime - 3 * 24 * 60 * 60;
-
-		// create some files
-		Filesystem::file_put_contents('file1.txt', 'file1');
-		Filesystem::file_put_contents('file2.txt', 'file2');
-		Filesystem::file_put_contents('file3.txt', 'file3');
-
-		// delete them so that they end up in the trash bin
-		Filesystem::unlink('file1.txt');
-		Filesystem::unlink('file2.txt');
-		Filesystem::unlink('file3.txt');
-
-		//make sure that files are in the trash bin
-		$filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'name');
-		$this->assertSame(3, count($filesInTrash));
-
-		// every second file will get a date in the past so that it will get expired
-		$manipulatedList = $this->manipulateDeleteTime($filesInTrash, $this->trashRoot1, $expiredDate);
-
-		$testClass = new TrashbinForTesting();
-		[$sizeOfDeletedFiles, $count] = $testClass->dummyDeleteExpiredFiles($manipulatedList, $expireAt);
-
-		$this->assertSame(10, $sizeOfDeletedFiles);
-		$this->assertSame(2, $count);
-
-		// only file2.txt should be left
-		$remainingFiles = array_slice($manipulatedList, $count);
-		$this->assertSame(1, count($remainingFiles));
-		$remainingFile = reset($remainingFiles);
-		// TODO: failing test
-		#$this->assertSame('file2.txt', $remainingFile['name']);
-
-		// check that file1.txt and file3.txt was really deleted
-		$newTrashContent = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1);
-		$this->assertSame(1, count($newTrashContent));
-		$element = reset($newTrashContent);
-		// TODO: failing test
-		#$this->assertSame('file2.txt', $element['name']);
-	}
-
-	/**
-	 * test expiration of files older then the max storage time defined for the trash
-	 * in this test we delete a shared file and check if both trash bins, the one from
-	 * the owner of the file and the one from the user who deleted the file get expired
-	 * correctly
-	 */
-	public function testExpireOldFilesShared(): void {
-		$currentTime = time();
-		$folder = 'trashTest-' . $currentTime . '/';
-		$expiredDate = $currentTime - 3 * 24 * 60 * 60;
-
-		// create some files
-		Filesystem::mkdir($folder);
-		Filesystem::file_put_contents($folder . 'user1-1.txt', 'file1');
-		Filesystem::file_put_contents($folder . 'user1-2.txt', 'file2');
-		Filesystem::file_put_contents($folder . 'user1-3.txt', 'file3');
-		Filesystem::file_put_contents($folder . 'user1-4.txt', 'file4');
-
-		//share user1-4.txt with user2
-		$node = \OC::$server->getUserFolder(self::TEST_TRASHBIN_USER1)->get($folder);
-		$share = Server::get(\OCP\Share\IManager::class)->newShare();
-		$share->setShareType(IShare::TYPE_USER)
-			->setNode($node)
-			->setSharedBy(self::TEST_TRASHBIN_USER1)
-			->setSharedWith(self::TEST_TRASHBIN_USER2)
-			->setPermissions(Constants::PERMISSION_ALL);
-		$share = Server::get(\OCP\Share\IManager::class)->createShare($share);
-		Server::get(\OCP\Share\IManager::class)->acceptShare($share, self::TEST_TRASHBIN_USER2);
-
-		// delete them so that they end up in the trash bin
-		Filesystem::unlink($folder . 'user1-1.txt');
-		Filesystem::unlink($folder . 'user1-2.txt');
-		Filesystem::unlink($folder . 'user1-3.txt');
-
-		$filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'name');
-		$this->assertSame(3, count($filesInTrash));
-
-		// every second file will get a date in the past so that it will get expired
-		$this->manipulateDeleteTime($filesInTrash, $this->trashRoot1, $expiredDate);
-
-		// login as user2
-		self::loginHelper(self::TEST_TRASHBIN_USER2);
-
-		$this->assertTrue(Filesystem::file_exists($folder . 'user1-4.txt'));
-
-		// create some files
-		Filesystem::file_put_contents('user2-1.txt', 'file1');
-		Filesystem::file_put_contents('user2-2.txt', 'file2');
-
-		// delete them so that they end up in the trash bin
-		Filesystem::unlink('user2-1.txt');
-		Filesystem::unlink('user2-2.txt');
-
-		$filesInTrashUser2 = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER2, 'name');
-		$this->assertSame(2, count($filesInTrashUser2));
-
-		// every second file will get a date in the past so that it will get expired
-		$this->manipulateDeleteTime($filesInTrashUser2, $this->trashRoot2, $expiredDate);
-
-		Filesystem::unlink($folder . 'user1-4.txt');
-
-		$this->runCommands();
-
-		$filesInTrashUser2AfterDelete = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER2);
-
-		// user2-1.txt should have been expired
-		$this->verifyArray($filesInTrashUser2AfterDelete, ['user2-2.txt', 'user1-4.txt']);
-
-		self::loginHelper(self::TEST_TRASHBIN_USER1);
-
-		// user1-1.txt and user1-3.txt should have been expired
-		$filesInTrashUser1AfterDelete = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1);
-
-		$this->verifyArray($filesInTrashUser1AfterDelete, ['user1-2.txt', 'user1-4.txt']);
-	}
-
-	/**
-	 * verify that the array contains the expected results
-	 *
-	 * @param FileInfo[] $result
-	 * @param string[] $expected
-	 */
-	private function verifyArray($result, $expected) {
-		$this->assertSame(count($expected), count($result));
-		foreach ($expected as $expectedFile) {
-			$found = false;
-			foreach ($result as $fileInTrash) {
-				if ($expectedFile === $fileInTrash['name']) {
-					$found = true;
-					break;
-				}
-			}
-			if (!$found) {
-				// if we didn't found the expected file, something went wrong
-				$this->assertTrue(false, "can't find expected file '" . $expectedFile . "' in trash bin");
-			}
-		}
-	}
-
-	/**
-	 * @param FileInfo[] $files
-	 * @param string $trashRoot
-	 * @param integer $expireDate
-	 */
-	private function manipulateDeleteTime($files, $trashRoot, $expireDate) {
-		$counter = 0;
-		foreach ($files as &$file) {
-			// modify every second file
-			$counter = ($counter + 1) % 2;
-			if ($counter === 1) {
-				$source = $trashRoot . '/files/' . $file['name'] . '.d' . $file['mtime'];
-				$target = Filesystem::normalizePath($trashRoot . '/files/' . $file['name'] . '.d' . $expireDate);
-				$this->rootView->rename($source, $target);
-				$file['mtime'] = $expireDate;
-			}
-		}
-		return \OCA\Files\Helper::sortFiles($files, 'mtime');
-	}
-
-
-	/**
-	 * test expiration of old files in the trash bin until the max size
-	 * of the trash bin is met again
-	 */
-	public function testExpireOldFilesUtilLimitsAreMet(): void {
-
-		// create some files
-		Filesystem::file_put_contents('file1.txt', 'file1');
-		Filesystem::file_put_contents('file2.txt', 'file2');
-		Filesystem::file_put_contents('file3.txt', 'file3');
-
-		// delete them so that they end up in the trash bin
-		Filesystem::unlink('file3.txt');
-		sleep(1); // make sure that every file has a unique mtime
-		Filesystem::unlink('file2.txt');
-		sleep(1); // make sure that every file has a unique mtime
-		Filesystem::unlink('file1.txt');
-
-		//make sure that files are in the trash bin
-		$filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
-		$this->assertSame(3, count($filesInTrash));
-
-		$testClass = new TrashbinForTesting();
-		$sizeOfDeletedFiles = $testClass->dummyDeleteFiles($filesInTrash, -8);
-
-		// the two oldest files (file3.txt and file2.txt) should be deleted
-		$this->assertSame(10, $sizeOfDeletedFiles);
-
-		$newTrashContent = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1);
-		$this->assertSame(1, count($newTrashContent));
-		$element = reset($newTrashContent);
-		$this->assertSame('file1.txt', $element['name']);
-	}
-
-	/**
-	 * Test restoring a file
-	 */
-	public function testRestoreFileInRoot(): void {
-		$userFolder = \OC::$server->getUserFolder();
-		$file = $userFolder->newFile('file1.txt');
-		$file->putContent('foo');
-
-		$this->assertTrue($userFolder->nodeExists('file1.txt'));
-
-		$file->delete();
-
-		$this->assertFalse($userFolder->nodeExists('file1.txt'));
-
-		$filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
-		$this->assertCount(1, $filesInTrash);
-
-		/** @var FileInfo */
-		$trashedFile = $filesInTrash[0];
-
-		$this->assertTrue(
-			Trashbin::restore(
-				'file1.txt.d' . $trashedFile->getMtime(),
-				$trashedFile->getName(),
-				$trashedFile->getMtime()
-			)
-		);
-
-		$file = $userFolder->get('file1.txt');
-		$this->assertEquals('foo', $file->getContent());
-	}
-
-	/**
-	 * Test restoring a file in subfolder
-	 */
-	public function testRestoreFileInSubfolder(): void {
-		$userFolder = \OC::$server->getUserFolder();
-		$folder = $userFolder->newFolder('folder');
-		$file = $folder->newFile('file1.txt');
-		$file->putContent('foo');
-
-		$this->assertTrue($userFolder->nodeExists('folder/file1.txt'));
-
-		$file->delete();
-
-		$this->assertFalse($userFolder->nodeExists('folder/file1.txt'));
-
-		$filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
-		$this->assertCount(1, $filesInTrash);
-
-		/** @var FileInfo */
-		$trashedFile = $filesInTrash[0];
-
-		$this->assertTrue(
-			Trashbin::restore(
-				'file1.txt.d' . $trashedFile->getMtime(),
-				$trashedFile->getName(),
-				$trashedFile->getMtime()
-			)
-		);
-
-		$file = $userFolder->get('folder/file1.txt');
-		$this->assertEquals('foo', $file->getContent());
-	}
-
-	/**
-	 * Test restoring a folder
-	 */
-	public function testRestoreFolder(): void {
-		$userFolder = \OC::$server->getUserFolder();
-		$folder = $userFolder->newFolder('folder');
-		$file = $folder->newFile('file1.txt');
-		$file->putContent('foo');
-
-		$this->assertTrue($userFolder->nodeExists('folder'));
-
-		$folder->delete();
-
-		$this->assertFalse($userFolder->nodeExists('folder'));
-
-		$filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
-		$this->assertCount(1, $filesInTrash);
+    public const TEST_TRASHBIN_USER1 = 'test-trashbin-user1';
+    public const TEST_TRASHBIN_USER2 = 'test-trashbin-user2';
+
+    private $trashRoot1;
+    private $trashRoot2;
+
+    private static $rememberRetentionObligation;
+
+    /**
+     * @var bool
+     */
+    private static $trashBinStatus;
+
+    /**
+     * @var View
+     */
+    private $rootView;
+
+    public static function setUpBeforeClass(): void {
+        parent::setUpBeforeClass();
+
+        $appManager = Server::get(IAppManager::class);
+        self::$trashBinStatus = $appManager->isEnabledForUser('files_trashbin');
+
+        // reset backend
+        Server::get(IUserManager::class)->clearBackends();
+        Server::get(IUserManager::class)->registerBackend(new Database());
+
+        // clear share hooks
+        \OC_Hook::clear('OCP\\Share');
+        \OC::registerShareHooks(Server::get(SystemConfig::class));
+
+        // init files sharing
+        new Application();
+
+        //disable encryption
+        Server::get(IAppManager::class)->disableApp('encryption');
+
+        $config = Server::get(IConfig::class);
+        //configure trashbin
+        self::$rememberRetentionObligation = $config->getSystemValue('trashbin_retention_obligation', Expiration::DEFAULT_RETENTION_OBLIGATION);
+        /** @var Expiration $expiration */
+        $expiration = Server::get(Expiration::class);
+        $expiration->setRetentionObligation('auto, 2');
+
+        // register trashbin hooks
+        $trashbinApp = new TrashbinApplication();
+        $trashbinApp->boot(new BootContext(new DIContainer('', [], \OC::$server)));
+
+        // create test user
+        self::loginHelper(self::TEST_TRASHBIN_USER2, true);
+        self::loginHelper(self::TEST_TRASHBIN_USER1, true);
+    }
+
+
+    public static function tearDownAfterClass(): void {
+        // cleanup test user
+        $user = Server::get(IUserManager::class)->get(self::TEST_TRASHBIN_USER1);
+        if ($user !== null) {
+            $user->delete();
+        }
+
+        /** @var Expiration $expiration */
+        $expiration = Server::get(Expiration::class);
+        $expiration->setRetentionObligation(self::$rememberRetentionObligation);
+
+        \OC_Hook::clear();
+
+        Filesystem::getLoader()->removeStorageWrapper('oc_trashbin');
+
+        if (self::$trashBinStatus) {
+            Server::get(IAppManager::class)->enableApp('files_trashbin');
+        }
+
+        parent::tearDownAfterClass();
+    }
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        Server::get(IAppManager::class)->enableApp('files_trashbin');
+        $config = Server::get(IConfig::class);
+        $mockConfig = $this->getMockBuilder(AllConfig::class)
+            ->onlyMethods(['getSystemValue'])
+            ->setConstructorArgs([Server::get(\OC\SystemConfig::class)])
+            ->getMock();
+        $mockConfig->expects($this->any())
+            ->method('getSystemValue')
+            ->willReturnCallback(static function ($key, $default) use ($config) {
+                if ($key === 'filesystem_check_changes') {
+                    return Watcher::CHECK_ONCE;
+                } else {
+                    return $config->getSystemValue($key, $default);
+                }
+            });
+        $this->overwriteService(AllConfig::class, $mockConfig);
+
+        $this->trashRoot1 = '/' . self::TEST_TRASHBIN_USER1 . '/files_trashbin';
+        $this->trashRoot2 = '/' . self::TEST_TRASHBIN_USER2 . '/files_trashbin';
+        $this->rootView = new View();
+        self::loginHelper(self::TEST_TRASHBIN_USER1);
+    }
+
+    protected function tearDown(): void {
+        $this->restoreService(AllConfig::class);
+        // disable trashbin to be able to properly clean up
+        Server::get(IAppManager::class)->disableApp('files_trashbin');
+
+        $this->rootView->deleteAll('/' . self::TEST_TRASHBIN_USER1 . '/files');
+        $this->rootView->deleteAll('/' . self::TEST_TRASHBIN_USER2 . '/files');
+        $this->rootView->deleteAll($this->trashRoot1);
+        $this->rootView->deleteAll($this->trashRoot2);
+
+        // clear trash table
+        $connection = Server::get(IDBConnection::class);
+        $connection->executeUpdate('DELETE FROM `*PREFIX*files_trash`');
+
+        parent::tearDown();
+    }
+
+    /**
+     * test expiration of files older then the max storage time defined for the trash
+     */
+    public function testExpireOldFiles(): void {
+
+        /** @var ITimeFactory $time */
+        $time = Server::get(ITimeFactory::class);
+        $currentTime = $time->getTime();
+        $expireAt = $currentTime - 2 * 24 * 60 * 60;
+        $expiredDate = $currentTime - 3 * 24 * 60 * 60;
+
+        // create some files
+        Filesystem::file_put_contents('file1.txt', 'file1');
+        Filesystem::file_put_contents('file2.txt', 'file2');
+        Filesystem::file_put_contents('file3.txt', 'file3');
+
+        // delete them so that they end up in the trash bin
+        Filesystem::unlink('file1.txt');
+        Filesystem::unlink('file2.txt');
+        Filesystem::unlink('file3.txt');
+
+        //make sure that files are in the trash bin
+        $filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'name');
+        $this->assertSame(3, count($filesInTrash));
+
+        // every second file will get a date in the past so that it will get expired
+        $manipulatedList = $this->manipulateDeleteTime($filesInTrash, $this->trashRoot1, $expiredDate);
+
+        $testClass = new TrashbinForTesting();
+        [$sizeOfDeletedFiles, $count] = $testClass->dummyDeleteExpiredFiles($manipulatedList, $expireAt);
+
+        $this->assertSame(10, $sizeOfDeletedFiles);
+        $this->assertSame(2, $count);
+
+        // only file2.txt should be left
+        $remainingFiles = array_slice($manipulatedList, $count);
+        $this->assertSame(1, count($remainingFiles));
+        $remainingFile = reset($remainingFiles);
+        // TODO: failing test
+        #$this->assertSame('file2.txt', $remainingFile['name']);
+
+        // check that file1.txt and file3.txt was really deleted
+        $newTrashContent = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1);
+        $this->assertSame(1, count($newTrashContent));
+        $element = reset($newTrashContent);
+        // TODO: failing test
+        #$this->assertSame('file2.txt', $element['name']);
+    }
+
+    /**
+     * test expiration of files older then the max storage time defined for the trash
+     * in this test we delete a shared file and check if both trash bins, the one from
+     * the owner of the file and the one from the user who deleted the file get expired
+     * correctly
+     */
+    public function testExpireOldFilesShared(): void {
+        $currentTime = time();
+        $folder = 'trashTest-' . $currentTime . '/';
+        $expiredDate = $currentTime - 3 * 24 * 60 * 60;
+
+        // create some files
+        Filesystem::mkdir($folder);
+        Filesystem::file_put_contents($folder . 'user1-1.txt', 'file1');
+        Filesystem::file_put_contents($folder . 'user1-2.txt', 'file2');
+        Filesystem::file_put_contents($folder . 'user1-3.txt', 'file3');
+        Filesystem::file_put_contents($folder . 'user1-4.txt', 'file4');
+
+        //share user1-4.txt with user2
+        $node = \OC::$server->getUserFolder(self::TEST_TRASHBIN_USER1)->get($folder);
+        $share = Server::get(\OCP\Share\IManager::class)->newShare();
+        $share->setShareType(IShare::TYPE_USER)
+            ->setNode($node)
+            ->setSharedBy(self::TEST_TRASHBIN_USER1)
+            ->setSharedWith(self::TEST_TRASHBIN_USER2)
+            ->setPermissions(Constants::PERMISSION_ALL);
+        $share = Server::get(\OCP\Share\IManager::class)->createShare($share);
+        Server::get(\OCP\Share\IManager::class)->acceptShare($share, self::TEST_TRASHBIN_USER2);
+
+        // delete them so that they end up in the trash bin
+        Filesystem::unlink($folder . 'user1-1.txt');
+        Filesystem::unlink($folder . 'user1-2.txt');
+        Filesystem::unlink($folder . 'user1-3.txt');
+
+        $filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'name');
+        $this->assertSame(3, count($filesInTrash));
+
+        // every second file will get a date in the past so that it will get expired
+        $this->manipulateDeleteTime($filesInTrash, $this->trashRoot1, $expiredDate);
+
+        // login as user2
+        self::loginHelper(self::TEST_TRASHBIN_USER2);
+
+        $this->assertTrue(Filesystem::file_exists($folder . 'user1-4.txt'));
+
+        // create some files
+        Filesystem::file_put_contents('user2-1.txt', 'file1');
+        Filesystem::file_put_contents('user2-2.txt', 'file2');
+
+        // delete them so that they end up in the trash bin
+        Filesystem::unlink('user2-1.txt');
+        Filesystem::unlink('user2-2.txt');
+
+        $filesInTrashUser2 = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER2, 'name');
+        $this->assertSame(2, count($filesInTrashUser2));
+
+        // every second file will get a date in the past so that it will get expired
+        $this->manipulateDeleteTime($filesInTrashUser2, $this->trashRoot2, $expiredDate);
+
+        Filesystem::unlink($folder . 'user1-4.txt');
+
+        $this->runCommands();
+
+        $filesInTrashUser2AfterDelete = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER2);
+
+        // user2-1.txt should have been expired
+        $this->verifyArray($filesInTrashUser2AfterDelete, ['user2-2.txt', 'user1-4.txt']);
+
+        self::loginHelper(self::TEST_TRASHBIN_USER1);
+
+        // user1-1.txt and user1-3.txt should have been expired
+        $filesInTrashUser1AfterDelete = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1);
+
+        $this->verifyArray($filesInTrashUser1AfterDelete, ['user1-2.txt', 'user1-4.txt']);
+    }
+
+    /**
+     * verify that the array contains the expected results
+     *
+     * @param FileInfo[] $result
+     * @param string[] $expected
+     */
+    private function verifyArray($result, $expected) {
+        $this->assertSame(count($expected), count($result));
+        foreach ($expected as $expectedFile) {
+            $found = false;
+            foreach ($result as $fileInTrash) {
+                if ($expectedFile === $fileInTrash['name']) {
+                    $found = true;
+                    break;
+                }
+            }
+            if (!$found) {
+                // if we didn't found the expected file, something went wrong
+                $this->assertTrue(false, "can't find expected file '" . $expectedFile . "' in trash bin");
+            }
+        }
+    }
+
+    /**
+     * @param FileInfo[] $files
+     * @param string $trashRoot
+     * @param integer $expireDate
+     */
+    private function manipulateDeleteTime($files, $trashRoot, $expireDate) {
+        $counter = 0;
+        foreach ($files as &$file) {
+            // modify every second file
+            $counter = ($counter + 1) % 2;
+            if ($counter === 1) {
+                $source = $trashRoot . '/files/' . $file['name'] . '.d' . $file['mtime'];
+                $target = Filesystem::normalizePath($trashRoot . '/files/' . $file['name'] . '.d' . $expireDate);
+                $this->rootView->rename($source, $target);
+                $file['mtime'] = $expireDate;
+            }
+        }
+        return \OCA\Files\Helper::sortFiles($files, 'mtime');
+    }
+
+
+    /**
+     * test expiration of old files in the trash bin until the max size
+     * of the trash bin is met again
+     */
+    public function testExpireOldFilesUtilLimitsAreMet(): void {
+
+        // create some files
+        Filesystem::file_put_contents('file1.txt', 'file1');
+        Filesystem::file_put_contents('file2.txt', 'file2');
+        Filesystem::file_put_contents('file3.txt', 'file3');
+
+        // delete them so that they end up in the trash bin
+        Filesystem::unlink('file3.txt');
+        sleep(1); // make sure that every file has a unique mtime
+        Filesystem::unlink('file2.txt');
+        sleep(1); // make sure that every file has a unique mtime
+        Filesystem::unlink('file1.txt');
+
+        //make sure that files are in the trash bin
+        $filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
+        $this->assertSame(3, count($filesInTrash));
+
+        $testClass = new TrashbinForTesting();
+        $sizeOfDeletedFiles = $testClass->dummyDeleteFiles($filesInTrash, -8);
+
+        // the two oldest files (file3.txt and file2.txt) should be deleted
+        $this->assertSame(10, $sizeOfDeletedFiles);
+
+        $newTrashContent = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1);
+        $this->assertSame(1, count($newTrashContent));
+        $element = reset($newTrashContent);
+        $this->assertSame('file1.txt', $element['name']);
+    }
+
+    /**
+     * Test restoring a file
+     */
+    public function testRestoreFileInRoot(): void {
+        $userFolder = \OC::$server->getUserFolder();
+        $file = $userFolder->newFile('file1.txt');
+        $file->putContent('foo');
+
+        $this->assertTrue($userFolder->nodeExists('file1.txt'));
+
+        $file->delete();
+
+        $this->assertFalse($userFolder->nodeExists('file1.txt'));
+
+        $filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
+        $this->assertCount(1, $filesInTrash);
+
+        /** @var FileInfo */
+        $trashedFile = $filesInTrash[0];
+
+        $this->assertTrue(
+            Trashbin::restore(
+                'file1.txt.d' . $trashedFile->getMtime(),
+                $trashedFile->getName(),
+                $trashedFile->getMtime()
+            )
+        );
+
+        $file = $userFolder->get('file1.txt');
+        $this->assertEquals('foo', $file->getContent());
+    }
+
+    /**
+     * Test restoring a file in subfolder
+     */
+    public function testRestoreFileInSubfolder(): void {
+        $userFolder = \OC::$server->getUserFolder();
+        $folder = $userFolder->newFolder('folder');
+        $file = $folder->newFile('file1.txt');
+        $file->putContent('foo');
+
+        $this->assertTrue($userFolder->nodeExists('folder/file1.txt'));
+
+        $file->delete();
+
+        $this->assertFalse($userFolder->nodeExists('folder/file1.txt'));
+
+        $filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
+        $this->assertCount(1, $filesInTrash);
+
+        /** @var FileInfo */
+        $trashedFile = $filesInTrash[0];
+
+        $this->assertTrue(
+            Trashbin::restore(
+                'file1.txt.d' . $trashedFile->getMtime(),
+                $trashedFile->getName(),
+                $trashedFile->getMtime()
+            )
+        );
+
+        $file = $userFolder->get('folder/file1.txt');
+        $this->assertEquals('foo', $file->getContent());
+    }
+
+    /**
+     * Test restoring a folder
+     */
+    public function testRestoreFolder(): void {
+        $userFolder = \OC::$server->getUserFolder();
+        $folder = $userFolder->newFolder('folder');
+        $file = $folder->newFile('file1.txt');
+        $file->putContent('foo');
+
+        $this->assertTrue($userFolder->nodeExists('folder'));
+
+        $folder->delete();
+
+        $this->assertFalse($userFolder->nodeExists('folder'));
+
+        $filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
+        $this->assertCount(1, $filesInTrash);
 
-		/** @var FileInfo */
-		$trashedFolder = $filesInTrash[0];
+        /** @var FileInfo */
+        $trashedFolder = $filesInTrash[0];
 
-		$this->assertTrue(
-			Trashbin::restore(
-				'folder.d' . $trashedFolder->getMtime(),
-				$trashedFolder->getName(),
-				$trashedFolder->getMtime()
-			)
-		);
+        $this->assertTrue(
+            Trashbin::restore(
+                'folder.d' . $trashedFolder->getMtime(),
+                $trashedFolder->getName(),
+                $trashedFolder->getMtime()
+            )
+        );
 
-		$file = $userFolder->get('folder/file1.txt');
-		$this->assertEquals('foo', $file->getContent());
-	}
-
-	/**
-	 * Test restoring a file from inside a trashed folder
-	 */
-	public function testRestoreFileFromTrashedSubfolder(): void {
-		$userFolder = \OC::$server->getUserFolder();
-		$folder = $userFolder->newFolder('folder');
-		$file = $folder->newFile('file1.txt');
-		$file->putContent('foo');
+        $file = $userFolder->get('folder/file1.txt');
+        $this->assertEquals('foo', $file->getContent());
+    }
+
+    /**
+     * Test restoring a file from inside a trashed folder
+     */
+    public function testRestoreFileFromTrashedSubfolder(): void {
+        $userFolder = \OC::$server->getUserFolder();
+        $folder = $userFolder->newFolder('folder');
+        $file = $folder->newFile('file1.txt');
+        $file->putContent('foo');
 
-		$this->assertTrue($userFolder->nodeExists('folder'));
+        $this->assertTrue($userFolder->nodeExists('folder'));
 
-		$folder->delete();
-
-		$this->assertFalse($userFolder->nodeExists('folder'));
-
-		$filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
-		$this->assertCount(1, $filesInTrash);
-
-		/** @var FileInfo */
-		$trashedFile = $filesInTrash[0];
-
-		$this->assertTrue(
-			Trashbin::restore(
-				'folder.d' . $trashedFile->getMtime() . '/file1.txt',
-				'file1.txt',
-				$trashedFile->getMtime()
-			)
-		);
+        $folder->delete();
+
+        $this->assertFalse($userFolder->nodeExists('folder'));
+
+        $filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
+        $this->assertCount(1, $filesInTrash);
+
+        /** @var FileInfo */
+        $trashedFile = $filesInTrash[0];
+
+        $this->assertTrue(
+            Trashbin::restore(
+                'folder.d' . $trashedFile->getMtime() . '/file1.txt',
+                'file1.txt',
+                $trashedFile->getMtime()
+            )
+        );
 
-		$file = $userFolder->get('file1.txt');
-		$this->assertEquals('foo', $file->getContent());
-	}
+        $file = $userFolder->get('file1.txt');
+        $this->assertEquals('foo', $file->getContent());
+    }
 
-	/**
-	 * Test restoring a file whenever the source folder was removed.
-	 * The file should then land in the root.
-	 */
-	public function testRestoreFileWithMissingSourceFolder(): void {
-		$userFolder = \OC::$server->getUserFolder();
-		$folder = $userFolder->newFolder('folder');
-		$file = $folder->newFile('file1.txt');
-		$file->putContent('foo');
+    /**
+     * Test restoring a file whenever the source folder was removed.
+     * The file should then land in the root.
+     */
+    public function testRestoreFileWithMissingSourceFolder(): void {
+        $userFolder = \OC::$server->getUserFolder();
+        $folder = $userFolder->newFolder('folder');
+        $file = $folder->newFile('file1.txt');
+        $file->putContent('foo');
 
-		$this->assertTrue($userFolder->nodeExists('folder/file1.txt'));
+        $this->assertTrue($userFolder->nodeExists('folder/file1.txt'));
 
-		$file->delete();
+        $file->delete();
 
-		$this->assertFalse($userFolder->nodeExists('folder/file1.txt'));
-
-		$filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
-		$this->assertCount(1, $filesInTrash);
-
-		/** @var FileInfo */
-		$trashedFile = $filesInTrash[0];
-
-		// delete source folder
-		$folder->delete();
-
-		$this->assertTrue(
-			Trashbin::restore(
-				'file1.txt.d' . $trashedFile->getMtime(),
-				$trashedFile->getName(),
-				$trashedFile->getMtime()
-			)
-		);
-
-		$file = $userFolder->get('file1.txt');
-		$this->assertEquals('foo', $file->getContent());
-	}
-
-	/**
-	 * Test restoring a file in the root folder whenever there is another file
-	 * with the same name in the root folder
-	 */
-	public function testRestoreFileDoesNotOverwriteExistingInRoot(): void {
-		$userFolder = \OC::$server->getUserFolder();
-		$file = $userFolder->newFile('file1.txt');
-		$file->putContent('foo');
-
-		$this->assertTrue($userFolder->nodeExists('file1.txt'));
-
-		$file->delete();
-
-		$this->assertFalse($userFolder->nodeExists('file1.txt'));
-
-		$filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
-		$this->assertCount(1, $filesInTrash);
-
-		/** @var FileInfo */
-		$trashedFile = $filesInTrash[0];
-
-		// create another file
-		$file = $userFolder->newFile('file1.txt');
-		$file->putContent('bar');
-
-		$this->assertTrue(
-			Trashbin::restore(
-				'file1.txt.d' . $trashedFile->getMtime(),
-				$trashedFile->getName(),
-				$trashedFile->getMtime()
-			)
-		);
-
-		$anotherFile = $userFolder->get('file1.txt');
-		$this->assertEquals('bar', $anotherFile->getContent());
-
-		$restoredFile = $userFolder->get('file1 (restored).txt');
-		$this->assertEquals('foo', $restoredFile->getContent());
-	}
-
-	/**
-	 * Test restoring a file whenever there is another file
-	 * with the same name in the source folder
-	 */
-	public function testRestoreFileDoesNotOverwriteExistingInSubfolder(): void {
-		$userFolder = \OC::$server->getUserFolder();
-		$folder = $userFolder->newFolder('folder');
-		$file = $folder->newFile('file1.txt');
-		$file->putContent('foo');
-
-		$this->assertTrue($userFolder->nodeExists('folder/file1.txt'));
-
-		$file->delete();
-
-		$this->assertFalse($userFolder->nodeExists('folder/file1.txt'));
-
-		$filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
-		$this->assertCount(1, $filesInTrash);
-
-		/** @var FileInfo */
-		$trashedFile = $filesInTrash[0];
-
-		// create another file
-		$file = $folder->newFile('file1.txt');
-		$file->putContent('bar');
-
-		$this->assertTrue(
-			Trashbin::restore(
-				'file1.txt.d' . $trashedFile->getMtime(),
-				$trashedFile->getName(),
-				$trashedFile->getMtime()
-			)
-		);
-
-		$anotherFile = $userFolder->get('folder/file1.txt');
-		$this->assertEquals('bar', $anotherFile->getContent());
-
-		$restoredFile = $userFolder->get('folder/file1 (restored).txt');
-		$this->assertEquals('foo', $restoredFile->getContent());
-	}
-
-	/**
-	 * Test restoring a non-existing file from trashbin, returns false
-	 */
-	public function testRestoreUnexistingFile(): void {
-		$this->assertFalse(
-			Trashbin::restore(
-				'unexist.txt.d123456',
-				'unexist.txt',
-				'123456'
-			)
-		);
-	}
-
-	/**
-	 * Test restoring a file into a read-only folder, will restore
-	 * the file to root instead
-	 */
-	public function testRestoreFileIntoReadOnlySourceFolder(): void {
-		$userFolder = \OC::$server->getUserFolder();
-		$folder = $userFolder->newFolder('folder');
-		$file = $folder->newFile('file1.txt');
-		$file->putContent('foo');
-
-		$this->assertTrue($userFolder->nodeExists('folder/file1.txt'));
-
-		$file->delete();
-
-		$this->assertFalse($userFolder->nodeExists('folder/file1.txt'));
-
-		$filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
-		$this->assertCount(1, $filesInTrash);
-
-		/** @var FileInfo */
-		$trashedFile = $filesInTrash[0];
-
-		// delete source folder
-		[$storage, $internalPath] = $this->rootView->resolvePath('/' . self::TEST_TRASHBIN_USER1 . '/files/folder');
-		if ($storage instanceof Local) {
-			$folderAbsPath = $storage->getSourcePath($internalPath);
-			// make folder read-only
-			chmod($folderAbsPath, 0555);
-
-			$this->assertTrue(
-				Trashbin::restore(
-					'file1.txt.d' . $trashedFile->getMtime(),
-					$trashedFile->getName(),
-					$trashedFile->getMtime()
-				)
-			);
-
-			$file = $userFolder->get('file1.txt');
-			$this->assertEquals('foo', $file->getContent());
-
-			chmod($folderAbsPath, 0755);
-		}
-	}
-
-	/**
-	 * @param string $user
-	 * @param bool $create
-	 */
-	public static function loginHelper($user, $create = false) {
-		if ($create) {
-			try {
-				Server::get(IUserManager::class)->createUser($user, $user);
-			} catch (\Exception $e) { // catch username is already being used from previous aborted runs
-			}
-		}
-
-		\OC_Util::tearDownFS();
-		\OC_User::setUserId('');
-		Filesystem::tearDown();
-		\OC_User::setUserId($user);
-		\OC_Util::setupFS($user);
-		\OC::$server->getUserFolder($user);
-	}
+        $this->assertFalse($userFolder->nodeExists('folder/file1.txt'));
+
+        $filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
+        $this->assertCount(1, $filesInTrash);
+
+        /** @var FileInfo */
+        $trashedFile = $filesInTrash[0];
+
+        // delete source folder
+        $folder->delete();
+
+        $this->assertTrue(
+            Trashbin::restore(
+                'file1.txt.d' . $trashedFile->getMtime(),
+                $trashedFile->getName(),
+                $trashedFile->getMtime()
+            )
+        );
+
+        $file = $userFolder->get('file1.txt');
+        $this->assertEquals('foo', $file->getContent());
+    }
+
+    /**
+     * Test restoring a file in the root folder whenever there is another file
+     * with the same name in the root folder
+     */
+    public function testRestoreFileDoesNotOverwriteExistingInRoot(): void {
+        $userFolder = \OC::$server->getUserFolder();
+        $file = $userFolder->newFile('file1.txt');
+        $file->putContent('foo');
+
+        $this->assertTrue($userFolder->nodeExists('file1.txt'));
+
+        $file->delete();
+
+        $this->assertFalse($userFolder->nodeExists('file1.txt'));
+
+        $filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
+        $this->assertCount(1, $filesInTrash);
+
+        /** @var FileInfo */
+        $trashedFile = $filesInTrash[0];
+
+        // create another file
+        $file = $userFolder->newFile('file1.txt');
+        $file->putContent('bar');
+
+        $this->assertTrue(
+            Trashbin::restore(
+                'file1.txt.d' . $trashedFile->getMtime(),
+                $trashedFile->getName(),
+                $trashedFile->getMtime()
+            )
+        );
+
+        $anotherFile = $userFolder->get('file1.txt');
+        $this->assertEquals('bar', $anotherFile->getContent());
+
+        $restoredFile = $userFolder->get('file1 (restored).txt');
+        $this->assertEquals('foo', $restoredFile->getContent());
+    }
+
+    /**
+     * Test restoring a file whenever there is another file
+     * with the same name in the source folder
+     */
+    public function testRestoreFileDoesNotOverwriteExistingInSubfolder(): void {
+        $userFolder = \OC::$server->getUserFolder();
+        $folder = $userFolder->newFolder('folder');
+        $file = $folder->newFile('file1.txt');
+        $file->putContent('foo');
+
+        $this->assertTrue($userFolder->nodeExists('folder/file1.txt'));
+
+        $file->delete();
+
+        $this->assertFalse($userFolder->nodeExists('folder/file1.txt'));
+
+        $filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
+        $this->assertCount(1, $filesInTrash);
+
+        /** @var FileInfo */
+        $trashedFile = $filesInTrash[0];
+
+        // create another file
+        $file = $folder->newFile('file1.txt');
+        $file->putContent('bar');
+
+        $this->assertTrue(
+            Trashbin::restore(
+                'file1.txt.d' . $trashedFile->getMtime(),
+                $trashedFile->getName(),
+                $trashedFile->getMtime()
+            )
+        );
+
+        $anotherFile = $userFolder->get('folder/file1.txt');
+        $this->assertEquals('bar', $anotherFile->getContent());
+
+        $restoredFile = $userFolder->get('folder/file1 (restored).txt');
+        $this->assertEquals('foo', $restoredFile->getContent());
+    }
+
+    /**
+     * Test restoring a non-existing file from trashbin, returns false
+     */
+    public function testRestoreUnexistingFile(): void {
+        $this->assertFalse(
+            Trashbin::restore(
+                'unexist.txt.d123456',
+                'unexist.txt',
+                '123456'
+            )
+        );
+    }
+
+    /**
+     * Test restoring a file into a read-only folder, will restore
+     * the file to root instead
+     */
+    public function testRestoreFileIntoReadOnlySourceFolder(): void {
+        $userFolder = \OC::$server->getUserFolder();
+        $folder = $userFolder->newFolder('folder');
+        $file = $folder->newFile('file1.txt');
+        $file->putContent('foo');
+
+        $this->assertTrue($userFolder->nodeExists('folder/file1.txt'));
+
+        $file->delete();
+
+        $this->assertFalse($userFolder->nodeExists('folder/file1.txt'));
+
+        $filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'mtime');
+        $this->assertCount(1, $filesInTrash);
+
+        /** @var FileInfo */
+        $trashedFile = $filesInTrash[0];
+
+        // delete source folder
+        [$storage, $internalPath] = $this->rootView->resolvePath('/' . self::TEST_TRASHBIN_USER1 . '/files/folder');
+        if ($storage instanceof Local) {
+            $folderAbsPath = $storage->getSourcePath($internalPath);
+            // make folder read-only
+            chmod($folderAbsPath, 0555);
+
+            $this->assertTrue(
+                Trashbin::restore(
+                    'file1.txt.d' . $trashedFile->getMtime(),
+                    $trashedFile->getName(),
+                    $trashedFile->getMtime()
+                )
+            );
+
+            $file = $userFolder->get('file1.txt');
+            $this->assertEquals('foo', $file->getContent());
+
+            chmod($folderAbsPath, 0755);
+        }
+    }
+
+    /**
+     * @param string $user
+     * @param bool $create
+     */
+    public static function loginHelper($user, $create = false) {
+        if ($create) {
+            try {
+                Server::get(IUserManager::class)->createUser($user, $user);
+            } catch (\Exception $e) { // catch username is already being used from previous aborted runs
+            }
+        }
+
+        \OC_Util::tearDownFS();
+        \OC_User::setUserId('');
+        Filesystem::tearDown();
+        \OC_User::setUserId($user);
+        \OC_Util::setupFS($user);
+        \OC::$server->getUserFolder($user);
+    }
 }
 
 
 // just a dummy class to make protected methods available for testing
 class TrashbinForTesting extends Trashbin {
 
-	/**
-	 * @param FileInfo[] $files
-	 * @param integer $limit
-	 */
-	public function dummyDeleteExpiredFiles($files) {
-		// dummy value for $retention_obligation because it is not needed here
-		return parent::deleteExpiredFiles($files, TrashbinTest::TEST_TRASHBIN_USER1);
-	}
-
-	/**
-	 * @param FileInfo[] $files
-	 * @param integer $availableSpace
-	 */
-	public function dummyDeleteFiles($files, $availableSpace) {
-		return parent::deleteFiles($files, TrashbinTest::TEST_TRASHBIN_USER1, $availableSpace);
-	}
+    /**
+     * @param FileInfo[] $files
+     * @param integer $limit
+     */
+    public function dummyDeleteExpiredFiles($files) {
+        // dummy value for $retention_obligation because it is not needed here
+        return parent::deleteExpiredFiles($files, TrashbinTest::TEST_TRASHBIN_USER1);
+    }
+
+    /**
+     * @param FileInfo[] $files
+     * @param integer $availableSpace
+     */
+    public function dummyDeleteFiles($files, $availableSpace) {
+        return parent::deleteFiles($files, TrashbinTest::TEST_TRASHBIN_USER1, $availableSpace);
+    }
 }

Spacing +27 added lines, -27 removed lines

@@ -122,7 +122,7 @@ 
 			->getMock();
 		$mockConfig->expects($this->any())
 			->method('getSystemValue')
-			->willReturnCallback(static function ($key, $default) use ($config) {
+			->willReturnCallback(static function($key, $default) use ($config) {
 				if ($key === 'filesystem_check_changes') {
 					return Watcher::CHECK_ONCE;
 				} else {
@@ -131,8 +131,8 @@ 
 			});
 		$this->overwriteService(AllConfig::class, $mockConfig);
 
-		$this->trashRoot1 = '/' . self::TEST_TRASHBIN_USER1 . '/files_trashbin';
-		$this->trashRoot2 = '/' . self::TEST_TRASHBIN_USER2 . '/files_trashbin';
+		$this->trashRoot1 = '/'.self::TEST_TRASHBIN_USER1.'/files_trashbin';
+		$this->trashRoot2 = '/'.self::TEST_TRASHBIN_USER2.'/files_trashbin';
 		$this->rootView = new View();
 		self::loginHelper(self::TEST_TRASHBIN_USER1);
 	}
@@ -142,8 +142,8 @@ 
 		// disable trashbin to be able to properly clean up
 		Server::get(IAppManager::class)->disableApp('files_trashbin');
 
-		$this->rootView->deleteAll('/' . self::TEST_TRASHBIN_USER1 . '/files');
-		$this->rootView->deleteAll('/' . self::TEST_TRASHBIN_USER2 . '/files');
+		$this->rootView->deleteAll('/'.self::TEST_TRASHBIN_USER1.'/files');
+		$this->rootView->deleteAll('/'.self::TEST_TRASHBIN_USER2.'/files');
 		$this->rootView->deleteAll($this->trashRoot1);
 		$this->rootView->deleteAll($this->trashRoot2);
 
@@ -211,15 +211,15 @@ 
 	 */
 	public function testExpireOldFilesShared(): void {
 		$currentTime = time();
-		$folder = 'trashTest-' . $currentTime . '/';
+		$folder = 'trashTest-'.$currentTime.'/';
 		$expiredDate = $currentTime - 3 * 24 * 60 * 60;
 
 		// create some files
 		Filesystem::mkdir($folder);
-		Filesystem::file_put_contents($folder . 'user1-1.txt', 'file1');
-		Filesystem::file_put_contents($folder . 'user1-2.txt', 'file2');
-		Filesystem::file_put_contents($folder . 'user1-3.txt', 'file3');
-		Filesystem::file_put_contents($folder . 'user1-4.txt', 'file4');
+		Filesystem::file_put_contents($folder.'user1-1.txt', 'file1');
+		Filesystem::file_put_contents($folder.'user1-2.txt', 'file2');
+		Filesystem::file_put_contents($folder.'user1-3.txt', 'file3');
+		Filesystem::file_put_contents($folder.'user1-4.txt', 'file4');
 
 		//share user1-4.txt with user2
 		$node = \OC::$server->getUserFolder(self::TEST_TRASHBIN_USER1)->get($folder);
@@ -233,9 +233,9 @@ 
 		Server::get(\OCP\Share\IManager::class)->acceptShare($share, self::TEST_TRASHBIN_USER2);
 
 		// delete them so that they end up in the trash bin
-		Filesystem::unlink($folder . 'user1-1.txt');
-		Filesystem::unlink($folder . 'user1-2.txt');
-		Filesystem::unlink($folder . 'user1-3.txt');
+		Filesystem::unlink($folder.'user1-1.txt');
+		Filesystem::unlink($folder.'user1-2.txt');
+		Filesystem::unlink($folder.'user1-3.txt');
 
 		$filesInTrash = Helper::getTrashFiles('/', self::TEST_TRASHBIN_USER1, 'name');
 		$this->assertSame(3, count($filesInTrash));
@@ -246,7 +246,7 @@ 
 		// login as user2
 		self::loginHelper(self::TEST_TRASHBIN_USER2);
 
-		$this->assertTrue(Filesystem::file_exists($folder . 'user1-4.txt'));
+		$this->assertTrue(Filesystem::file_exists($folder.'user1-4.txt'));
 
 		// create some files
 		Filesystem::file_put_contents('user2-1.txt', 'file1');
@@ -262,7 +262,7 @@ 
 		// every second file will get a date in the past so that it will get expired
 		$this->manipulateDeleteTime($filesInTrashUser2, $this->trashRoot2, $expiredDate);
 
-		Filesystem::unlink($folder . 'user1-4.txt');
+		Filesystem::unlink($folder.'user1-4.txt');
 
 		$this->runCommands();
 
@@ -297,7 +297,7 @@ 
 			}
 			if (!$found) {
 				// if we didn't found the expected file, something went wrong
-				$this->assertTrue(false, "can't find expected file '" . $expectedFile . "' in trash bin");
+				$this->assertTrue(false, "can't find expected file '".$expectedFile."' in trash bin");
 			}
 		}
 	}
@@ -313,8 +313,8 @@ 
 			// modify every second file
 			$counter = ($counter + 1) % 2;
 			if ($counter === 1) {
-				$source = $trashRoot . '/files/' . $file['name'] . '.d' . $file['mtime'];
-				$target = Filesystem::normalizePath($trashRoot . '/files/' . $file['name'] . '.d' . $expireDate);
+				$source = $trashRoot.'/files/'.$file['name'].'.d'.$file['mtime'];
+				$target = Filesystem::normalizePath($trashRoot.'/files/'.$file['name'].'.d'.$expireDate);
 				$this->rootView->rename($source, $target);
 				$file['mtime'] = $expireDate;
 			}
@@ -379,7 +379,7 @@ 
 
 		$this->assertTrue(
 			Trashbin::restore(
-				'file1.txt.d' . $trashedFile->getMtime(),
+				'file1.txt.d'.$trashedFile->getMtime(),
 				$trashedFile->getName(),
 				$trashedFile->getMtime()
 			)
@@ -412,7 +412,7 @@ 
 
 		$this->assertTrue(
 			Trashbin::restore(
-				'file1.txt.d' . $trashedFile->getMtime(),
+				'file1.txt.d'.$trashedFile->getMtime(),
 				$trashedFile->getName(),
 				$trashedFile->getMtime()
 			)
@@ -445,7 +445,7 @@ 
 
 		$this->assertTrue(
 			Trashbin::restore(
-				'folder.d' . $trashedFolder->getMtime(),
+				'folder.d'.$trashedFolder->getMtime(),
 				$trashedFolder->getName(),
 				$trashedFolder->getMtime()
 			)
@@ -478,7 +478,7 @@ 
 
 		$this->assertTrue(
 			Trashbin::restore(
-				'folder.d' . $trashedFile->getMtime() . '/file1.txt',
+				'folder.d'.$trashedFile->getMtime().'/file1.txt',
 				'file1.txt',
 				$trashedFile->getMtime()
 			)
@@ -515,7 +515,7 @@ 
 
 		$this->assertTrue(
 			Trashbin::restore(
-				'file1.txt.d' . $trashedFile->getMtime(),
+				'file1.txt.d'.$trashedFile->getMtime(),
 				$trashedFile->getName(),
 				$trashedFile->getMtime()
 			)
@@ -552,7 +552,7 @@ 
 
 		$this->assertTrue(
 			Trashbin::restore(
-				'file1.txt.d' . $trashedFile->getMtime(),
+				'file1.txt.d'.$trashedFile->getMtime(),
 				$trashedFile->getName(),
 				$trashedFile->getMtime()
 			)
@@ -593,7 +593,7 @@ 
 
 		$this->assertTrue(
 			Trashbin::restore(
-				'file1.txt.d' . $trashedFile->getMtime(),
+				'file1.txt.d'.$trashedFile->getMtime(),
 				$trashedFile->getName(),
 				$trashedFile->getMtime()
 			)
@@ -642,7 +642,7 @@ 
 		$trashedFile = $filesInTrash[0];
 
 		// delete source folder
-		[$storage, $internalPath] = $this->rootView->resolvePath('/' . self::TEST_TRASHBIN_USER1 . '/files/folder');
+		[$storage, $internalPath] = $this->rootView->resolvePath('/'.self::TEST_TRASHBIN_USER1.'/files/folder');
 		if ($storage instanceof Local) {
 			$folderAbsPath = $storage->getSourcePath($internalPath);
 			// make folder read-only
@@ -650,7 +650,7 @@ 
 
 			$this->assertTrue(
 				Trashbin::restore(
-					'file1.txt.d' . $trashedFile->getMtime(),
+					'file1.txt.d'.$trashedFile->getMtime(),
 					$trashedFile->getName(),
 					$trashedFile->getMtime()
 				)

apps/admin_audit/lib/Actions/Files.php

Indentation +139 added lines, -139 removed lines

@@ -25,151 +25,151 @@
  * @package OCA\AdminAudit\Actions
  */
 class Files extends Action {
-	/**
-	 * Logs file read actions
-	 */
-	public function read(BeforeNodeReadEvent $event): void {
-		try {
-			$node = $event->getNode();
-			$params = [
-				'id' => $node instanceof NonExistingFile ? null : $node->getId(),
-				'path' => $node->getPath(),
-			];
-		} catch (InvalidPathException|NotFoundException $e) {
-			Server::get(LoggerInterface::class)->error(
-				'Exception thrown in file read: ' . $e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
-			);
-			return;
-		}
-		$this->log(
-			'File with id "%s" accessed: "%s"',
-			$params,
-			array_keys($params)
-		);
-	}
+    /**
+     * Logs file read actions
+     */
+    public function read(BeforeNodeReadEvent $event): void {
+        try {
+            $node = $event->getNode();
+            $params = [
+                'id' => $node instanceof NonExistingFile ? null : $node->getId(),
+                'path' => $node->getPath(),
+            ];
+        } catch (InvalidPathException|NotFoundException $e) {
+            Server::get(LoggerInterface::class)->error(
+                'Exception thrown in file read: ' . $e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
+            );
+            return;
+        }
+        $this->log(
+            'File with id "%s" accessed: "%s"',
+            $params,
+            array_keys($params)
+        );
+    }
 
-	/**
-	 * Logs rename actions of files
-	 */
-	public function afterRename(NodeRenamedEvent $event): void {
-		try {
-			$target = $event->getTarget();
-			$source = $event->getSource();
-			$params = [
-				'newid' => $target->getId(),
-				'oldpath' => $source->getPath(),
-				'newpath' => $target->getPath(),
-			];
-		} catch (InvalidPathException|NotFoundException $e) {
-			Server::get(LoggerInterface::class)->error(
-				'Exception thrown in file rename: ' . $e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
-			);
-			return;
-		}
+    /**
+     * Logs rename actions of files
+     */
+    public function afterRename(NodeRenamedEvent $event): void {
+        try {
+            $target = $event->getTarget();
+            $source = $event->getSource();
+            $params = [
+                'newid' => $target->getId(),
+                'oldpath' => $source->getPath(),
+                'newpath' => $target->getPath(),
+            ];
+        } catch (InvalidPathException|NotFoundException $e) {
+            Server::get(LoggerInterface::class)->error(
+                'Exception thrown in file rename: ' . $e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
+            );
+            return;
+        }
 
-		$this->log(
-			'File renamed with id "%s" from "%s" to "%s"',
-			$params,
-			array_keys($params)
-		);
-	}
+        $this->log(
+            'File renamed with id "%s" from "%s" to "%s"',
+            $params,
+            array_keys($params)
+        );
+    }
 
 
-	/**
-	 * Logs creation of files
-	 */
-	public function create(NodeCreatedEvent $event): void {
-		try {
-			$params = [
-				'id' => $event->getNode()->getId(),
-				'path' => $event->getNode()->getPath(),
-			];
-		} catch (InvalidPathException|NotFoundException $e) {
-			Server::get(LoggerInterface::class)->error(
-				'Exception thrown in file create: ' . $e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
-			);
-			return;
-		}
-		if ($params['path'] === '/' || $params['path'] === '') {
-			return;
-		}
-		$this->log(
-			'File with id "%s" created: "%s"',
-			$params,
-			array_keys($params)
-		);
-	}
+    /**
+     * Logs creation of files
+     */
+    public function create(NodeCreatedEvent $event): void {
+        try {
+            $params = [
+                'id' => $event->getNode()->getId(),
+                'path' => $event->getNode()->getPath(),
+            ];
+        } catch (InvalidPathException|NotFoundException $e) {
+            Server::get(LoggerInterface::class)->error(
+                'Exception thrown in file create: ' . $e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
+            );
+            return;
+        }
+        if ($params['path'] === '/' || $params['path'] === '') {
+            return;
+        }
+        $this->log(
+            'File with id "%s" created: "%s"',
+            $params,
+            array_keys($params)
+        );
+    }
 
-	/**
-	 * Logs copying of files
-	 */
-	public function copy(NodeCopiedEvent $event): void {
-		try {
-			$params = [
-				'oldid' => $event->getSource()->getId(),
-				'newid' => $event->getTarget()->getId(),
-				'oldpath' => $event->getSource()->getPath(),
-				'newpath' => $event->getTarget()->getPath(),
-			];
-		} catch (InvalidPathException|NotFoundException $e) {
-			Server::get(LoggerInterface::class)->error(
-				'Exception thrown in file copy: ' . $e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
-			);
-			return;
-		}
-		$this->log(
-			'File id copied from: "%s" to "%s", path from "%s" to "%s"',
-			$params,
-			array_keys($params)
-		);
-	}
+    /**
+     * Logs copying of files
+     */
+    public function copy(NodeCopiedEvent $event): void {
+        try {
+            $params = [
+                'oldid' => $event->getSource()->getId(),
+                'newid' => $event->getTarget()->getId(),
+                'oldpath' => $event->getSource()->getPath(),
+                'newpath' => $event->getTarget()->getPath(),
+            ];
+        } catch (InvalidPathException|NotFoundException $e) {
+            Server::get(LoggerInterface::class)->error(
+                'Exception thrown in file copy: ' . $e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
+            );
+            return;
+        }
+        $this->log(
+            'File id copied from: "%s" to "%s", path from "%s" to "%s"',
+            $params,
+            array_keys($params)
+        );
+    }
 
-	/**
-	 * Logs writing of files
-	 */
-	public function write(NodeWrittenEvent $event): void {
-		$node = $event->getNode();
-		try {
-			$params = [
-				'id' => $node->getId(),
-				'path' => $node->getPath(),
-			];
-		} catch (InvalidPathException|NotFoundException $e) {
-			Server::get(LoggerInterface::class)->error(
-				'Exception thrown in file write: ' . $e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
-			);
-			return;
-		}
-		if ($params['path'] === '/' || $params['path'] === '') {
-			return;
-		}
+    /**
+     * Logs writing of files
+     */
+    public function write(NodeWrittenEvent $event): void {
+        $node = $event->getNode();
+        try {
+            $params = [
+                'id' => $node->getId(),
+                'path' => $node->getPath(),
+            ];
+        } catch (InvalidPathException|NotFoundException $e) {
+            Server::get(LoggerInterface::class)->error(
+                'Exception thrown in file write: ' . $e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
+            );
+            return;
+        }
+        if ($params['path'] === '/' || $params['path'] === '') {
+            return;
+        }
 
-		$this->log(
-			'File with id "%s" written to: "%s"',
-			$params,
-			array_keys($params)
-		);
-	}
+        $this->log(
+            'File with id "%s" written to: "%s"',
+            $params,
+            array_keys($params)
+        );
+    }
 
-	/**
-	 * Logs deletions of files
-	 */
-	public function delete(BeforeNodeDeletedEvent $event): void {
-		try {
-			$params = [
-				'id' => $event->getNode()->getId(),
-				'path' => $event->getNode()->getPath(),
-			];
-		} catch (InvalidPathException|NotFoundException $e) {
-			Server::get(LoggerInterface::class)->error(
-				'Exception thrown in file delete: ' . $e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
-			);
-			return;
-		}
-		$this->log(
-			'File with id "%s" deleted: "%s"',
-			$params,
-			array_keys($params)
-		);
-	}
+    /**
+     * Logs deletions of files
+     */
+    public function delete(BeforeNodeDeletedEvent $event): void {
+        try {
+            $params = [
+                'id' => $event->getNode()->getId(),
+                'path' => $event->getNode()->getPath(),
+            ];
+        } catch (InvalidPathException|NotFoundException $e) {
+            Server::get(LoggerInterface::class)->error(
+                'Exception thrown in file delete: ' . $e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
+            );
+            return;
+        }
+        $this->log(
+            'File with id "%s" deleted: "%s"',
+            $params,
+            array_keys($params)
+        );
+    }
 }

Spacing +12 added lines, -12 removed lines

@@ -35,9 +35,9 @@ 
 				'id' => $node instanceof NonExistingFile ? null : $node->getId(),
 				'path' => $node->getPath(),
 			];
-		} catch (InvalidPathException|NotFoundException $e) {
+		} catch (InvalidPathException | NotFoundException $e) {
 			Server::get(LoggerInterface::class)->error(
-				'Exception thrown in file read: ' . $e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
+				'Exception thrown in file read: '.$e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
 			);
 			return;
 		}
@@ -60,9 +60,9 @@ 
 				'oldpath' => $source->getPath(),
 				'newpath' => $target->getPath(),
 			];
-		} catch (InvalidPathException|NotFoundException $e) {
+		} catch (InvalidPathException | NotFoundException $e) {
 			Server::get(LoggerInterface::class)->error(
-				'Exception thrown in file rename: ' . $e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
+				'Exception thrown in file rename: '.$e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
 			);
 			return;
 		}
@@ -84,9 +84,9 @@ 
 				'id' => $event->getNode()->getId(),
 				'path' => $event->getNode()->getPath(),
 			];
-		} catch (InvalidPathException|NotFoundException $e) {
+		} catch (InvalidPathException | NotFoundException $e) {
 			Server::get(LoggerInterface::class)->error(
-				'Exception thrown in file create: ' . $e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
+				'Exception thrown in file create: '.$e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
 			);
 			return;
 		}
@@ -111,9 +111,9 @@ 
 				'oldpath' => $event->getSource()->getPath(),
 				'newpath' => $event->getTarget()->getPath(),
 			];
-		} catch (InvalidPathException|NotFoundException $e) {
+		} catch (InvalidPathException | NotFoundException $e) {
 			Server::get(LoggerInterface::class)->error(
-				'Exception thrown in file copy: ' . $e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
+				'Exception thrown in file copy: '.$e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
 			);
 			return;
 		}
@@ -134,9 +134,9 @@ 
 				'id' => $node->getId(),
 				'path' => $node->getPath(),
 			];
-		} catch (InvalidPathException|NotFoundException $e) {
+		} catch (InvalidPathException | NotFoundException $e) {
 			Server::get(LoggerInterface::class)->error(
-				'Exception thrown in file write: ' . $e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
+				'Exception thrown in file write: '.$e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
 			);
 			return;
 		}
@@ -160,9 +160,9 @@ 
 				'id' => $event->getNode()->getId(),
 				'path' => $event->getNode()->getPath(),
 			];
-		} catch (InvalidPathException|NotFoundException $e) {
+		} catch (InvalidPathException | NotFoundException $e) {
 			Server::get(LoggerInterface::class)->error(
-				'Exception thrown in file delete: ' . $e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
+				'Exception thrown in file delete: '.$e->getMessage(), ['app' => 'admin_audit', 'exception' => $e]
 			);
 			return;
 		}

apps/admin_audit/lib/AppInfo/Application.php

Indentation +147 added lines, -147 removed lines

@@ -72,154 +72,154 @@
 use Psr\Container\ContainerInterface;
 
 class Application extends App implements IBootstrap {
-	public function __construct() {
-		parent::__construct('admin_audit');
-	}
-
-	public function register(IRegistrationContext $context): void {
-		$context->registerService(IAuditLogger::class, function (ContainerInterface $c) {
-			return new AuditLogger($c->get(ILogFactory::class), $c->get(IConfig::class));
-		});
-
-		$context->registerEventListener(CriticalActionPerformedEvent::class, CriticalActionPerformedEventListener::class);
-
-		// User management events
-		$context->registerEventListener(UserCreatedEvent::class, UserManagementEventListener::class);
-		$context->registerEventListener(UserDeletedEvent::class, UserManagementEventListener::class);
-		$context->registerEventListener(UserChangedEvent::class, UserManagementEventListener::class);
-		$context->registerEventListener(PasswordUpdatedEvent::class, UserManagementEventListener::class);
-		$context->registerEventListener(UserIdAssignedEvent::class, UserManagementEventListener::class);
-		$context->registerEventListener(UserIdUnassignedEvent::class, UserManagementEventListener::class);
-
-		// Group management events
-		$context->registerEventListener(UserAddedEvent::class, GroupManagementEventListener::class);
-		$context->registerEventListener(UserRemovedEvent::class, GroupManagementEventListener::class);
-		$context->registerEventListener(GroupCreatedEvent::class, GroupManagementEventListener::class);
-		$context->registerEventListener(GroupDeletedEvent::class, GroupManagementEventListener::class);
-
-		// Sharing events
-		$context->registerEventListener(ShareCreatedEvent::class, SharingEventListener::class);
-		$context->registerEventListener(ShareDeletedEvent::class, SharingEventListener::class);
-
-		// Auth events
-		$context->registerEventListener(BeforeUserLoggedInEvent::class, AuthEventListener::class);
-		$context->registerEventListener(UserLoggedInWithCookieEvent::class, AuthEventListener::class);
-		$context->registerEventListener(UserLoggedInEvent::class, AuthEventListener::class);
-		$context->registerEventListener(BeforeUserLoggedOutEvent::class, AuthEventListener::class);
-		$context->registerEventListener(AnyLoginFailedEvent::class, AuthEventListener::class);
-
-		// File events
-		$context->registerEventListener(BeforePreviewFetchedEvent::class, FileEventListener::class);
-		$context->registerEventListener(VersionRestoredEvent::class, FileEventListener::class);
-
-		// Security events
-		$context->registerEventListener(TwoFactorProviderChallengePassed::class, SecurityEventListener::class);
-		$context->registerEventListener(TwoFactorProviderChallengeFailed::class, SecurityEventListener::class);
-
-		// App management events
-		$context->registerEventListener(AppEnableEvent::class, AppManagementEventListener::class);
-		$context->registerEventListener(AppDisableEvent::class, AppManagementEventListener::class);
-		$context->registerEventListener(AppUpdateEvent::class, AppManagementEventListener::class);
-
-		// Console events
-		$context->registerEventListener(ConsoleEvent::class, ConsoleEventListener::class);
-	}
-
-	public function boot(IBootContext $context): void {
-		/** @var IAuditLogger $logger */
-		$logger = $context->getAppContainer()->get(IAuditLogger::class);
-
-		/*
+    public function __construct() {
+        parent::__construct('admin_audit');
+    }
+
+    public function register(IRegistrationContext $context): void {
+        $context->registerService(IAuditLogger::class, function (ContainerInterface $c) {
+            return new AuditLogger($c->get(ILogFactory::class), $c->get(IConfig::class));
+        });
+
+        $context->registerEventListener(CriticalActionPerformedEvent::class, CriticalActionPerformedEventListener::class);
+
+        // User management events
+        $context->registerEventListener(UserCreatedEvent::class, UserManagementEventListener::class);
+        $context->registerEventListener(UserDeletedEvent::class, UserManagementEventListener::class);
+        $context->registerEventListener(UserChangedEvent::class, UserManagementEventListener::class);
+        $context->registerEventListener(PasswordUpdatedEvent::class, UserManagementEventListener::class);
+        $context->registerEventListener(UserIdAssignedEvent::class, UserManagementEventListener::class);
+        $context->registerEventListener(UserIdUnassignedEvent::class, UserManagementEventListener::class);
+
+        // Group management events
+        $context->registerEventListener(UserAddedEvent::class, GroupManagementEventListener::class);
+        $context->registerEventListener(UserRemovedEvent::class, GroupManagementEventListener::class);
+        $context->registerEventListener(GroupCreatedEvent::class, GroupManagementEventListener::class);
+        $context->registerEventListener(GroupDeletedEvent::class, GroupManagementEventListener::class);
+
+        // Sharing events
+        $context->registerEventListener(ShareCreatedEvent::class, SharingEventListener::class);
+        $context->registerEventListener(ShareDeletedEvent::class, SharingEventListener::class);
+
+        // Auth events
+        $context->registerEventListener(BeforeUserLoggedInEvent::class, AuthEventListener::class);
+        $context->registerEventListener(UserLoggedInWithCookieEvent::class, AuthEventListener::class);
+        $context->registerEventListener(UserLoggedInEvent::class, AuthEventListener::class);
+        $context->registerEventListener(BeforeUserLoggedOutEvent::class, AuthEventListener::class);
+        $context->registerEventListener(AnyLoginFailedEvent::class, AuthEventListener::class);
+
+        // File events
+        $context->registerEventListener(BeforePreviewFetchedEvent::class, FileEventListener::class);
+        $context->registerEventListener(VersionRestoredEvent::class, FileEventListener::class);
+
+        // Security events
+        $context->registerEventListener(TwoFactorProviderChallengePassed::class, SecurityEventListener::class);
+        $context->registerEventListener(TwoFactorProviderChallengeFailed::class, SecurityEventListener::class);
+
+        // App management events
+        $context->registerEventListener(AppEnableEvent::class, AppManagementEventListener::class);
+        $context->registerEventListener(AppDisableEvent::class, AppManagementEventListener::class);
+        $context->registerEventListener(AppUpdateEvent::class, AppManagementEventListener::class);
+
+        // Console events
+        $context->registerEventListener(ConsoleEvent::class, ConsoleEventListener::class);
+    }
+
+    public function boot(IBootContext $context): void {
+        /** @var IAuditLogger $logger */
+        $logger = $context->getAppContainer()->get(IAuditLogger::class);
+
+        /*
 		 * TODO: once the hooks are migrated to lazy events, this should be done
 		 *       in \OCA\AdminAudit\AppInfo\Application::register
 		 */
-		$this->registerLegacyHooks($logger, $context->getServerContainer());
-	}
-
-	/**
-	 * Register hooks in order to log them
-	 */
-	private function registerLegacyHooks(IAuditLogger $logger, ContainerInterface $serverContainer): void {
-		/** @var IEventDispatcher $eventDispatcher */
-		$eventDispatcher = $serverContainer->get(IEventDispatcher::class);
-		$this->sharingLegacyHooks($logger);
-		$this->fileHooks($logger, $eventDispatcher);
-		$this->trashbinHooks($logger);
-		$this->versionsHooks($logger);
-		$this->tagHooks($logger, $eventDispatcher);
-	}
-
-	private function sharingLegacyHooks(IAuditLogger $logger): void {
-		$shareActions = new Sharing($logger);
-
-		Util::connectHook(Share::class, 'post_update_permissions', $shareActions, 'updatePermissions');
-		Util::connectHook(Share::class, 'post_update_password', $shareActions, 'updatePassword');
-		Util::connectHook(Share::class, 'post_set_expiration_date', $shareActions, 'updateExpirationDate');
-		Util::connectHook(Share::class, 'share_link_access', $shareActions, 'shareAccessed');
-	}
-
-	private function tagHooks(IAuditLogger $logger,
-		IEventDispatcher $eventDispatcher): void {
-		$eventDispatcher->addListener(ManagerEvent::EVENT_CREATE, function (ManagerEvent $event) use ($logger): void {
-			$tagActions = new TagManagement($logger);
-			$tagActions->createTag($event->getTag());
-		});
-	}
-
-	private function fileHooks(IAuditLogger $logger, IEventDispatcher $eventDispatcher): void {
-		$fileActions = new Files($logger);
-
-		$eventDispatcher->addListener(
-			NodeRenamedEvent::class,
-			function (NodeRenamedEvent $event) use ($fileActions): void {
-				$fileActions->afterRename($event);
-			}
-		);
-
-		$eventDispatcher->addListener(
-			NodeCreatedEvent::class,
-			function (NodeCreatedEvent $event) use ($fileActions): void {
-				$fileActions->create($event);
-			}
-		);
-
-		$eventDispatcher->addListener(
-			NodeCopiedEvent::class,
-			function (NodeCopiedEvent $event) use ($fileActions): void {
-				$fileActions->copy($event);
-			}
-		);
-
-		$eventDispatcher->addListener(
-			NodeWrittenEvent::class,
-			function (NodeWrittenEvent $event) use ($fileActions): void {
-				$fileActions->write($event);
-			}
-		);
-
-		$eventDispatcher->addListener(
-			BeforeNodeReadEvent::class,
-			function (BeforeNodeReadEvent $event) use ($fileActions): void {
-				$fileActions->read($event);
-			}
-		);
-
-		$eventDispatcher->addListener(
-			BeforeNodeDeletedEvent::class,
-			function (BeforeNodeDeletedEvent $event) use ($fileActions): void {
-				$fileActions->delete($event);
-			}
-		);
-	}
-
-	private function versionsHooks(IAuditLogger $logger): void {
-		$versionsActions = new Versions($logger);
-		Util::connectHook('\OCP\Versions', 'delete', $versionsActions, 'delete');
-	}
-
-	private function trashbinHooks(IAuditLogger $logger): void {
-		$trashActions = new Trashbin($logger);
-		Util::connectHook('\OCP\Trashbin', 'preDelete', $trashActions, 'delete');
-		Util::connectHook('\OCA\Files_Trashbin\Trashbin', 'post_restore', $trashActions, 'restore');
-	}
+        $this->registerLegacyHooks($logger, $context->getServerContainer());
+    }
+
+    /**
+     * Register hooks in order to log them
+     */
+    private function registerLegacyHooks(IAuditLogger $logger, ContainerInterface $serverContainer): void {
+        /** @var IEventDispatcher $eventDispatcher */
+        $eventDispatcher = $serverContainer->get(IEventDispatcher::class);
+        $this->sharingLegacyHooks($logger);
+        $this->fileHooks($logger, $eventDispatcher);
+        $this->trashbinHooks($logger);
+        $this->versionsHooks($logger);
+        $this->tagHooks($logger, $eventDispatcher);
+    }
+
+    private function sharingLegacyHooks(IAuditLogger $logger): void {
+        $shareActions = new Sharing($logger);
+
+        Util::connectHook(Share::class, 'post_update_permissions', $shareActions, 'updatePermissions');
+        Util::connectHook(Share::class, 'post_update_password', $shareActions, 'updatePassword');
+        Util::connectHook(Share::class, 'post_set_expiration_date', $shareActions, 'updateExpirationDate');
+        Util::connectHook(Share::class, 'share_link_access', $shareActions, 'shareAccessed');
+    }
+
+    private function tagHooks(IAuditLogger $logger,
+        IEventDispatcher $eventDispatcher): void {
+        $eventDispatcher->addListener(ManagerEvent::EVENT_CREATE, function (ManagerEvent $event) use ($logger): void {
+            $tagActions = new TagManagement($logger);
+            $tagActions->createTag($event->getTag());
+        });
+    }
+
+    private function fileHooks(IAuditLogger $logger, IEventDispatcher $eventDispatcher): void {
+        $fileActions = new Files($logger);
+
+        $eventDispatcher->addListener(
+            NodeRenamedEvent::class,
+            function (NodeRenamedEvent $event) use ($fileActions): void {
+                $fileActions->afterRename($event);
+            }
+        );
+
+        $eventDispatcher->addListener(
+            NodeCreatedEvent::class,
+            function (NodeCreatedEvent $event) use ($fileActions): void {
+                $fileActions->create($event);
+            }
+        );
+
+        $eventDispatcher->addListener(
+            NodeCopiedEvent::class,
+            function (NodeCopiedEvent $event) use ($fileActions): void {
+                $fileActions->copy($event);
+            }
+        );
+
+        $eventDispatcher->addListener(
+            NodeWrittenEvent::class,
+            function (NodeWrittenEvent $event) use ($fileActions): void {
+                $fileActions->write($event);
+            }
+        );
+
+        $eventDispatcher->addListener(
+            BeforeNodeReadEvent::class,
+            function (BeforeNodeReadEvent $event) use ($fileActions): void {
+                $fileActions->read($event);
+            }
+        );
+
+        $eventDispatcher->addListener(
+            BeforeNodeDeletedEvent::class,
+            function (BeforeNodeDeletedEvent $event) use ($fileActions): void {
+                $fileActions->delete($event);
+            }
+        );
+    }
+
+    private function versionsHooks(IAuditLogger $logger): void {
+        $versionsActions = new Versions($logger);
+        Util::connectHook('\OCP\Versions', 'delete', $versionsActions, 'delete');
+    }
+
+    private function trashbinHooks(IAuditLogger $logger): void {
+        $trashActions = new Trashbin($logger);
+        Util::connectHook('\OCP\Trashbin', 'preDelete', $trashActions, 'delete');
+        Util::connectHook('\OCA\Files_Trashbin\Trashbin', 'post_restore', $trashActions, 'restore');
+    }
 }

Spacing +8 added lines, -8 removed lines

@@ -77,7 +77,7 @@ 
 	}
 
 	public function register(IRegistrationContext $context): void {
-		$context->registerService(IAuditLogger::class, function (ContainerInterface $c) {
+		$context->registerService(IAuditLogger::class, function(ContainerInterface $c) {
 			return new AuditLogger($c->get(ILogFactory::class), $c->get(IConfig::class));
 		});
 
@@ -160,7 +160,7 @@ 
 
 	private function tagHooks(IAuditLogger $logger,
 		IEventDispatcher $eventDispatcher): void {
-		$eventDispatcher->addListener(ManagerEvent::EVENT_CREATE, function (ManagerEvent $event) use ($logger): void {
+		$eventDispatcher->addListener(ManagerEvent::EVENT_CREATE, function(ManagerEvent $event) use ($logger): void {
 			$tagActions = new TagManagement($logger);
 			$tagActions->createTag($event->getTag());
 		});
@@ -171,42 +171,42 @@ 
 
 		$eventDispatcher->addListener(
 			NodeRenamedEvent::class,
-			function (NodeRenamedEvent $event) use ($fileActions): void {
+			function(NodeRenamedEvent $event) use ($fileActions): void {
 				$fileActions->afterRename($event);
 			}
 		);
 
 		$eventDispatcher->addListener(
 			NodeCreatedEvent::class,
-			function (NodeCreatedEvent $event) use ($fileActions): void {
+			function(NodeCreatedEvent $event) use ($fileActions): void {
 				$fileActions->create($event);
 			}
 		);
 
 		$eventDispatcher->addListener(
 			NodeCopiedEvent::class,
-			function (NodeCopiedEvent $event) use ($fileActions): void {
+			function(NodeCopiedEvent $event) use ($fileActions): void {
 				$fileActions->copy($event);
 			}
 		);
 
 		$eventDispatcher->addListener(
 			NodeWrittenEvent::class,
-			function (NodeWrittenEvent $event) use ($fileActions): void {
+			function(NodeWrittenEvent $event) use ($fileActions): void {
 				$fileActions->write($event);
 			}
 		);
 
 		$eventDispatcher->addListener(
 			BeforeNodeReadEvent::class,
-			function (BeforeNodeReadEvent $event) use ($fileActions): void {
+			function(BeforeNodeReadEvent $event) use ($fileActions): void {
 				$fileActions->read($event);
 			}
 		);
 
 		$eventDispatcher->addListener(
 			BeforeNodeDeletedEvent::class,
-			function (BeforeNodeDeletedEvent $event) use ($fileActions): void {
+			function(BeforeNodeDeletedEvent $event) use ($fileActions): void {
 				$fileActions->delete($event);
 			}
 		);

apps/files_versions/tests/VersioningTest.php

Indentation +875 added lines, -875 removed lines

@@ -36,964 +36,964 @@
  * @group DB
  */
 class VersioningTest extends \Test\TestCase {
-	public const TEST_VERSIONS_USER = 'test-versions-user';
-	public const TEST_VERSIONS_USER2 = 'test-versions-user2';
-	public const USERS_VERSIONS_ROOT = '/test-versions-user/files_versions';
-
-	/**
-	 * @var View
-	 */
-	private $rootView;
-	/**
-	 * @var VersionsMapper
-	 */
-	private $versionsMapper;
-	/**
-	 * @var IMimeTypeLoader
-	 */
-	private $mimeTypeLoader;
-	private $user1;
-	private $user2;
-
-	public static function setUpBeforeClass(): void {
-		parent::setUpBeforeClass();
-
-		$application = new Application();
-
-		// create test user
-		self::loginHelper(self::TEST_VERSIONS_USER2, true);
-		self::loginHelper(self::TEST_VERSIONS_USER, true);
-	}
-
-	public static function tearDownAfterClass(): void {
-		// cleanup test user
-		$user = Server::get(IUserManager::class)->get(self::TEST_VERSIONS_USER);
-		if ($user !== null) {
-			$user->delete();
-		}
-		$user = Server::get(IUserManager::class)->get(self::TEST_VERSIONS_USER2);
-		if ($user !== null) {
-			$user->delete();
-		}
-
-		parent::tearDownAfterClass();
-	}
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$config = Server::get(IConfig::class);
-		$mockConfig = $this->getMockBuilder(AllConfig::class)
-			->onlyMethods(['getSystemValue'])
-			->setConstructorArgs([Server::get(\OC\SystemConfig::class)])
-			->getMock();
-		$mockConfig->expects($this->any())
-			->method('getSystemValue')
-			->willReturnCallback(function ($key, $default) use ($config) {
-				if ($key === 'filesystem_check_changes') {
-					return Watcher::CHECK_ONCE;
-				} else {
-					return $config->getSystemValue($key, $default);
-				}
-			});
-		$this->overwriteService(AllConfig::class, $mockConfig);
-
-		// clear hooks
-		\OC_Hook::clear();
-		\OC::registerShareHooks(Server::get(SystemConfig::class));
-		\OC::$server->boot();
-
-		self::loginHelper(self::TEST_VERSIONS_USER);
-		$this->rootView = new View();
-		if (!$this->rootView->file_exists(self::USERS_VERSIONS_ROOT)) {
-			$this->rootView->mkdir(self::USERS_VERSIONS_ROOT);
-		}
-
-		$this->versionsMapper = Server::get(VersionsMapper::class);
-		$this->mimeTypeLoader = Server::get(IMimeTypeLoader::class);
-
-		$this->user1 = $this->createMock(IUser::class);
-		$this->user1->method('getUID')
-			->willReturn(self::TEST_VERSIONS_USER);
-		$this->user2 = $this->createMock(IUser::class);
-		$this->user2->method('getUID')
-			->willReturn(self::TEST_VERSIONS_USER2);
-	}
-
-	protected function tearDown(): void {
-		$this->restoreService(AllConfig::class);
-
-		if ($this->rootView) {
-			$this->rootView->deleteAll(self::TEST_VERSIONS_USER . '/files/');
-			$this->rootView->deleteAll(self::TEST_VERSIONS_USER2 . '/files/');
-			$this->rootView->deleteAll(self::TEST_VERSIONS_USER . '/files_versions/');
-			$this->rootView->deleteAll(self::TEST_VERSIONS_USER2 . '/files_versions/');
-		}
-
-		\OC_Hook::clear();
-
-		parent::tearDown();
-	}
-
-	/**
-	 * @medium
-	 * test expire logic
-	 * @dataProvider versionsProvider
-	 */
-	public function testGetExpireList($versions, $sizeOfAllDeletedFiles): void {
-
-		// last interval end at 2592000
-		$startTime = 5000000;
-
-		$testClass = new VersionStorageToTest();
-		[$deleted, $size] = $testClass->callProtectedGetExpireList($startTime, $versions);
-
-		// we should have deleted 16 files each of the size 1
-		$this->assertEquals($sizeOfAllDeletedFiles, $size);
-
-		// the deleted array should only contain versions which should be deleted
-		foreach ($deleted as $key => $path) {
-			unset($versions[$key]);
-			$this->assertEquals('delete', substr($path, 0, strlen('delete')));
-		}
-
-		// the versions array should only contain versions which should be kept
-		foreach ($versions as $version) {
-			$this->assertEquals('keep', $version['path']);
-		}
-	}
-
-	public function versionsProvider() {
-		return [
-			// first set of versions uniformly distributed versions
-			[
-				[
-					// first slice (10sec) keep one version every 2 seconds
-					['version' => 4999999, 'path' => 'keep', 'size' => 1],
-					['version' => 4999998, 'path' => 'delete', 'size' => 1],
-					['version' => 4999997, 'path' => 'keep', 'size' => 1],
-					['version' => 4999995, 'path' => 'keep', 'size' => 1],
-					['version' => 4999994, 'path' => 'delete', 'size' => 1],
-					//next slice (60sec) starts at 4999990 keep one version every 10 secons
-					['version' => 4999988, 'path' => 'keep', 'size' => 1],
-					['version' => 4999978, 'path' => 'keep', 'size' => 1],
-					['version' => 4999975, 'path' => 'delete', 'size' => 1],
-					['version' => 4999972, 'path' => 'delete', 'size' => 1],
-					['version' => 4999967, 'path' => 'keep', 'size' => 1],
-					['version' => 4999958, 'path' => 'delete', 'size' => 1],
-					['version' => 4999957, 'path' => 'keep', 'size' => 1],
-					//next slice (3600sec) start at 4999940 keep one version every 60 seconds
-					['version' => 4999900, 'path' => 'keep', 'size' => 1],
-					['version' => 4999841, 'path' => 'delete', 'size' => 1],
-					['version' => 4999840, 'path' => 'keep', 'size' => 1],
-					['version' => 4999780, 'path' => 'keep', 'size' => 1],
-					['version' => 4996401, 'path' => 'keep', 'size' => 1],
-					// next slice (86400sec) start at 4996400 keep one version every 3600 seconds
-					['version' => 4996350, 'path' => 'delete', 'size' => 1],
-					['version' => 4992800, 'path' => 'keep', 'size' => 1],
-					['version' => 4989800, 'path' => 'delete', 'size' => 1],
-					['version' => 4989700, 'path' => 'delete', 'size' => 1],
-					['version' => 4989200, 'path' => 'keep', 'size' => 1],
-					// next slice (2592000sec) start at 4913600 keep one version every 86400 seconds
-					['version' => 4913600, 'path' => 'keep', 'size' => 1],
-					['version' => 4852800, 'path' => 'delete', 'size' => 1],
-					['version' => 4827201, 'path' => 'delete', 'size' => 1],
-					['version' => 4827200, 'path' => 'keep', 'size' => 1],
-					['version' => 4777201, 'path' => 'delete', 'size' => 1],
-					['version' => 4777501, 'path' => 'delete', 'size' => 1],
-					['version' => 4740000, 'path' => 'keep', 'size' => 1],
-					// final slice starts at 2408000 keep one version every 604800 secons
-					['version' => 2408000, 'path' => 'keep', 'size' => 1],
-					['version' => 1803201, 'path' => 'delete', 'size' => 1],
-					['version' => 1803200, 'path' => 'keep', 'size' => 1],
-					['version' => 1800199, 'path' => 'delete', 'size' => 1],
-					['version' => 1800100, 'path' => 'delete', 'size' => 1],
-					['version' => 1198300, 'path' => 'keep', 'size' => 1],
-				],
-				16 // size of all deleted files (every file has the size 1)
-			],
-			// second set of versions, here we have only really old versions
-			[
-				[
-					// first slice (10sec) keep one version every 2 seconds
-					// next slice (60sec) starts at 4999990 keep one version every 10 secons
-					// next slice (3600sec) start at 4999940 keep one version every 60 seconds
-					// next slice (86400sec) start at 4996400 keep one version every 3600 seconds
-					['version' => 4996400, 'path' => 'keep', 'size' => 1],
-					['version' => 4996350, 'path' => 'delete', 'size' => 1],
-					['version' => 4996350, 'path' => 'delete', 'size' => 1],
-					['version' => 4992800, 'path' => 'keep', 'size' => 1],
-					['version' => 4989800, 'path' => 'delete', 'size' => 1],
-					['version' => 4989700, 'path' => 'delete', 'size' => 1],
-					['version' => 4989200, 'path' => 'keep', 'size' => 1],
-					// next slice (2592000sec) start at 4913600 keep one version every 86400 seconds
-					['version' => 4913600, 'path' => 'keep', 'size' => 1],
-					['version' => 4852800, 'path' => 'delete', 'size' => 1],
-					['version' => 4827201, 'path' => 'delete', 'size' => 1],
-					['version' => 4827200, 'path' => 'keep', 'size' => 1],
-					['version' => 4777201, 'path' => 'delete', 'size' => 1],
-					['version' => 4777501, 'path' => 'delete', 'size' => 1],
-					['version' => 4740000, 'path' => 'keep', 'size' => 1],
-					// final slice starts at 2408000 keep one version every 604800 secons
-					['version' => 2408000, 'path' => 'keep', 'size' => 1],
-					['version' => 1803201, 'path' => 'delete', 'size' => 1],
-					['version' => 1803200, 'path' => 'keep', 'size' => 1],
-					['version' => 1800199, 'path' => 'delete', 'size' => 1],
-					['version' => 1800100, 'path' => 'delete', 'size' => 1],
-					['version' => 1198300, 'path' => 'keep', 'size' => 1],
-				],
-				11 // size of all deleted files (every file has the size 1)
-			],
-			// third set of versions, with some gaps between
-			[
-				[
-					// first slice (10sec) keep one version every 2 seconds
-					['version' => 4999999, 'path' => 'keep', 'size' => 1],
-					['version' => 4999998, 'path' => 'delete', 'size' => 1],
-					['version' => 4999997, 'path' => 'keep', 'size' => 1],
-					['version' => 4999995, 'path' => 'keep', 'size' => 1],
-					['version' => 4999994, 'path' => 'delete', 'size' => 1],
-					//next slice (60sec) starts at 4999990 keep one version every 10 secons
-					['version' => 4999988, 'path' => 'keep', 'size' => 1],
-					['version' => 4999978, 'path' => 'keep', 'size' => 1],
-					//next slice (3600sec) start at 4999940 keep one version every 60 seconds
-					// next slice (86400sec) start at 4996400 keep one version every 3600 seconds
-					['version' => 4989200, 'path' => 'keep', 'size' => 1],
-					// next slice (2592000sec) start at 4913600 keep one version every 86400 seconds
-					['version' => 4913600, 'path' => 'keep', 'size' => 1],
-					['version' => 4852800, 'path' => 'delete', 'size' => 1],
-					['version' => 4827201, 'path' => 'delete', 'size' => 1],
-					['version' => 4827200, 'path' => 'keep', 'size' => 1],
-					['version' => 4777201, 'path' => 'delete', 'size' => 1],
-					['version' => 4777501, 'path' => 'delete', 'size' => 1],
-					['version' => 4740000, 'path' => 'keep', 'size' => 1],
-					// final slice starts at 2408000 keep one version every 604800 secons
-					['version' => 2408000, 'path' => 'keep', 'size' => 1],
-					['version' => 1803201, 'path' => 'delete', 'size' => 1],
-					['version' => 1803200, 'path' => 'keep', 'size' => 1],
-					['version' => 1800199, 'path' => 'delete', 'size' => 1],
-					['version' => 1800100, 'path' => 'delete', 'size' => 1],
-					['version' => 1198300, 'path' => 'keep', 'size' => 1],
-				],
-				9 // size of all deleted files (every file has the size 1)
-			],
-			// fourth set of versions: empty (see issue #19066)
-			[
-				[],
-				0
-			]
-
-		];
-	}
-
-	public function testRename(): void {
-		Filesystem::file_put_contents('test.txt', 'test file');
-
-		$t1 = time();
-		// second version is two weeks older, this way we make sure that no
-		// version will be expired
-		$t2 = $t1 - 60 * 60 * 24 * 14;
-
-		// create some versions
-		$v1 = self::USERS_VERSIONS_ROOT . '/test.txt.v' . $t1;
-		$v2 = self::USERS_VERSIONS_ROOT . '/test.txt.v' . $t2;
-		$v1Renamed = self::USERS_VERSIONS_ROOT . '/test2.txt.v' . $t1;
-		$v2Renamed = self::USERS_VERSIONS_ROOT . '/test2.txt.v' . $t2;
-
-		$this->rootView->file_put_contents($v1, 'version1');
-		$this->rootView->file_put_contents($v2, 'version2');
-
-		// execute rename hook of versions app
-		Filesystem::rename('test.txt', 'test2.txt');
-
-		$this->runCommands();
-
-		$this->assertFalse($this->rootView->file_exists($v1), 'version 1 of old file does not exist');
-		$this->assertFalse($this->rootView->file_exists($v2), 'version 2 of old file does not exist');
-
-		$this->assertTrue($this->rootView->file_exists($v1Renamed), 'version 1 of renamed file exists');
-		$this->assertTrue($this->rootView->file_exists($v2Renamed), 'version 2 of renamed file exists');
-	}
-
-	public function testRenameInSharedFolder(): void {
-		Filesystem::mkdir('folder1');
-		Filesystem::mkdir('folder1/folder2');
-		Filesystem::file_put_contents('folder1/test.txt', 'test file');
-
-		$t1 = time();
-		// second version is two weeks older, this way we make sure that no
-		// version will be expired
-		$t2 = $t1 - 60 * 60 * 24 * 14;
-
-		$this->rootView->mkdir(self::USERS_VERSIONS_ROOT . '/folder1');
-		// create some versions
-		$v1 = self::USERS_VERSIONS_ROOT . '/folder1/test.txt.v' . $t1;
-		$v2 = self::USERS_VERSIONS_ROOT . '/folder1/test.txt.v' . $t2;
-		$v1Renamed = self::USERS_VERSIONS_ROOT . '/folder1/folder2/test.txt.v' . $t1;
-		$v2Renamed = self::USERS_VERSIONS_ROOT . '/folder1/folder2/test.txt.v' . $t2;
-
-		$this->rootView->file_put_contents($v1, 'version1');
-		$this->rootView->file_put_contents($v2, 'version2');
-
-		$node = \OC::$server->getUserFolder(self::TEST_VERSIONS_USER)->get('folder1');
-		$share = Server::get(\OCP\Share\IManager::class)->newShare();
-		$share->setNode($node)
-			->setShareType(IShare::TYPE_USER)
-			->setSharedBy(self::TEST_VERSIONS_USER)
-			->setSharedWith(self::TEST_VERSIONS_USER2)
-			->setPermissions(Constants::PERMISSION_ALL);
-		$share = Server::get(\OCP\Share\IManager::class)->createShare($share);
-		Server::get(\OCP\Share\IManager::class)->acceptShare($share, self::TEST_VERSIONS_USER2);
-
-		self::loginHelper(self::TEST_VERSIONS_USER2);
-
-		$this->assertTrue(Filesystem::file_exists('folder1/test.txt'));
-
-		// execute rename hook of versions app
-		Filesystem::rename('/folder1/test.txt', '/folder1/folder2/test.txt');
-
-		$this->runCommands();
-
-		self::loginHelper(self::TEST_VERSIONS_USER);
-
-		$this->assertFalse($this->rootView->file_exists($v1), 'version 1 of old file does not exist');
-		$this->assertFalse($this->rootView->file_exists($v2), 'version 2 of old file does not exist');
-
-		$this->assertTrue($this->rootView->file_exists($v1Renamed), 'version 1 of renamed file exists');
-		$this->assertTrue($this->rootView->file_exists($v2Renamed), 'version 2 of renamed file exists');
-
-		Server::get(\OCP\Share\IManager::class)->deleteShare($share);
-	}
-
-	public function testMoveFolder(): void {
-		Filesystem::mkdir('folder1');
-		Filesystem::mkdir('folder2');
-		Filesystem::file_put_contents('folder1/test.txt', 'test file');
-
-		$t1 = time();
-		// second version is two weeks older, this way we make sure that no
-		// version will be expired
-		$t2 = $t1 - 60 * 60 * 24 * 14;
-
-		// create some versions
-		$this->rootView->mkdir(self::USERS_VERSIONS_ROOT . '/folder1');
-		$v1 = self::USERS_VERSIONS_ROOT . '/folder1/test.txt.v' . $t1;
-		$v2 = self::USERS_VERSIONS_ROOT . '/folder1/test.txt.v' . $t2;
-		$v1Renamed = self::USERS_VERSIONS_ROOT . '/folder2/folder1/test.txt.v' . $t1;
-		$v2Renamed = self::USERS_VERSIONS_ROOT . '/folder2/folder1/test.txt.v' . $t2;
+    public const TEST_VERSIONS_USER = 'test-versions-user';
+    public const TEST_VERSIONS_USER2 = 'test-versions-user2';
+    public const USERS_VERSIONS_ROOT = '/test-versions-user/files_versions';
+
+    /**
+     * @var View
+     */
+    private $rootView;
+    /**
+     * @var VersionsMapper
+     */
+    private $versionsMapper;
+    /**
+     * @var IMimeTypeLoader
+     */
+    private $mimeTypeLoader;
+    private $user1;
+    private $user2;
+
+    public static function setUpBeforeClass(): void {
+        parent::setUpBeforeClass();
+
+        $application = new Application();
+
+        // create test user
+        self::loginHelper(self::TEST_VERSIONS_USER2, true);
+        self::loginHelper(self::TEST_VERSIONS_USER, true);
+    }
+
+    public static function tearDownAfterClass(): void {
+        // cleanup test user
+        $user = Server::get(IUserManager::class)->get(self::TEST_VERSIONS_USER);
+        if ($user !== null) {
+            $user->delete();
+        }
+        $user = Server::get(IUserManager::class)->get(self::TEST_VERSIONS_USER2);
+        if ($user !== null) {
+            $user->delete();
+        }
+
+        parent::tearDownAfterClass();
+    }
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $config = Server::get(IConfig::class);
+        $mockConfig = $this->getMockBuilder(AllConfig::class)
+            ->onlyMethods(['getSystemValue'])
+            ->setConstructorArgs([Server::get(\OC\SystemConfig::class)])
+            ->getMock();
+        $mockConfig->expects($this->any())
+            ->method('getSystemValue')
+            ->willReturnCallback(function ($key, $default) use ($config) {
+                if ($key === 'filesystem_check_changes') {
+                    return Watcher::CHECK_ONCE;
+                } else {
+                    return $config->getSystemValue($key, $default);
+                }
+            });
+        $this->overwriteService(AllConfig::class, $mockConfig);
+
+        // clear hooks
+        \OC_Hook::clear();
+        \OC::registerShareHooks(Server::get(SystemConfig::class));
+        \OC::$server->boot();
+
+        self::loginHelper(self::TEST_VERSIONS_USER);
+        $this->rootView = new View();
+        if (!$this->rootView->file_exists(self::USERS_VERSIONS_ROOT)) {
+            $this->rootView->mkdir(self::USERS_VERSIONS_ROOT);
+        }
+
+        $this->versionsMapper = Server::get(VersionsMapper::class);
+        $this->mimeTypeLoader = Server::get(IMimeTypeLoader::class);
+
+        $this->user1 = $this->createMock(IUser::class);
+        $this->user1->method('getUID')
+            ->willReturn(self::TEST_VERSIONS_USER);
+        $this->user2 = $this->createMock(IUser::class);
+        $this->user2->method('getUID')
+            ->willReturn(self::TEST_VERSIONS_USER2);
+    }
+
+    protected function tearDown(): void {
+        $this->restoreService(AllConfig::class);
+
+        if ($this->rootView) {
+            $this->rootView->deleteAll(self::TEST_VERSIONS_USER . '/files/');
+            $this->rootView->deleteAll(self::TEST_VERSIONS_USER2 . '/files/');
+            $this->rootView->deleteAll(self::TEST_VERSIONS_USER . '/files_versions/');
+            $this->rootView->deleteAll(self::TEST_VERSIONS_USER2 . '/files_versions/');
+        }
+
+        \OC_Hook::clear();
+
+        parent::tearDown();
+    }
+
+    /**
+     * @medium
+     * test expire logic
+     * @dataProvider versionsProvider
+     */
+    public function testGetExpireList($versions, $sizeOfAllDeletedFiles): void {
+
+        // last interval end at 2592000
+        $startTime = 5000000;
+
+        $testClass = new VersionStorageToTest();
+        [$deleted, $size] = $testClass->callProtectedGetExpireList($startTime, $versions);
+
+        // we should have deleted 16 files each of the size 1
+        $this->assertEquals($sizeOfAllDeletedFiles, $size);
+
+        // the deleted array should only contain versions which should be deleted
+        foreach ($deleted as $key => $path) {
+            unset($versions[$key]);
+            $this->assertEquals('delete', substr($path, 0, strlen('delete')));
+        }
+
+        // the versions array should only contain versions which should be kept
+        foreach ($versions as $version) {
+            $this->assertEquals('keep', $version['path']);
+        }
+    }
+
+    public function versionsProvider() {
+        return [
+            // first set of versions uniformly distributed versions
+            [
+                [
+                    // first slice (10sec) keep one version every 2 seconds
+                    ['version' => 4999999, 'path' => 'keep', 'size' => 1],
+                    ['version' => 4999998, 'path' => 'delete', 'size' => 1],
+                    ['version' => 4999997, 'path' => 'keep', 'size' => 1],
+                    ['version' => 4999995, 'path' => 'keep', 'size' => 1],
+                    ['version' => 4999994, 'path' => 'delete', 'size' => 1],
+                    //next slice (60sec) starts at 4999990 keep one version every 10 secons
+                    ['version' => 4999988, 'path' => 'keep', 'size' => 1],
+                    ['version' => 4999978, 'path' => 'keep', 'size' => 1],
+                    ['version' => 4999975, 'path' => 'delete', 'size' => 1],
+                    ['version' => 4999972, 'path' => 'delete', 'size' => 1],
+                    ['version' => 4999967, 'path' => 'keep', 'size' => 1],
+                    ['version' => 4999958, 'path' => 'delete', 'size' => 1],
+                    ['version' => 4999957, 'path' => 'keep', 'size' => 1],
+                    //next slice (3600sec) start at 4999940 keep one version every 60 seconds
+                    ['version' => 4999900, 'path' => 'keep', 'size' => 1],
+                    ['version' => 4999841, 'path' => 'delete', 'size' => 1],
+                    ['version' => 4999840, 'path' => 'keep', 'size' => 1],
+                    ['version' => 4999780, 'path' => 'keep', 'size' => 1],
+                    ['version' => 4996401, 'path' => 'keep', 'size' => 1],
+                    // next slice (86400sec) start at 4996400 keep one version every 3600 seconds
+                    ['version' => 4996350, 'path' => 'delete', 'size' => 1],
+                    ['version' => 4992800, 'path' => 'keep', 'size' => 1],
+                    ['version' => 4989800, 'path' => 'delete', 'size' => 1],
+                    ['version' => 4989700, 'path' => 'delete', 'size' => 1],
+                    ['version' => 4989200, 'path' => 'keep', 'size' => 1],
+                    // next slice (2592000sec) start at 4913600 keep one version every 86400 seconds
+                    ['version' => 4913600, 'path' => 'keep', 'size' => 1],
+                    ['version' => 4852800, 'path' => 'delete', 'size' => 1],
+                    ['version' => 4827201, 'path' => 'delete', 'size' => 1],
+                    ['version' => 4827200, 'path' => 'keep', 'size' => 1],
+                    ['version' => 4777201, 'path' => 'delete', 'size' => 1],
+                    ['version' => 4777501, 'path' => 'delete', 'size' => 1],
+                    ['version' => 4740000, 'path' => 'keep', 'size' => 1],
+                    // final slice starts at 2408000 keep one version every 604800 secons
+                    ['version' => 2408000, 'path' => 'keep', 'size' => 1],
+                    ['version' => 1803201, 'path' => 'delete', 'size' => 1],
+                    ['version' => 1803200, 'path' => 'keep', 'size' => 1],
+                    ['version' => 1800199, 'path' => 'delete', 'size' => 1],
+                    ['version' => 1800100, 'path' => 'delete', 'size' => 1],
+                    ['version' => 1198300, 'path' => 'keep', 'size' => 1],
+                ],
+                16 // size of all deleted files (every file has the size 1)
+            ],
+            // second set of versions, here we have only really old versions
+            [
+                [
+                    // first slice (10sec) keep one version every 2 seconds
+                    // next slice (60sec) starts at 4999990 keep one version every 10 secons
+                    // next slice (3600sec) start at 4999940 keep one version every 60 seconds
+                    // next slice (86400sec) start at 4996400 keep one version every 3600 seconds
+                    ['version' => 4996400, 'path' => 'keep', 'size' => 1],
+                    ['version' => 4996350, 'path' => 'delete', 'size' => 1],
+                    ['version' => 4996350, 'path' => 'delete', 'size' => 1],
+                    ['version' => 4992800, 'path' => 'keep', 'size' => 1],
+                    ['version' => 4989800, 'path' => 'delete', 'size' => 1],
+                    ['version' => 4989700, 'path' => 'delete', 'size' => 1],
+                    ['version' => 4989200, 'path' => 'keep', 'size' => 1],
+                    // next slice (2592000sec) start at 4913600 keep one version every 86400 seconds
+                    ['version' => 4913600, 'path' => 'keep', 'size' => 1],
+                    ['version' => 4852800, 'path' => 'delete', 'size' => 1],
+                    ['version' => 4827201, 'path' => 'delete', 'size' => 1],
+                    ['version' => 4827200, 'path' => 'keep', 'size' => 1],
+                    ['version' => 4777201, 'path' => 'delete', 'size' => 1],
+                    ['version' => 4777501, 'path' => 'delete', 'size' => 1],
+                    ['version' => 4740000, 'path' => 'keep', 'size' => 1],
+                    // final slice starts at 2408000 keep one version every 604800 secons
+                    ['version' => 2408000, 'path' => 'keep', 'size' => 1],
+                    ['version' => 1803201, 'path' => 'delete', 'size' => 1],
+                    ['version' => 1803200, 'path' => 'keep', 'size' => 1],
+                    ['version' => 1800199, 'path' => 'delete', 'size' => 1],
+                    ['version' => 1800100, 'path' => 'delete', 'size' => 1],
+                    ['version' => 1198300, 'path' => 'keep', 'size' => 1],
+                ],
+                11 // size of all deleted files (every file has the size 1)
+            ],
+            // third set of versions, with some gaps between
+            [
+                [
+                    // first slice (10sec) keep one version every 2 seconds
+                    ['version' => 4999999, 'path' => 'keep', 'size' => 1],
+                    ['version' => 4999998, 'path' => 'delete', 'size' => 1],
+                    ['version' => 4999997, 'path' => 'keep', 'size' => 1],
+                    ['version' => 4999995, 'path' => 'keep', 'size' => 1],
+                    ['version' => 4999994, 'path' => 'delete', 'size' => 1],
+                    //next slice (60sec) starts at 4999990 keep one version every 10 secons
+                    ['version' => 4999988, 'path' => 'keep', 'size' => 1],
+                    ['version' => 4999978, 'path' => 'keep', 'size' => 1],
+                    //next slice (3600sec) start at 4999940 keep one version every 60 seconds
+                    // next slice (86400sec) start at 4996400 keep one version every 3600 seconds
+                    ['version' => 4989200, 'path' => 'keep', 'size' => 1],
+                    // next slice (2592000sec) start at 4913600 keep one version every 86400 seconds
+                    ['version' => 4913600, 'path' => 'keep', 'size' => 1],
+                    ['version' => 4852800, 'path' => 'delete', 'size' => 1],
+                    ['version' => 4827201, 'path' => 'delete', 'size' => 1],
+                    ['version' => 4827200, 'path' => 'keep', 'size' => 1],
+                    ['version' => 4777201, 'path' => 'delete', 'size' => 1],
+                    ['version' => 4777501, 'path' => 'delete', 'size' => 1],
+                    ['version' => 4740000, 'path' => 'keep', 'size' => 1],
+                    // final slice starts at 2408000 keep one version every 604800 secons
+                    ['version' => 2408000, 'path' => 'keep', 'size' => 1],
+                    ['version' => 1803201, 'path' => 'delete', 'size' => 1],
+                    ['version' => 1803200, 'path' => 'keep', 'size' => 1],
+                    ['version' => 1800199, 'path' => 'delete', 'size' => 1],
+                    ['version' => 1800100, 'path' => 'delete', 'size' => 1],
+                    ['version' => 1198300, 'path' => 'keep', 'size' => 1],
+                ],
+                9 // size of all deleted files (every file has the size 1)
+            ],
+            // fourth set of versions: empty (see issue #19066)
+            [
+                [],
+                0
+            ]
+
+        ];
+    }
+
+    public function testRename(): void {
+        Filesystem::file_put_contents('test.txt', 'test file');
+
+        $t1 = time();
+        // second version is two weeks older, this way we make sure that no
+        // version will be expired
+        $t2 = $t1 - 60 * 60 * 24 * 14;
+
+        // create some versions
+        $v1 = self::USERS_VERSIONS_ROOT . '/test.txt.v' . $t1;
+        $v2 = self::USERS_VERSIONS_ROOT . '/test.txt.v' . $t2;
+        $v1Renamed = self::USERS_VERSIONS_ROOT . '/test2.txt.v' . $t1;
+        $v2Renamed = self::USERS_VERSIONS_ROOT . '/test2.txt.v' . $t2;
+
+        $this->rootView->file_put_contents($v1, 'version1');
+        $this->rootView->file_put_contents($v2, 'version2');
+
+        // execute rename hook of versions app
+        Filesystem::rename('test.txt', 'test2.txt');
+
+        $this->runCommands();
+
+        $this->assertFalse($this->rootView->file_exists($v1), 'version 1 of old file does not exist');
+        $this->assertFalse($this->rootView->file_exists($v2), 'version 2 of old file does not exist');
+
+        $this->assertTrue($this->rootView->file_exists($v1Renamed), 'version 1 of renamed file exists');
+        $this->assertTrue($this->rootView->file_exists($v2Renamed), 'version 2 of renamed file exists');
+    }
+
+    public function testRenameInSharedFolder(): void {
+        Filesystem::mkdir('folder1');
+        Filesystem::mkdir('folder1/folder2');
+        Filesystem::file_put_contents('folder1/test.txt', 'test file');
+
+        $t1 = time();
+        // second version is two weeks older, this way we make sure that no
+        // version will be expired
+        $t2 = $t1 - 60 * 60 * 24 * 14;
+
+        $this->rootView->mkdir(self::USERS_VERSIONS_ROOT . '/folder1');
+        // create some versions
+        $v1 = self::USERS_VERSIONS_ROOT . '/folder1/test.txt.v' . $t1;
+        $v2 = self::USERS_VERSIONS_ROOT . '/folder1/test.txt.v' . $t2;
+        $v1Renamed = self::USERS_VERSIONS_ROOT . '/folder1/folder2/test.txt.v' . $t1;
+        $v2Renamed = self::USERS_VERSIONS_ROOT . '/folder1/folder2/test.txt.v' . $t2;
+
+        $this->rootView->file_put_contents($v1, 'version1');
+        $this->rootView->file_put_contents($v2, 'version2');
+
+        $node = \OC::$server->getUserFolder(self::TEST_VERSIONS_USER)->get('folder1');
+        $share = Server::get(\OCP\Share\IManager::class)->newShare();
+        $share->setNode($node)
+            ->setShareType(IShare::TYPE_USER)
+            ->setSharedBy(self::TEST_VERSIONS_USER)
+            ->setSharedWith(self::TEST_VERSIONS_USER2)
+            ->setPermissions(Constants::PERMISSION_ALL);
+        $share = Server::get(\OCP\Share\IManager::class)->createShare($share);
+        Server::get(\OCP\Share\IManager::class)->acceptShare($share, self::TEST_VERSIONS_USER2);
+
+        self::loginHelper(self::TEST_VERSIONS_USER2);
+
+        $this->assertTrue(Filesystem::file_exists('folder1/test.txt'));
+
+        // execute rename hook of versions app
+        Filesystem::rename('/folder1/test.txt', '/folder1/folder2/test.txt');
+
+        $this->runCommands();
+
+        self::loginHelper(self::TEST_VERSIONS_USER);
+
+        $this->assertFalse($this->rootView->file_exists($v1), 'version 1 of old file does not exist');
+        $this->assertFalse($this->rootView->file_exists($v2), 'version 2 of old file does not exist');
+
+        $this->assertTrue($this->rootView->file_exists($v1Renamed), 'version 1 of renamed file exists');
+        $this->assertTrue($this->rootView->file_exists($v2Renamed), 'version 2 of renamed file exists');
+
+        Server::get(\OCP\Share\IManager::class)->deleteShare($share);
+    }
+
+    public function testMoveFolder(): void {
+        Filesystem::mkdir('folder1');
+        Filesystem::mkdir('folder2');
+        Filesystem::file_put_contents('folder1/test.txt', 'test file');
+
+        $t1 = time();
+        // second version is two weeks older, this way we make sure that no
+        // version will be expired
+        $t2 = $t1 - 60 * 60 * 24 * 14;
+
+        // create some versions
+        $this->rootView->mkdir(self::USERS_VERSIONS_ROOT . '/folder1');
+        $v1 = self::USERS_VERSIONS_ROOT . '/folder1/test.txt.v' . $t1;
+        $v2 = self::USERS_VERSIONS_ROOT . '/folder1/test.txt.v' . $t2;
+        $v1Renamed = self::USERS_VERSIONS_ROOT . '/folder2/folder1/test.txt.v' . $t1;
+        $v2Renamed = self::USERS_VERSIONS_ROOT . '/folder2/folder1/test.txt.v' . $t2;
 
-		$this->rootView->file_put_contents($v1, 'version1');
-		$this->rootView->file_put_contents($v2, 'version2');
+        $this->rootView->file_put_contents($v1, 'version1');
+        $this->rootView->file_put_contents($v2, 'version2');
 
-		// execute rename hook of versions app
-		Filesystem::rename('folder1', 'folder2/folder1');
+        // execute rename hook of versions app
+        Filesystem::rename('folder1', 'folder2/folder1');
 
-		$this->runCommands();
+        $this->runCommands();
 
-		$this->assertFalse($this->rootView->file_exists($v1));
-		$this->assertFalse($this->rootView->file_exists($v2));
+        $this->assertFalse($this->rootView->file_exists($v1));
+        $this->assertFalse($this->rootView->file_exists($v2));
 
-		$this->assertTrue($this->rootView->file_exists($v1Renamed));
-		$this->assertTrue($this->rootView->file_exists($v2Renamed));
-	}
+        $this->assertTrue($this->rootView->file_exists($v1Renamed));
+        $this->assertTrue($this->rootView->file_exists($v2Renamed));
+    }
 
 
-	public function testMoveFileIntoSharedFolderAsRecipient(): void {
-		Filesystem::mkdir('folder1');
-		$fileInfo = Filesystem::getFileInfo('folder1');
+    public function testMoveFileIntoSharedFolderAsRecipient(): void {
+        Filesystem::mkdir('folder1');
+        $fileInfo = Filesystem::getFileInfo('folder1');
 
-		$node = \OC::$server->getUserFolder(self::TEST_VERSIONS_USER)->get('folder1');
-		$share = Server::get(\OCP\Share\IManager::class)->newShare();
-		$share->setNode($node)
-			->setShareType(IShare::TYPE_USER)
-			->setSharedBy(self::TEST_VERSIONS_USER)
-			->setSharedWith(self::TEST_VERSIONS_USER2)
-			->setPermissions(Constants::PERMISSION_ALL);
-		$share = Server::get(\OCP\Share\IManager::class)->createShare($share);
-		Server::get(\OCP\Share\IManager::class)->acceptShare($share, self::TEST_VERSIONS_USER2);
+        $node = \OC::$server->getUserFolder(self::TEST_VERSIONS_USER)->get('folder1');
+        $share = Server::get(\OCP\Share\IManager::class)->newShare();
+        $share->setNode($node)
+            ->setShareType(IShare::TYPE_USER)
+            ->setSharedBy(self::TEST_VERSIONS_USER)
+            ->setSharedWith(self::TEST_VERSIONS_USER2)
+            ->setPermissions(Constants::PERMISSION_ALL);
+        $share = Server::get(\OCP\Share\IManager::class)->createShare($share);
+        Server::get(\OCP\Share\IManager::class)->acceptShare($share, self::TEST_VERSIONS_USER2);
 
-		self::loginHelper(self::TEST_VERSIONS_USER2);
-		$versionsFolder2 = '/' . self::TEST_VERSIONS_USER2 . '/files_versions';
-		Filesystem::file_put_contents('test.txt', 'test file');
+        self::loginHelper(self::TEST_VERSIONS_USER2);
+        $versionsFolder2 = '/' . self::TEST_VERSIONS_USER2 . '/files_versions';
+        Filesystem::file_put_contents('test.txt', 'test file');
 
-		$t1 = time();
-		// second version is two weeks older, this way we make sure that no
-		// version will be expired
-		$t2 = $t1 - 60 * 60 * 24 * 14;
+        $t1 = time();
+        // second version is two weeks older, this way we make sure that no
+        // version will be expired
+        $t2 = $t1 - 60 * 60 * 24 * 14;
 
-		$this->rootView->mkdir($versionsFolder2);
-		// create some versions
-		$v1 = $versionsFolder2 . '/test.txt.v' . $t1;
-		$v2 = $versionsFolder2 . '/test.txt.v' . $t2;
+        $this->rootView->mkdir($versionsFolder2);
+        // create some versions
+        $v1 = $versionsFolder2 . '/test.txt.v' . $t1;
+        $v2 = $versionsFolder2 . '/test.txt.v' . $t2;
 
-		$this->rootView->file_put_contents($v1, 'version1');
-		$this->rootView->file_put_contents($v2, 'version2');
+        $this->rootView->file_put_contents($v1, 'version1');
+        $this->rootView->file_put_contents($v2, 'version2');
 
-		// move file into the shared folder as recipient
-		$success = Filesystem::rename('/test.txt', '/folder1/test.txt');
+        // move file into the shared folder as recipient
+        $success = Filesystem::rename('/test.txt', '/folder1/test.txt');
 
-		$this->assertTrue($success);
-		$this->assertFalse($this->rootView->file_exists($v1));
-		$this->assertFalse($this->rootView->file_exists($v2));
+        $this->assertTrue($success);
+        $this->assertFalse($this->rootView->file_exists($v1));
+        $this->assertFalse($this->rootView->file_exists($v2));
 
-		self::loginHelper(self::TEST_VERSIONS_USER);
+        self::loginHelper(self::TEST_VERSIONS_USER);
 
-		$versionsFolder1 = '/' . self::TEST_VERSIONS_USER . '/files_versions';
+        $versionsFolder1 = '/' . self::TEST_VERSIONS_USER . '/files_versions';
 
-		$v1Renamed = $versionsFolder1 . '/folder1/test.txt.v' . $t1;
-		$v2Renamed = $versionsFolder1 . '/folder1/test.txt.v' . $t2;
+        $v1Renamed = $versionsFolder1 . '/folder1/test.txt.v' . $t1;
+        $v2Renamed = $versionsFolder1 . '/folder1/test.txt.v' . $t2;
 
-		$this->assertTrue($this->rootView->file_exists($v1Renamed));
-		$this->assertTrue($this->rootView->file_exists($v2Renamed));
+        $this->assertTrue($this->rootView->file_exists($v1Renamed));
+        $this->assertTrue($this->rootView->file_exists($v2Renamed));
 
-		Server::get(\OCP\Share\IManager::class)->deleteShare($share);
-	}
+        Server::get(\OCP\Share\IManager::class)->deleteShare($share);
+    }
 
-	public function testMoveFolderIntoSharedFolderAsRecipient(): void {
-		Filesystem::mkdir('folder1');
+    public function testMoveFolderIntoSharedFolderAsRecipient(): void {
+        Filesystem::mkdir('folder1');
 
-		$node = \OC::$server->getUserFolder(self::TEST_VERSIONS_USER)->get('folder1');
-		$share = Server::get(\OCP\Share\IManager::class)->newShare();
-		$share->setNode($node)
-			->setShareType(IShare::TYPE_USER)
-			->setSharedBy(self::TEST_VERSIONS_USER)
-			->setSharedWith(self::TEST_VERSIONS_USER2)
-			->setPermissions(Constants::PERMISSION_ALL);
-		$share = Server::get(\OCP\Share\IManager::class)->createShare($share);
-		Server::get(\OCP\Share\IManager::class)->acceptShare($share, self::TEST_VERSIONS_USER2);
+        $node = \OC::$server->getUserFolder(self::TEST_VERSIONS_USER)->get('folder1');
+        $share = Server::get(\OCP\Share\IManager::class)->newShare();
+        $share->setNode($node)
+            ->setShareType(IShare::TYPE_USER)
+            ->setSharedBy(self::TEST_VERSIONS_USER)
+            ->setSharedWith(self::TEST_VERSIONS_USER2)
+            ->setPermissions(Constants::PERMISSION_ALL);
+        $share = Server::get(\OCP\Share\IManager::class)->createShare($share);
+        Server::get(\OCP\Share\IManager::class)->acceptShare($share, self::TEST_VERSIONS_USER2);
 
-		self::loginHelper(self::TEST_VERSIONS_USER2);
-		$versionsFolder2 = '/' . self::TEST_VERSIONS_USER2 . '/files_versions';
-		Filesystem::mkdir('folder2');
-		Filesystem::file_put_contents('folder2/test.txt', 'test file');
+        self::loginHelper(self::TEST_VERSIONS_USER2);
+        $versionsFolder2 = '/' . self::TEST_VERSIONS_USER2 . '/files_versions';
+        Filesystem::mkdir('folder2');
+        Filesystem::file_put_contents('folder2/test.txt', 'test file');
 
-		$t1 = time();
-		// second version is two weeks older, this way we make sure that no
-		// version will be expired
-		$t2 = $t1 - 60 * 60 * 24 * 14;
+        $t1 = time();
+        // second version is two weeks older, this way we make sure that no
+        // version will be expired
+        $t2 = $t1 - 60 * 60 * 24 * 14;
 
-		$this->rootView->mkdir($versionsFolder2);
-		$this->rootView->mkdir($versionsFolder2 . '/folder2');
-		// create some versions
-		$v1 = $versionsFolder2 . '/folder2/test.txt.v' . $t1;
-		$v2 = $versionsFolder2 . '/folder2/test.txt.v' . $t2;
+        $this->rootView->mkdir($versionsFolder2);
+        $this->rootView->mkdir($versionsFolder2 . '/folder2');
+        // create some versions
+        $v1 = $versionsFolder2 . '/folder2/test.txt.v' . $t1;
+        $v2 = $versionsFolder2 . '/folder2/test.txt.v' . $t2;
 
-		$this->rootView->file_put_contents($v1, 'version1');
-		$this->rootView->file_put_contents($v2, 'version2');
+        $this->rootView->file_put_contents($v1, 'version1');
+        $this->rootView->file_put_contents($v2, 'version2');
 
-		// move file into the shared folder as recipient
-		Filesystem::rename('/folder2', '/folder1/folder2');
+        // move file into the shared folder as recipient
+        Filesystem::rename('/folder2', '/folder1/folder2');
 
-		$this->assertFalse($this->rootView->file_exists($v1));
-		$this->assertFalse($this->rootView->file_exists($v2));
+        $this->assertFalse($this->rootView->file_exists($v1));
+        $this->assertFalse($this->rootView->file_exists($v2));
 
-		self::loginHelper(self::TEST_VERSIONS_USER);
+        self::loginHelper(self::TEST_VERSIONS_USER);
 
-		$versionsFolder1 = '/' . self::TEST_VERSIONS_USER . '/files_versions';
+        $versionsFolder1 = '/' . self::TEST_VERSIONS_USER . '/files_versions';
 
-		$v1Renamed = $versionsFolder1 . '/folder1/folder2/test.txt.v' . $t1;
-		$v2Renamed = $versionsFolder1 . '/folder1/folder2/test.txt.v' . $t2;
+        $v1Renamed = $versionsFolder1 . '/folder1/folder2/test.txt.v' . $t1;
+        $v2Renamed = $versionsFolder1 . '/folder1/folder2/test.txt.v' . $t2;
 
-		$this->assertTrue($this->rootView->file_exists($v1Renamed));
-		$this->assertTrue($this->rootView->file_exists($v2Renamed));
+        $this->assertTrue($this->rootView->file_exists($v1Renamed));
+        $this->assertTrue($this->rootView->file_exists($v2Renamed));
 
-		Server::get(\OCP\Share\IManager::class)->deleteShare($share);
-	}
+        Server::get(\OCP\Share\IManager::class)->deleteShare($share);
+    }
 
-	public function testRenameSharedFile(): void {
-		Filesystem::file_put_contents('test.txt', 'test file');
+    public function testRenameSharedFile(): void {
+        Filesystem::file_put_contents('test.txt', 'test file');
 
-		$t1 = time();
-		// second version is two weeks older, this way we make sure that no
-		// version will be expired
-		$t2 = $t1 - 60 * 60 * 24 * 14;
+        $t1 = time();
+        // second version is two weeks older, this way we make sure that no
+        // version will be expired
+        $t2 = $t1 - 60 * 60 * 24 * 14;
 
-		$this->rootView->mkdir(self::USERS_VERSIONS_ROOT);
-		// create some versions
-		$v1 = self::USERS_VERSIONS_ROOT . '/test.txt.v' . $t1;
-		$v2 = self::USERS_VERSIONS_ROOT . '/test.txt.v' . $t2;
-		// the renamed versions should not exist! Because we only moved the mount point!
-		$v1Renamed = self::USERS_VERSIONS_ROOT . '/test2.txt.v' . $t1;
-		$v2Renamed = self::USERS_VERSIONS_ROOT . '/test2.txt.v' . $t2;
+        $this->rootView->mkdir(self::USERS_VERSIONS_ROOT);
+        // create some versions
+        $v1 = self::USERS_VERSIONS_ROOT . '/test.txt.v' . $t1;
+        $v2 = self::USERS_VERSIONS_ROOT . '/test.txt.v' . $t2;
+        // the renamed versions should not exist! Because we only moved the mount point!
+        $v1Renamed = self::USERS_VERSIONS_ROOT . '/test2.txt.v' . $t1;
+        $v2Renamed = self::USERS_VERSIONS_ROOT . '/test2.txt.v' . $t2;
 
-		$this->rootView->file_put_contents($v1, 'version1');
-		$this->rootView->file_put_contents($v2, 'version2');
+        $this->rootView->file_put_contents($v1, 'version1');
+        $this->rootView->file_put_contents($v2, 'version2');
 
-		$node = \OC::$server->getUserFolder(self::TEST_VERSIONS_USER)->get('test.txt');
-		$share = Server::get(\OCP\Share\IManager::class)->newShare();
-		$share->setNode($node)
-			->setShareType(IShare::TYPE_USER)
-			->setSharedBy(self::TEST_VERSIONS_USER)
-			->setSharedWith(self::TEST_VERSIONS_USER2)
-			->setPermissions(Constants::PERMISSION_READ | Constants::PERMISSION_UPDATE | Constants::PERMISSION_SHARE);
-		$share = Server::get(\OCP\Share\IManager::class)->createShare($share);
-		Server::get(\OCP\Share\IManager::class)->acceptShare($share, self::TEST_VERSIONS_USER2);
+        $node = \OC::$server->getUserFolder(self::TEST_VERSIONS_USER)->get('test.txt');
+        $share = Server::get(\OCP\Share\IManager::class)->newShare();
+        $share->setNode($node)
+            ->setShareType(IShare::TYPE_USER)
+            ->setSharedBy(self::TEST_VERSIONS_USER)
+            ->setSharedWith(self::TEST_VERSIONS_USER2)
+            ->setPermissions(Constants::PERMISSION_READ | Constants::PERMISSION_UPDATE | Constants::PERMISSION_SHARE);
+        $share = Server::get(\OCP\Share\IManager::class)->createShare($share);
+        Server::get(\OCP\Share\IManager::class)->acceptShare($share, self::TEST_VERSIONS_USER2);
 
-		self::loginHelper(self::TEST_VERSIONS_USER2);
+        self::loginHelper(self::TEST_VERSIONS_USER2);
 
-		$this->assertTrue(Filesystem::file_exists('test.txt'));
+        $this->assertTrue(Filesystem::file_exists('test.txt'));
 
-		// execute rename hook of versions app
-		Filesystem::rename('test.txt', 'test2.txt');
+        // execute rename hook of versions app
+        Filesystem::rename('test.txt', 'test2.txt');
 
-		self::loginHelper(self::TEST_VERSIONS_USER);
+        self::loginHelper(self::TEST_VERSIONS_USER);
 
-		$this->runCommands();
+        $this->runCommands();
 
-		$this->assertTrue($this->rootView->file_exists($v1));
-		$this->assertTrue($this->rootView->file_exists($v2));
+        $this->assertTrue($this->rootView->file_exists($v1));
+        $this->assertTrue($this->rootView->file_exists($v2));
 
-		$this->assertFalse($this->rootView->file_exists($v1Renamed));
-		$this->assertFalse($this->rootView->file_exists($v2Renamed));
+        $this->assertFalse($this->rootView->file_exists($v1Renamed));
+        $this->assertFalse($this->rootView->file_exists($v2Renamed));
 
-		Server::get(\OCP\Share\IManager::class)->deleteShare($share);
-	}
+        Server::get(\OCP\Share\IManager::class)->deleteShare($share);
+    }
 
-	public function testCopy(): void {
-		Filesystem::file_put_contents('test.txt', 'test file');
+    public function testCopy(): void {
+        Filesystem::file_put_contents('test.txt', 'test file');
 
-		$t1 = time();
-		// second version is two weeks older, this way we make sure that no
-		// version will be expired
-		$t2 = $t1 - 60 * 60 * 24 * 14;
+        $t1 = time();
+        // second version is two weeks older, this way we make sure that no
+        // version will be expired
+        $t2 = $t1 - 60 * 60 * 24 * 14;
 
-		// create some versions
-		$v1 = self::USERS_VERSIONS_ROOT . '/test.txt.v' . $t1;
-		$v2 = self::USERS_VERSIONS_ROOT . '/test.txt.v' . $t2;
-		$v1Copied = self::USERS_VERSIONS_ROOT . '/test2.txt.v' . $t1;
-		$v2Copied = self::USERS_VERSIONS_ROOT . '/test2.txt.v' . $t2;
+        // create some versions
+        $v1 = self::USERS_VERSIONS_ROOT . '/test.txt.v' . $t1;
+        $v2 = self::USERS_VERSIONS_ROOT . '/test.txt.v' . $t2;
+        $v1Copied = self::USERS_VERSIONS_ROOT . '/test2.txt.v' . $t1;
+        $v2Copied = self::USERS_VERSIONS_ROOT . '/test2.txt.v' . $t2;
 
-		$this->rootView->file_put_contents($v1, 'version1');
-		$this->rootView->file_put_contents($v2, 'version2');
+        $this->rootView->file_put_contents($v1, 'version1');
+        $this->rootView->file_put_contents($v2, 'version2');
 
-		// execute copy hook of versions app
-		Filesystem::copy('test.txt', 'test2.txt');
+        // execute copy hook of versions app
+        Filesystem::copy('test.txt', 'test2.txt');
 
-		$this->runCommands();
+        $this->runCommands();
 
-		$this->assertTrue($this->rootView->file_exists($v1), 'version 1 of original file exists');
-		$this->assertTrue($this->rootView->file_exists($v2), 'version 2 of original file exists');
+        $this->assertTrue($this->rootView->file_exists($v1), 'version 1 of original file exists');
+        $this->assertTrue($this->rootView->file_exists($v2), 'version 2 of original file exists');
 
-		$this->assertTrue($this->rootView->file_exists($v1Copied), 'version 1 of copied file exists');
-		$this->assertTrue($this->rootView->file_exists($v2Copied), 'version 2 of copied file exists');
-	}
+        $this->assertTrue($this->rootView->file_exists($v1Copied), 'version 1 of copied file exists');
+        $this->assertTrue($this->rootView->file_exists($v2Copied), 'version 2 of copied file exists');
+    }
 
-	/**
-	 * test if we find all versions and if the versions array contain
-	 * the correct 'path' and 'name'
-	 */
-	public function testGetVersions(): void {
-		$t1 = time();
-		// second version is two weeks older, this way we make sure that no
-		// version will be expired
-		$t2 = $t1 - 60 * 60 * 24 * 14;
+    /**
+     * test if we find all versions and if the versions array contain
+     * the correct 'path' and 'name'
+     */
+    public function testGetVersions(): void {
+        $t1 = time();
+        // second version is two weeks older, this way we make sure that no
+        // version will be expired
+        $t2 = $t1 - 60 * 60 * 24 * 14;
 
-		// create some versions
-		$v1 = self::USERS_VERSIONS_ROOT . '/subfolder/test.txt.v' . $t1;
-		$v2 = self::USERS_VERSIONS_ROOT . '/subfolder/test.txt.v' . $t2;
+        // create some versions
+        $v1 = self::USERS_VERSIONS_ROOT . '/subfolder/test.txt.v' . $t1;
+        $v2 = self::USERS_VERSIONS_ROOT . '/subfolder/test.txt.v' . $t2;
 
-		$this->rootView->mkdir(self::USERS_VERSIONS_ROOT . '/subfolder/');
+        $this->rootView->mkdir(self::USERS_VERSIONS_ROOT . '/subfolder/');
 
-		$this->rootView->file_put_contents($v1, 'version1');
-		$this->rootView->file_put_contents($v2, 'version2');
+        $this->rootView->file_put_contents($v1, 'version1');
+        $this->rootView->file_put_contents($v2, 'version2');
 
-		// execute copy hook of versions app
-		$versions = Storage::getVersions(self::TEST_VERSIONS_USER, '/subfolder/test.txt');
+        // execute copy hook of versions app
+        $versions = Storage::getVersions(self::TEST_VERSIONS_USER, '/subfolder/test.txt');
 
-		$this->assertCount(2, $versions);
+        $this->assertCount(2, $versions);
 
-		foreach ($versions as $version) {
-			$this->assertSame('/subfolder/test.txt', $version['path']);
-			$this->assertSame('test.txt', $version['name']);
-		}
+        foreach ($versions as $version) {
+            $this->assertSame('/subfolder/test.txt', $version['path']);
+            $this->assertSame('test.txt', $version['name']);
+        }
 
-		//cleanup
-		$this->rootView->deleteAll(self::USERS_VERSIONS_ROOT . '/subfolder');
-	}
+        //cleanup
+        $this->rootView->deleteAll(self::USERS_VERSIONS_ROOT . '/subfolder');
+    }
 
-	/**
-	 * test if we find all versions and if the versions array contain
-	 * the correct 'path' and 'name'
-	 */
-	public function testGetVersionsEmptyFile(): void {
-		// execute copy hook of versions app
-		$versions = Storage::getVersions(self::TEST_VERSIONS_USER, '');
-		$this->assertCount(0, $versions);
+    /**
+     * test if we find all versions and if the versions array contain
+     * the correct 'path' and 'name'
+     */
+    public function testGetVersionsEmptyFile(): void {
+        // execute copy hook of versions app
+        $versions = Storage::getVersions(self::TEST_VERSIONS_USER, '');
+        $this->assertCount(0, $versions);
 
-		$versions = Storage::getVersions(self::TEST_VERSIONS_USER, null);
-		$this->assertCount(0, $versions);
-	}
+        $versions = Storage::getVersions(self::TEST_VERSIONS_USER, null);
+        $this->assertCount(0, $versions);
+    }
 
-	public function testExpireNonexistingFile(): void {
-		$this->logout();
-		// needed to have a FS setup (the background job does this)
-		\OC_Util::setupFS(self::TEST_VERSIONS_USER);
+    public function testExpireNonexistingFile(): void {
+        $this->logout();
+        // needed to have a FS setup (the background job does this)
+        \OC_Util::setupFS(self::TEST_VERSIONS_USER);
 
-		$this->assertFalse(Storage::expire('/void/unexist.txt', self::TEST_VERSIONS_USER));
-	}
+        $this->assertFalse(Storage::expire('/void/unexist.txt', self::TEST_VERSIONS_USER));
+    }
 
 
-	public function testExpireNonexistingUser(): void {
-		$this->expectException(NoUserException::class);
+    public function testExpireNonexistingUser(): void {
+        $this->expectException(NoUserException::class);
 
-		$this->logout();
-		// needed to have a FS setup (the background job does this)
-		\OC_Util::setupFS(self::TEST_VERSIONS_USER);
-		Filesystem::file_put_contents('test.txt', 'test file');
+        $this->logout();
+        // needed to have a FS setup (the background job does this)
+        \OC_Util::setupFS(self::TEST_VERSIONS_USER);
+        Filesystem::file_put_contents('test.txt', 'test file');
 
-		$this->assertFalse(Storage::expire('test.txt', 'unexist'));
-	}
+        $this->assertFalse(Storage::expire('test.txt', 'unexist'));
+    }
 
-	public function testRestoreSameStorage(): void {
-		Filesystem::mkdir('sub');
-		$this->doTestRestore();
-	}
+    public function testRestoreSameStorage(): void {
+        Filesystem::mkdir('sub');
+        $this->doTestRestore();
+    }
 
-	public function testRestoreCrossStorage(): void {
-		$storage2 = new Temporary([]);
-		Filesystem::mount($storage2, [], self::TEST_VERSIONS_USER . '/files/sub');
+    public function testRestoreCrossStorage(): void {
+        $storage2 = new Temporary([]);
+        Filesystem::mount($storage2, [], self::TEST_VERSIONS_USER . '/files/sub');
 
-		$this->doTestRestore();
-	}
+        $this->doTestRestore();
+    }
 
-	public function testRestoreNoPermission(): void {
-		$this->loginAsUser(self::TEST_VERSIONS_USER);
+    public function testRestoreNoPermission(): void {
+        $this->loginAsUser(self::TEST_VERSIONS_USER);
 
-		$userHome = \OC::$server->getUserFolder(self::TEST_VERSIONS_USER);
-		$node = $userHome->newFolder('folder');
-		$file = $node->newFile('test.txt');
+        $userHome = \OC::$server->getUserFolder(self::TEST_VERSIONS_USER);
+        $node = $userHome->newFolder('folder');
+        $file = $node->newFile('test.txt');
 
-		$share = Server::get(\OCP\Share\IManager::class)->newShare();
-		$share->setNode($node)
-			->setShareType(IShare::TYPE_USER)
-			->setSharedBy(self::TEST_VERSIONS_USER)
-			->setSharedWith(self::TEST_VERSIONS_USER2)
-			->setPermissions(Constants::PERMISSION_READ);
-		$share = Server::get(\OCP\Share\IManager::class)->createShare($share);
-		Server::get(\OCP\Share\IManager::class)->acceptShare($share, self::TEST_VERSIONS_USER2);
-
-		$versions = $this->createAndCheckVersions(
-			Filesystem::getView(),
-			'folder/test.txt'
-		);
-
-		$file->putContent('test file');
-
-		$this->loginAsUser(self::TEST_VERSIONS_USER2);
+        $share = Server::get(\OCP\Share\IManager::class)->newShare();
+        $share->setNode($node)
+            ->setShareType(IShare::TYPE_USER)
+            ->setSharedBy(self::TEST_VERSIONS_USER)
+            ->setSharedWith(self::TEST_VERSIONS_USER2)
+            ->setPermissions(Constants::PERMISSION_READ);
+        $share = Server::get(\OCP\Share\IManager::class)->createShare($share);
+        Server::get(\OCP\Share\IManager::class)->acceptShare($share, self::TEST_VERSIONS_USER2);
+
+        $versions = $this->createAndCheckVersions(
+            Filesystem::getView(),
+            'folder/test.txt'
+        );
+
+        $file->putContent('test file');
+
+        $this->loginAsUser(self::TEST_VERSIONS_USER2);
 
-		$firstVersion = current($versions);
+        $firstVersion = current($versions);
 
-		$this->assertFalse(Storage::rollback('folder/test.txt', $firstVersion['version'], $this->user2), 'Revert did not happen');
+        $this->assertFalse(Storage::rollback('folder/test.txt', $firstVersion['version'], $this->user2), 'Revert did not happen');
 
-		$this->loginAsUser(self::TEST_VERSIONS_USER);
+        $this->loginAsUser(self::TEST_VERSIONS_USER);
 
-		Server::get(\OCP\Share\IManager::class)->deleteShare($share);
-		$this->assertEquals('test file', $file->getContent(), 'File content has not changed');
-	}
+        Server::get(\OCP\Share\IManager::class)->deleteShare($share);
+        $this->assertEquals('test file', $file->getContent(), 'File content has not changed');
+    }
 
-	public function testRestoreMovedShare(): void {
-		$this->markTestSkipped('Unreliable test');
-		$this->loginAsUser(self::TEST_VERSIONS_USER);
-
-		$userHome = \OC::$server->getUserFolder(self::TEST_VERSIONS_USER);
-		$node = $userHome->newFolder('folder');
-		$file = $node->newFile('test.txt');
-
-		$userHome2 = \OC::$server->getUserFolder(self::TEST_VERSIONS_USER2);
-		$userHome2->newFolder('subfolder');
-
-		$share = Server::get(\OCP\Share\IManager::class)->newShare();
-		$share->setNode($node)
-			->setShareType(IShare::TYPE_USER)
-			->setSharedBy(self::TEST_VERSIONS_USER)
-			->setSharedWith(self::TEST_VERSIONS_USER2)
-			->setPermissions(Constants::PERMISSION_ALL);
-		$share = Server::get(\OCP\Share\IManager::class)->createShare($share);
-		$shareManager = Server::get(\OCP\Share\IManager::class);
-		$shareManager->acceptShare($share, self::TEST_VERSIONS_USER2);
-
-		$share->setTarget('subfolder/folder');
-		$shareManager->moveShare($share, self::TEST_VERSIONS_USER2);
-
-		$versions = $this->createAndCheckVersions(
-			Filesystem::getView(),
-			'folder/test.txt'
-		);
-
-		$file->putContent('test file');
-
-		$this->loginAsUser(self::TEST_VERSIONS_USER2);
-
-		$firstVersion = current($versions);
-
-		$this->assertTrue(Storage::rollback('folder/test.txt', $firstVersion['version'], $this->user1));
-
-		$this->loginAsUser(self::TEST_VERSIONS_USER);
-
-		Server::get(\OCP\Share\IManager::class)->deleteShare($share);
-		$this->assertEquals('version 2', $file->getContent(), 'File content has not changed');
-	}
-
-	/**
-	 * @param string $hookName name of hook called
-	 * @param string $params variable to receive parameters provided by hook
-	 */
-	private function connectMockHooks($hookName, &$params) {
-		if ($hookName === null) {
-			return;
-		}
-
-		$eventHandler = $this->getMockBuilder(\stdclass::class)
-			->setMethods(['callback'])
-			->getMock();
-
-		$eventHandler->expects($this->any())
-			->method('callback')
-			->willReturnCallback(
-				function ($p) use (&$params): void {
-					$params = $p;
-				}
-			);
-
-		Util::connectHook(
-			'\OCP\Versions',
-			$hookName,
-			$eventHandler,
-			'callback'
-		);
-	}
-
-	private function doTestRestore() {
-		$filePath = self::TEST_VERSIONS_USER . '/files/sub/test.txt';
-		$this->rootView->file_put_contents($filePath, 'test file');
-
-		$fileInfo = $this->rootView->getFileInfo($filePath);
-		$t0 = $this->rootView->filemtime($filePath);
-
-		// not exactly the same timestamp as the file
-		$t1 = time() - 60;
-		// second version is two weeks older
-		$t2 = $t1 - 60 * 60 * 24 * 14;
-
-		// create some versions
-		$v1 = self::USERS_VERSIONS_ROOT . '/sub/test.txt.v' . $t1;
-		$v2 = self::USERS_VERSIONS_ROOT . '/sub/test.txt.v' . $t2;
-
-		$this->rootView->mkdir(self::USERS_VERSIONS_ROOT . '/sub');
-
-		$this->rootView->file_put_contents($v1, 'version1');
-		$fileInfoV1 = $this->rootView->getFileInfo($v1);
-		$versionEntity = new VersionEntity();
-		$versionEntity->setFileId($fileInfo->getId());
-		$versionEntity->setTimestamp($t1);
-		$versionEntity->setSize($fileInfoV1->getSize());
-		$versionEntity->setMimetype($this->mimeTypeLoader->getId($fileInfoV1->getMimetype()));
-		$versionEntity->setMetadata([]);
-		$this->versionsMapper->insert($versionEntity);
-
-		$this->rootView->file_put_contents($v2, 'version2');
-		$fileInfoV2 = $this->rootView->getFileInfo($v2);
-		$versionEntity = new VersionEntity();
-		$versionEntity->setFileId($fileInfo->getId());
-		$versionEntity->setTimestamp($t2);
-		$versionEntity->setSize($fileInfoV2->getSize());
-		$versionEntity->setMimetype($this->mimeTypeLoader->getId($fileInfoV2->getMimetype()));
-		$versionEntity->setMetadata([]);
-		$this->versionsMapper->insert($versionEntity);
-
-		$oldVersions = Storage::getVersions(
-			self::TEST_VERSIONS_USER, '/sub/test.txt'
-		);
-
-		$this->assertCount(2, $oldVersions);
-
-		$this->assertEquals('test file', $this->rootView->file_get_contents($filePath));
-		$info1 = $this->rootView->getFileInfo($filePath);
-
-		$eventDispatcher = Server::get(IEventDispatcher::class);
-		$eventFired = false;
-		$eventDispatcher->addListener(VersionRestoredEvent::class, function ($event) use (&$eventFired, $t2): void {
-			$eventFired = true;
-			$this->assertEquals('/sub/test.txt', $event->getVersion()->getVersionPath());
-			$this->assertTrue($event->getVersion()->getRevisionId() > 0);
-		});
-
-		$versionManager = Server::get(IVersionManager::class);
-		$versions = $versionManager->getVersionsForFile($this->user1, $info1);
-		$version = array_filter($versions, function ($version) use ($t2) {
-			return $version->getRevisionId() === $t2;
-		});
-		$this->assertTrue($versionManager->rollback(current($version)));
-
-		$this->assertTrue($eventFired, 'VersionRestoredEvent was not fired');
-
-		$this->assertEquals('version2', $this->rootView->file_get_contents($filePath));
-		$info2 = $this->rootView->getFileInfo($filePath);
-
-		$this->assertNotEquals(
-			$info2['etag'],
-			$info1['etag'],
-			'Etag must change after rolling back version'
-		);
-		$this->assertEquals(
-			$info2['fileid'],
-			$info1['fileid'],
-			'File id must not change after rolling back version'
-		);
-		$this->assertEquals(
-			$info2['mtime'],
-			$t2,
-			'Restored file has mtime from version'
-		);
-
-		$newVersions = Storage::getVersions(
-			self::TEST_VERSIONS_USER, '/sub/test.txt'
-		);
-
-		$this->assertTrue(
-			$this->rootView->file_exists(self::USERS_VERSIONS_ROOT . '/sub/test.txt.v' . $t0),
-			'A version file was created for the file before restoration'
-		);
-		$this->assertTrue(
-			$this->rootView->file_exists($v1),
-			'Untouched version file is still there'
-		);
-		$this->assertFalse(
-			$this->rootView->file_exists($v2),
-			'Restored version file gone from files_version folder'
-		);
-
-		$this->assertCount(2, $newVersions, 'Additional version created');
-
-		$this->assertTrue(
-			isset($newVersions[$t0 . '#' . 'test.txt']),
-			'A version was created for the file before restoration'
-		);
-		$this->assertTrue(
-			isset($newVersions[$t1 . '#' . 'test.txt']),
-			'Untouched version is still there'
-		);
-		$this->assertFalse(
-			isset($newVersions[$t2 . '#' . 'test.txt']),
-			'Restored version is not in the list any more'
-		);
-	}
-
-	/**
-	 * Test whether versions are created when overwriting as owner
-	 */
-	public function testStoreVersionAsOwner(): void {
-		$this->loginAsUser(self::TEST_VERSIONS_USER);
-
-		$this->createAndCheckVersions(
-			Filesystem::getView(),
-			'test.txt'
-		);
-	}
-
-	/**
-	 * Test whether versions are created when overwriting as share recipient
-	 */
-	public function testStoreVersionAsRecipient(): void {
-		$this->loginAsUser(self::TEST_VERSIONS_USER);
-
-		Filesystem::mkdir('folder');
-		Filesystem::file_put_contents('folder/test.txt', 'test file');
-
-		$node = \OC::$server->getUserFolder(self::TEST_VERSIONS_USER)->get('folder');
-		$share = Server::get(\OCP\Share\IManager::class)->newShare();
-		$share->setNode($node)
-			->setShareType(IShare::TYPE_USER)
-			->setSharedBy(self::TEST_VERSIONS_USER)
-			->setSharedWith(self::TEST_VERSIONS_USER2)
-			->setPermissions(Constants::PERMISSION_ALL);
-		$share = Server::get(\OCP\Share\IManager::class)->createShare($share);
-		Server::get(\OCP\Share\IManager::class)->acceptShare($share, self::TEST_VERSIONS_USER2);
-
-		$this->loginAsUser(self::TEST_VERSIONS_USER2);
-
-		$this->createAndCheckVersions(
-			Filesystem::getView(),
-			'folder/test.txt'
-		);
-
-		Server::get(\OCP\Share\IManager::class)->deleteShare($share);
-	}
-
-	/**
-	 * Test whether versions are created when overwriting anonymously.
-	 *
-	 * When uploading through a public link or publicwebdav, no user
-	 * is logged in. File modification must still be able to find
-	 * the owner and create versions.
-	 */
-	public function testStoreVersionAsAnonymous(): void {
-		$this->logout();
-
-		// note: public link upload does this,
-		// needed to make the hooks fire
-		\OC_Util::setupFS(self::TEST_VERSIONS_USER);
-
-		$userView = new View('/' . self::TEST_VERSIONS_USER . '/files');
-		$this->createAndCheckVersions(
-			$userView,
-			'test.txt'
-		);
-	}
-
-	/**
-	 * @param View $view
-	 * @param string $path
-	 */
-	private function createAndCheckVersions(View $view, $path) {
-		$view->file_put_contents($path, 'test file');
-		$view->file_put_contents($path, 'version 1');
-		$view->file_put_contents($path, 'version 2');
-
-		$this->loginAsUser(self::TEST_VERSIONS_USER);
-
-		// need to scan for the versions
-		[$rootStorage,] = $this->rootView->resolvePath(self::TEST_VERSIONS_USER . '/files_versions');
-		$rootStorage->getScanner()->scan('files_versions');
-
-		$versions = Storage::getVersions(
-			self::TEST_VERSIONS_USER, '/' . $path
-		);
-
-		// note: we cannot predict how many versions are created due to
-		// test run timing
-		$this->assertGreaterThan(0, count($versions));
-
-		return $versions;
-	}
-
-	/**
-	 * @param string $user
-	 * @param bool $create
-	 */
-	public static function loginHelper($user, $create = false) {
-		if ($create) {
-			$backend = new \Test\Util\User\Dummy();
-			$backend->createUser($user, $user);
-			Server::get(IUserManager::class)->registerBackend($backend);
-		}
-
-		\OC_Util::tearDownFS();
-		\OC_User::setUserId('');
-		Filesystem::tearDown();
-		\OC_User::setUserId($user);
-		\OC_Util::setupFS($user);
-		\OC::$server->getUserFolder($user);
-	}
+    public function testRestoreMovedShare(): void {
+        $this->markTestSkipped('Unreliable test');
+        $this->loginAsUser(self::TEST_VERSIONS_USER);
+
+        $userHome = \OC::$server->getUserFolder(self::TEST_VERSIONS_USER);
+        $node = $userHome->newFolder('folder');
+        $file = $node->newFile('test.txt');
+
+        $userHome2 = \OC::$server->getUserFolder(self::TEST_VERSIONS_USER2);
+        $userHome2->newFolder('subfolder');
+
+        $share = Server::get(\OCP\Share\IManager::class)->newShare();
+        $share->setNode($node)
+            ->setShareType(IShare::TYPE_USER)
+            ->setSharedBy(self::TEST_VERSIONS_USER)
+            ->setSharedWith(self::TEST_VERSIONS_USER2)
+            ->setPermissions(Constants::PERMISSION_ALL);
+        $share = Server::get(\OCP\Share\IManager::class)->createShare($share);
+        $shareManager = Server::get(\OCP\Share\IManager::class);
+        $shareManager->acceptShare($share, self::TEST_VERSIONS_USER2);
+
+        $share->setTarget('subfolder/folder');
+        $shareManager->moveShare($share, self::TEST_VERSIONS_USER2);
+
+        $versions = $this->createAndCheckVersions(
+            Filesystem::getView(),
+            'folder/test.txt'
+        );
+
+        $file->putContent('test file');
+
+        $this->loginAsUser(self::TEST_VERSIONS_USER2);
+
+        $firstVersion = current($versions);
+
+        $this->assertTrue(Storage::rollback('folder/test.txt', $firstVersion['version'], $this->user1));
+
+        $this->loginAsUser(self::TEST_VERSIONS_USER);
+
+        Server::get(\OCP\Share\IManager::class)->deleteShare($share);
+        $this->assertEquals('version 2', $file->getContent(), 'File content has not changed');
+    }
+
+    /**
+     * @param string $hookName name of hook called
+     * @param string $params variable to receive parameters provided by hook
+     */
+    private function connectMockHooks($hookName, &$params) {
+        if ($hookName === null) {
+            return;
+        }
+
+        $eventHandler = $this->getMockBuilder(\stdclass::class)
+            ->setMethods(['callback'])
+            ->getMock();
+
+        $eventHandler->expects($this->any())
+            ->method('callback')
+            ->willReturnCallback(
+                function ($p) use (&$params): void {
+                    $params = $p;
+                }
+            );
+
+        Util::connectHook(
+            '\OCP\Versions',
+            $hookName,
+            $eventHandler,
+            'callback'
+        );
+    }
+
+    private function doTestRestore() {
+        $filePath = self::TEST_VERSIONS_USER . '/files/sub/test.txt';
+        $this->rootView->file_put_contents($filePath, 'test file');
+
+        $fileInfo = $this->rootView->getFileInfo($filePath);
+        $t0 = $this->rootView->filemtime($filePath);
+
+        // not exactly the same timestamp as the file
+        $t1 = time() - 60;
+        // second version is two weeks older
+        $t2 = $t1 - 60 * 60 * 24 * 14;
+
+        // create some versions
+        $v1 = self::USERS_VERSIONS_ROOT . '/sub/test.txt.v' . $t1;
+        $v2 = self::USERS_VERSIONS_ROOT . '/sub/test.txt.v' . $t2;
+
+        $this->rootView->mkdir(self::USERS_VERSIONS_ROOT . '/sub');
+
+        $this->rootView->file_put_contents($v1, 'version1');
+        $fileInfoV1 = $this->rootView->getFileInfo($v1);
+        $versionEntity = new VersionEntity();
+        $versionEntity->setFileId($fileInfo->getId());
+        $versionEntity->setTimestamp($t1);
+        $versionEntity->setSize($fileInfoV1->getSize());
+        $versionEntity->setMimetype($this->mimeTypeLoader->getId($fileInfoV1->getMimetype()));
+        $versionEntity->setMetadata([]);
+        $this->versionsMapper->insert($versionEntity);
+
+        $this->rootView->file_put_contents($v2, 'version2');
+        $fileInfoV2 = $this->rootView->getFileInfo($v2);
+        $versionEntity = new VersionEntity();
+        $versionEntity->setFileId($fileInfo->getId());
+        $versionEntity->setTimestamp($t2);
+        $versionEntity->setSize($fileInfoV2->getSize());
+        $versionEntity->setMimetype($this->mimeTypeLoader->getId($fileInfoV2->getMimetype()));
+        $versionEntity->setMetadata([]);
+        $this->versionsMapper->insert($versionEntity);
+
+        $oldVersions = Storage::getVersions(
+            self::TEST_VERSIONS_USER, '/sub/test.txt'
+        );
+
+        $this->assertCount(2, $oldVersions);
+
+        $this->assertEquals('test file', $this->rootView->file_get_contents($filePath));
+        $info1 = $this->rootView->getFileInfo($filePath);
+
+        $eventDispatcher = Server::get(IEventDispatcher::class);
+        $eventFired = false;
+        $eventDispatcher->addListener(VersionRestoredEvent::class, function ($event) use (&$eventFired, $t2): void {
+            $eventFired = true;
+            $this->assertEquals('/sub/test.txt', $event->getVersion()->getVersionPath());
+            $this->assertTrue($event->getVersion()->getRevisionId() > 0);
+        });
+
+        $versionManager = Server::get(IVersionManager::class);
+        $versions = $versionManager->getVersionsForFile($this->user1, $info1);
+        $version = array_filter($versions, function ($version) use ($t2) {
+            return $version->getRevisionId() === $t2;
+        });
+        $this->assertTrue($versionManager->rollback(current($version)));
+
+        $this->assertTrue($eventFired, 'VersionRestoredEvent was not fired');
+
+        $this->assertEquals('version2', $this->rootView->file_get_contents($filePath));
+        $info2 = $this->rootView->getFileInfo($filePath);
+
+        $this->assertNotEquals(
+            $info2['etag'],
+            $info1['etag'],
+            'Etag must change after rolling back version'
+        );
+        $this->assertEquals(
+            $info2['fileid'],
+            $info1['fileid'],
+            'File id must not change after rolling back version'
+        );
+        $this->assertEquals(
+            $info2['mtime'],
+            $t2,
+            'Restored file has mtime from version'
+        );
+
+        $newVersions = Storage::getVersions(
+            self::TEST_VERSIONS_USER, '/sub/test.txt'
+        );
+
+        $this->assertTrue(
+            $this->rootView->file_exists(self::USERS_VERSIONS_ROOT . '/sub/test.txt.v' . $t0),
+            'A version file was created for the file before restoration'
+        );
+        $this->assertTrue(
+            $this->rootView->file_exists($v1),
+            'Untouched version file is still there'
+        );
+        $this->assertFalse(
+            $this->rootView->file_exists($v2),
+            'Restored version file gone from files_version folder'
+        );
+
+        $this->assertCount(2, $newVersions, 'Additional version created');
+
+        $this->assertTrue(
+            isset($newVersions[$t0 . '#' . 'test.txt']),
+            'A version was created for the file before restoration'
+        );
+        $this->assertTrue(
+            isset($newVersions[$t1 . '#' . 'test.txt']),
+            'Untouched version is still there'
+        );
+        $this->assertFalse(
+            isset($newVersions[$t2 . '#' . 'test.txt']),
+            'Restored version is not in the list any more'
+        );
+    }
+
+    /**
+     * Test whether versions are created when overwriting as owner
+     */
+    public function testStoreVersionAsOwner(): void {
+        $this->loginAsUser(self::TEST_VERSIONS_USER);
+
+        $this->createAndCheckVersions(
+            Filesystem::getView(),
+            'test.txt'
+        );
+    }
+
+    /**
+     * Test whether versions are created when overwriting as share recipient
+     */
+    public function testStoreVersionAsRecipient(): void {
+        $this->loginAsUser(self::TEST_VERSIONS_USER);
+
+        Filesystem::mkdir('folder');
+        Filesystem::file_put_contents('folder/test.txt', 'test file');
+
+        $node = \OC::$server->getUserFolder(self::TEST_VERSIONS_USER)->get('folder');
+        $share = Server::get(\OCP\Share\IManager::class)->newShare();
+        $share->setNode($node)
+            ->setShareType(IShare::TYPE_USER)
+            ->setSharedBy(self::TEST_VERSIONS_USER)
+            ->setSharedWith(self::TEST_VERSIONS_USER2)
+            ->setPermissions(Constants::PERMISSION_ALL);
+        $share = Server::get(\OCP\Share\IManager::class)->createShare($share);
+        Server::get(\OCP\Share\IManager::class)->acceptShare($share, self::TEST_VERSIONS_USER2);
+
+        $this->loginAsUser(self::TEST_VERSIONS_USER2);
+
+        $this->createAndCheckVersions(
+            Filesystem::getView(),
+            'folder/test.txt'
+        );
+
+        Server::get(\OCP\Share\IManager::class)->deleteShare($share);
+    }
+
+    /**
+     * Test whether versions are created when overwriting anonymously.
+     *
+     * When uploading through a public link or publicwebdav, no user
+     * is logged in. File modification must still be able to find
+     * the owner and create versions.
+     */
+    public function testStoreVersionAsAnonymous(): void {
+        $this->logout();
+
+        // note: public link upload does this,
+        // needed to make the hooks fire
+        \OC_Util::setupFS(self::TEST_VERSIONS_USER);
+
+        $userView = new View('/' . self::TEST_VERSIONS_USER . '/files');
+        $this->createAndCheckVersions(
+            $userView,
+            'test.txt'
+        );
+    }
+
+    /**
+     * @param View $view
+     * @param string $path
+     */
+    private function createAndCheckVersions(View $view, $path) {
+        $view->file_put_contents($path, 'test file');
+        $view->file_put_contents($path, 'version 1');
+        $view->file_put_contents($path, 'version 2');
+
+        $this->loginAsUser(self::TEST_VERSIONS_USER);
+
+        // need to scan for the versions
+        [$rootStorage,] = $this->rootView->resolvePath(self::TEST_VERSIONS_USER . '/files_versions');
+        $rootStorage->getScanner()->scan('files_versions');
+
+        $versions = Storage::getVersions(
+            self::TEST_VERSIONS_USER, '/' . $path
+        );
+
+        // note: we cannot predict how many versions are created due to
+        // test run timing
+        $this->assertGreaterThan(0, count($versions));
+
+        return $versions;
+    }
+
+    /**
+     * @param string $user
+     * @param bool $create
+     */
+    public static function loginHelper($user, $create = false) {
+        if ($create) {
+            $backend = new \Test\Util\User\Dummy();
+            $backend->createUser($user, $user);
+            Server::get(IUserManager::class)->registerBackend($backend);
+        }
+
+        \OC_Util::tearDownFS();
+        \OC_User::setUserId('');
+        Filesystem::tearDown();
+        \OC_User::setUserId($user);
+        \OC_Util::setupFS($user);
+        \OC::$server->getUserFolder($user);
+    }
 }
 
 // extend the original class to make it possible to test protected methods
 class VersionStorageToTest extends Storage {
 
-	/**
-	 * @param integer $time
-	 */
-	public function callProtectedGetExpireList($time, $versions) {
-		return self::getExpireList($time, $versions);
-	}
+    /**
+     * @param integer $time
+     */
+    public function callProtectedGetExpireList($time, $versions) {
+        return self::getExpireList($time, $versions);
+    }
 }

Spacing +59 added lines, -59 removed lines

@@ -89,7 +89,7 @@ 
 			->getMock();
 		$mockConfig->expects($this->any())
 			->method('getSystemValue')
-			->willReturnCallback(function ($key, $default) use ($config) {
+			->willReturnCallback(function($key, $default) use ($config) {
 				if ($key === 'filesystem_check_changes') {
 					return Watcher::CHECK_ONCE;
 				} else {
@@ -124,10 +124,10 @@ 
 		$this->restoreService(AllConfig::class);
 
 		if ($this->rootView) {
-			$this->rootView->deleteAll(self::TEST_VERSIONS_USER . '/files/');
-			$this->rootView->deleteAll(self::TEST_VERSIONS_USER2 . '/files/');
-			$this->rootView->deleteAll(self::TEST_VERSIONS_USER . '/files_versions/');
-			$this->rootView->deleteAll(self::TEST_VERSIONS_USER2 . '/files_versions/');
+			$this->rootView->deleteAll(self::TEST_VERSIONS_USER.'/files/');
+			$this->rootView->deleteAll(self::TEST_VERSIONS_USER2.'/files/');
+			$this->rootView->deleteAll(self::TEST_VERSIONS_USER.'/files_versions/');
+			$this->rootView->deleteAll(self::TEST_VERSIONS_USER2.'/files_versions/');
 		}
 
 		\OC_Hook::clear();
@@ -295,10 +295,10 @@ 
 		$t2 = $t1 - 60 * 60 * 24 * 14;
 
 		// create some versions
-		$v1 = self::USERS_VERSIONS_ROOT . '/test.txt.v' . $t1;
-		$v2 = self::USERS_VERSIONS_ROOT . '/test.txt.v' . $t2;
-		$v1Renamed = self::USERS_VERSIONS_ROOT . '/test2.txt.v' . $t1;
-		$v2Renamed = self::USERS_VERSIONS_ROOT . '/test2.txt.v' . $t2;
+		$v1 = self::USERS_VERSIONS_ROOT.'/test.txt.v'.$t1;
+		$v2 = self::USERS_VERSIONS_ROOT.'/test.txt.v'.$t2;
+		$v1Renamed = self::USERS_VERSIONS_ROOT.'/test2.txt.v'.$t1;
+		$v2Renamed = self::USERS_VERSIONS_ROOT.'/test2.txt.v'.$t2;
 
 		$this->rootView->file_put_contents($v1, 'version1');
 		$this->rootView->file_put_contents($v2, 'version2');
@@ -325,12 +325,12 @@ 
 		// version will be expired
 		$t2 = $t1 - 60 * 60 * 24 * 14;
 
-		$this->rootView->mkdir(self::USERS_VERSIONS_ROOT . '/folder1');
+		$this->rootView->mkdir(self::USERS_VERSIONS_ROOT.'/folder1');
 		// create some versions
-		$v1 = self::USERS_VERSIONS_ROOT . '/folder1/test.txt.v' . $t1;
-		$v2 = self::USERS_VERSIONS_ROOT . '/folder1/test.txt.v' . $t2;
-		$v1Renamed = self::USERS_VERSIONS_ROOT . '/folder1/folder2/test.txt.v' . $t1;
-		$v2Renamed = self::USERS_VERSIONS_ROOT . '/folder1/folder2/test.txt.v' . $t2;
+		$v1 = self::USERS_VERSIONS_ROOT.'/folder1/test.txt.v'.$t1;
+		$v2 = self::USERS_VERSIONS_ROOT.'/folder1/test.txt.v'.$t2;
+		$v1Renamed = self::USERS_VERSIONS_ROOT.'/folder1/folder2/test.txt.v'.$t1;
+		$v2Renamed = self::USERS_VERSIONS_ROOT.'/folder1/folder2/test.txt.v'.$t2;
 
 		$this->rootView->file_put_contents($v1, 'version1');
 		$this->rootView->file_put_contents($v2, 'version2');
@@ -376,11 +376,11 @@ 
 		$t2 = $t1 - 60 * 60 * 24 * 14;
 
 		// create some versions
-		$this->rootView->mkdir(self::USERS_VERSIONS_ROOT . '/folder1');
-		$v1 = self::USERS_VERSIONS_ROOT . '/folder1/test.txt.v' . $t1;
-		$v2 = self::USERS_VERSIONS_ROOT . '/folder1/test.txt.v' . $t2;
-		$v1Renamed = self::USERS_VERSIONS_ROOT . '/folder2/folder1/test.txt.v' . $t1;
-		$v2Renamed = self::USERS_VERSIONS_ROOT . '/folder2/folder1/test.txt.v' . $t2;
+		$this->rootView->mkdir(self::USERS_VERSIONS_ROOT.'/folder1');
+		$v1 = self::USERS_VERSIONS_ROOT.'/folder1/test.txt.v'.$t1;
+		$v2 = self::USERS_VERSIONS_ROOT.'/folder1/test.txt.v'.$t2;
+		$v1Renamed = self::USERS_VERSIONS_ROOT.'/folder2/folder1/test.txt.v'.$t1;
+		$v2Renamed = self::USERS_VERSIONS_ROOT.'/folder2/folder1/test.txt.v'.$t2;
 
 		$this->rootView->file_put_contents($v1, 'version1');
 		$this->rootView->file_put_contents($v2, 'version2');
@@ -413,7 +413,7 @@ 
 		Server::get(\OCP\Share\IManager::class)->acceptShare($share, self::TEST_VERSIONS_USER2);
 
 		self::loginHelper(self::TEST_VERSIONS_USER2);
-		$versionsFolder2 = '/' . self::TEST_VERSIONS_USER2 . '/files_versions';
+		$versionsFolder2 = '/'.self::TEST_VERSIONS_USER2.'/files_versions';
 		Filesystem::file_put_contents('test.txt', 'test file');
 
 		$t1 = time();
@@ -423,8 +423,8 @@ 
 
 		$this->rootView->mkdir($versionsFolder2);
 		// create some versions
-		$v1 = $versionsFolder2 . '/test.txt.v' . $t1;
-		$v2 = $versionsFolder2 . '/test.txt.v' . $t2;
+		$v1 = $versionsFolder2.'/test.txt.v'.$t1;
+		$v2 = $versionsFolder2.'/test.txt.v'.$t2;
 
 		$this->rootView->file_put_contents($v1, 'version1');
 		$this->rootView->file_put_contents($v2, 'version2');
@@ -438,10 +438,10 @@ 
 
 		self::loginHelper(self::TEST_VERSIONS_USER);
 
-		$versionsFolder1 = '/' . self::TEST_VERSIONS_USER . '/files_versions';
+		$versionsFolder1 = '/'.self::TEST_VERSIONS_USER.'/files_versions';
 
-		$v1Renamed = $versionsFolder1 . '/folder1/test.txt.v' . $t1;
-		$v2Renamed = $versionsFolder1 . '/folder1/test.txt.v' . $t2;
+		$v1Renamed = $versionsFolder1.'/folder1/test.txt.v'.$t1;
+		$v2Renamed = $versionsFolder1.'/folder1/test.txt.v'.$t2;
 
 		$this->assertTrue($this->rootView->file_exists($v1Renamed));
 		$this->assertTrue($this->rootView->file_exists($v2Renamed));
@@ -463,7 +463,7 @@ 
 		Server::get(\OCP\Share\IManager::class)->acceptShare($share, self::TEST_VERSIONS_USER2);
 
 		self::loginHelper(self::TEST_VERSIONS_USER2);
-		$versionsFolder2 = '/' . self::TEST_VERSIONS_USER2 . '/files_versions';
+		$versionsFolder2 = '/'.self::TEST_VERSIONS_USER2.'/files_versions';
 		Filesystem::mkdir('folder2');
 		Filesystem::file_put_contents('folder2/test.txt', 'test file');
 
@@ -473,10 +473,10 @@ 
 		$t2 = $t1 - 60 * 60 * 24 * 14;
 
 		$this->rootView->mkdir($versionsFolder2);
-		$this->rootView->mkdir($versionsFolder2 . '/folder2');
+		$this->rootView->mkdir($versionsFolder2.'/folder2');
 		// create some versions
-		$v1 = $versionsFolder2 . '/folder2/test.txt.v' . $t1;
-		$v2 = $versionsFolder2 . '/folder2/test.txt.v' . $t2;
+		$v1 = $versionsFolder2.'/folder2/test.txt.v'.$t1;
+		$v2 = $versionsFolder2.'/folder2/test.txt.v'.$t2;
 
 		$this->rootView->file_put_contents($v1, 'version1');
 		$this->rootView->file_put_contents($v2, 'version2');
@@ -489,10 +489,10 @@ 
 
 		self::loginHelper(self::TEST_VERSIONS_USER);
 
-		$versionsFolder1 = '/' . self::TEST_VERSIONS_USER . '/files_versions';
+		$versionsFolder1 = '/'.self::TEST_VERSIONS_USER.'/files_versions';
 
-		$v1Renamed = $versionsFolder1 . '/folder1/folder2/test.txt.v' . $t1;
-		$v2Renamed = $versionsFolder1 . '/folder1/folder2/test.txt.v' . $t2;
+		$v1Renamed = $versionsFolder1.'/folder1/folder2/test.txt.v'.$t1;
+		$v2Renamed = $versionsFolder1.'/folder1/folder2/test.txt.v'.$t2;
 
 		$this->assertTrue($this->rootView->file_exists($v1Renamed));
 		$this->assertTrue($this->rootView->file_exists($v2Renamed));
@@ -510,11 +510,11 @@ 
 
 		$this->rootView->mkdir(self::USERS_VERSIONS_ROOT);
 		// create some versions
-		$v1 = self::USERS_VERSIONS_ROOT . '/test.txt.v' . $t1;
-		$v2 = self::USERS_VERSIONS_ROOT . '/test.txt.v' . $t2;
+		$v1 = self::USERS_VERSIONS_ROOT.'/test.txt.v'.$t1;
+		$v2 = self::USERS_VERSIONS_ROOT.'/test.txt.v'.$t2;
 		// the renamed versions should not exist! Because we only moved the mount point!
-		$v1Renamed = self::USERS_VERSIONS_ROOT . '/test2.txt.v' . $t1;
-		$v2Renamed = self::USERS_VERSIONS_ROOT . '/test2.txt.v' . $t2;
+		$v1Renamed = self::USERS_VERSIONS_ROOT.'/test2.txt.v'.$t1;
+		$v2Renamed = self::USERS_VERSIONS_ROOT.'/test2.txt.v'.$t2;
 
 		$this->rootView->file_put_contents($v1, 'version1');
 		$this->rootView->file_put_contents($v2, 'version2');
@@ -558,10 +558,10 @@ 
 		$t2 = $t1 - 60 * 60 * 24 * 14;
 
 		// create some versions
-		$v1 = self::USERS_VERSIONS_ROOT . '/test.txt.v' . $t1;
-		$v2 = self::USERS_VERSIONS_ROOT . '/test.txt.v' . $t2;
-		$v1Copied = self::USERS_VERSIONS_ROOT . '/test2.txt.v' . $t1;
-		$v2Copied = self::USERS_VERSIONS_ROOT . '/test2.txt.v' . $t2;
+		$v1 = self::USERS_VERSIONS_ROOT.'/test.txt.v'.$t1;
+		$v2 = self::USERS_VERSIONS_ROOT.'/test.txt.v'.$t2;
+		$v1Copied = self::USERS_VERSIONS_ROOT.'/test2.txt.v'.$t1;
+		$v2Copied = self::USERS_VERSIONS_ROOT.'/test2.txt.v'.$t2;
 
 		$this->rootView->file_put_contents($v1, 'version1');
 		$this->rootView->file_put_contents($v2, 'version2');
@@ -589,10 +589,10 @@ 
 		$t2 = $t1 - 60 * 60 * 24 * 14;
 
 		// create some versions
-		$v1 = self::USERS_VERSIONS_ROOT . '/subfolder/test.txt.v' . $t1;
-		$v2 = self::USERS_VERSIONS_ROOT . '/subfolder/test.txt.v' . $t2;
+		$v1 = self::USERS_VERSIONS_ROOT.'/subfolder/test.txt.v'.$t1;
+		$v2 = self::USERS_VERSIONS_ROOT.'/subfolder/test.txt.v'.$t2;
 
-		$this->rootView->mkdir(self::USERS_VERSIONS_ROOT . '/subfolder/');
+		$this->rootView->mkdir(self::USERS_VERSIONS_ROOT.'/subfolder/');
 
 		$this->rootView->file_put_contents($v1, 'version1');
 		$this->rootView->file_put_contents($v2, 'version2');
@@ -608,7 +608,7 @@ 
 		}
 
 		//cleanup
-		$this->rootView->deleteAll(self::USERS_VERSIONS_ROOT . '/subfolder');
+		$this->rootView->deleteAll(self::USERS_VERSIONS_ROOT.'/subfolder');
 	}
 
 	/**
@@ -651,7 +651,7 @@ 
 
 	public function testRestoreCrossStorage(): void {
 		$storage2 = new Temporary([]);
-		Filesystem::mount($storage2, [], self::TEST_VERSIONS_USER . '/files/sub');
+		Filesystem::mount($storage2, [], self::TEST_VERSIONS_USER.'/files/sub');
 
 		$this->doTestRestore();
 	}
@@ -750,7 +750,7 @@ 
 		$eventHandler->expects($this->any())
 			->method('callback')
 			->willReturnCallback(
-				function ($p) use (&$params): void {
+				function($p) use (&$params): void {
 					$params = $p;
 				}
 			);
@@ -764,7 +764,7 @@ 
 	}
 
 	private function doTestRestore() {
-		$filePath = self::TEST_VERSIONS_USER . '/files/sub/test.txt';
+		$filePath = self::TEST_VERSIONS_USER.'/files/sub/test.txt';
 		$this->rootView->file_put_contents($filePath, 'test file');
 
 		$fileInfo = $this->rootView->getFileInfo($filePath);
@@ -776,10 +776,10 @@ 
 		$t2 = $t1 - 60 * 60 * 24 * 14;
 
 		// create some versions
-		$v1 = self::USERS_VERSIONS_ROOT . '/sub/test.txt.v' . $t1;
-		$v2 = self::USERS_VERSIONS_ROOT . '/sub/test.txt.v' . $t2;
+		$v1 = self::USERS_VERSIONS_ROOT.'/sub/test.txt.v'.$t1;
+		$v2 = self::USERS_VERSIONS_ROOT.'/sub/test.txt.v'.$t2;
 
-		$this->rootView->mkdir(self::USERS_VERSIONS_ROOT . '/sub');
+		$this->rootView->mkdir(self::USERS_VERSIONS_ROOT.'/sub');
 
 		$this->rootView->file_put_contents($v1, 'version1');
 		$fileInfoV1 = $this->rootView->getFileInfo($v1);
@@ -812,7 +812,7 @@ 
 
 		$eventDispatcher = Server::get(IEventDispatcher::class);
 		$eventFired = false;
-		$eventDispatcher->addListener(VersionRestoredEvent::class, function ($event) use (&$eventFired, $t2): void {
+		$eventDispatcher->addListener(VersionRestoredEvent::class, function($event) use (&$eventFired, $t2): void {
 			$eventFired = true;
 			$this->assertEquals('/sub/test.txt', $event->getVersion()->getVersionPath());
 			$this->assertTrue($event->getVersion()->getRevisionId() > 0);
@@ -820,7 +820,7 @@ 
 
 		$versionManager = Server::get(IVersionManager::class);
 		$versions = $versionManager->getVersionsForFile($this->user1, $info1);
-		$version = array_filter($versions, function ($version) use ($t2) {
+		$version = array_filter($versions, function($version) use ($t2) {
 			return $version->getRevisionId() === $t2;
 		});
 		$this->assertTrue($versionManager->rollback(current($version)));
@@ -851,7 +851,7 @@ 
 		);
 
 		$this->assertTrue(
-			$this->rootView->file_exists(self::USERS_VERSIONS_ROOT . '/sub/test.txt.v' . $t0),
+			$this->rootView->file_exists(self::USERS_VERSIONS_ROOT.'/sub/test.txt.v'.$t0),
 			'A version file was created for the file before restoration'
 		);
 		$this->assertTrue(
@@ -866,15 +866,15 @@ 
 		$this->assertCount(2, $newVersions, 'Additional version created');
 
 		$this->assertTrue(
-			isset($newVersions[$t0 . '#' . 'test.txt']),
+			isset($newVersions[$t0.'#'.'test.txt']),
 			'A version was created for the file before restoration'
 		);
 		$this->assertTrue(
-			isset($newVersions[$t1 . '#' . 'test.txt']),
+			isset($newVersions[$t1.'#'.'test.txt']),
 			'Untouched version is still there'
 		);
 		$this->assertFalse(
-			isset($newVersions[$t2 . '#' . 'test.txt']),
+			isset($newVersions[$t2.'#'.'test.txt']),
 			'Restored version is not in the list any more'
 		);
 	}
@@ -934,7 +934,7 @@ 
 		// needed to make the hooks fire
 		\OC_Util::setupFS(self::TEST_VERSIONS_USER);
 
-		$userView = new View('/' . self::TEST_VERSIONS_USER . '/files');
+		$userView = new View('/'.self::TEST_VERSIONS_USER.'/files');
 		$this->createAndCheckVersions(
 			$userView,
 			'test.txt'
@@ -953,11 +953,11 @@ 
 		$this->loginAsUser(self::TEST_VERSIONS_USER);
 
 		// need to scan for the versions
-		[$rootStorage,] = $this->rootView->resolvePath(self::TEST_VERSIONS_USER . '/files_versions');
+		[$rootStorage, ] = $this->rootView->resolvePath(self::TEST_VERSIONS_USER.'/files_versions');
 		$rootStorage->getScanner()->scan('files_versions');
 
 		$versions = Storage::getVersions(
-			self::TEST_VERSIONS_USER, '/' . $path
+			self::TEST_VERSIONS_USER, '/'.$path
 		);
 
 		// note: we cannot predict how many versions are created due to

apps/files_versions/lib/Listener/FileEventsListener.php

Indentation +362 added lines, -362 removed lines

@@ -42,366 +42,366 @@
 
 /** @template-implements IEventListener<BeforeNodeCopiedEvent|BeforeNodeDeletedEvent|BeforeNodeRenamedEvent|BeforeNodeTouchedEvent|BeforeNodeWrittenEvent|NodeCopiedEvent|NodeCreatedEvent|NodeDeletedEvent|NodeRenamedEvent|NodeTouchedEvent|NodeWrittenEvent> */
 class FileEventsListener implements IEventListener {
-	/**
-	 * @var array<int, array>
-	 */
-	private array $writeHookInfo = [];
-	/**
-	 * @var array<int, Node>
-	 */
-	private array $nodesTouched = [];
-	/**
-	 * @var array<string, Node>
-	 */
-	private array $versionsDeleted = [];
-
-	public function __construct(
-		private IRootFolder $rootFolder,
-		private IVersionManager $versionManager,
-		private IMimeTypeLoader $mimeTypeLoader,
-		private IUserSession $userSession,
-		private LoggerInterface $logger,
-	) {
-	}
-
-	public function handle(Event $event): void {
-		if ($event instanceof NodeCreatedEvent) {
-			$this->created($event->getNode());
-		}
-
-		if ($event instanceof BeforeNodeTouchedEvent) {
-			$this->pre_touch_hook($event->getNode());
-		}
-
-		if ($event instanceof NodeTouchedEvent) {
-			$this->touch_hook($event->getNode());
-		}
-
-		if ($event instanceof BeforeNodeWrittenEvent) {
-			$this->write_hook($event->getNode());
-		}
-
-		if ($event instanceof NodeWrittenEvent) {
-			$this->post_write_hook($event->getNode());
-		}
-
-		if ($event instanceof BeforeNodeDeletedEvent) {
-			$this->pre_remove_hook($event->getNode());
-		}
-
-		if ($event instanceof NodeDeletedEvent) {
-			$this->remove_hook($event->getNode());
-		}
-
-		if ($event instanceof NodeRenamedEvent) {
-			$this->rename_hook($event->getSource(), $event->getTarget());
-		}
-
-		if ($event instanceof NodeCopiedEvent) {
-			$this->copy_hook($event->getSource(), $event->getTarget());
-		}
-
-		if ($event instanceof BeforeNodeRenamedEvent) {
-			$this->pre_renameOrCopy_hook($event->getSource(), $event->getTarget());
-		}
-
-		if ($event instanceof BeforeNodeCopiedEvent) {
-			$this->pre_renameOrCopy_hook($event->getSource(), $event->getTarget());
-		}
-	}
-
-	public function pre_touch_hook(Node $node): void {
-		// Do not handle folders.
-		if ($node instanceof Folder) {
-			return;
-		}
-
-		// $node is a non-existing on file creation.
-		if ($node instanceof NonExistingFile) {
-			return;
-		}
-
-		$this->nodesTouched[$node->getId()] = $node;
-	}
-
-	public function touch_hook(Node $node): void {
-		$previousNode = $this->nodesTouched[$node->getId()] ?? null;
-
-		if ($previousNode === null) {
-			return;
-		}
-
-		unset($this->nodesTouched[$node->getId()]);
-
-		try {
-			if ($node instanceof File && $this->versionManager instanceof INeedSyncVersionBackend) {
-				// We update the timestamp of the version entity associated with the previousNode.
-				$this->versionManager->updateVersionEntity($node, $previousNode->getMTime(), ['timestamp' => $node->getMTime()]);
-			}
-		} catch (DbalException $ex) {
-			// Ignore UniqueConstraintViolationException, as we are probably in the middle of a rollback
-			// Where the previous node would temporary have the mtime of the old version, so the rollback touches it to fix it.
-			if (!($ex->getPrevious() instanceof UniqueConstraintViolationException)) {
-				throw $ex;
-			}
-		} catch (DoesNotExistException $ex) {
-			// Ignore DoesNotExistException, as we are probably in the middle of a rollback
-			// Where the previous node would temporary have a wrong mtime, so the rollback touches it to fix it.
-		}
-	}
-
-	public function created(Node $node): void {
-		// Do not handle folders.
-		if ($node instanceof File && $this->versionManager instanceof INeedSyncVersionBackend) {
-			$this->versionManager->createVersionEntity($node);
-		}
-	}
-
-	/**
-	 * listen to write event.
-	 */
-	public function write_hook(Node $node): void {
-		// Do not handle folders.
-		if ($node instanceof Folder) {
-			return;
-		}
-
-		// $node is a non-existing on file creation.
-		if ($node instanceof NonExistingFile) {
-			return;
-		}
-
-		$path = $this->getPathForNode($node);
-		$result = Storage::store($path);
-
-		// Store the result of the version creation so it can be used in post_write_hook.
-		$this->writeHookInfo[$node->getId()] = [
-			'previousNode' => $node,
-			'versionCreated' => $result !== false
-		];
-	}
-
-	/**
-	 * listen to post_write event.
-	 */
-	public function post_write_hook(Node $node): void {
-		// Do not handle folders.
-		if ($node instanceof Folder) {
-			return;
-		}
-
-		$writeHookInfo = $this->writeHookInfo[$node->getId()] ?? null;
-
-		if ($writeHookInfo === null) {
-			return;
-		}
-
-		if (
-			$writeHookInfo['versionCreated']
-			&& $node->getMTime() !== $writeHookInfo['previousNode']->getMTime()
-		) {
-			// If a new version was created, insert a version in the DB for the current content.
-			// If both versions have the same mtime, it means the latest version file simply got overrode,
-			// so no need to create a new version.
-			$this->created($node);
-		} else {
-			try {
-				// If no new version was stored in the FS, no new version should be added in the DB.
-				// So we simply update the associated version.
-				if ($node instanceof File && $this->versionManager instanceof INeedSyncVersionBackend) {
-					$this->versionManager->updateVersionEntity(
-						$node,
-						$writeHookInfo['previousNode']->getMtime(),
-						[
-							'timestamp' => $node->getMTime(),
-							'size' => $node->getSize(),
-							'mimetype' => $this->mimeTypeLoader->getId($node->getMimetype()),
-						],
-					);
-				}
-			} catch (DoesNotExistException $e) {
-				// This happens if the versions app was not enabled while the file was created or updated the last time.
-				// meaning there is no such revision and we need to create this file.
-				if ($writeHookInfo['versionCreated']) {
-					$this->created($node);
-				} else {
-					// Normally this should not happen so we re-throw the exception to not hide any potential issues.
-					throw $e;
-				}
-			} catch (Exception $e) {
-				$this->logger->error('Failed to update existing version for ' . $node->getPath(), [
-					'exception' => $e,
-					'versionCreated' => $writeHookInfo['versionCreated'],
-					'previousNode' => [
-						'size' => $writeHookInfo['previousNode']->getSize(),
-						'mtime' => $writeHookInfo['previousNode']->getMTime(),
-					],
-					'node' => [
-						'size' => $node->getSize(),
-						'mtime' => $node->getMTime(),
-					]
-				]);
-				throw $e;
-			}
-		}
-
-		unset($this->writeHookInfo[$node->getId()]);
-	}
-
-	/**
-	 * Erase versions of deleted file
-	 *
-	 * This function is connected to the NodeDeletedEvent event
-	 * cleanup the versions directory if the actual file gets deleted
-	 */
-	public function remove_hook(Node $node): void {
-		// Need to normalize the path as there is an issue with path concatenation in View.php::getAbsolutePath.
-		$path = Filesystem::normalizePath($node->getPath());
-		if (!array_key_exists($path, $this->versionsDeleted)) {
-			return;
-		}
-		$node = $this->versionsDeleted[$path];
-		$relativePath = $this->getPathForNode($node);
-		unset($this->versionsDeleted[$path]);
-		Storage::delete($relativePath);
-		// If no new version was stored in the FS, no new version should be added in the DB.
-		// So we simply update the associated version.
-		if ($node instanceof File && $this->versionManager instanceof INeedSyncVersionBackend) {
-			$this->versionManager->deleteVersionsEntity($node);
-		}
-	}
-
-	/**
-	 * mark file as "deleted" so that we can clean up the versions if the file is gone
-	 */
-	public function pre_remove_hook(Node $node): void {
-		$path = $this->getPathForNode($node);
-		Storage::markDeletedFile($path);
-		$this->versionsDeleted[$node->getPath()] = $node;
-	}
-
-	/**
-	 * rename/move versions of renamed/moved files
-	 *
-	 * This function is connected to the NodeRenamedEvent event and adjust the name and location
-	 * of the stored versions along the actual file
-	 */
-	public function rename_hook(Node $source, Node $target): void {
-		$sourceBackend = $this->versionManager->getBackendForStorage($source->getParent()->getStorage());
-		$targetBackend = $this->versionManager->getBackendForStorage($target->getStorage());
-		// If different backends, do nothing.
-		if ($sourceBackend !== $targetBackend) {
-			return;
-		}
-
-		$oldPath = $this->getPathForNode($source);
-		$newPath = $this->getPathForNode($target);
-		Storage::renameOrCopy($oldPath, $newPath, 'rename');
-	}
-
-	/**
-	 * copy versions of copied files
-	 *
-	 * This function is connected to the NodeCopiedEvent event and copies the
-	 * the stored versions to the new location
-	 */
-	public function copy_hook(Node $source, Node $target): void {
-		$sourceBackend = $this->versionManager->getBackendForStorage($source->getParent()->getStorage());
-		$targetBackend = $this->versionManager->getBackendForStorage($target->getStorage());
-		// If different backends, do nothing.
-		if ($sourceBackend !== $targetBackend) {
-			return;
-		}
-
-		$oldPath = $this->getPathForNode($source);
-		$newPath = $this->getPathForNode($target);
-		Storage::renameOrCopy($oldPath, $newPath, 'copy');
-	}
-
-	/**
-	 * Remember owner and the owner path of the source file.
-	 * If the file already exists, then it was a upload of a existing file
-	 * over the web interface and we call Storage::store() directly
-	 *
-	 *
-	 */
-	public function pre_renameOrCopy_hook(Node $source, Node $target): void {
-		$sourceBackend = $this->versionManager->getBackendForStorage($source->getStorage());
-		$targetBackend = $this->versionManager->getBackendForStorage($target->getParent()->getStorage());
-		// If different backends, do nothing.
-		if ($sourceBackend !== $targetBackend) {
-			return;
-		}
-
-		// if we rename a movable mount point, then the versions don't have to be renamed
-		$oldPath = $this->getPathForNode($source);
-		$newPath = $this->getPathForNode($target);
-		if ($oldPath === null || $newPath === null) {
-			return;
-		}
-
-		$user = $this->userSession->getUser()?->getUID();
-		if ($user === null) {
-			return;
-		}
-
-		$absOldPath = Filesystem::normalizePath('/' . $user . '/files' . $oldPath);
-		$manager = Filesystem::getMountManager();
-		$mount = $manager->find($absOldPath);
-		$internalPath = $mount->getInternalPath($absOldPath);
-		if ($internalPath === '' and $mount instanceof MoveableMount) {
-			return;
-		}
-
-		$view = new View($user . '/files');
-		if ($view->file_exists($newPath)) {
-			Storage::store($newPath);
-		} else {
-			Storage::setSourcePathAndUser($oldPath);
-		}
-	}
-
-	/**
-	 * Retrieve the path relative to the current user root folder.
-	 * If no user is connected, try to use the node's owner.
-	 */
-	private function getPathForNode(Node $node): ?string {
-		$user = $this->userSession->getUser()?->getUID();
-		if ($user) {
-			$path = $this->rootFolder
-				->getUserFolder($user)
-				->getRelativePath($node->getPath());
-
-			if ($path !== null) {
-				return $path;
-			}
-		}
-
-		try {
-			$owner = $node->getOwner()?->getUid();
-		} catch (NotFoundException) {
-			$owner = null;
-		}
-
-		// If no owner, extract it from the path.
-		// e.g. /user/files/foobar.txt
-		if (!$owner) {
-			$parts = explode('/', $node->getPath(), 4);
-			if (count($parts) === 4) {
-				$owner = $parts[1];
-			}
-		}
-
-		if ($owner) {
-			$path = $this->rootFolder
-				->getUserFolder($owner)
-				->getRelativePath($node->getPath());
-
-			if ($path !== null) {
-				return $path;
-			}
-		}
-
-		return null;
-	}
+    /**
+     * @var array<int, array>
+     */
+    private array $writeHookInfo = [];
+    /**
+     * @var array<int, Node>
+     */
+    private array $nodesTouched = [];
+    /**
+     * @var array<string, Node>
+     */
+    private array $versionsDeleted = [];
+
+    public function __construct(
+        private IRootFolder $rootFolder,
+        private IVersionManager $versionManager,
+        private IMimeTypeLoader $mimeTypeLoader,
+        private IUserSession $userSession,
+        private LoggerInterface $logger,
+    ) {
+    }
+
+    public function handle(Event $event): void {
+        if ($event instanceof NodeCreatedEvent) {
+            $this->created($event->getNode());
+        }
+
+        if ($event instanceof BeforeNodeTouchedEvent) {
+            $this->pre_touch_hook($event->getNode());
+        }
+
+        if ($event instanceof NodeTouchedEvent) {
+            $this->touch_hook($event->getNode());
+        }
+
+        if ($event instanceof BeforeNodeWrittenEvent) {
+            $this->write_hook($event->getNode());
+        }
+
+        if ($event instanceof NodeWrittenEvent) {
+            $this->post_write_hook($event->getNode());
+        }
+
+        if ($event instanceof BeforeNodeDeletedEvent) {
+            $this->pre_remove_hook($event->getNode());
+        }
+
+        if ($event instanceof NodeDeletedEvent) {
+            $this->remove_hook($event->getNode());
+        }
+
+        if ($event instanceof NodeRenamedEvent) {
+            $this->rename_hook($event->getSource(), $event->getTarget());
+        }
+
+        if ($event instanceof NodeCopiedEvent) {
+            $this->copy_hook($event->getSource(), $event->getTarget());
+        }
+
+        if ($event instanceof BeforeNodeRenamedEvent) {
+            $this->pre_renameOrCopy_hook($event->getSource(), $event->getTarget());
+        }
+
+        if ($event instanceof BeforeNodeCopiedEvent) {
+            $this->pre_renameOrCopy_hook($event->getSource(), $event->getTarget());
+        }
+    }
+
+    public function pre_touch_hook(Node $node): void {
+        // Do not handle folders.
+        if ($node instanceof Folder) {
+            return;
+        }
+
+        // $node is a non-existing on file creation.
+        if ($node instanceof NonExistingFile) {
+            return;
+        }
+
+        $this->nodesTouched[$node->getId()] = $node;
+    }
+
+    public function touch_hook(Node $node): void {
+        $previousNode = $this->nodesTouched[$node->getId()] ?? null;
+
+        if ($previousNode === null) {
+            return;
+        }
+
+        unset($this->nodesTouched[$node->getId()]);
+
+        try {
+            if ($node instanceof File && $this->versionManager instanceof INeedSyncVersionBackend) {
+                // We update the timestamp of the version entity associated with the previousNode.
+                $this->versionManager->updateVersionEntity($node, $previousNode->getMTime(), ['timestamp' => $node->getMTime()]);
+            }
+        } catch (DbalException $ex) {
+            // Ignore UniqueConstraintViolationException, as we are probably in the middle of a rollback
+            // Where the previous node would temporary have the mtime of the old version, so the rollback touches it to fix it.
+            if (!($ex->getPrevious() instanceof UniqueConstraintViolationException)) {
+                throw $ex;
+            }
+        } catch (DoesNotExistException $ex) {
+            // Ignore DoesNotExistException, as we are probably in the middle of a rollback
+            // Where the previous node would temporary have a wrong mtime, so the rollback touches it to fix it.
+        }
+    }
+
+    public function created(Node $node): void {
+        // Do not handle folders.
+        if ($node instanceof File && $this->versionManager instanceof INeedSyncVersionBackend) {
+            $this->versionManager->createVersionEntity($node);
+        }
+    }
+
+    /**
+     * listen to write event.
+     */
+    public function write_hook(Node $node): void {
+        // Do not handle folders.
+        if ($node instanceof Folder) {
+            return;
+        }
+
+        // $node is a non-existing on file creation.
+        if ($node instanceof NonExistingFile) {
+            return;
+        }
+
+        $path = $this->getPathForNode($node);
+        $result = Storage::store($path);
+
+        // Store the result of the version creation so it can be used in post_write_hook.
+        $this->writeHookInfo[$node->getId()] = [
+            'previousNode' => $node,
+            'versionCreated' => $result !== false
+        ];
+    }
+
+    /**
+     * listen to post_write event.
+     */
+    public function post_write_hook(Node $node): void {
+        // Do not handle folders.
+        if ($node instanceof Folder) {
+            return;
+        }
+
+        $writeHookInfo = $this->writeHookInfo[$node->getId()] ?? null;
+
+        if ($writeHookInfo === null) {
+            return;
+        }
+
+        if (
+            $writeHookInfo['versionCreated']
+            && $node->getMTime() !== $writeHookInfo['previousNode']->getMTime()
+        ) {
+            // If a new version was created, insert a version in the DB for the current content.
+            // If both versions have the same mtime, it means the latest version file simply got overrode,
+            // so no need to create a new version.
+            $this->created($node);
+        } else {
+            try {
+                // If no new version was stored in the FS, no new version should be added in the DB.
+                // So we simply update the associated version.
+                if ($node instanceof File && $this->versionManager instanceof INeedSyncVersionBackend) {
+                    $this->versionManager->updateVersionEntity(
+                        $node,
+                        $writeHookInfo['previousNode']->getMtime(),
+                        [
+                            'timestamp' => $node->getMTime(),
+                            'size' => $node->getSize(),
+                            'mimetype' => $this->mimeTypeLoader->getId($node->getMimetype()),
+                        ],
+                    );
+                }
+            } catch (DoesNotExistException $e) {
+                // This happens if the versions app was not enabled while the file was created or updated the last time.
+                // meaning there is no such revision and we need to create this file.
+                if ($writeHookInfo['versionCreated']) {
+                    $this->created($node);
+                } else {
+                    // Normally this should not happen so we re-throw the exception to not hide any potential issues.
+                    throw $e;
+                }
+            } catch (Exception $e) {
+                $this->logger->error('Failed to update existing version for ' . $node->getPath(), [
+                    'exception' => $e,
+                    'versionCreated' => $writeHookInfo['versionCreated'],
+                    'previousNode' => [
+                        'size' => $writeHookInfo['previousNode']->getSize(),
+                        'mtime' => $writeHookInfo['previousNode']->getMTime(),
+                    ],
+                    'node' => [
+                        'size' => $node->getSize(),
+                        'mtime' => $node->getMTime(),
+                    ]
+                ]);
+                throw $e;
+            }
+        }
+
+        unset($this->writeHookInfo[$node->getId()]);
+    }
+
+    /**
+     * Erase versions of deleted file
+     *
+     * This function is connected to the NodeDeletedEvent event
+     * cleanup the versions directory if the actual file gets deleted
+     */
+    public function remove_hook(Node $node): void {
+        // Need to normalize the path as there is an issue with path concatenation in View.php::getAbsolutePath.
+        $path = Filesystem::normalizePath($node->getPath());
+        if (!array_key_exists($path, $this->versionsDeleted)) {
+            return;
+        }
+        $node = $this->versionsDeleted[$path];
+        $relativePath = $this->getPathForNode($node);
+        unset($this->versionsDeleted[$path]);
+        Storage::delete($relativePath);
+        // If no new version was stored in the FS, no new version should be added in the DB.
+        // So we simply update the associated version.
+        if ($node instanceof File && $this->versionManager instanceof INeedSyncVersionBackend) {
+            $this->versionManager->deleteVersionsEntity($node);
+        }
+    }
+
+    /**
+     * mark file as "deleted" so that we can clean up the versions if the file is gone
+     */
+    public function pre_remove_hook(Node $node): void {
+        $path = $this->getPathForNode($node);
+        Storage::markDeletedFile($path);
+        $this->versionsDeleted[$node->getPath()] = $node;
+    }
+
+    /**
+     * rename/move versions of renamed/moved files
+     *
+     * This function is connected to the NodeRenamedEvent event and adjust the name and location
+     * of the stored versions along the actual file
+     */
+    public function rename_hook(Node $source, Node $target): void {
+        $sourceBackend = $this->versionManager->getBackendForStorage($source->getParent()->getStorage());
+        $targetBackend = $this->versionManager->getBackendForStorage($target->getStorage());
+        // If different backends, do nothing.
+        if ($sourceBackend !== $targetBackend) {
+            return;
+        }
+
+        $oldPath = $this->getPathForNode($source);
+        $newPath = $this->getPathForNode($target);
+        Storage::renameOrCopy($oldPath, $newPath, 'rename');
+    }
+
+    /**
+     * copy versions of copied files
+     *
+     * This function is connected to the NodeCopiedEvent event and copies the
+     * the stored versions to the new location
+     */
+    public function copy_hook(Node $source, Node $target): void {
+        $sourceBackend = $this->versionManager->getBackendForStorage($source->getParent()->getStorage());
+        $targetBackend = $this->versionManager->getBackendForStorage($target->getStorage());
+        // If different backends, do nothing.
+        if ($sourceBackend !== $targetBackend) {
+            return;
+        }
+
+        $oldPath = $this->getPathForNode($source);
+        $newPath = $this->getPathForNode($target);
+        Storage::renameOrCopy($oldPath, $newPath, 'copy');
+    }
+
+    /**
+     * Remember owner and the owner path of the source file.
+     * If the file already exists, then it was a upload of a existing file
+     * over the web interface and we call Storage::store() directly
+     *
+     *
+     */
+    public function pre_renameOrCopy_hook(Node $source, Node $target): void {
+        $sourceBackend = $this->versionManager->getBackendForStorage($source->getStorage());
+        $targetBackend = $this->versionManager->getBackendForStorage($target->getParent()->getStorage());
+        // If different backends, do nothing.
+        if ($sourceBackend !== $targetBackend) {
+            return;
+        }
+
+        // if we rename a movable mount point, then the versions don't have to be renamed
+        $oldPath = $this->getPathForNode($source);
+        $newPath = $this->getPathForNode($target);
+        if ($oldPath === null || $newPath === null) {
+            return;
+        }
+
+        $user = $this->userSession->getUser()?->getUID();
+        if ($user === null) {
+            return;
+        }
+
+        $absOldPath = Filesystem::normalizePath('/' . $user . '/files' . $oldPath);
+        $manager = Filesystem::getMountManager();
+        $mount = $manager->find($absOldPath);
+        $internalPath = $mount->getInternalPath($absOldPath);
+        if ($internalPath === '' and $mount instanceof MoveableMount) {
+            return;
+        }
+
+        $view = new View($user . '/files');
+        if ($view->file_exists($newPath)) {
+            Storage::store($newPath);
+        } else {
+            Storage::setSourcePathAndUser($oldPath);
+        }
+    }
+
+    /**
+     * Retrieve the path relative to the current user root folder.
+     * If no user is connected, try to use the node's owner.
+     */
+    private function getPathForNode(Node $node): ?string {
+        $user = $this->userSession->getUser()?->getUID();
+        if ($user) {
+            $path = $this->rootFolder
+                ->getUserFolder($user)
+                ->getRelativePath($node->getPath());
+
+            if ($path !== null) {
+                return $path;
+            }
+        }
+
+        try {
+            $owner = $node->getOwner()?->getUid();
+        } catch (NotFoundException) {
+            $owner = null;
+        }
+
+        // If no owner, extract it from the path.
+        // e.g. /user/files/foobar.txt
+        if (!$owner) {
+            $parts = explode('/', $node->getPath(), 4);
+            if (count($parts) === 4) {
+                $owner = $parts[1];
+            }
+        }
+
+        if ($owner) {
+            $path = $this->rootFolder
+                ->getUserFolder($owner)
+                ->getRelativePath($node->getPath());
+
+            if ($path !== null) {
+                return $path;
+            }
+        }
+
+        return null;
+    }
 }

apps/files_sharing/tests/TestCase.php

Indentation +210 added lines, -210 removed lines

@@ -33,214 +33,214 @@
  * Base class for sharing tests.
  */
 abstract class TestCase extends \Test\TestCase {
-	use MountProviderTrait;
-
-	public const TEST_FILES_SHARING_API_USER1 = 'test-share-user1';
-	public const TEST_FILES_SHARING_API_USER2 = 'test-share-user2';
-	public const TEST_FILES_SHARING_API_USER3 = 'test-share-user3';
-	public const TEST_FILES_SHARING_API_USER4 = 'test-share-user4';
-
-	public const TEST_FILES_SHARING_API_GROUP1 = 'test-share-group1';
-
-	public $filename;
-	public $data;
-	/**
-	 * @var View
-	 */
-	public $view;
-	/**
-	 * @var View
-	 */
-	public $view2;
-	public $folder;
-	public $subfolder;
-
-	/** @var \OCP\Share\IManager */
-	protected $shareManager;
-	/** @var IRootFolder */
-	protected $rootFolder;
-
-	public static function setUpBeforeClass(): void {
-		parent::setUpBeforeClass();
-
-		$app = new Application();
-		$app->registerMountProviders(
-			Server::get(IMountProviderCollection::class),
-			Server::get(MountProvider::class),
-			Server::get(ExternalMountProvider::class),
-		);
-
-		// reset backend
-		Server::get(IUserManager::class)->clearBackends();
-		Server::get(IGroupManager::class)->clearBackends();
-
-		// clear share hooks
-		\OC_Hook::clear('OCP\\Share');
-		\OC::registerShareHooks(Server::get(SystemConfig::class));
-
-		// create users
-		$backend = new \Test\Util\User\Dummy();
-		Server::get(IUserManager::class)->registerBackend($backend);
-		$backend->createUser(self::TEST_FILES_SHARING_API_USER1, self::TEST_FILES_SHARING_API_USER1);
-		$backend->createUser(self::TEST_FILES_SHARING_API_USER2, self::TEST_FILES_SHARING_API_USER2);
-		$backend->createUser(self::TEST_FILES_SHARING_API_USER3, self::TEST_FILES_SHARING_API_USER3);
-		$backend->createUser(self::TEST_FILES_SHARING_API_USER4, self::TEST_FILES_SHARING_API_USER4);
-
-		// create group
-		$groupBackend = new \Test\Util\Group\Dummy();
-		$groupBackend->createGroup(self::TEST_FILES_SHARING_API_GROUP1);
-		$groupBackend->createGroup('group');
-		$groupBackend->createGroup('group1');
-		$groupBackend->createGroup('group2');
-		$groupBackend->createGroup('group3');
-		$groupBackend->addToGroup(self::TEST_FILES_SHARING_API_USER1, 'group');
-		$groupBackend->addToGroup(self::TEST_FILES_SHARING_API_USER2, 'group');
-		$groupBackend->addToGroup(self::TEST_FILES_SHARING_API_USER3, 'group');
-		$groupBackend->addToGroup(self::TEST_FILES_SHARING_API_USER2, 'group1');
-		$groupBackend->addToGroup(self::TEST_FILES_SHARING_API_USER3, 'group2');
-		$groupBackend->addToGroup(self::TEST_FILES_SHARING_API_USER4, 'group3');
-		$groupBackend->addToGroup(self::TEST_FILES_SHARING_API_USER2, self::TEST_FILES_SHARING_API_GROUP1);
-		Server::get(IGroupManager::class)->addBackend($groupBackend);
-	}
-
-	protected function setUp(): void {
-		parent::setUp();
-		Server::get(DisplayNameCache::class)->clear();
-
-		//login as user1
-		$this->loginHelper(self::TEST_FILES_SHARING_API_USER1);
-
-		$this->data = 'foobar';
-		$this->view = new View('/' . self::TEST_FILES_SHARING_API_USER1 . '/files');
-		$this->view2 = new View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
-
-		$this->shareManager = Server::get(\OCP\Share\IManager::class);
-		$this->rootFolder = Server::get(IRootFolder::class);
-	}
-
-	protected function tearDown(): void {
-		$qb = Server::get(IDBConnection::class)->getQueryBuilder();
-		$qb->delete('share');
-		$qb->execute();
-
-		$qb = Server::get(IDBConnection::class)->getQueryBuilder();
-		$qb->delete('mounts');
-		$qb->execute();
-
-		$qb = Server::get(IDBConnection::class)->getQueryBuilder();
-		$qb->delete('filecache')->runAcrossAllShards();
-		$qb->execute();
-
-		parent::tearDown();
-	}
-
-	public static function tearDownAfterClass(): void {
-		// cleanup users
-		$user = Server::get(IUserManager::class)->get(self::TEST_FILES_SHARING_API_USER1);
-		if ($user !== null) {
-			$user->delete();
-		}
-		$user = Server::get(IUserManager::class)->get(self::TEST_FILES_SHARING_API_USER2);
-		if ($user !== null) {
-			$user->delete();
-		}
-		$user = Server::get(IUserManager::class)->get(self::TEST_FILES_SHARING_API_USER3);
-		if ($user !== null) {
-			$user->delete();
-		}
-
-		// delete group
-		$group = Server::get(IGroupManager::class)->get(self::TEST_FILES_SHARING_API_GROUP1);
-		if ($group) {
-			$group->delete();
-		}
-
-		\OC_Util::tearDownFS();
-		\OC_User::setUserId('');
-		Filesystem::tearDown();
-
-		// reset backend
-		Server::get(IUserManager::class)->clearBackends();
-		Server::get(IUserManager::class)->registerBackend(new \OC\User\Database());
-		Server::get(IGroupManager::class)->clearBackends();
-		Server::get(IGroupManager::class)->addBackend(new Database());
-
-		parent::tearDownAfterClass();
-	}
-
-	/**
-	 * @param string $user
-	 * @param bool $create
-	 * @param bool $password
-	 */
-	protected function loginHelper($user, $create = false, $password = false) {
-		if ($password === false) {
-			$password = $user;
-		}
-
-		if ($create) {
-			$userManager = Server::get(IUserManager::class);
-			$groupManager = Server::get(IGroupManager::class);
-
-			$userObject = $userManager->createUser($user, $password);
-			$group = $groupManager->createGroup('group');
-
-			if ($group && $userObject) {
-				$group->addUser($userObject);
-			}
-		}
-
-		\OC_Util::tearDownFS();
-		Storage::getGlobalCache()->clearCache();
-		Server::get(IUserSession::class)->setUser(null);
-		Filesystem::tearDown();
-		Server::get(IUserSession::class)->login($user, $password);
-		\OC::$server->getUserFolder($user);
-
-		\OC_Util::setupFS($user);
-	}
-
-	/**
-	 * get some information from a given share
-	 * @param int $shareID
-	 * @return array with: item_source, share_type, share_with, item_type, permissions
-	 */
-	protected function getShareFromId($shareID) {
-		$qb = Server::get(IDBConnection::class)->getQueryBuilder();
-		$qb->select('item_source', '`share_type', 'share_with', 'item_type', 'permissions')
-			->from('share')
-			->where(
-				$qb->expr()->eq('id', $qb->createNamedParameter($shareID))
-			);
-		$result = $qb->execute();
-		$share = $result->fetch();
-		$result->closeCursor();
-
-		return $share;
-	}
-
-	/**
-	 * @param int $type The share type
-	 * @param string $path The path to share relative to $initiators root
-	 * @param string $initiator
-	 * @param string $recipient
-	 * @param int $permissions
-	 * @return IShare
-	 */
-	protected function share($type, $path, $initiator, $recipient, $permissions) {
-		$userFolder = $this->rootFolder->getUserFolder($initiator);
-		$node = $userFolder->get($path);
-
-		$share = $this->shareManager->newShare();
-		$share->setShareType($type)
-			->setSharedWith($recipient)
-			->setSharedBy($initiator)
-			->setNode($node)
-			->setPermissions($permissions);
-		$share = $this->shareManager->createShare($share);
-		$share->setStatus(IShare::STATUS_ACCEPTED);
-		$share = $this->shareManager->updateShare($share);
-
-		return $share;
-	}
+    use MountProviderTrait;
+
+    public const TEST_FILES_SHARING_API_USER1 = 'test-share-user1';
+    public const TEST_FILES_SHARING_API_USER2 = 'test-share-user2';
+    public const TEST_FILES_SHARING_API_USER3 = 'test-share-user3';
+    public const TEST_FILES_SHARING_API_USER4 = 'test-share-user4';
+
+    public const TEST_FILES_SHARING_API_GROUP1 = 'test-share-group1';
+
+    public $filename;
+    public $data;
+    /**
+     * @var View
+     */
+    public $view;
+    /**
+     * @var View
+     */
+    public $view2;
+    public $folder;
+    public $subfolder;
+
+    /** @var \OCP\Share\IManager */
+    protected $shareManager;
+    /** @var IRootFolder */
+    protected $rootFolder;
+
+    public static function setUpBeforeClass(): void {
+        parent::setUpBeforeClass();
+
+        $app = new Application();
+        $app->registerMountProviders(
+            Server::get(IMountProviderCollection::class),
+            Server::get(MountProvider::class),
+            Server::get(ExternalMountProvider::class),
+        );
+
+        // reset backend
+        Server::get(IUserManager::class)->clearBackends();
+        Server::get(IGroupManager::class)->clearBackends();
+
+        // clear share hooks
+        \OC_Hook::clear('OCP\\Share');
+        \OC::registerShareHooks(Server::get(SystemConfig::class));
+
+        // create users
+        $backend = new \Test\Util\User\Dummy();
+        Server::get(IUserManager::class)->registerBackend($backend);
+        $backend->createUser(self::TEST_FILES_SHARING_API_USER1, self::TEST_FILES_SHARING_API_USER1);
+        $backend->createUser(self::TEST_FILES_SHARING_API_USER2, self::TEST_FILES_SHARING_API_USER2);
+        $backend->createUser(self::TEST_FILES_SHARING_API_USER3, self::TEST_FILES_SHARING_API_USER3);
+        $backend->createUser(self::TEST_FILES_SHARING_API_USER4, self::TEST_FILES_SHARING_API_USER4);
+
+        // create group
+        $groupBackend = new \Test\Util\Group\Dummy();
+        $groupBackend->createGroup(self::TEST_FILES_SHARING_API_GROUP1);
+        $groupBackend->createGroup('group');
+        $groupBackend->createGroup('group1');
+        $groupBackend->createGroup('group2');
+        $groupBackend->createGroup('group3');
+        $groupBackend->addToGroup(self::TEST_FILES_SHARING_API_USER1, 'group');
+        $groupBackend->addToGroup(self::TEST_FILES_SHARING_API_USER2, 'group');
+        $groupBackend->addToGroup(self::TEST_FILES_SHARING_API_USER3, 'group');
+        $groupBackend->addToGroup(self::TEST_FILES_SHARING_API_USER2, 'group1');
+        $groupBackend->addToGroup(self::TEST_FILES_SHARING_API_USER3, 'group2');
+        $groupBackend->addToGroup(self::TEST_FILES_SHARING_API_USER4, 'group3');
+        $groupBackend->addToGroup(self::TEST_FILES_SHARING_API_USER2, self::TEST_FILES_SHARING_API_GROUP1);
+        Server::get(IGroupManager::class)->addBackend($groupBackend);
+    }
+
+    protected function setUp(): void {
+        parent::setUp();
+        Server::get(DisplayNameCache::class)->clear();
+
+        //login as user1
+        $this->loginHelper(self::TEST_FILES_SHARING_API_USER1);
+
+        $this->data = 'foobar';
+        $this->view = new View('/' . self::TEST_FILES_SHARING_API_USER1 . '/files');
+        $this->view2 = new View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
+
+        $this->shareManager = Server::get(\OCP\Share\IManager::class);
+        $this->rootFolder = Server::get(IRootFolder::class);
+    }
+
+    protected function tearDown(): void {
+        $qb = Server::get(IDBConnection::class)->getQueryBuilder();
+        $qb->delete('share');
+        $qb->execute();
+
+        $qb = Server::get(IDBConnection::class)->getQueryBuilder();
+        $qb->delete('mounts');
+        $qb->execute();
+
+        $qb = Server::get(IDBConnection::class)->getQueryBuilder();
+        $qb->delete('filecache')->runAcrossAllShards();
+        $qb->execute();
+
+        parent::tearDown();
+    }
+
+    public static function tearDownAfterClass(): void {
+        // cleanup users
+        $user = Server::get(IUserManager::class)->get(self::TEST_FILES_SHARING_API_USER1);
+        if ($user !== null) {
+            $user->delete();
+        }
+        $user = Server::get(IUserManager::class)->get(self::TEST_FILES_SHARING_API_USER2);
+        if ($user !== null) {
+            $user->delete();
+        }
+        $user = Server::get(IUserManager::class)->get(self::TEST_FILES_SHARING_API_USER3);
+        if ($user !== null) {
+            $user->delete();
+        }
+
+        // delete group
+        $group = Server::get(IGroupManager::class)->get(self::TEST_FILES_SHARING_API_GROUP1);
+        if ($group) {
+            $group->delete();
+        }
+
+        \OC_Util::tearDownFS();
+        \OC_User::setUserId('');
+        Filesystem::tearDown();
+
+        // reset backend
+        Server::get(IUserManager::class)->clearBackends();
+        Server::get(IUserManager::class)->registerBackend(new \OC\User\Database());
+        Server::get(IGroupManager::class)->clearBackends();
+        Server::get(IGroupManager::class)->addBackend(new Database());
+
+        parent::tearDownAfterClass();
+    }
+
+    /**
+     * @param string $user
+     * @param bool $create
+     * @param bool $password
+     */
+    protected function loginHelper($user, $create = false, $password = false) {
+        if ($password === false) {
+            $password = $user;
+        }
+
+        if ($create) {
+            $userManager = Server::get(IUserManager::class);
+            $groupManager = Server::get(IGroupManager::class);
+
+            $userObject = $userManager->createUser($user, $password);
+            $group = $groupManager->createGroup('group');
+
+            if ($group && $userObject) {
+                $group->addUser($userObject);
+            }
+        }
+
+        \OC_Util::tearDownFS();
+        Storage::getGlobalCache()->clearCache();
+        Server::get(IUserSession::class)->setUser(null);
+        Filesystem::tearDown();
+        Server::get(IUserSession::class)->login($user, $password);
+        \OC::$server->getUserFolder($user);
+
+        \OC_Util::setupFS($user);
+    }
+
+    /**
+     * get some information from a given share
+     * @param int $shareID
+     * @return array with: item_source, share_type, share_with, item_type, permissions
+     */
+    protected function getShareFromId($shareID) {
+        $qb = Server::get(IDBConnection::class)->getQueryBuilder();
+        $qb->select('item_source', '`share_type', 'share_with', 'item_type', 'permissions')
+            ->from('share')
+            ->where(
+                $qb->expr()->eq('id', $qb->createNamedParameter($shareID))
+            );
+        $result = $qb->execute();
+        $share = $result->fetch();
+        $result->closeCursor();
+
+        return $share;
+    }
+
+    /**
+     * @param int $type The share type
+     * @param string $path The path to share relative to $initiators root
+     * @param string $initiator
+     * @param string $recipient
+     * @param int $permissions
+     * @return IShare
+     */
+    protected function share($type, $path, $initiator, $recipient, $permissions) {
+        $userFolder = $this->rootFolder->getUserFolder($initiator);
+        $node = $userFolder->get($path);
+
+        $share = $this->shareManager->newShare();
+        $share->setShareType($type)
+            ->setSharedWith($recipient)
+            ->setSharedBy($initiator)
+            ->setNode($node)
+            ->setPermissions($permissions);
+        $share = $this->shareManager->createShare($share);
+        $share->setStatus(IShare::STATUS_ACCEPTED);
+        $share = $this->shareManager->updateShare($share);
+
+        return $share;
+    }
 }

Spacing +2 added lines, -2 removed lines

@@ -111,8 +111,8 @@
 		$this->loginHelper(self::TEST_FILES_SHARING_API_USER1);
 
 		$this->data = 'foobar';
-		$this->view = new View('/' . self::TEST_FILES_SHARING_API_USER1 . '/files');
-		$this->view2 = new View('/' . self::TEST_FILES_SHARING_API_USER2 . '/files');
+		$this->view = new View('/'.self::TEST_FILES_SHARING_API_USER1.'/files');
+		$this->view2 = new View('/'.self::TEST_FILES_SHARING_API_USER2.'/files');
 
 		$this->shareManager = Server::get(\OCP\Share\IManager::class);
 		$this->rootFolder = Server::get(IRootFolder::class);