nextcloud / server

tests/lib/Files/Cache/Wrapper/CachePermissionsMaskTest.php

Indentation +68 added lines, -68 removed lines

@@ -18,83 +18,83 @@
  * @package Test\Files\Cache\Wrapper
  */
 class CachePermissionsMaskTest extends CacheTest {
-	/**
-	 * @var \OC\Files\Cache\Cache $sourceCache
-	 */
-	protected $sourceCache;
+    /**
+     * @var \OC\Files\Cache\Cache $sourceCache
+     */
+    protected $sourceCache;
 
-	protected function setUp(): void {
-		parent::setUp();
-		$this->storage->mkdir('foo');
-		$this->sourceCache = $this->cache;
-		$this->cache = $this->getMaskedCached(Constants::PERMISSION_ALL);
-	}
+    protected function setUp(): void {
+        parent::setUp();
+        $this->storage->mkdir('foo');
+        $this->sourceCache = $this->cache;
+        $this->cache = $this->getMaskedCached(Constants::PERMISSION_ALL);
+    }
 
-	protected function getMaskedCached($mask) {
-		return new \OC\Files\Cache\Wrapper\CachePermissionsMask($this->sourceCache, $mask);
-	}
+    protected function getMaskedCached($mask) {
+        return new \OC\Files\Cache\Wrapper\CachePermissionsMask($this->sourceCache, $mask);
+    }
 
-	public static function maskProvider(): array {
-		return [
-			[Constants::PERMISSION_ALL],
-			[Constants::PERMISSION_ALL - Constants::PERMISSION_SHARE],
-			[Constants::PERMISSION_ALL - Constants::PERMISSION_UPDATE],
-			[Constants::PERMISSION_READ]
-		];
-	}
+    public static function maskProvider(): array {
+        return [
+            [Constants::PERMISSION_ALL],
+            [Constants::PERMISSION_ALL - Constants::PERMISSION_SHARE],
+            [Constants::PERMISSION_ALL - Constants::PERMISSION_UPDATE],
+            [Constants::PERMISSION_READ]
+        ];
+    }
 
-	/**
-	 * @dataProvider maskProvider
-	 * @param int $mask
-	 */
-	public function testGetMasked($mask): void {
-		$cache = $this->getMaskedCached($mask);
-		$data = ['size' => 100, 'mtime' => 50, 'mimetype' => 'text/plain', 'permissions' => Constants::PERMISSION_ALL];
-		$this->sourceCache->put('foo', $data);
-		$result = $cache->get('foo');
-		$this->assertEquals($mask, $result['permissions']);
+    /**
+     * @dataProvider maskProvider
+     * @param int $mask
+     */
+    public function testGetMasked($mask): void {
+        $cache = $this->getMaskedCached($mask);
+        $data = ['size' => 100, 'mtime' => 50, 'mimetype' => 'text/plain', 'permissions' => Constants::PERMISSION_ALL];
+        $this->sourceCache->put('foo', $data);
+        $result = $cache->get('foo');
+        $this->assertEquals($mask, $result['permissions']);
 
-		$data = ['size' => 100, 'mtime' => 50, 'mimetype' => 'text/plain', 'permissions' => Constants::PERMISSION_ALL - Constants::PERMISSION_DELETE];
-		$this->sourceCache->put('bar', $data);
-		$result = $cache->get('bar');
-		$this->assertEquals($mask & ~Constants::PERMISSION_DELETE, $result['permissions']);
-	}
+        $data = ['size' => 100, 'mtime' => 50, 'mimetype' => 'text/plain', 'permissions' => Constants::PERMISSION_ALL - Constants::PERMISSION_DELETE];
+        $this->sourceCache->put('bar', $data);
+        $result = $cache->get('bar');
+        $this->assertEquals($mask & ~Constants::PERMISSION_DELETE, $result['permissions']);
+    }
 
-	/**
-	 * @dataProvider maskProvider
-	 * @param int $mask
-	 */
-	public function testGetFolderContentMasked($mask): void {
-		$this->storage->mkdir('foo');
-		$this->storage->file_put_contents('foo/bar', 'asd');
-		$this->storage->file_put_contents('foo/asd', 'bar');
-		$this->storage->getScanner()->scan('');
+    /**
+     * @dataProvider maskProvider
+     * @param int $mask
+     */
+    public function testGetFolderContentMasked($mask): void {
+        $this->storage->mkdir('foo');
+        $this->storage->file_put_contents('foo/bar', 'asd');
+        $this->storage->file_put_contents('foo/asd', 'bar');
+        $this->storage->getScanner()->scan('');
 
-		$cache = $this->getMaskedCached($mask);
-		$files = $cache->getFolderContents('foo');
-		$this->assertCount(2, $files);
+        $cache = $this->getMaskedCached($mask);
+        $files = $cache->getFolderContents('foo');
+        $this->assertCount(2, $files);
 
-		foreach ($files as $file) {
-			$this->assertEquals($mask & ~Constants::PERMISSION_CREATE, $file['permissions']);
-		}
-	}
+        foreach ($files as $file) {
+            $this->assertEquals($mask & ~Constants::PERMISSION_CREATE, $file['permissions']);
+        }
+    }
 
-	/**
-	 * @dataProvider maskProvider
-	 * @param int $mask
-	 */
-	public function testSearchMasked($mask): void {
-		$this->storage->mkdir('foo');
-		$this->storage->file_put_contents('foo/bar', 'asd');
-		$this->storage->file_put_contents('foo/foobar', 'bar');
-		$this->storage->getScanner()->scan('');
+    /**
+     * @dataProvider maskProvider
+     * @param int $mask
+     */
+    public function testSearchMasked($mask): void {
+        $this->storage->mkdir('foo');
+        $this->storage->file_put_contents('foo/bar', 'asd');
+        $this->storage->file_put_contents('foo/foobar', 'bar');
+        $this->storage->getScanner()->scan('');
 
-		$cache = $this->getMaskedCached($mask);
-		$files = $cache->search('%bar');
-		$this->assertCount(2, $files);
+        $cache = $this->getMaskedCached($mask);
+        $files = $cache->search('%bar');
+        $this->assertCount(2, $files);
 
-		foreach ($files as $file) {
-			$this->assertEquals($mask & ~Constants::PERMISSION_CREATE, $file['permissions']);
-		}
-	}
+        foreach ($files as $file) {
+            $this->assertEquals($mask & ~Constants::PERMISSION_CREATE, $file['permissions']);
+        }
+    }
 }

tests/lib/Files/Cache/UpdaterTest.php

Indentation +259 added lines, -259 removed lines

@@ -21,319 +21,319 @@
  * @package Test\Files\Cache
  */
 class UpdaterTest extends \Test\TestCase {
-	/**
-	 * @var \OC\Files\Storage\Storage
-	 */
-	protected $storage;
+    /**
+     * @var \OC\Files\Storage\Storage
+     */
+    protected $storage;
 
-	/**
-	 * @var \OC\Files\Cache\Cache
-	 */
-	protected $cache;
+    /**
+     * @var \OC\Files\Cache\Cache
+     */
+    protected $cache;
 
-	/**
-	 * @var \OC\Files\View
-	 */
-	protected $view;
+    /**
+     * @var \OC\Files\View
+     */
+    protected $view;
 
-	/**
-	 * @var \OC\Files\Cache\Updater
-	 */
-	protected $updater;
+    /**
+     * @var \OC\Files\Cache\Updater
+     */
+    protected $updater;
 
-	protected function setUp(): void {
-		parent::setUp();
+    protected function setUp(): void {
+        parent::setUp();
 
-		$this->loginAsUser();
+        $this->loginAsUser();
 
-		$this->storage = new Temporary([]);
-		$this->updater = $this->storage->getUpdater();
-		$this->cache = $this->storage->getCache();
-	}
+        $this->storage = new Temporary([]);
+        $this->updater = $this->storage->getUpdater();
+        $this->cache = $this->storage->getCache();
+    }
 
-	protected function tearDown(): void {
-		$this->logout();
-		parent::tearDown();
-	}
+    protected function tearDown(): void {
+        $this->logout();
+        parent::tearDown();
+    }
 
-	public function testNewFile(): void {
-		$this->storage->file_put_contents('foo.txt', 'bar');
-		$this->assertFalse($this->cache->inCache('foo.txt'));
+    public function testNewFile(): void {
+        $this->storage->file_put_contents('foo.txt', 'bar');
+        $this->assertFalse($this->cache->inCache('foo.txt'));
 
-		$this->updater->update('foo.txt');
+        $this->updater->update('foo.txt');
 
-		$this->assertTrue($this->cache->inCache('foo.txt'));
-		$cached = $this->cache->get('foo.txt');
-		$this->assertEquals(3, $cached['size']);
-		$this->assertEquals('text/plain', $cached['mimetype']);
-	}
+        $this->assertTrue($this->cache->inCache('foo.txt'));
+        $cached = $this->cache->get('foo.txt');
+        $this->assertEquals(3, $cached['size']);
+        $this->assertEquals('text/plain', $cached['mimetype']);
+    }
 
-	public function testUpdatedFile(): void {
-		$this->storage->file_put_contents('foo.txt', 'bar');
-		$this->updater->update('foo.txt');
+    public function testUpdatedFile(): void {
+        $this->storage->file_put_contents('foo.txt', 'bar');
+        $this->updater->update('foo.txt');
 
-		$cached = $this->cache->get('foo.txt');
-		$this->assertEquals(3, $cached['size']);
-		$this->assertEquals('text/plain', $cached['mimetype']);
+        $cached = $this->cache->get('foo.txt');
+        $this->assertEquals(3, $cached['size']);
+        $this->assertEquals('text/plain', $cached['mimetype']);
 
-		$this->storage->file_put_contents('foo.txt', 'qwerty');
+        $this->storage->file_put_contents('foo.txt', 'qwerty');
 
-		$cached = $this->cache->get('foo.txt');
-		$this->assertEquals(3, $cached['size']);
+        $cached = $this->cache->get('foo.txt');
+        $this->assertEquals(3, $cached['size']);
 
-		$this->updater->update('/foo.txt');
+        $this->updater->update('/foo.txt');
 
-		$cached = $this->cache->get('foo.txt');
-		$this->assertEquals(6, $cached['size']);
-	}
+        $cached = $this->cache->get('foo.txt');
+        $this->assertEquals(6, $cached['size']);
+    }
 
-	public function testParentSize(): void {
-		$this->storage->getScanner()->scan('');
+    public function testParentSize(): void {
+        $this->storage->getScanner()->scan('');
 
-		$parentCached = $this->cache->get('');
-		$this->assertEquals(0, $parentCached['size']);
+        $parentCached = $this->cache->get('');
+        $this->assertEquals(0, $parentCached['size']);
 
-		$this->storage->file_put_contents('foo.txt', 'bar');
+        $this->storage->file_put_contents('foo.txt', 'bar');
 
-		$parentCached = $this->cache->get('');
-		$this->assertEquals(0, $parentCached['size']);
+        $parentCached = $this->cache->get('');
+        $this->assertEquals(0, $parentCached['size']);
 
-		$this->updater->update('foo.txt');
+        $this->updater->update('foo.txt');
 
-		$parentCached = $this->cache->get('');
-		$this->assertEquals(3, $parentCached['size']);
+        $parentCached = $this->cache->get('');
+        $this->assertEquals(3, $parentCached['size']);
 
-		$this->storage->file_put_contents('foo.txt', 'qwerty');
+        $this->storage->file_put_contents('foo.txt', 'qwerty');
 
-		$parentCached = $this->cache->get('');
-		$this->assertEquals(3, $parentCached['size']);
+        $parentCached = $this->cache->get('');
+        $this->assertEquals(3, $parentCached['size']);
 
-		$this->updater->update('foo.txt');
+        $this->updater->update('foo.txt');
 
-		$parentCached = $this->cache->get('');
-		$this->assertEquals(6, $parentCached['size']);
+        $parentCached = $this->cache->get('');
+        $this->assertEquals(6, $parentCached['size']);
 
-		$this->storage->unlink('foo.txt');
+        $this->storage->unlink('foo.txt');
 
-		$parentCached = $this->cache->get('');
-		$this->assertEquals(6, $parentCached['size']);
+        $parentCached = $this->cache->get('');
+        $this->assertEquals(6, $parentCached['size']);
 
-		$this->updater->remove('foo.txt');
+        $this->updater->remove('foo.txt');
 
-		$parentCached = $this->cache->get('');
-		$this->assertEquals(0, $parentCached['size']);
-	}
+        $parentCached = $this->cache->get('');
+        $this->assertEquals(0, $parentCached['size']);
+    }
 
-	public function testMove(): void {
-		$this->storage->file_put_contents('foo.txt', 'qwerty');
-		$this->updater->update('foo.txt');
+    public function testMove(): void {
+        $this->storage->file_put_contents('foo.txt', 'qwerty');
+        $this->updater->update('foo.txt');
 
-		$this->assertTrue($this->cache->inCache('foo.txt'));
-		$this->assertFalse($this->cache->inCache('bar.txt'));
-		$cached = $this->cache->get('foo.txt');
+        $this->assertTrue($this->cache->inCache('foo.txt'));
+        $this->assertFalse($this->cache->inCache('bar.txt'));
+        $cached = $this->cache->get('foo.txt');
 
-		$this->storage->rename('foo.txt', 'bar.txt');
+        $this->storage->rename('foo.txt', 'bar.txt');
 
-		$this->assertTrue($this->cache->inCache('foo.txt'));
-		$this->assertFalse($this->cache->inCache('bar.txt'));
+        $this->assertTrue($this->cache->inCache('foo.txt'));
+        $this->assertFalse($this->cache->inCache('bar.txt'));
 
-		$this->updater->renameFromStorage($this->storage, 'foo.txt', 'bar.txt');
+        $this->updater->renameFromStorage($this->storage, 'foo.txt', 'bar.txt');
 
-		$this->assertFalse($this->cache->inCache('foo.txt'));
-		$this->assertTrue($this->cache->inCache('bar.txt'));
+        $this->assertFalse($this->cache->inCache('foo.txt'));
+        $this->assertTrue($this->cache->inCache('bar.txt'));
 
-		$cachedTarget = $this->cache->get('bar.txt');
-		$this->assertEquals($cached['etag'], $cachedTarget['etag']);
-		$this->assertEquals($cached['mtime'], $cachedTarget['mtime']);
-		$this->assertEquals($cached['size'], $cachedTarget['size']);
-		$this->assertEquals($cached['fileid'], $cachedTarget['fileid']);
-	}
+        $cachedTarget = $this->cache->get('bar.txt');
+        $this->assertEquals($cached['etag'], $cachedTarget['etag']);
+        $this->assertEquals($cached['mtime'], $cachedTarget['mtime']);
+        $this->assertEquals($cached['size'], $cachedTarget['size']);
+        $this->assertEquals($cached['fileid'], $cachedTarget['fileid']);
+    }
 
-	public function testMoveNonExistingOverwrite(): void {
-		$this->storage->file_put_contents('bar.txt', 'qwerty');
-		$this->updater->update('bar.txt');
+    public function testMoveNonExistingOverwrite(): void {
+        $this->storage->file_put_contents('bar.txt', 'qwerty');
+        $this->updater->update('bar.txt');
 
-		$cached = $this->cache->get('bar.txt');
+        $cached = $this->cache->get('bar.txt');
 
-		$this->updater->renameFromStorage($this->storage, 'foo.txt', 'bar.txt');
+        $this->updater->renameFromStorage($this->storage, 'foo.txt', 'bar.txt');
 
-		$this->assertFalse($this->cache->inCache('foo.txt'));
-		$this->assertTrue($this->cache->inCache('bar.txt'));
+        $this->assertFalse($this->cache->inCache('foo.txt'));
+        $this->assertTrue($this->cache->inCache('bar.txt'));
 
-		$cachedTarget = $this->cache->get('bar.txt');
-		$this->assertEquals($cached['etag'], $cachedTarget['etag']);
-		$this->assertEquals($cached['mtime'], $cachedTarget['mtime']);
-		$this->assertEquals($cached['size'], $cachedTarget['size']);
-		$this->assertEquals($cached['fileid'], $cachedTarget['fileid']);
-	}
+        $cachedTarget = $this->cache->get('bar.txt');
+        $this->assertEquals($cached['etag'], $cachedTarget['etag']);
+        $this->assertEquals($cached['mtime'], $cachedTarget['mtime']);
+        $this->assertEquals($cached['size'], $cachedTarget['size']);
+        $this->assertEquals($cached['fileid'], $cachedTarget['fileid']);
+    }
 
-	public function testUpdateStorageMTime(): void {
-		$this->storage->mkdir('sub');
-		$this->storage->mkdir('sub2');
-		$this->storage->file_put_contents('sub/foo.txt', 'qwerty');
+    public function testUpdateStorageMTime(): void {
+        $this->storage->mkdir('sub');
+        $this->storage->mkdir('sub2');
+        $this->storage->file_put_contents('sub/foo.txt', 'qwerty');
 
-		$this->updater->update('sub');
-		$this->updater->update('sub/foo.txt');
-		$this->updater->update('sub2');
+        $this->updater->update('sub');
+        $this->updater->update('sub/foo.txt');
+        $this->updater->update('sub2');
 
-		$cachedSourceParent = $this->cache->get('sub');
-		$cachedSource = $this->cache->get('sub/foo.txt');
+        $cachedSourceParent = $this->cache->get('sub');
+        $cachedSource = $this->cache->get('sub/foo.txt');
 
-		$this->storage->rename('sub/foo.txt', 'sub2/bar.txt');
+        $this->storage->rename('sub/foo.txt', 'sub2/bar.txt');
 
-		// simulate storage having a different mtime
-		$testmtime = 1433323578;
+        // simulate storage having a different mtime
+        $testmtime = 1433323578;
 
-		// source storage mtime change
-		$this->storage->touch('sub', $testmtime);
+        // source storage mtime change
+        $this->storage->touch('sub', $testmtime);
 
-		// target storage mtime change
-		$this->storage->touch('sub2', $testmtime);
-		// some storages (like Dropbox) change storage mtime on rename
-		$this->storage->touch('sub2/bar.txt', $testmtime);
+        // target storage mtime change
+        $this->storage->touch('sub2', $testmtime);
+        // some storages (like Dropbox) change storage mtime on rename
+        $this->storage->touch('sub2/bar.txt', $testmtime);
 
-		$this->updater->renameFromStorage($this->storage, 'sub/foo.txt', 'sub2/bar.txt');
+        $this->updater->renameFromStorage($this->storage, 'sub/foo.txt', 'sub2/bar.txt');
 
-		$cachedTargetParent = $this->cache->get('sub2');
-		$cachedTarget = $this->cache->get('sub2/bar.txt');
+        $cachedTargetParent = $this->cache->get('sub2');
+        $cachedTarget = $this->cache->get('sub2/bar.txt');
 
-		$this->assertEquals($cachedSource['mtime'], $cachedTarget['mtime'], 'file mtime preserved');
+        $this->assertEquals($cachedSource['mtime'], $cachedTarget['mtime'], 'file mtime preserved');
 
-		$this->assertNotEquals($cachedTarget['storage_mtime'], $cachedTarget['mtime'], 'mtime is not storage_mtime for moved file');
+        $this->assertNotEquals($cachedTarget['storage_mtime'], $cachedTarget['mtime'], 'mtime is not storage_mtime for moved file');
 
-		$this->assertEquals($testmtime, $cachedTarget['storage_mtime'], 'target file storage_mtime propagated');
-		$this->assertNotEquals($testmtime, $cachedTarget['mtime'], 'target file mtime changed, not from storage');
+        $this->assertEquals($testmtime, $cachedTarget['storage_mtime'], 'target file storage_mtime propagated');
+        $this->assertNotEquals($testmtime, $cachedTarget['mtime'], 'target file mtime changed, not from storage');
 
-		$this->assertEquals($testmtime, $cachedTargetParent['storage_mtime'], 'target parent storage_mtime propagated');
-		$this->assertNotEquals($testmtime, $cachedTargetParent['mtime'], 'target folder mtime changed, not from storage');
-	}
+        $this->assertEquals($testmtime, $cachedTargetParent['storage_mtime'], 'target parent storage_mtime propagated');
+        $this->assertNotEquals($testmtime, $cachedTargetParent['mtime'], 'target folder mtime changed, not from storage');
+    }
 
-	public function testNewFileDisabled(): void {
-		$this->storage->file_put_contents('foo.txt', 'bar');
-		$this->assertFalse($this->cache->inCache('foo.txt'));
-
-		$this->updater->disable();
-		$this->updater->update('/foo.txt');
-
-		$this->assertFalse($this->cache->inCache('foo.txt'));
-	}
-
-	public function testMoveCrossStorage(): void {
-		$storage2 = new Temporary([]);
-		$cache2 = $storage2->getCache();
-		Filesystem::mount($storage2, [], '/bar');
-		$this->storage->file_put_contents('foo.txt', 'qwerty');
-
-		$this->updater->update('foo.txt');
-
-		$this->assertTrue($this->cache->inCache('foo.txt'));
-		$this->assertFalse($cache2->inCache('bar.txt'));
-		$cached = $this->cache->get('foo.txt');
-
-		// "rename"
-		$storage2->file_put_contents('bar.txt', 'qwerty');
-		$this->storage->unlink('foo.txt');
-
-		$this->assertTrue($this->cache->inCache('foo.txt'));
-		$this->assertFalse($cache2->inCache('bar.txt'));
-
-		$storage2->getUpdater()->renameFromStorage($this->storage, 'foo.txt', 'bar.txt');
-
-		$this->assertFalse($this->cache->inCache('foo.txt'));
-		$this->assertTrue($cache2->inCache('bar.txt'));
-
-		$cachedTarget = $cache2->get('bar.txt');
-		$this->assertEquals($cached['mtime'], $cachedTarget['mtime']);
-		$this->assertEquals($cached['size'], $cachedTarget['size']);
-		$this->assertEquals($cached['etag'], $cachedTarget['etag']);
-		$this->assertEquals($cached['fileid'], $cachedTarget['fileid']);
-	}
-
-	public function testMoveFolderCrossStorage(): void {
-		$storage2 = new Temporary([]);
-		$cache2 = $storage2->getCache();
-		Filesystem::mount($storage2, [], '/bar');
-		$this->storage->mkdir('foo');
-		$this->storage->mkdir('foo/bar');
-		$this->storage->file_put_contents('foo/foo.txt', 'qwerty');
-		$this->storage->file_put_contents('foo/bar.txt', 'foo');
-		$this->storage->file_put_contents('foo/bar/bar.txt', 'qwertyuiop');
-
-		$this->storage->getScanner()->scan('');
-
-		$this->assertTrue($this->cache->inCache('foo'));
-		$this->assertTrue($this->cache->inCache('foo/foo.txt'));
-		$this->assertTrue($this->cache->inCache('foo/bar.txt'));
-		$this->assertTrue($this->cache->inCache('foo/bar'));
-		$this->assertTrue($this->cache->inCache('foo/bar/bar.txt'));
-		$cached = [];
-		$cached[] = $this->cache->get('foo');
-		$cached[] = $this->cache->get('foo/foo.txt');
-		$cached[] = $this->cache->get('foo/bar.txt');
-		$cached[] = $this->cache->get('foo/bar');
-		$cached[] = $this->cache->get('foo/bar/bar.txt');
-
-		// add extension to trigger the possible mimetype change
-		$storage2->moveFromStorage($this->storage, 'foo', 'foo.b');
-		$storage2->getUpdater()->renameFromStorage($this->storage, 'foo', 'foo.b');
-
-		$this->assertFalse($this->cache->inCache('foo'));
-		$this->assertFalse($this->cache->inCache('foo/foo.txt'));
-		$this->assertFalse($this->cache->inCache('foo/bar.txt'));
-		$this->assertFalse($this->cache->inCache('foo/bar'));
-		$this->assertFalse($this->cache->inCache('foo/bar/bar.txt'));
-		$this->assertTrue($cache2->inCache('foo.b'));
-		$this->assertTrue($cache2->inCache('foo.b/foo.txt'));
-		$this->assertTrue($cache2->inCache('foo.b/bar.txt'));
-		$this->assertTrue($cache2->inCache('foo.b/bar'));
-		$this->assertTrue($cache2->inCache('foo.b/bar/bar.txt'));
-
-		$cachedTarget = [];
-		$cachedTarget[] = $cache2->get('foo.b');
-		$cachedTarget[] = $cache2->get('foo.b/foo.txt');
-		$cachedTarget[] = $cache2->get('foo.b/bar.txt');
-		$cachedTarget[] = $cache2->get('foo.b/bar');
-		$cachedTarget[] = $cache2->get('foo.b/bar/bar.txt');
-
-		foreach ($cached as $i => $old) {
-			$new = $cachedTarget[$i];
-			$this->assertEquals($old['mtime'], $new['mtime']);
-			$this->assertEquals($old['size'], $new['size']);
-			$this->assertEquals($old['etag'], $new['etag']);
-			$this->assertEquals($old['fileid'], $new['fileid']);
-			$this->assertEquals($old['mimetype'], $new['mimetype']);
-		}
-	}
-
-	public static function changeExtensionProvider(): array {
-		return [
-			[new Temporary()],
-			[new ObjectStoreStorage(['objectstore' => new StorageObjectStore(new Temporary())])]
-		];
-	}
-
-	/**
-	 * @dataProvider changeExtensionProvider
-	 */
-	public function testChangeExtension(IStorage $storage) {
-		$updater = $storage->getUpdater();
-		$cache = $storage->getCache();
-		$storage->file_put_contents('foo', 'qwerty');
-		$updater->update('foo');
-
-		$bareCached = $cache->get('foo');
-		$this->assertEquals('application/octet-stream', $bareCached->getMimeType());
-
-		$storage->rename('foo', 'foo.txt');
-		$updater->renameFromStorage($storage, 'foo', 'foo.txt');
-
-		$cached = $cache->get('foo.txt');
-		$this->assertEquals('text/plain', $cached->getMimeType());
-
-		$storage->rename('foo.txt', 'foo.md');
-		$updater->renameFromStorage($storage, 'foo.txt', 'foo.md');
-
-		$cachedTarget = $cache->get('foo.md');
-		$this->assertEquals('text/markdown', $cachedTarget->getMimeType());
-	}
+    public function testNewFileDisabled(): void {
+        $this->storage->file_put_contents('foo.txt', 'bar');
+        $this->assertFalse($this->cache->inCache('foo.txt'));
+
+        $this->updater->disable();
+        $this->updater->update('/foo.txt');
+
+        $this->assertFalse($this->cache->inCache('foo.txt'));
+    }
+
+    public function testMoveCrossStorage(): void {
+        $storage2 = new Temporary([]);
+        $cache2 = $storage2->getCache();
+        Filesystem::mount($storage2, [], '/bar');
+        $this->storage->file_put_contents('foo.txt', 'qwerty');
+
+        $this->updater->update('foo.txt');
+
+        $this->assertTrue($this->cache->inCache('foo.txt'));
+        $this->assertFalse($cache2->inCache('bar.txt'));
+        $cached = $this->cache->get('foo.txt');
+
+        // "rename"
+        $storage2->file_put_contents('bar.txt', 'qwerty');
+        $this->storage->unlink('foo.txt');
+
+        $this->assertTrue($this->cache->inCache('foo.txt'));
+        $this->assertFalse($cache2->inCache('bar.txt'));
+
+        $storage2->getUpdater()->renameFromStorage($this->storage, 'foo.txt', 'bar.txt');
+
+        $this->assertFalse($this->cache->inCache('foo.txt'));
+        $this->assertTrue($cache2->inCache('bar.txt'));
+
+        $cachedTarget = $cache2->get('bar.txt');
+        $this->assertEquals($cached['mtime'], $cachedTarget['mtime']);
+        $this->assertEquals($cached['size'], $cachedTarget['size']);
+        $this->assertEquals($cached['etag'], $cachedTarget['etag']);
+        $this->assertEquals($cached['fileid'], $cachedTarget['fileid']);
+    }
+
+    public function testMoveFolderCrossStorage(): void {
+        $storage2 = new Temporary([]);
+        $cache2 = $storage2->getCache();
+        Filesystem::mount($storage2, [], '/bar');
+        $this->storage->mkdir('foo');
+        $this->storage->mkdir('foo/bar');
+        $this->storage->file_put_contents('foo/foo.txt', 'qwerty');
+        $this->storage->file_put_contents('foo/bar.txt', 'foo');
+        $this->storage->file_put_contents('foo/bar/bar.txt', 'qwertyuiop');
+
+        $this->storage->getScanner()->scan('');
+
+        $this->assertTrue($this->cache->inCache('foo'));
+        $this->assertTrue($this->cache->inCache('foo/foo.txt'));
+        $this->assertTrue($this->cache->inCache('foo/bar.txt'));
+        $this->assertTrue($this->cache->inCache('foo/bar'));
+        $this->assertTrue($this->cache->inCache('foo/bar/bar.txt'));
+        $cached = [];
+        $cached[] = $this->cache->get('foo');
+        $cached[] = $this->cache->get('foo/foo.txt');
+        $cached[] = $this->cache->get('foo/bar.txt');
+        $cached[] = $this->cache->get('foo/bar');
+        $cached[] = $this->cache->get('foo/bar/bar.txt');
+
+        // add extension to trigger the possible mimetype change
+        $storage2->moveFromStorage($this->storage, 'foo', 'foo.b');
+        $storage2->getUpdater()->renameFromStorage($this->storage, 'foo', 'foo.b');
+
+        $this->assertFalse($this->cache->inCache('foo'));
+        $this->assertFalse($this->cache->inCache('foo/foo.txt'));
+        $this->assertFalse($this->cache->inCache('foo/bar.txt'));
+        $this->assertFalse($this->cache->inCache('foo/bar'));
+        $this->assertFalse($this->cache->inCache('foo/bar/bar.txt'));
+        $this->assertTrue($cache2->inCache('foo.b'));
+        $this->assertTrue($cache2->inCache('foo.b/foo.txt'));
+        $this->assertTrue($cache2->inCache('foo.b/bar.txt'));
+        $this->assertTrue($cache2->inCache('foo.b/bar'));
+        $this->assertTrue($cache2->inCache('foo.b/bar/bar.txt'));
+
+        $cachedTarget = [];
+        $cachedTarget[] = $cache2->get('foo.b');
+        $cachedTarget[] = $cache2->get('foo.b/foo.txt');
+        $cachedTarget[] = $cache2->get('foo.b/bar.txt');
+        $cachedTarget[] = $cache2->get('foo.b/bar');
+        $cachedTarget[] = $cache2->get('foo.b/bar/bar.txt');
+
+        foreach ($cached as $i => $old) {
+            $new = $cachedTarget[$i];
+            $this->assertEquals($old['mtime'], $new['mtime']);
+            $this->assertEquals($old['size'], $new['size']);
+            $this->assertEquals($old['etag'], $new['etag']);
+            $this->assertEquals($old['fileid'], $new['fileid']);
+            $this->assertEquals($old['mimetype'], $new['mimetype']);
+        }
+    }
+
+    public static function changeExtensionProvider(): array {
+        return [
+            [new Temporary()],
+            [new ObjectStoreStorage(['objectstore' => new StorageObjectStore(new Temporary())])]
+        ];
+    }
+
+    /**
+     * @dataProvider changeExtensionProvider
+     */
+    public function testChangeExtension(IStorage $storage) {
+        $updater = $storage->getUpdater();
+        $cache = $storage->getCache();
+        $storage->file_put_contents('foo', 'qwerty');
+        $updater->update('foo');
+
+        $bareCached = $cache->get('foo');
+        $this->assertEquals('application/octet-stream', $bareCached->getMimeType());
+
+        $storage->rename('foo', 'foo.txt');
+        $updater->renameFromStorage($storage, 'foo', 'foo.txt');
+
+        $cached = $cache->get('foo.txt');
+        $this->assertEquals('text/plain', $cached->getMimeType());
+
+        $storage->rename('foo.txt', 'foo.md');
+        $updater->renameFromStorage($storage, 'foo.txt', 'foo.md');
+
+        $cachedTarget = $cache->get('foo.md');
+        $this->assertEquals('text/markdown', $cachedTarget->getMimeType());
+    }
 }

tests/lib/Files/Cache/SearchBuilderTest.php

Indentation +185 added lines, -185 removed lines

@@ -22,189 +22,189 @@
  * @group DB
  */
 class SearchBuilderTest extends TestCase {
-	/** @var IQueryBuilder */
-	private $builder;
-
-	/** @var IMimeTypeLoader&\PHPUnit\Framework\MockObject\MockObject */
-	private $mimetypeLoader;
-
-	/** @var IFilesMetadataManager&\PHPUnit\Framework\MockObject\MockObject */
-	private $filesMetadataManager;
-
-	/** @var SearchBuilder */
-	private $searchBuilder;
-
-	/** @var integer */
-	private $numericStorageId;
-
-	protected function setUp(): void {
-		parent::setUp();
-		$this->builder = \OC::$server->getDatabaseConnection()->getQueryBuilder();
-		$this->mimetypeLoader = $this->createMock(IMimeTypeLoader::class);
-		$this->filesMetadataManager = $this->createMock(IFilesMetadataManager::class);
-
-		$this->mimetypeLoader->expects($this->any())
-			->method('getId')
-			->willReturnMap([
-				['text', 1],
-				['text/plain', 2],
-				['text/xml', 3],
-				['image/jpg', 4],
-				['image/png', 5],
-				['image', 6],
-			]);
-
-		$this->mimetypeLoader->expects($this->any())
-			->method('getMimetypeById')
-			->willReturnMap([
-				[1, 'text'],
-				[2, 'text/plain'],
-				[3, 'text/xml'],
-				[4, 'image/jpg'],
-				[5, 'image/png'],
-				[6, 'image']
-			]);
-
-		$this->searchBuilder = new SearchBuilder($this->mimetypeLoader, $this->filesMetadataManager);
-		$this->numericStorageId = 10000;
-
-		$this->builder->select(['fileid'])
-			->from('filecache', 'file') // alias needed for QuerySearchHelper#getOperatorFieldAndValue
-			->where($this->builder->expr()->eq('storage', new Literal($this->numericStorageId)));
-	}
-
-	protected function tearDown(): void {
-		parent::tearDown();
-
-		$builder = \OC::$server->getDatabaseConnection()->getQueryBuilder();
-
-		$builder->delete('filecache')
-			->where($builder->expr()->eq('storage', $builder->createNamedParameter($this->numericStorageId, IQueryBuilder::PARAM_INT)));
-
-		$builder->execute();
-	}
-
-	private function addCacheEntry(array $data) {
-		$data['storage'] = $this->numericStorageId;
-		$data['etag'] = 'unimportant';
-		$data['storage_mtime'] = $data['mtime'];
-		if (!isset($data['path'])) {
-			$data['path'] = 'random/' . $this->getUniqueID();
-		}
-		$data['path_hash'] = md5($data['path']);
-		if (!isset($data['mtime'])) {
-			$data['mtime'] = 100;
-		}
-		if (!isset($data['size'])) {
-			$data['size'] = 100;
-		}
-		$data['name'] = basename($data['path']);
-		$data['parent'] = -1;
-		if (isset($data['mimetype'])) {
-			[$mimepart,] = explode('/', $data['mimetype']);
-			$data['mimepart'] = $this->mimetypeLoader->getId($mimepart);
-			$data['mimetype'] = $this->mimetypeLoader->getId($data['mimetype']);
-		} else {
-			$data['mimepart'] = 1;
-			$data['mimetype'] = 1;
-		}
-
-		$builder = \OC::$server->getDatabaseConnection()->getQueryBuilder();
-
-		$values = [];
-		foreach ($data as $key => $value) {
-			$values[$key] = $builder->createNamedParameter($value);
-		}
-
-		$builder->insert('filecache')
-			->values($values)
-			->execute();
-
-		return $builder->getLastInsertId();
-	}
-
-	private function search(ISearchOperator $operator) {
-		$dbOperator = $this->searchBuilder->searchOperatorToDBExpr($this->builder, $operator);
-		$this->builder->andWhere($dbOperator);
-
-		$result = $this->builder->execute();
-		$rows = $result->fetchAll(\PDO::FETCH_COLUMN);
-		$result->closeCursor();
-
-		return $rows;
-	}
-
-	public static function comparisonProvider(): array {
-		return [
-			[new SearchComparison(ISearchComparison::COMPARE_GREATER_THAN, 'mtime', 125), [1]],
-			[new SearchComparison(ISearchComparison::COMPARE_LESS_THAN, 'mtime', 125), [0]],
-			[new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'size', 125), []],
-			[new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'size', 50), [0, 1]],
-			[new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'name', 'foobar'), [0]],
-			[new SearchComparison(ISearchComparison::COMPARE_LIKE, 'name', 'foo%'), [0, 1]],
-			[new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'mimetype', 'image/jpg'), [0]],
-			[new SearchComparison(ISearchComparison::COMPARE_LIKE, 'mimetype', 'image/%'), [0, 1]],
-			[new SearchComparison(ISearchComparison::COMPARE_IN, 'mimetype', ['image/jpg', 'image/png']), [0, 1]],
-			[new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_AND, [
-				new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'size', 50),
-				new SearchComparison(ISearchComparison::COMPARE_LESS_THAN, 'mtime', 125)
-			]), [0]],
-			[new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_AND, [
-				new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'size', 50),
-				new SearchComparison(ISearchComparison::COMPARE_LESS_THAN, 'mtime', 125),
-				new SearchComparison(ISearchComparison::COMPARE_LIKE, 'mimetype', 'text/%')
-			]), []],
-			[new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_OR, [
-				new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'mtime', 100),
-				new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'mtime', 150),
-			]), [0, 1]],
-			[new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_NOT, [
-				new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'mtime', 150),
-			]), [0]],
-			[new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_NOT, [
-				new SearchComparison(ISearchComparison::COMPARE_GREATER_THAN, 'mtime', 125),
-			]), [0]],
-			[new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_NOT, [
-				new SearchComparison(ISearchComparison::COMPARE_LESS_THAN, 'mtime', 125),
-			]), [1]],
-			[new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_NOT, [
-				new SearchComparison(ISearchComparison::COMPARE_LIKE, 'name', '%bar'),
-			]), [1]],
-
-		];
-	}
-
-	/**
-	 * @dataProvider comparisonProvider
-	 *
-	 * @param ISearchOperator $operator
-	 * @param array $fileIds
-	 */
-	public function testComparison(ISearchOperator $operator, array $fileIds): void {
-		$fileId = [];
-		$fileId[] = $this->addCacheEntry([
-			'path' => 'foobar',
-			'mtime' => 100,
-			'size' => 50,
-			'mimetype' => 'image/jpg'
-		]);
-
-		$fileId[] = $this->addCacheEntry([
-			'path' => 'fooasd',
-			'mtime' => 150,
-			'size' => 50,
-			'mimetype' => 'image/png'
-		]);
-
-		$fileIds = array_map(function ($i) use ($fileId) {
-			return $fileId[$i];
-		}, $fileIds);
-
-		$results = $this->search($operator);
-
-		sort($fileIds);
-		sort($results);
-
-		$this->assertEquals($fileIds, $results);
-	}
+    /** @var IQueryBuilder */
+    private $builder;
+
+    /** @var IMimeTypeLoader&\PHPUnit\Framework\MockObject\MockObject */
+    private $mimetypeLoader;
+
+    /** @var IFilesMetadataManager&\PHPUnit\Framework\MockObject\MockObject */
+    private $filesMetadataManager;
+
+    /** @var SearchBuilder */
+    private $searchBuilder;
+
+    /** @var integer */
+    private $numericStorageId;
+
+    protected function setUp(): void {
+        parent::setUp();
+        $this->builder = \OC::$server->getDatabaseConnection()->getQueryBuilder();
+        $this->mimetypeLoader = $this->createMock(IMimeTypeLoader::class);
+        $this->filesMetadataManager = $this->createMock(IFilesMetadataManager::class);
+
+        $this->mimetypeLoader->expects($this->any())
+            ->method('getId')
+            ->willReturnMap([
+                ['text', 1],
+                ['text/plain', 2],
+                ['text/xml', 3],
+                ['image/jpg', 4],
+                ['image/png', 5],
+                ['image', 6],
+            ]);
+
+        $this->mimetypeLoader->expects($this->any())
+            ->method('getMimetypeById')
+            ->willReturnMap([
+                [1, 'text'],
+                [2, 'text/plain'],
+                [3, 'text/xml'],
+                [4, 'image/jpg'],
+                [5, 'image/png'],
+                [6, 'image']
+            ]);
+
+        $this->searchBuilder = new SearchBuilder($this->mimetypeLoader, $this->filesMetadataManager);
+        $this->numericStorageId = 10000;
+
+        $this->builder->select(['fileid'])
+            ->from('filecache', 'file') // alias needed for QuerySearchHelper#getOperatorFieldAndValue
+            ->where($this->builder->expr()->eq('storage', new Literal($this->numericStorageId)));
+    }
+
+    protected function tearDown(): void {
+        parent::tearDown();
+
+        $builder = \OC::$server->getDatabaseConnection()->getQueryBuilder();
+
+        $builder->delete('filecache')
+            ->where($builder->expr()->eq('storage', $builder->createNamedParameter($this->numericStorageId, IQueryBuilder::PARAM_INT)));
+
+        $builder->execute();
+    }
+
+    private function addCacheEntry(array $data) {
+        $data['storage'] = $this->numericStorageId;
+        $data['etag'] = 'unimportant';
+        $data['storage_mtime'] = $data['mtime'];
+        if (!isset($data['path'])) {
+            $data['path'] = 'random/' . $this->getUniqueID();
+        }
+        $data['path_hash'] = md5($data['path']);
+        if (!isset($data['mtime'])) {
+            $data['mtime'] = 100;
+        }
+        if (!isset($data['size'])) {
+            $data['size'] = 100;
+        }
+        $data['name'] = basename($data['path']);
+        $data['parent'] = -1;
+        if (isset($data['mimetype'])) {
+            [$mimepart,] = explode('/', $data['mimetype']);
+            $data['mimepart'] = $this->mimetypeLoader->getId($mimepart);
+            $data['mimetype'] = $this->mimetypeLoader->getId($data['mimetype']);
+        } else {
+            $data['mimepart'] = 1;
+            $data['mimetype'] = 1;
+        }
+
+        $builder = \OC::$server->getDatabaseConnection()->getQueryBuilder();
+
+        $values = [];
+        foreach ($data as $key => $value) {
+            $values[$key] = $builder->createNamedParameter($value);
+        }
+
+        $builder->insert('filecache')
+            ->values($values)
+            ->execute();
+
+        return $builder->getLastInsertId();
+    }
+
+    private function search(ISearchOperator $operator) {
+        $dbOperator = $this->searchBuilder->searchOperatorToDBExpr($this->builder, $operator);
+        $this->builder->andWhere($dbOperator);
+
+        $result = $this->builder->execute();
+        $rows = $result->fetchAll(\PDO::FETCH_COLUMN);
+        $result->closeCursor();
+
+        return $rows;
+    }
+
+    public static function comparisonProvider(): array {
+        return [
+            [new SearchComparison(ISearchComparison::COMPARE_GREATER_THAN, 'mtime', 125), [1]],
+            [new SearchComparison(ISearchComparison::COMPARE_LESS_THAN, 'mtime', 125), [0]],
+            [new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'size', 125), []],
+            [new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'size', 50), [0, 1]],
+            [new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'name', 'foobar'), [0]],
+            [new SearchComparison(ISearchComparison::COMPARE_LIKE, 'name', 'foo%'), [0, 1]],
+            [new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'mimetype', 'image/jpg'), [0]],
+            [new SearchComparison(ISearchComparison::COMPARE_LIKE, 'mimetype', 'image/%'), [0, 1]],
+            [new SearchComparison(ISearchComparison::COMPARE_IN, 'mimetype', ['image/jpg', 'image/png']), [0, 1]],
+            [new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_AND, [
+                new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'size', 50),
+                new SearchComparison(ISearchComparison::COMPARE_LESS_THAN, 'mtime', 125)
+            ]), [0]],
+            [new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_AND, [
+                new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'size', 50),
+                new SearchComparison(ISearchComparison::COMPARE_LESS_THAN, 'mtime', 125),
+                new SearchComparison(ISearchComparison::COMPARE_LIKE, 'mimetype', 'text/%')
+            ]), []],
+            [new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_OR, [
+                new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'mtime', 100),
+                new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'mtime', 150),
+            ]), [0, 1]],
+            [new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_NOT, [
+                new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'mtime', 150),
+            ]), [0]],
+            [new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_NOT, [
+                new SearchComparison(ISearchComparison::COMPARE_GREATER_THAN, 'mtime', 125),
+            ]), [0]],
+            [new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_NOT, [
+                new SearchComparison(ISearchComparison::COMPARE_LESS_THAN, 'mtime', 125),
+            ]), [1]],
+            [new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_NOT, [
+                new SearchComparison(ISearchComparison::COMPARE_LIKE, 'name', '%bar'),
+            ]), [1]],
+
+        ];
+    }
+
+    /**
+     * @dataProvider comparisonProvider
+     *
+     * @param ISearchOperator $operator
+     * @param array $fileIds
+     */
+    public function testComparison(ISearchOperator $operator, array $fileIds): void {
+        $fileId = [];
+        $fileId[] = $this->addCacheEntry([
+            'path' => 'foobar',
+            'mtime' => 100,
+            'size' => 50,
+            'mimetype' => 'image/jpg'
+        ]);
+
+        $fileId[] = $this->addCacheEntry([
+            'path' => 'fooasd',
+            'mtime' => 150,
+            'size' => 50,
+            'mimetype' => 'image/png'
+        ]);
+
+        $fileIds = array_map(function ($i) use ($fileId) {
+            return $fileId[$i];
+        }, $fileIds);
+
+        $results = $this->search($operator);
+
+        sort($fileIds);
+        sort($results);
+
+        $this->assertEquals($fileIds, $results);
+    }
 }

tests/lib/Files/Utils/ScannerTest.php

Indentation +190 added lines, -190 removed lines

@@ -17,21 +17,21 @@ 
 use Psr\Log\LoggerInterface;
 
 class TestScanner extends \OC\Files\Utils\Scanner {
-	/**
-	 * @var \OC\Files\Mount\MountPoint[] $mounts
-	 */
-	private $mounts = [];
-
-	/**
-	 * @param \OC\Files\Mount\MountPoint $mount
-	 */
-	public function addMount($mount) {
-		$this->mounts[] = $mount;
-	}
-
-	protected function getMounts($dir) {
-		return $this->mounts;
-	}
+    /**
+     * @var \OC\Files\Mount\MountPoint[] $mounts
+     */
+    private $mounts = [];
+
+    /**
+     * @param \OC\Files\Mount\MountPoint $mount
+     */
+    public function addMount($mount) {
+        $this->mounts[] = $mount;
+    }
+
+    protected function getMounts($dir) {
+        return $this->mounts;
+    }
 }
 
 /**
@@ -42,179 +42,179 @@ 
  * @package Test\Files\Utils
  */
 class ScannerTest extends \Test\TestCase {
-	/**
-	 * @var \Test\Util\User\Dummy
-	 */
-	private $userBackend;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->userBackend = new \Test\Util\User\Dummy();
-		\OC::$server->getUserManager()->registerBackend($this->userBackend);
-		$this->loginAsUser();
-	}
-
-	protected function tearDown(): void {
-		$this->logout();
-		\OC::$server->getUserManager()->removeBackend($this->userBackend);
-		parent::tearDown();
-	}
-
-	public function testReuseExistingRoot(): void {
-		$storage = new Temporary([]);
-		$mount = new MountPoint($storage, '');
-		Filesystem::getMountManager()->addMount($mount);
-		$cache = $storage->getCache();
-
-		$storage->mkdir('folder');
-		$storage->file_put_contents('foo.txt', 'qwerty');
-		$storage->file_put_contents('folder/bar.txt', 'qwerty');
-
-		$scanner = new TestScanner('', \OC::$server->getDatabaseConnection(), $this->createMock(IEventDispatcher::class), \OC::$server->get(LoggerInterface::class));
-		$scanner->addMount($mount);
-
-		$scanner->scan('');
-		$this->assertTrue($cache->inCache('folder/bar.txt'));
-		$oldRoot = $cache->get('');
-
-		$scanner->scan('');
-		$newRoot = $cache->get('');
-		$this->assertEquals($oldRoot, $newRoot);
-	}
-
-	public function testReuseExistingFile(): void {
-		$storage = new Temporary([]);
-		$mount = new MountPoint($storage, '');
-		Filesystem::getMountManager()->addMount($mount);
-		$cache = $storage->getCache();
-
-		$storage->mkdir('folder');
-		$storage->file_put_contents('foo.txt', 'qwerty');
-		$storage->file_put_contents('folder/bar.txt', 'qwerty');
-
-		$scanner = new TestScanner('', \OC::$server->getDatabaseConnection(), $this->createMock(IEventDispatcher::class), \OC::$server->get(LoggerInterface::class));
-		$scanner->addMount($mount);
-
-		$scanner->scan('');
-		$this->assertTrue($cache->inCache('folder/bar.txt'));
-		$old = $cache->get('folder/bar.txt');
-
-		$scanner->scan('');
-		$new = $cache->get('folder/bar.txt');
-		$this->assertEquals($old, $new);
-	}
-
-	public function testScanSubMount(): void {
-		$uid = $this->getUniqueID();
-		$this->userBackend->createUser($uid, 'test');
-
-		$mountProvider = $this->createMock(IMountProvider::class);
-
-		$storage = new Temporary([]);
-		$mount = new MountPoint($storage, '/' . $uid . '/files/foo');
-
-		$mountProvider->expects($this->any())
-			->method('getMountsForUser')
-			->willReturnCallback(function (IUser $user, IStorageFactory $storageFactory) use ($mount, $uid) {
-				if ($user->getUID() === $uid) {
-					return [$mount];
-				} else {
-					return [];
-				}
-			});
-
-		\OC::$server->getMountProviderCollection()->registerProvider($mountProvider);
-		$cache = $storage->getCache();
-
-		$storage->mkdir('folder');
-		$storage->file_put_contents('foo.txt', 'qwerty');
-		$storage->file_put_contents('folder/bar.txt', 'qwerty');
-
-		$scanner = new \OC\Files\Utils\Scanner($uid, \OC::$server->getDatabaseConnection(), \OC::$server->query(IEventDispatcher::class), \OC::$server->get(LoggerInterface::class));
-
-		$this->assertFalse($cache->inCache('folder/bar.txt'));
-		$scanner->scan('/' . $uid . '/files/foo');
-		$this->assertTrue($cache->inCache('folder/bar.txt'));
-	}
-
-	public static function invalidPathProvider(): array {
-		return [
-			[
-				'../',
-			],
-			[
-				'..\\',
-			],
-			[
-				'../..\\../',
-			],
-		];
-	}
-
-	/**
-	 * @dataProvider invalidPathProvider
-	 * @param string $invalidPath
-	 */
-	public function testInvalidPathScanning($invalidPath): void {
-		$this->expectException(\InvalidArgumentException::class);
-		$this->expectExceptionMessage('Invalid path to scan');
-
-		$scanner = new TestScanner('', \OC::$server->getDatabaseConnection(), $this->createMock(IEventDispatcher::class), \OC::$server->get(LoggerInterface::class));
-		$scanner->scan($invalidPath);
-	}
-
-	public function testPropagateEtag(): void {
-		$storage = new Temporary([]);
-		$mount = new MountPoint($storage, '');
-		Filesystem::getMountManager()->addMount($mount);
-		$cache = $storage->getCache();
-
-		$storage->mkdir('folder');
-		$storage->file_put_contents('folder/bar.txt', 'qwerty');
-		$storage->touch('folder/bar.txt', time() - 200);
-
-		$scanner = new TestScanner('', \OC::$server->getDatabaseConnection(), $this->createMock(IEventDispatcher::class), \OC::$server->get(LoggerInterface::class));
-		$scanner->addMount($mount);
-
-		$scanner->scan('');
-		$this->assertTrue($cache->inCache('folder/bar.txt'));
-		$oldRoot = $cache->get('');
-
-		$storage->file_put_contents('folder/bar.txt', 'qwerty');
-		$scanner->scan('');
-		$newRoot = $cache->get('');
-
-		$this->assertNotEquals($oldRoot->getEtag(), $newRoot->getEtag());
-	}
-
-	public function testShallow(): void {
-		$storage = new Temporary([]);
-		$mount = new MountPoint($storage, '');
-		Filesystem::getMountManager()->addMount($mount);
-		$cache = $storage->getCache();
-
-		$storage->mkdir('folder');
-		$storage->mkdir('folder/subfolder');
-		$storage->file_put_contents('foo.txt', 'qwerty');
-		$storage->file_put_contents('folder/bar.txt', 'qwerty');
-		$storage->file_put_contents('folder/subfolder/foobar.txt', 'qwerty');
-
-		$scanner = new TestScanner('', \OC::$server->getDatabaseConnection(), $this->createMock(IEventDispatcher::class), \OC::$server->get(LoggerInterface::class));
-		$scanner->addMount($mount);
-
-		$scanner->scan('', $recusive = false);
-		$this->assertTrue($cache->inCache('folder'));
-		$this->assertFalse($cache->inCache('folder/subfolder'));
-		$this->assertTrue($cache->inCache('foo.txt'));
-		$this->assertFalse($cache->inCache('folder/bar.txt'));
-		$this->assertFalse($cache->inCache('folder/subfolder/foobar.txt'));
-
-		$scanner->scan('folder', $recusive = false);
-		$this->assertTrue($cache->inCache('folder'));
-		$this->assertTrue($cache->inCache('folder/subfolder'));
-		$this->assertTrue($cache->inCache('foo.txt'));
-		$this->assertTrue($cache->inCache('folder/bar.txt'));
-		$this->assertFalse($cache->inCache('folder/subfolder/foobar.txt'));
-	}
+    /**
+     * @var \Test\Util\User\Dummy
+     */
+    private $userBackend;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->userBackend = new \Test\Util\User\Dummy();
+        \OC::$server->getUserManager()->registerBackend($this->userBackend);
+        $this->loginAsUser();
+    }
+
+    protected function tearDown(): void {
+        $this->logout();
+        \OC::$server->getUserManager()->removeBackend($this->userBackend);
+        parent::tearDown();
+    }
+
+    public function testReuseExistingRoot(): void {
+        $storage = new Temporary([]);
+        $mount = new MountPoint($storage, '');
+        Filesystem::getMountManager()->addMount($mount);
+        $cache = $storage->getCache();
+
+        $storage->mkdir('folder');
+        $storage->file_put_contents('foo.txt', 'qwerty');
+        $storage->file_put_contents('folder/bar.txt', 'qwerty');
+
+        $scanner = new TestScanner('', \OC::$server->getDatabaseConnection(), $this->createMock(IEventDispatcher::class), \OC::$server->get(LoggerInterface::class));
+        $scanner->addMount($mount);
+
+        $scanner->scan('');
+        $this->assertTrue($cache->inCache('folder/bar.txt'));
+        $oldRoot = $cache->get('');
+
+        $scanner->scan('');
+        $newRoot = $cache->get('');
+        $this->assertEquals($oldRoot, $newRoot);
+    }
+
+    public function testReuseExistingFile(): void {
+        $storage = new Temporary([]);
+        $mount = new MountPoint($storage, '');
+        Filesystem::getMountManager()->addMount($mount);
+        $cache = $storage->getCache();
+
+        $storage->mkdir('folder');
+        $storage->file_put_contents('foo.txt', 'qwerty');
+        $storage->file_put_contents('folder/bar.txt', 'qwerty');
+
+        $scanner = new TestScanner('', \OC::$server->getDatabaseConnection(), $this->createMock(IEventDispatcher::class), \OC::$server->get(LoggerInterface::class));
+        $scanner->addMount($mount);
+
+        $scanner->scan('');
+        $this->assertTrue($cache->inCache('folder/bar.txt'));
+        $old = $cache->get('folder/bar.txt');
+
+        $scanner->scan('');
+        $new = $cache->get('folder/bar.txt');
+        $this->assertEquals($old, $new);
+    }
+
+    public function testScanSubMount(): void {
+        $uid = $this->getUniqueID();
+        $this->userBackend->createUser($uid, 'test');
+
+        $mountProvider = $this->createMock(IMountProvider::class);
+
+        $storage = new Temporary([]);
+        $mount = new MountPoint($storage, '/' . $uid . '/files/foo');
+
+        $mountProvider->expects($this->any())
+            ->method('getMountsForUser')
+            ->willReturnCallback(function (IUser $user, IStorageFactory $storageFactory) use ($mount, $uid) {
+                if ($user->getUID() === $uid) {
+                    return [$mount];
+                } else {
+                    return [];
+                }
+            });
+
+        \OC::$server->getMountProviderCollection()->registerProvider($mountProvider);
+        $cache = $storage->getCache();
+
+        $storage->mkdir('folder');
+        $storage->file_put_contents('foo.txt', 'qwerty');
+        $storage->file_put_contents('folder/bar.txt', 'qwerty');
+
+        $scanner = new \OC\Files\Utils\Scanner($uid, \OC::$server->getDatabaseConnection(), \OC::$server->query(IEventDispatcher::class), \OC::$server->get(LoggerInterface::class));
+
+        $this->assertFalse($cache->inCache('folder/bar.txt'));
+        $scanner->scan('/' . $uid . '/files/foo');
+        $this->assertTrue($cache->inCache('folder/bar.txt'));
+    }
+
+    public static function invalidPathProvider(): array {
+        return [
+            [
+                '../',
+            ],
+            [
+                '..\\',
+            ],
+            [
+                '../..\\../',
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider invalidPathProvider
+     * @param string $invalidPath
+     */
+    public function testInvalidPathScanning($invalidPath): void {
+        $this->expectException(\InvalidArgumentException::class);
+        $this->expectExceptionMessage('Invalid path to scan');
+
+        $scanner = new TestScanner('', \OC::$server->getDatabaseConnection(), $this->createMock(IEventDispatcher::class), \OC::$server->get(LoggerInterface::class));
+        $scanner->scan($invalidPath);
+    }
+
+    public function testPropagateEtag(): void {
+        $storage = new Temporary([]);
+        $mount = new MountPoint($storage, '');
+        Filesystem::getMountManager()->addMount($mount);
+        $cache = $storage->getCache();
+
+        $storage->mkdir('folder');
+        $storage->file_put_contents('folder/bar.txt', 'qwerty');
+        $storage->touch('folder/bar.txt', time() - 200);
+
+        $scanner = new TestScanner('', \OC::$server->getDatabaseConnection(), $this->createMock(IEventDispatcher::class), \OC::$server->get(LoggerInterface::class));
+        $scanner->addMount($mount);
+
+        $scanner->scan('');
+        $this->assertTrue($cache->inCache('folder/bar.txt'));
+        $oldRoot = $cache->get('');
+
+        $storage->file_put_contents('folder/bar.txt', 'qwerty');
+        $scanner->scan('');
+        $newRoot = $cache->get('');
+
+        $this->assertNotEquals($oldRoot->getEtag(), $newRoot->getEtag());
+    }
+
+    public function testShallow(): void {
+        $storage = new Temporary([]);
+        $mount = new MountPoint($storage, '');
+        Filesystem::getMountManager()->addMount($mount);
+        $cache = $storage->getCache();
+
+        $storage->mkdir('folder');
+        $storage->mkdir('folder/subfolder');
+        $storage->file_put_contents('foo.txt', 'qwerty');
+        $storage->file_put_contents('folder/bar.txt', 'qwerty');
+        $storage->file_put_contents('folder/subfolder/foobar.txt', 'qwerty');
+
+        $scanner = new TestScanner('', \OC::$server->getDatabaseConnection(), $this->createMock(IEventDispatcher::class), \OC::$server->get(LoggerInterface::class));
+        $scanner->addMount($mount);
+
+        $scanner->scan('', $recusive = false);
+        $this->assertTrue($cache->inCache('folder'));
+        $this->assertFalse($cache->inCache('folder/subfolder'));
+        $this->assertTrue($cache->inCache('foo.txt'));
+        $this->assertFalse($cache->inCache('folder/bar.txt'));
+        $this->assertFalse($cache->inCache('folder/subfolder/foobar.txt'));
+
+        $scanner->scan('folder', $recusive = false);
+        $this->assertTrue($cache->inCache('folder'));
+        $this->assertTrue($cache->inCache('folder/subfolder'));
+        $this->assertTrue($cache->inCache('foo.txt'));
+        $this->assertTrue($cache->inCache('folder/bar.txt'));
+        $this->assertFalse($cache->inCache('folder/subfolder/foobar.txt'));
+    }
 }

tests/lib/Files/Storage/Storage.php

Indentation +653 added lines, -653 removed lines

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

Spacing +39 added lines, -39 removed lines

@@ -53,17 +53,17 @@ 
 	 * @dataProvider directoryProvider
 	 */
 	public function testDirectories($directory): void {
-		$this->assertFalse($this->instance->file_exists('/' . $directory));
+		$this->assertFalse($this->instance->file_exists('/'.$directory));
 
-		$this->assertTrue($this->instance->mkdir('/' . $directory));
+		$this->assertTrue($this->instance->mkdir('/'.$directory));
 
-		$this->assertTrue($this->instance->file_exists('/' . $directory));
-		$this->assertTrue($this->instance->is_dir('/' . $directory));
-		$this->assertFalse($this->instance->is_file('/' . $directory));
-		$this->assertEquals('dir', $this->instance->filetype('/' . $directory));
-		$this->assertEquals(0, $this->instance->filesize('/' . $directory));
-		$this->assertTrue($this->instance->isReadable('/' . $directory));
-		$this->assertTrue($this->instance->isUpdatable('/' . $directory));
+		$this->assertTrue($this->instance->file_exists('/'.$directory));
+		$this->assertTrue($this->instance->is_dir('/'.$directory));
+		$this->assertFalse($this->instance->is_file('/'.$directory));
+		$this->assertEquals('dir', $this->instance->filetype('/'.$directory));
+		$this->assertEquals(0, $this->instance->filesize('/'.$directory));
+		$this->assertTrue($this->instance->isReadable('/'.$directory));
+		$this->assertTrue($this->instance->isUpdatable('/'.$directory));
 
 		$dh = $this->instance->opendir('/');
 		$content = [];
@@ -90,13 +90,13 @@ 
 			'permissions' => $this->instance->getPermissions($directory),
 		], $dirEntry);
 
-		$this->assertFalse($this->instance->mkdir('/' . $directory)); //can't create existing folders
-		$this->assertTrue($this->instance->rmdir('/' . $directory));
+		$this->assertFalse($this->instance->mkdir('/'.$directory)); //can't create existing folders
+		$this->assertTrue($this->instance->rmdir('/'.$directory));
 
 		$this->wait();
-		$this->assertFalse($this->instance->file_exists('/' . $directory));
+		$this->assertFalse($this->instance->file_exists('/'.$directory));
 
-		$this->assertFalse($this->instance->rmdir('/' . $directory)); //can't remove non existing folders
+		$this->assertFalse($this->instance->rmdir('/'.$directory)); //can't remove non existing folders
 
 		$dh = $this->instance->opendir('/');
 		$content = [];
@@ -131,12 +131,12 @@ 
 	}
 
 	public static function loremFileProvider(): array {
-		$root = \OC::$SERVERROOT . '/tests/data/';
+		$root = \OC::$SERVERROOT.'/tests/data/';
 		return [
 			// small file
-			[$root . 'lorem.txt'],
+			[$root.'lorem.txt'],
 			// bigger file (> 8 KB which is the standard PHP block size)
-			[$root . 'lorem-big.txt']
+			[$root.'lorem-big.txt']
 		];
 	}
 
@@ -165,15 +165,15 @@ 
 		$this->assertEquals('httpd/unix-directory', $this->instance->getMimeType('/'));
 		$this->assertEquals(false, $this->instance->getMimeType('/non/existing/file'));
 
-		$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+		$textFile = \OC::$SERVERROOT.'/tests/data/lorem.txt';
 		$this->instance->file_put_contents('/lorem.txt', file_get_contents($textFile, 'r'));
 		$this->assertEquals('text/plain', $this->instance->getMimeType('/lorem.txt'));
 
-		$pngFile = \OC::$SERVERROOT . '/tests/data/desktopapp.png';
+		$pngFile = \OC::$SERVERROOT.'/tests/data/desktopapp.png';
 		$this->instance->file_put_contents('/desktopapp.png', file_get_contents($pngFile, 'r'));
 		$this->assertEquals('image/png', $this->instance->getMimeType('/desktopapp.png'));
 
-		$svgFile = \OC::$SERVERROOT . '/tests/data/desktopapp.svg';
+		$svgFile = \OC::$SERVERROOT.'/tests/data/desktopapp.svg';
 		$this->instance->file_put_contents('/desktopapp.svg', file_get_contents($svgFile, 'r'));
 		$this->assertEquals('image/svg+xml', $this->instance->getMimeType('/desktopapp.svg'));
 	}
@@ -193,7 +193,7 @@ 
 	}
 
 	public function initSourceAndTarget($source, $target = null) {
-		$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+		$textFile = \OC::$SERVERROOT.'/tests/data/lorem.txt';
 		$this->instance->file_put_contents($source, file_get_contents($textFile));
 		if ($target) {
 			$testContents = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
@@ -202,11 +202,11 @@ 
 	}
 
 	public function assertSameAsLorem($file) {
-		$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+		$textFile = \OC::$SERVERROOT.'/tests/data/lorem.txt';
 		$this->assertEquals(
 			file_get_contents($textFile),
 			$this->instance->file_get_contents($file),
-			'Expected ' . $file . ' to be a copy of ' . $textFile
+			'Expected '.$file.' to be a copy of '.$textFile
 		);
 	}
 
@@ -218,9 +218,9 @@ 
 
 		$this->instance->copy($source, $target);
 
-		$this->assertTrue($this->instance->file_exists($target), $target . ' was not created');
+		$this->assertTrue($this->instance->file_exists($target), $target.' was not created');
 		$this->assertSameAsLorem($target);
-		$this->assertTrue($this->instance->file_exists($source), $source . ' was deleted');
+		$this->assertTrue($this->instance->file_exists($source), $source.' was deleted');
 	}
 
 	/**
@@ -232,8 +232,8 @@ 
 		$this->instance->rename($source, $target);
 
 		$this->wait();
-		$this->assertTrue($this->instance->file_exists($target), $target . ' was not created');
-		$this->assertFalse($this->instance->file_exists($source), $source . ' still exists');
+		$this->assertTrue($this->instance->file_exists($target), $target.' was not created');
+		$this->assertFalse($this->instance->file_exists($source), $source.' still exists');
 		$this->assertSameAsLorem($target);
 	}
 
@@ -245,8 +245,8 @@ 
 
 		$this->instance->copy($source, $target);
 
-		$this->assertTrue($this->instance->file_exists($target), $target . ' was not created');
-		$this->assertTrue($this->instance->file_exists($source), $source . ' was deleted');
+		$this->assertTrue($this->instance->file_exists($target), $target.' was not created');
+		$this->assertTrue($this->instance->file_exists($source), $source.' was deleted');
 		$this->assertSameAsLorem($target);
 		$this->assertSameAsLorem($source);
 	}
@@ -259,13 +259,13 @@ 
 
 		$this->instance->rename($source, $target);
 
-		$this->assertTrue($this->instance->file_exists($target), $target . ' was not created');
-		$this->assertFalse($this->instance->file_exists($source), $source . ' still exists');
+		$this->assertTrue($this->instance->file_exists($target), $target.' was not created');
+		$this->assertFalse($this->instance->file_exists($source), $source.' still exists');
 		$this->assertSameAsLorem($target);
 	}
 
 	public function testLocal(): void {
-		$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+		$textFile = \OC::$SERVERROOT.'/tests/data/lorem.txt';
 		$this->instance->file_put_contents('/lorem.txt', file_get_contents($textFile));
 		$localFile = $this->instance->getLocalFile('/lorem.txt');
 		$this->assertTrue(file_exists($localFile));
@@ -292,7 +292,7 @@ 
 	}
 
 	public function testStat(): void {
-		$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+		$textFile = \OC::$SERVERROOT.'/tests/data/lorem.txt';
 		$ctimeStart = time();
 		$this->instance->file_put_contents('/lorem.txt', file_get_contents($textFile));
 		$this->assertTrue($this->instance->isReadable('/lorem.txt'));
@@ -330,7 +330,7 @@ 
 		if ($this->instance instanceof \OC\Files\Storage\Wrapper\Wrapper) {
 			$this->markTestSkipped('Cannot test update check on wrappers');
 		}
-		$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+		$textFile = \OC::$SERVERROOT.'/tests/data/lorem.txt';
 		$watcher = $this->instance->getWatcher();
 		$watcher->setPolicy(Watcher::CHECK_ALWAYS);
 		$this->instance->file_put_contents('/lorem.txt', file_get_contents($textFile));
@@ -339,7 +339,7 @@ 
 	}
 
 	public function testUnlink(): void {
-		$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+		$textFile = \OC::$SERVERROOT.'/tests/data/lorem.txt';
 		$this->instance->file_put_contents('/lorem.txt', file_get_contents($textFile));
 
 		$this->assertTrue($this->instance->file_exists('/lorem.txt'));
@@ -354,7 +354,7 @@ 
 	 * @dataProvider fileNameProvider
 	 */
 	public function testFOpen($fileName): void {
-		$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+		$textFile = \OC::$SERVERROOT.'/tests/data/lorem.txt';
 
 		$fh = @$this->instance->fopen($fileName, 'r');
 		if ($fh) {
@@ -586,9 +586,9 @@ 
 
 		$this->instance->copyFromStorage($this->instance, $source, $target);
 
-		$this->assertTrue($this->instance->file_exists($target), $target . ' was not created');
+		$this->assertTrue($this->instance->file_exists($target), $target.' was not created');
 		$this->assertSameAsLorem($target);
-		$this->assertTrue($this->instance->file_exists($source), $source . ' was deleted');
+		$this->assertTrue($this->instance->file_exists($source), $source.' was deleted');
 	}
 
 	public function testIsCreatable(): void {
@@ -636,7 +636,7 @@ 
 	}
 
 	public function testWriteStream(): void {
-		$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+		$textFile = \OC::$SERVERROOT.'/tests/data/lorem.txt';
 
 		if (!$this->instance->instanceOfStorage(IWriteStreamStorage::class)) {
 			$this->markTestSkipped('Not a WriteSteamStorage');
@@ -653,7 +653,7 @@ 
 	}
 
 	public function testFseekSize(): void {
-		$textFile = \OC::$SERVERROOT . '/tests/data/lorem.txt';
+		$textFile = \OC::$SERVERROOT.'/tests/data/lorem.txt';
 		$this->instance->file_put_contents('bar.txt', file_get_contents($textFile));
 
 		$size = $this->instance->filesize('bar.txt');

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

Indentation +239 added lines, -239 removed lines

@@ -8,244 +8,244 @@
 namespace Test\Files\Storage\Wrapper;
 
 class EncodingTest extends \Test\Files\Storage\Storage {
-	public const NFD_NAME = 'ümlaut';
-	public const NFC_NAME = 'ümlaut';
-
-	/**
-	 * @var \OC\Files\Storage\Temporary
-	 */
-	private $sourceStorage;
-
-	protected function setUp(): void {
-		parent::setUp();
-		$this->sourceStorage = new \OC\Files\Storage\Temporary([]);
-		$this->instance = new \OC\Files\Storage\Wrapper\Encoding([
-			'storage' => $this->sourceStorage
-		]);
-	}
-
-	protected function tearDown(): void {
-		$this->sourceStorage->cleanUp();
-		parent::tearDown();
-	}
-
-	public static function directoryProvider(): array {
-		$a = parent::directoryProvider();
-		$a[] = [self::NFC_NAME];
-		return $a;
-	}
-
-	public static function fileNameProvider(): array {
-		$a = parent::fileNameProvider();
-		$a[] = [self::NFD_NAME . '.txt'];
-		return $a;
-	}
-
-	public static function copyAndMoveProvider(): array {
-		$a = parent::copyAndMoveProvider();
-		$a[] = [self::NFD_NAME . '.txt', self::NFC_NAME . '-renamed.txt'];
-		return $a;
-	}
-
-	public static function accessNameProvider(): array {
-		return [
-			[self::NFD_NAME],
-			[self::NFC_NAME],
-		];
-	}
-
-	/**
-	 * @dataProvider accessNameProvider
-	 */
-	public function testFputEncoding($accessName): void {
-		$this->sourceStorage->file_put_contents(self::NFD_NAME, 'bar');
-		$this->assertEquals('bar', $this->instance->file_get_contents($accessName));
-	}
-
-	/**
-	 * @dataProvider accessNameProvider
-	 */
-	public function testFopenReadEncoding($accessName): void {
-		$this->sourceStorage->file_put_contents(self::NFD_NAME, 'bar');
-		$fh = $this->instance->fopen($accessName, 'r');
-		$data = fgets($fh);
-		fclose($fh);
-		$this->assertEquals('bar', $data);
-	}
-
-	/**
-	 * @dataProvider accessNameProvider
-	 */
-	public function testFopenOverwriteEncoding($accessName): void {
-		$this->sourceStorage->file_put_contents(self::NFD_NAME, 'bar');
-		$fh = $this->instance->fopen($accessName, 'w');
-		$data = fputs($fh, 'test');
-		fclose($fh);
-		$data = $this->sourceStorage->file_get_contents(self::NFD_NAME);
-		$this->assertEquals('test', $data);
-		$this->assertFalse($this->sourceStorage->file_exists(self::NFC_NAME));
-	}
-
-	/**
-	 * @dataProvider accessNameProvider
-	 */
-	public function testFileExistsEncoding($accessName): void {
-		$this->sourceStorage->file_put_contents(self::NFD_NAME, 'bar');
-		$this->assertTrue($this->instance->file_exists($accessName));
-	}
-
-	/**
-	 * @dataProvider accessNameProvider
-	 */
-	public function testUnlinkEncoding($accessName): void {
-		$this->sourceStorage->file_put_contents(self::NFD_NAME, 'bar');
-		$this->assertTrue($this->instance->unlink($accessName));
-		$this->assertFalse($this->sourceStorage->file_exists(self::NFC_NAME));
-		$this->assertFalse($this->sourceStorage->file_exists(self::NFD_NAME));
-	}
-
-	public function testNfcHigherPriority(): void {
-		$this->sourceStorage->file_put_contents(self::NFC_NAME, 'nfc');
-		$this->sourceStorage->file_put_contents(self::NFD_NAME, 'nfd');
-		$this->assertEquals('nfc', $this->instance->file_get_contents(self::NFC_NAME));
-	}
-
-	public static function encodedDirectoriesProvider(): array {
-		return [
-			[self::NFD_NAME, self::NFC_NAME],
-			[self::NFD_NAME . '/' . self::NFD_NAME, self::NFC_NAME . '/' . self::NFC_NAME],
-			[self::NFD_NAME . '/' . self::NFC_NAME . '/' . self::NFD_NAME, self::NFC_NAME . '/' . self::NFC_NAME . '/' . self::NFC_NAME],
-		];
-	}
-
-	/**
-	 * @dataProvider encodedDirectoriesProvider
-	 */
-	public function testOperationInsideDirectory($sourceDir, $accessDir): void {
-		$this->sourceStorage->mkdir($sourceDir);
-		$this->instance->file_put_contents($accessDir . '/test.txt', 'bar');
-		$this->assertTrue($this->instance->file_exists($accessDir . '/test.txt'));
-		$this->assertEquals('bar', $this->instance->file_get_contents($accessDir . '/test.txt'));
-
-		$this->sourceStorage->file_put_contents($sourceDir . '/' . self::NFD_NAME, 'foo');
-		$this->assertTrue($this->instance->file_exists($accessDir . '/' . self::NFC_NAME));
-		$this->assertEquals('foo', $this->instance->file_get_contents($accessDir . '/' . self::NFC_NAME));
-
-		// try again to make it use cached path
-		$this->assertEquals('bar', $this->instance->file_get_contents($accessDir . '/test.txt'));
-		$this->assertTrue($this->instance->file_exists($accessDir . '/test.txt'));
-		$this->assertEquals('foo', $this->instance->file_get_contents($accessDir . '/' . self::NFC_NAME));
-		$this->assertTrue($this->instance->file_exists($accessDir . '/' . self::NFC_NAME));
-	}
-
-	public function testCacheExtraSlash(): void {
-		$this->sourceStorage->file_put_contents(self::NFD_NAME, 'foo');
-		$this->assertEquals(3, $this->instance->file_put_contents(self::NFC_NAME, 'bar'));
-		$this->assertEquals('bar', $this->instance->file_get_contents(self::NFC_NAME));
-		clearstatcache();
-		$this->assertEquals(5, $this->instance->file_put_contents('/' . self::NFC_NAME, 'baric'));
-		$this->assertEquals('baric', $this->instance->file_get_contents(self::NFC_NAME));
-		clearstatcache();
-		$this->assertEquals(8, $this->instance->file_put_contents('/' . self::NFC_NAME, 'barbaric'));
-		$this->assertEquals('barbaric', $this->instance->file_get_contents('//' . self::NFC_NAME));
-	}
-
-	public static function sourceAndTargetDirectoryProvider(): array {
-		return [
-			[self::NFC_NAME . '1', self::NFC_NAME . '2'],
-			[self::NFD_NAME . '1', self::NFC_NAME . '2'],
-			[self::NFC_NAME . '1', self::NFD_NAME . '2'],
-			[self::NFD_NAME . '1', self::NFD_NAME . '2'],
-		];
-	}
-
-	/**
-	 * @dataProvider sourceAndTargetDirectoryProvider
-	 */
-	public function testCopyAndMoveEncodedFolder($sourceDir, $targetDir): void {
-		$this->sourceStorage->mkdir($sourceDir);
-		$this->sourceStorage->mkdir($targetDir);
-		$this->sourceStorage->file_put_contents($sourceDir . '/test.txt', 'bar');
-		$this->assertTrue($this->instance->copy(self::NFC_NAME . '1/test.txt', self::NFC_NAME . '2/test.txt'));
-
-		$this->assertTrue($this->instance->file_exists(self::NFC_NAME . '1/test.txt'));
-		$this->assertTrue($this->instance->file_exists(self::NFC_NAME . '2/test.txt'));
-		$this->assertEquals('bar', $this->instance->file_get_contents(self::NFC_NAME . '2/test.txt'));
-
-		$this->assertTrue($this->instance->rename(self::NFC_NAME . '1/test.txt', self::NFC_NAME . '2/test2.txt'));
-		$this->assertFalse($this->instance->file_exists(self::NFC_NAME . '1/test.txt'));
-		$this->assertTrue($this->instance->file_exists(self::NFC_NAME . '2/test2.txt'));
-
-		$this->assertEquals('bar', $this->instance->file_get_contents(self::NFC_NAME . '2/test2.txt'));
-	}
-
-	/**
-	 * @dataProvider sourceAndTargetDirectoryProvider
-	 */
-	public function testCopyAndMoveFromStorageEncodedFolder($sourceDir, $targetDir): void {
-		$this->sourceStorage->mkdir($sourceDir);
-		$this->sourceStorage->mkdir($targetDir);
-		$this->sourceStorage->file_put_contents($sourceDir . '/test.txt', 'bar');
-		$this->assertTrue($this->instance->copyFromStorage($this->instance, self::NFC_NAME . '1/test.txt', self::NFC_NAME . '2/test.txt'));
-
-		$this->assertTrue($this->instance->file_exists(self::NFC_NAME . '1/test.txt'));
-		$this->assertTrue($this->instance->file_exists(self::NFC_NAME . '2/test.txt'));
-		$this->assertEquals('bar', $this->instance->file_get_contents(self::NFC_NAME . '2/test.txt'));
-
-		$this->assertTrue($this->instance->moveFromStorage($this->instance, self::NFC_NAME . '1/test.txt', self::NFC_NAME . '2/test2.txt'));
-		$this->assertFalse($this->instance->file_exists(self::NFC_NAME . '1/test.txt'));
-		$this->assertTrue($this->instance->file_exists(self::NFC_NAME . '2/test2.txt'));
-
-		$this->assertEquals('bar', $this->instance->file_get_contents(self::NFC_NAME . '2/test2.txt'));
-	}
-
-	public function testNormalizedDirectoryEntriesOpenDir(): void {
-		$this->sourceStorage->mkdir('/test');
-		$this->sourceStorage->mkdir('/test/' . self::NFD_NAME);
-
-		$this->assertTrue($this->instance->file_exists('/test/' . self::NFC_NAME));
-		$this->assertTrue($this->instance->file_exists('/test/' . self::NFD_NAME));
-
-		$dh = $this->instance->opendir('/test');
-		$content = [];
-		while (($file = readdir($dh)) !== false) {
-			if ($file != '.' and $file != '..') {
-				$content[] = $file;
-			}
-		}
-
-		$this->assertCount(1, $content);
-		$this->assertEquals(self::NFC_NAME, $content[0]);
-	}
-
-	public function testNormalizedDirectoryEntriesGetDirectoryContent(): void {
-		$this->sourceStorage->mkdir('/test');
-		$this->sourceStorage->mkdir('/test/' . self::NFD_NAME);
-
-		$this->assertTrue($this->instance->file_exists('/test/' . self::NFC_NAME));
-		$this->assertTrue($this->instance->file_exists('/test/' . self::NFD_NAME));
-
-		$content = iterator_to_array($this->instance->getDirectoryContent('/test'));
-		$this->assertCount(1, $content);
-		$this->assertEquals(self::NFC_NAME, $content[0]['name']);
-	}
-
-	public function testNormalizedGetMetaData(): void {
-		$this->sourceStorage->mkdir('/test');
-		$this->sourceStorage->mkdir('/test/' . self::NFD_NAME);
-
-		$entry = $this->instance->getMetaData('/test/' . self::NFC_NAME);
-		$this->assertEquals(self::NFC_NAME, $entry['name']);
-
-		$entry = $this->instance->getMetaData('/test/' . self::NFD_NAME);
-		$this->assertEquals(self::NFC_NAME, $entry['name']);
-	}
-
-	/**
-	 * Regression test of https://github.com/nextcloud/server/issues/50431
-	 */
-	public function testNoMetadata() {
-		$this->assertNull($this->instance->getMetaData('/test/null'));
-	}
+    public const NFD_NAME = 'ümlaut';
+    public const NFC_NAME = 'ümlaut';
+
+    /**
+     * @var \OC\Files\Storage\Temporary
+     */
+    private $sourceStorage;
+
+    protected function setUp(): void {
+        parent::setUp();
+        $this->sourceStorage = new \OC\Files\Storage\Temporary([]);
+        $this->instance = new \OC\Files\Storage\Wrapper\Encoding([
+            'storage' => $this->sourceStorage
+        ]);
+    }
+
+    protected function tearDown(): void {
+        $this->sourceStorage->cleanUp();
+        parent::tearDown();
+    }
+
+    public static function directoryProvider(): array {
+        $a = parent::directoryProvider();
+        $a[] = [self::NFC_NAME];
+        return $a;
+    }
+
+    public static function fileNameProvider(): array {
+        $a = parent::fileNameProvider();
+        $a[] = [self::NFD_NAME . '.txt'];
+        return $a;
+    }
+
+    public static function copyAndMoveProvider(): array {
+        $a = parent::copyAndMoveProvider();
+        $a[] = [self::NFD_NAME . '.txt', self::NFC_NAME . '-renamed.txt'];
+        return $a;
+    }
+
+    public static function accessNameProvider(): array {
+        return [
+            [self::NFD_NAME],
+            [self::NFC_NAME],
+        ];
+    }
+
+    /**
+     * @dataProvider accessNameProvider
+     */
+    public function testFputEncoding($accessName): void {
+        $this->sourceStorage->file_put_contents(self::NFD_NAME, 'bar');
+        $this->assertEquals('bar', $this->instance->file_get_contents($accessName));
+    }
+
+    /**
+     * @dataProvider accessNameProvider
+     */
+    public function testFopenReadEncoding($accessName): void {
+        $this->sourceStorage->file_put_contents(self::NFD_NAME, 'bar');
+        $fh = $this->instance->fopen($accessName, 'r');
+        $data = fgets($fh);
+        fclose($fh);
+        $this->assertEquals('bar', $data);
+    }
+
+    /**
+     * @dataProvider accessNameProvider
+     */
+    public function testFopenOverwriteEncoding($accessName): void {
+        $this->sourceStorage->file_put_contents(self::NFD_NAME, 'bar');
+        $fh = $this->instance->fopen($accessName, 'w');
+        $data = fputs($fh, 'test');
+        fclose($fh);
+        $data = $this->sourceStorage->file_get_contents(self::NFD_NAME);
+        $this->assertEquals('test', $data);
+        $this->assertFalse($this->sourceStorage->file_exists(self::NFC_NAME));
+    }
+
+    /**
+     * @dataProvider accessNameProvider
+     */
+    public function testFileExistsEncoding($accessName): void {
+        $this->sourceStorage->file_put_contents(self::NFD_NAME, 'bar');
+        $this->assertTrue($this->instance->file_exists($accessName));
+    }
+
+    /**
+     * @dataProvider accessNameProvider
+     */
+    public function testUnlinkEncoding($accessName): void {
+        $this->sourceStorage->file_put_contents(self::NFD_NAME, 'bar');
+        $this->assertTrue($this->instance->unlink($accessName));
+        $this->assertFalse($this->sourceStorage->file_exists(self::NFC_NAME));
+        $this->assertFalse($this->sourceStorage->file_exists(self::NFD_NAME));
+    }
+
+    public function testNfcHigherPriority(): void {
+        $this->sourceStorage->file_put_contents(self::NFC_NAME, 'nfc');
+        $this->sourceStorage->file_put_contents(self::NFD_NAME, 'nfd');
+        $this->assertEquals('nfc', $this->instance->file_get_contents(self::NFC_NAME));
+    }
+
+    public static function encodedDirectoriesProvider(): array {
+        return [
+            [self::NFD_NAME, self::NFC_NAME],
+            [self::NFD_NAME . '/' . self::NFD_NAME, self::NFC_NAME . '/' . self::NFC_NAME],
+            [self::NFD_NAME . '/' . self::NFC_NAME . '/' . self::NFD_NAME, self::NFC_NAME . '/' . self::NFC_NAME . '/' . self::NFC_NAME],
+        ];
+    }
+
+    /**
+     * @dataProvider encodedDirectoriesProvider
+     */
+    public function testOperationInsideDirectory($sourceDir, $accessDir): void {
+        $this->sourceStorage->mkdir($sourceDir);
+        $this->instance->file_put_contents($accessDir . '/test.txt', 'bar');
+        $this->assertTrue($this->instance->file_exists($accessDir . '/test.txt'));
+        $this->assertEquals('bar', $this->instance->file_get_contents($accessDir . '/test.txt'));
+
+        $this->sourceStorage->file_put_contents($sourceDir . '/' . self::NFD_NAME, 'foo');
+        $this->assertTrue($this->instance->file_exists($accessDir . '/' . self::NFC_NAME));
+        $this->assertEquals('foo', $this->instance->file_get_contents($accessDir . '/' . self::NFC_NAME));
+
+        // try again to make it use cached path
+        $this->assertEquals('bar', $this->instance->file_get_contents($accessDir . '/test.txt'));
+        $this->assertTrue($this->instance->file_exists($accessDir . '/test.txt'));
+        $this->assertEquals('foo', $this->instance->file_get_contents($accessDir . '/' . self::NFC_NAME));
+        $this->assertTrue($this->instance->file_exists($accessDir . '/' . self::NFC_NAME));
+    }
+
+    public function testCacheExtraSlash(): void {
+        $this->sourceStorage->file_put_contents(self::NFD_NAME, 'foo');
+        $this->assertEquals(3, $this->instance->file_put_contents(self::NFC_NAME, 'bar'));
+        $this->assertEquals('bar', $this->instance->file_get_contents(self::NFC_NAME));
+        clearstatcache();
+        $this->assertEquals(5, $this->instance->file_put_contents('/' . self::NFC_NAME, 'baric'));
+        $this->assertEquals('baric', $this->instance->file_get_contents(self::NFC_NAME));
+        clearstatcache();
+        $this->assertEquals(8, $this->instance->file_put_contents('/' . self::NFC_NAME, 'barbaric'));
+        $this->assertEquals('barbaric', $this->instance->file_get_contents('//' . self::NFC_NAME));
+    }
+
+    public static function sourceAndTargetDirectoryProvider(): array {
+        return [
+            [self::NFC_NAME . '1', self::NFC_NAME . '2'],
+            [self::NFD_NAME . '1', self::NFC_NAME . '2'],
+            [self::NFC_NAME . '1', self::NFD_NAME . '2'],
+            [self::NFD_NAME . '1', self::NFD_NAME . '2'],
+        ];
+    }
+
+    /**
+     * @dataProvider sourceAndTargetDirectoryProvider
+     */
+    public function testCopyAndMoveEncodedFolder($sourceDir, $targetDir): void {
+        $this->sourceStorage->mkdir($sourceDir);
+        $this->sourceStorage->mkdir($targetDir);
+        $this->sourceStorage->file_put_contents($sourceDir . '/test.txt', 'bar');
+        $this->assertTrue($this->instance->copy(self::NFC_NAME . '1/test.txt', self::NFC_NAME . '2/test.txt'));
+
+        $this->assertTrue($this->instance->file_exists(self::NFC_NAME . '1/test.txt'));
+        $this->assertTrue($this->instance->file_exists(self::NFC_NAME . '2/test.txt'));
+        $this->assertEquals('bar', $this->instance->file_get_contents(self::NFC_NAME . '2/test.txt'));
+
+        $this->assertTrue($this->instance->rename(self::NFC_NAME . '1/test.txt', self::NFC_NAME . '2/test2.txt'));
+        $this->assertFalse($this->instance->file_exists(self::NFC_NAME . '1/test.txt'));
+        $this->assertTrue($this->instance->file_exists(self::NFC_NAME . '2/test2.txt'));
+
+        $this->assertEquals('bar', $this->instance->file_get_contents(self::NFC_NAME . '2/test2.txt'));
+    }
+
+    /**
+     * @dataProvider sourceAndTargetDirectoryProvider
+     */
+    public function testCopyAndMoveFromStorageEncodedFolder($sourceDir, $targetDir): void {
+        $this->sourceStorage->mkdir($sourceDir);
+        $this->sourceStorage->mkdir($targetDir);
+        $this->sourceStorage->file_put_contents($sourceDir . '/test.txt', 'bar');
+        $this->assertTrue($this->instance->copyFromStorage($this->instance, self::NFC_NAME . '1/test.txt', self::NFC_NAME . '2/test.txt'));
+
+        $this->assertTrue($this->instance->file_exists(self::NFC_NAME . '1/test.txt'));
+        $this->assertTrue($this->instance->file_exists(self::NFC_NAME . '2/test.txt'));
+        $this->assertEquals('bar', $this->instance->file_get_contents(self::NFC_NAME . '2/test.txt'));
+
+        $this->assertTrue($this->instance->moveFromStorage($this->instance, self::NFC_NAME . '1/test.txt', self::NFC_NAME . '2/test2.txt'));
+        $this->assertFalse($this->instance->file_exists(self::NFC_NAME . '1/test.txt'));
+        $this->assertTrue($this->instance->file_exists(self::NFC_NAME . '2/test2.txt'));
+
+        $this->assertEquals('bar', $this->instance->file_get_contents(self::NFC_NAME . '2/test2.txt'));
+    }
+
+    public function testNormalizedDirectoryEntriesOpenDir(): void {
+        $this->sourceStorage->mkdir('/test');
+        $this->sourceStorage->mkdir('/test/' . self::NFD_NAME);
+
+        $this->assertTrue($this->instance->file_exists('/test/' . self::NFC_NAME));
+        $this->assertTrue($this->instance->file_exists('/test/' . self::NFD_NAME));
+
+        $dh = $this->instance->opendir('/test');
+        $content = [];
+        while (($file = readdir($dh)) !== false) {
+            if ($file != '.' and $file != '..') {
+                $content[] = $file;
+            }
+        }
+
+        $this->assertCount(1, $content);
+        $this->assertEquals(self::NFC_NAME, $content[0]);
+    }
+
+    public function testNormalizedDirectoryEntriesGetDirectoryContent(): void {
+        $this->sourceStorage->mkdir('/test');
+        $this->sourceStorage->mkdir('/test/' . self::NFD_NAME);
+
+        $this->assertTrue($this->instance->file_exists('/test/' . self::NFC_NAME));
+        $this->assertTrue($this->instance->file_exists('/test/' . self::NFD_NAME));
+
+        $content = iterator_to_array($this->instance->getDirectoryContent('/test'));
+        $this->assertCount(1, $content);
+        $this->assertEquals(self::NFC_NAME, $content[0]['name']);
+    }
+
+    public function testNormalizedGetMetaData(): void {
+        $this->sourceStorage->mkdir('/test');
+        $this->sourceStorage->mkdir('/test/' . self::NFD_NAME);
+
+        $entry = $this->instance->getMetaData('/test/' . self::NFC_NAME);
+        $this->assertEquals(self::NFC_NAME, $entry['name']);
+
+        $entry = $this->instance->getMetaData('/test/' . self::NFD_NAME);
+        $this->assertEquals(self::NFC_NAME, $entry['name']);
+    }
+
+    /**
+     * Regression test of https://github.com/nextcloud/server/issues/50431
+     */
+    public function testNoMetadata() {
+        $this->assertNull($this->instance->getMetaData('/test/null'));
+    }
 
 }

Spacing +48 added lines, -48 removed lines

@@ -37,13 +37,13 @@ 
 
 	public static function fileNameProvider(): array {
 		$a = parent::fileNameProvider();
-		$a[] = [self::NFD_NAME . '.txt'];
+		$a[] = [self::NFD_NAME.'.txt'];
 		return $a;
 	}
 
 	public static function copyAndMoveProvider(): array {
 		$a = parent::copyAndMoveProvider();
-		$a[] = [self::NFD_NAME . '.txt', self::NFC_NAME . '-renamed.txt'];
+		$a[] = [self::NFD_NAME.'.txt', self::NFC_NAME.'-renamed.txt'];
 		return $a;
 	}
 
@@ -113,8 +113,8 @@ 
 	public static function encodedDirectoriesProvider(): array {
 		return [
 			[self::NFD_NAME, self::NFC_NAME],
-			[self::NFD_NAME . '/' . self::NFD_NAME, self::NFC_NAME . '/' . self::NFC_NAME],
-			[self::NFD_NAME . '/' . self::NFC_NAME . '/' . self::NFD_NAME, self::NFC_NAME . '/' . self::NFC_NAME . '/' . self::NFC_NAME],
+			[self::NFD_NAME.'/'.self::NFD_NAME, self::NFC_NAME.'/'.self::NFC_NAME],
+			[self::NFD_NAME.'/'.self::NFC_NAME.'/'.self::NFD_NAME, self::NFC_NAME.'/'.self::NFC_NAME.'/'.self::NFC_NAME],
 		];
 	}
 
@@ -123,19 +123,19 @@ 
 	 */
 	public function testOperationInsideDirectory($sourceDir, $accessDir): void {
 		$this->sourceStorage->mkdir($sourceDir);
-		$this->instance->file_put_contents($accessDir . '/test.txt', 'bar');
-		$this->assertTrue($this->instance->file_exists($accessDir . '/test.txt'));
-		$this->assertEquals('bar', $this->instance->file_get_contents($accessDir . '/test.txt'));
+		$this->instance->file_put_contents($accessDir.'/test.txt', 'bar');
+		$this->assertTrue($this->instance->file_exists($accessDir.'/test.txt'));
+		$this->assertEquals('bar', $this->instance->file_get_contents($accessDir.'/test.txt'));
 
-		$this->sourceStorage->file_put_contents($sourceDir . '/' . self::NFD_NAME, 'foo');
-		$this->assertTrue($this->instance->file_exists($accessDir . '/' . self::NFC_NAME));
-		$this->assertEquals('foo', $this->instance->file_get_contents($accessDir . '/' . self::NFC_NAME));
+		$this->sourceStorage->file_put_contents($sourceDir.'/'.self::NFD_NAME, 'foo');
+		$this->assertTrue($this->instance->file_exists($accessDir.'/'.self::NFC_NAME));
+		$this->assertEquals('foo', $this->instance->file_get_contents($accessDir.'/'.self::NFC_NAME));
 
 		// try again to make it use cached path
-		$this->assertEquals('bar', $this->instance->file_get_contents($accessDir . '/test.txt'));
-		$this->assertTrue($this->instance->file_exists($accessDir . '/test.txt'));
-		$this->assertEquals('foo', $this->instance->file_get_contents($accessDir . '/' . self::NFC_NAME));
-		$this->assertTrue($this->instance->file_exists($accessDir . '/' . self::NFC_NAME));
+		$this->assertEquals('bar', $this->instance->file_get_contents($accessDir.'/test.txt'));
+		$this->assertTrue($this->instance->file_exists($accessDir.'/test.txt'));
+		$this->assertEquals('foo', $this->instance->file_get_contents($accessDir.'/'.self::NFC_NAME));
+		$this->assertTrue($this->instance->file_exists($accessDir.'/'.self::NFC_NAME));
 	}
 
 	public function testCacheExtraSlash(): void {
@@ -143,19 +143,19 @@ 
 		$this->assertEquals(3, $this->instance->file_put_contents(self::NFC_NAME, 'bar'));
 		$this->assertEquals('bar', $this->instance->file_get_contents(self::NFC_NAME));
 		clearstatcache();
-		$this->assertEquals(5, $this->instance->file_put_contents('/' . self::NFC_NAME, 'baric'));
+		$this->assertEquals(5, $this->instance->file_put_contents('/'.self::NFC_NAME, 'baric'));
 		$this->assertEquals('baric', $this->instance->file_get_contents(self::NFC_NAME));
 		clearstatcache();
-		$this->assertEquals(8, $this->instance->file_put_contents('/' . self::NFC_NAME, 'barbaric'));
-		$this->assertEquals('barbaric', $this->instance->file_get_contents('//' . self::NFC_NAME));
+		$this->assertEquals(8, $this->instance->file_put_contents('/'.self::NFC_NAME, 'barbaric'));
+		$this->assertEquals('barbaric', $this->instance->file_get_contents('//'.self::NFC_NAME));
 	}
 
 	public static function sourceAndTargetDirectoryProvider(): array {
 		return [
-			[self::NFC_NAME . '1', self::NFC_NAME . '2'],
-			[self::NFD_NAME . '1', self::NFC_NAME . '2'],
-			[self::NFC_NAME . '1', self::NFD_NAME . '2'],
-			[self::NFD_NAME . '1', self::NFD_NAME . '2'],
+			[self::NFC_NAME.'1', self::NFC_NAME.'2'],
+			[self::NFD_NAME.'1', self::NFC_NAME.'2'],
+			[self::NFC_NAME.'1', self::NFD_NAME.'2'],
+			[self::NFD_NAME.'1', self::NFD_NAME.'2'],
 		];
 	}
 
@@ -165,18 +165,18 @@ 
 	public function testCopyAndMoveEncodedFolder($sourceDir, $targetDir): void {
 		$this->sourceStorage->mkdir($sourceDir);
 		$this->sourceStorage->mkdir($targetDir);
-		$this->sourceStorage->file_put_contents($sourceDir . '/test.txt', 'bar');
-		$this->assertTrue($this->instance->copy(self::NFC_NAME . '1/test.txt', self::NFC_NAME . '2/test.txt'));
+		$this->sourceStorage->file_put_contents($sourceDir.'/test.txt', 'bar');
+		$this->assertTrue($this->instance->copy(self::NFC_NAME.'1/test.txt', self::NFC_NAME.'2/test.txt'));
 
-		$this->assertTrue($this->instance->file_exists(self::NFC_NAME . '1/test.txt'));
-		$this->assertTrue($this->instance->file_exists(self::NFC_NAME . '2/test.txt'));
-		$this->assertEquals('bar', $this->instance->file_get_contents(self::NFC_NAME . '2/test.txt'));
+		$this->assertTrue($this->instance->file_exists(self::NFC_NAME.'1/test.txt'));
+		$this->assertTrue($this->instance->file_exists(self::NFC_NAME.'2/test.txt'));
+		$this->assertEquals('bar', $this->instance->file_get_contents(self::NFC_NAME.'2/test.txt'));
 
-		$this->assertTrue($this->instance->rename(self::NFC_NAME . '1/test.txt', self::NFC_NAME . '2/test2.txt'));
-		$this->assertFalse($this->instance->file_exists(self::NFC_NAME . '1/test.txt'));
-		$this->assertTrue($this->instance->file_exists(self::NFC_NAME . '2/test2.txt'));
+		$this->assertTrue($this->instance->rename(self::NFC_NAME.'1/test.txt', self::NFC_NAME.'2/test2.txt'));
+		$this->assertFalse($this->instance->file_exists(self::NFC_NAME.'1/test.txt'));
+		$this->assertTrue($this->instance->file_exists(self::NFC_NAME.'2/test2.txt'));
 
-		$this->assertEquals('bar', $this->instance->file_get_contents(self::NFC_NAME . '2/test2.txt'));
+		$this->assertEquals('bar', $this->instance->file_get_contents(self::NFC_NAME.'2/test2.txt'));
 	}
 
 	/**
@@ -185,26 +185,26 @@ 
 	public function testCopyAndMoveFromStorageEncodedFolder($sourceDir, $targetDir): void {
 		$this->sourceStorage->mkdir($sourceDir);
 		$this->sourceStorage->mkdir($targetDir);
-		$this->sourceStorage->file_put_contents($sourceDir . '/test.txt', 'bar');
-		$this->assertTrue($this->instance->copyFromStorage($this->instance, self::NFC_NAME . '1/test.txt', self::NFC_NAME . '2/test.txt'));
+		$this->sourceStorage->file_put_contents($sourceDir.'/test.txt', 'bar');
+		$this->assertTrue($this->instance->copyFromStorage($this->instance, self::NFC_NAME.'1/test.txt', self::NFC_NAME.'2/test.txt'));
 
-		$this->assertTrue($this->instance->file_exists(self::NFC_NAME . '1/test.txt'));
-		$this->assertTrue($this->instance->file_exists(self::NFC_NAME . '2/test.txt'));
-		$this->assertEquals('bar', $this->instance->file_get_contents(self::NFC_NAME . '2/test.txt'));
+		$this->assertTrue($this->instance->file_exists(self::NFC_NAME.'1/test.txt'));
+		$this->assertTrue($this->instance->file_exists(self::NFC_NAME.'2/test.txt'));
+		$this->assertEquals('bar', $this->instance->file_get_contents(self::NFC_NAME.'2/test.txt'));
 
-		$this->assertTrue($this->instance->moveFromStorage($this->instance, self::NFC_NAME . '1/test.txt', self::NFC_NAME . '2/test2.txt'));
-		$this->assertFalse($this->instance->file_exists(self::NFC_NAME . '1/test.txt'));
-		$this->assertTrue($this->instance->file_exists(self::NFC_NAME . '2/test2.txt'));
+		$this->assertTrue($this->instance->moveFromStorage($this->instance, self::NFC_NAME.'1/test.txt', self::NFC_NAME.'2/test2.txt'));
+		$this->assertFalse($this->instance->file_exists(self::NFC_NAME.'1/test.txt'));
+		$this->assertTrue($this->instance->file_exists(self::NFC_NAME.'2/test2.txt'));
 
-		$this->assertEquals('bar', $this->instance->file_get_contents(self::NFC_NAME . '2/test2.txt'));
+		$this->assertEquals('bar', $this->instance->file_get_contents(self::NFC_NAME.'2/test2.txt'));
 	}
 
 	public function testNormalizedDirectoryEntriesOpenDir(): void {
 		$this->sourceStorage->mkdir('/test');
-		$this->sourceStorage->mkdir('/test/' . self::NFD_NAME);
+		$this->sourceStorage->mkdir('/test/'.self::NFD_NAME);
 
-		$this->assertTrue($this->instance->file_exists('/test/' . self::NFC_NAME));
-		$this->assertTrue($this->instance->file_exists('/test/' . self::NFD_NAME));
+		$this->assertTrue($this->instance->file_exists('/test/'.self::NFC_NAME));
+		$this->assertTrue($this->instance->file_exists('/test/'.self::NFD_NAME));
 
 		$dh = $this->instance->opendir('/test');
 		$content = [];
@@ -220,10 +220,10 @@ 
 
 	public function testNormalizedDirectoryEntriesGetDirectoryContent(): void {
 		$this->sourceStorage->mkdir('/test');
-		$this->sourceStorage->mkdir('/test/' . self::NFD_NAME);
+		$this->sourceStorage->mkdir('/test/'.self::NFD_NAME);
 
-		$this->assertTrue($this->instance->file_exists('/test/' . self::NFC_NAME));
-		$this->assertTrue($this->instance->file_exists('/test/' . self::NFD_NAME));
+		$this->assertTrue($this->instance->file_exists('/test/'.self::NFC_NAME));
+		$this->assertTrue($this->instance->file_exists('/test/'.self::NFD_NAME));
 
 		$content = iterator_to_array($this->instance->getDirectoryContent('/test'));
 		$this->assertCount(1, $content);
@@ -232,12 +232,12 @@ 
 
 	public function testNormalizedGetMetaData(): void {
 		$this->sourceStorage->mkdir('/test');
-		$this->sourceStorage->mkdir('/test/' . self::NFD_NAME);
+		$this->sourceStorage->mkdir('/test/'.self::NFD_NAME);
 
-		$entry = $this->instance->getMetaData('/test/' . self::NFC_NAME);
+		$entry = $this->instance->getMetaData('/test/'.self::NFC_NAME);
 		$this->assertEquals(self::NFC_NAME, $entry['name']);
 
-		$entry = $this->instance->getMetaData('/test/' . self::NFD_NAME);
+		$entry = $this->instance->getMetaData('/test/'.self::NFD_NAME);
 		$this->assertEquals(self::NFC_NAME, $entry['name']);
 	}
 

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

Indentation +992 added lines, -992 removed lines

@@ -33,996 +33,996 @@
 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::class)
-			->disableOriginalConstructor()
-			->onlyMethods(['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(Util::class)
-			->onlyMethods(['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(File::class)
-			->disableOriginalConstructor()
-			->onlyMethods(['getAccessList'])
-			->getMock();
-		$this->file->expects($this->any())->method('getAccessList')->willReturn([]);
-
-		$this->logger = $this->createMock(LoggerInterface::class);
-
-		$this->sourceStorage = new Temporary([]);
-
-		$this->keyStore = $this->createMock(\OC\Encryption\Keys\Storage::class);
-
-		$this->mount = $this->getMockBuilder(MountPoint::class)
-			->disableOriginalConstructor()
-			->onlyMethods(['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
-				]
-			)
-			->onlyMethods(['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()
-			->onlyMethods(['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,
-				]
-			)
-			->onlyMethods(['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 static function dataTestGetMetaData(): array {
-		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,
-				]
-			)
-			->onlyMethods(['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,
-				]
-			)
-			->onlyMethods(['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 static function dataTestVerifyUnencryptedSize(): array {
-		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 static function dataTestCopyAndRename(): array {
-		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 static function dataTestRmdir(): array {
-		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 static function dataTestCopyKeys(): array {
-		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,
-				]
-			)
-			->onlyMethods(['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 static function dataTestGetHeader(): array {
-		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::class)
-			->disableOriginalConstructor()->getMock();
-
-		$sourceStorage->expects($this->once())
-			->method('is_file')
-			->with('test.txt')
-			->willReturn($strippedPathExists);
-
-		$util = $this->getMockBuilder(Util::class)
-			->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->createMock(Cache::class);
-		$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,
-				]
-			)
-			->onlyMethods(['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 static function dataTestGetHeaderAddLegacyModule(): array {
-		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 static function dataCopyBetweenStorage(): array {
-		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
-				]
-			)
-			->onlyMethods(['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 static function dataTestCopyBetweenStorageVersions(): array {
-		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 static function dataTestIsVersion(): array {
-		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
-				]
-			)
-			->onlyMethods(['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 static function dataTestShouldEncrypt(): array {
-		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::class)
+            ->disableOriginalConstructor()
+            ->onlyMethods(['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(Util::class)
+            ->onlyMethods(['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(File::class)
+            ->disableOriginalConstructor()
+            ->onlyMethods(['getAccessList'])
+            ->getMock();
+        $this->file->expects($this->any())->method('getAccessList')->willReturn([]);
+
+        $this->logger = $this->createMock(LoggerInterface::class);
+
+        $this->sourceStorage = new Temporary([]);
+
+        $this->keyStore = $this->createMock(\OC\Encryption\Keys\Storage::class);
+
+        $this->mount = $this->getMockBuilder(MountPoint::class)
+            ->disableOriginalConstructor()
+            ->onlyMethods(['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
+                ]
+            )
+            ->onlyMethods(['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()
+            ->onlyMethods(['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,
+                ]
+            )
+            ->onlyMethods(['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 static function dataTestGetMetaData(): array {
+        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,
+                ]
+            )
+            ->onlyMethods(['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,
+                ]
+            )
+            ->onlyMethods(['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 static function dataTestVerifyUnencryptedSize(): array {
+        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 static function dataTestCopyAndRename(): array {
+        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 static function dataTestRmdir(): array {
+        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 static function dataTestCopyKeys(): array {
+        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,
+                ]
+            )
+            ->onlyMethods(['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 static function dataTestGetHeader(): array {
+        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::class)
+            ->disableOriginalConstructor()->getMock();
+
+        $sourceStorage->expects($this->once())
+            ->method('is_file')
+            ->with('test.txt')
+            ->willReturn($strippedPathExists);
+
+        $util = $this->getMockBuilder(Util::class)
+            ->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->createMock(Cache::class);
+        $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,
+                ]
+            )
+            ->onlyMethods(['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 static function dataTestGetHeaderAddLegacyModule(): array {
+        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 static function dataCopyBetweenStorage(): array {
+        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
+                ]
+            )
+            ->onlyMethods(['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 static function dataTestCopyBetweenStorageVersions(): array {
+        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 static function dataTestIsVersion(): array {
+        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
+                ]
+            )
+            ->onlyMethods(['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 static function dataTestShouldEncrypt(): array {
+        return [
+            [false, false, false, false],
+            [true, false, false, false],
+            [true, true, false, false],
+            [true, true, true, true],
+            [true, null, false, true],
+        ];
+    }
 }

Spacing +17 added lines, -17 removed lines

@@ -87,12 +87,12 @@ 
 			->getMock();
 		$this->util->expects($this->any())
 			->method('getUidAndFilename')
-			->willReturnCallback(function ($path) {
+			->willReturnCallback(function($path) {
 				return ['user1', $path];
 			});
 		$this->util->expects($this->any())
 			->method('stripPartialFileExtension')
-			->willReturnCallback(function ($path) {
+			->willReturnCallback(function($path) {
 				return $path;
 			});
 
@@ -112,7 +112,7 @@ 
 			->disableOriginalConstructor()
 			->onlyMethods(['getOption'])
 			->getMock();
-		$this->mount->expects($this->any())->method('getOption')->willReturnCallback(function ($option, $default) {
+		$this->mount->expects($this->any())->method('getOption')->willReturnCallback(function($option, $default) {
 			if ($option === 'encrypt' && $default === true) {
 				global $mockedMountPointEncryptionEnabled;
 				if ($mockedMountPointEncryptionEnabled !== null) {
@@ -126,7 +126,7 @@ 
 			->disableOriginalConstructor()->getMock();
 		$this->cache->expects($this->any())
 			->method('get')
-			->willReturnCallback(function ($path) {
+			->willReturnCallback(function($path) {
 				return ['encrypted' => false, 'path' => $path];
 			});
 
@@ -158,7 +158,7 @@ 
 
 		$this->instance->expects($this->any())
 			->method('getMetaData')
-			->willReturnCallback(function ($path) {
+			->willReturnCallback(function($path) {
 				return ['encrypted' => true, 'size' => $this->dummySize, 'path' => $path];
 			});
 
@@ -210,7 +210,7 @@ 
 		$cache->expects($this->any())
 			->method('get')
 			->willReturnCallback(
-				function ($path) use ($encrypted) {
+				function($path) use ($encrypted) {
 					return new CacheEntry(['encrypted' => $encrypted, 'path' => $path, 'size' => 0, 'fileid' => 1]);
 				}
 			);
@@ -263,7 +263,7 @@ 
 
 		$result = $this->instance->getMetaData($path);
 		if (isset($expected['encrypted'])) {
-			$this->assertSame($expected['encrypted'], (bool)$result['encrypted']);
+			$this->assertSame($expected['encrypted'], (bool) $result['encrypted']);
 
 			if (isset($expected['encryptedVersion'])) {
 				$this->assertSame($expected['encryptedVersion'], $result['encryptedVersion']);
@@ -364,7 +364,7 @@ 
 		$this->instance->expects($this->any())->method('fixUnencryptedSize')
 			->with('/test.txt', $encryptedSize, $unencryptedSize)
 			->willReturnCallback(
-				function () use ($failure, $expected) {
+				function() use ($failure, $expected) {
 					if ($failure) {
 						throw new Exception();
 					} else {
@@ -487,7 +487,7 @@ 
 
 
 		if ($rmdirResult === true && $isExcluded === false && $encryptionEnabled === true) {
-			$this->keyStore->expects($this->once())->method('deleteAllFileKeys')->with('/mountPoint' . $path);
+			$this->keyStore->expects($this->once())->method('deleteAllFileKeys')->with('/mountPoint'.$path);
 		} else {
 			$this->keyStore->expects($this->never())->method('deleteAllFileKeys');
 		}
@@ -568,7 +568,7 @@ 
 			->disableOriginalConstructor()->getMock();
 		$cache->expects($this->any())
 			->method('get')
-			->willReturnCallback(function ($path) {
+			->willReturnCallback(function($path) {
 				return ['encrypted' => true, 'path' => $path];
 			});
 
@@ -653,14 +653,14 @@ 
 			->getMock();
 		$util->expects($this->any())
 			->method('stripPartialFileExtension')
-			->willReturnCallback(function ($path) {
+			->willReturnCallback(function($path) {
 				return $path;
 			});
 
 		$cache = $this->createMock(Cache::class);
 		$cache->expects($this->any())
 			->method('get')
-			->willReturnCallback(function ($path) use ($isEncrypted) {
+			->willReturnCallback(function($path) use ($isEncrypted) {
 				return ['encrypted' => $isEncrypted, 'path' => $path];
 			});
 
@@ -725,7 +725,7 @@ 
 
 		$storage2->expects($this->any())
 			->method('fopen')
-			->willReturnCallback(function ($path, $mode) {
+			->willReturnCallback(function($path, $mode) {
 				$temp = OC::$server->getTempManager();
 				return fopen($temp->getTemporaryFile(), $mode);
 			});
@@ -774,7 +774,7 @@ 
 
 		$storage2->expects($this->any())
 			->method('fopen')
-			->willReturnCallback(function ($path, $mode) {
+			->willReturnCallback(function($path, $mode) {
 				$temp = OC::$server->getTempManager();
 				return fopen($temp->getTemporaryFile(), $mode);
 			});
@@ -868,7 +868,7 @@ 
 			->willReturn($cache);
 
 		$this->arrayCache->expects($this->once())->method('set')
-			->with('encryption_copy_version_' . $sourceInternalPath, true);
+			->with('encryption_copy_version_'.$sourceInternalPath, true);
 
 		if ($copyResult) {
 			$cache->expects($this->once())->method('get')
@@ -876,7 +876,7 @@ 
 				->willReturn(new CacheEntry(['encrypted' => $encrypted, 'size' => 42]));
 			if ($encrypted) {
 				$instance->expects($this->once())->method('updateUnencryptedSize')
-					->with($mountPoint . $targetInternalPath, 42);
+					->with($mountPoint.$targetInternalPath, 42);
 			} else {
 				$instance->expects($this->never())->method('updateUnencryptedSize');
 			}
@@ -987,7 +987,7 @@ 
 			->method('getEncryptionModule')
 			->with($fullPath)
 			->willReturnCallback(
-				function () use ($encryptionModule) {
+				function() use ($encryptionModule) {
 					if ($encryptionModule === false) {
 						throw new ModuleDoesNotExistsException();
 					}

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

Indentation +205 added lines, -205 removed lines

@@ -21,209 +21,209 @@
  * @package Test\Files\Storage\Wrapper
  */
 class QuotaTest extends \Test\Files\Storage\Storage {
-	/**
-	 * @var string tmpDir
-	 */
-	private $tmpDir;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->tmpDir = \OC::$server->getTempManager()->getTemporaryFolder();
-		$storage = new \OC\Files\Storage\Local(['datadir' => $this->tmpDir]);
-		$this->instance = new \OC\Files\Storage\Wrapper\Quota(['storage' => $storage, 'quota' => 10000000]);
-	}
-
-	protected function tearDown(): void {
-		\OC_Helper::rmdirr($this->tmpDir);
-		parent::tearDown();
-	}
-
-	/**
-	 * @param integer $limit
-	 */
-	protected function getLimitedStorage($limit) {
-		$storage = new \OC\Files\Storage\Local(['datadir' => $this->tmpDir]);
-		$storage->mkdir('files');
-		$storage->getScanner()->scan('');
-		return new \OC\Files\Storage\Wrapper\Quota(['storage' => $storage, 'quota' => $limit]);
-	}
-
-	public function testFilePutContentsNotEnoughSpace(): void {
-		$instance = $this->getLimitedStorage(3);
-		$this->assertFalse($instance->file_put_contents('files/foo', 'foobar'));
-	}
-
-	public function testCopyNotEnoughSpace(): void {
-		$instance = $this->getLimitedStorage(9);
-		$this->assertEquals(6, $instance->file_put_contents('files/foo', 'foobar'));
-		$instance->getScanner()->scan('');
-		$this->assertFalse($instance->copy('files/foo', 'files/bar'));
-	}
-
-	public function testFreeSpace(): void {
-		$instance = $this->getLimitedStorage(9);
-		$this->assertEquals(9, $instance->free_space(''));
-	}
-
-	public function testFreeSpaceWithUsedSpace(): void {
-		$instance = $this->getLimitedStorage(9);
-		$instance->getCache()->put(
-			'', ['size' => 3]
-		);
-		$this->assertEquals(6, $instance->free_space(''));
-	}
-
-	public function testFreeSpaceWithUnknownDiskSpace(): void {
-		$storage = $this->getMockBuilder(Local::class)
-			->onlyMethods(['free_space'])
-			->setConstructorArgs([['datadir' => $this->tmpDir]])
-			->getMock();
-		$storage->expects($this->any())
-			->method('free_space')
-			->willReturn(-2);
-		$storage->getScanner()->scan('');
-
-		$instance = new \OC\Files\Storage\Wrapper\Quota(['storage' => $storage, 'quota' => 9]);
-		$instance->getCache()->put(
-			'', ['size' => 3]
-		);
-		$this->assertEquals(6, $instance->free_space(''));
-	}
-
-	public function testFreeSpaceWithUsedSpaceAndEncryption(): void {
-		$instance = $this->getLimitedStorage(9);
-		$instance->getCache()->put(
-			'', ['size' => 7]
-		);
-		$this->assertEquals(2, $instance->free_space(''));
-	}
-
-	public function testFWriteNotEnoughSpace(): void {
-		$instance = $this->getLimitedStorage(9);
-		$stream = $instance->fopen('files/foo', 'w+');
-		$this->assertEquals(6, fwrite($stream, 'foobar'));
-		$this->assertEquals(3, fwrite($stream, 'qwerty'));
-		fclose($stream);
-		$this->assertEquals('foobarqwe', $instance->file_get_contents('files/foo'));
-	}
-
-	public function testStreamCopyWithEnoughSpace(): void {
-		$instance = $this->getLimitedStorage(16);
-		$inputStream = fopen('data://text/plain,foobarqwerty', 'r');
-		$outputStream = $instance->fopen('files/foo', 'w+');
-		[$count, $result] = \OC_Helper::streamCopy($inputStream, $outputStream);
-		$this->assertEquals(12, $count);
-		$this->assertTrue($result);
-		fclose($inputStream);
-		fclose($outputStream);
-	}
-
-	public function testStreamCopyNotEnoughSpace(): void {
-		$instance = $this->getLimitedStorage(9);
-		$inputStream = fopen('data://text/plain,foobarqwerty', 'r');
-		$outputStream = $instance->fopen('files/foo', 'w+');
-		[$count, $result] = \OC_Helper::streamCopy($inputStream, $outputStream);
-		$this->assertEquals(9, $count);
-		$this->assertFalse($result);
-		fclose($inputStream);
-		fclose($outputStream);
-	}
-
-	public function testReturnFalseWhenFopenFailed(): void {
-		$failStorage = $this->getMockBuilder(Local::class)
-			->onlyMethods(['fopen'])
-			->setConstructorArgs([['datadir' => $this->tmpDir]])
-			->getMock();
-		$failStorage->expects($this->any())
-			->method('fopen')
-			->willReturn(false);
-
-		$instance = new \OC\Files\Storage\Wrapper\Quota(['storage' => $failStorage, 'quota' => 1000]);
-
-		$this->assertFalse($instance->fopen('failedfopen', 'r'));
-	}
-
-	public function testReturnRegularStreamOnRead(): void {
-		$instance = $this->getLimitedStorage(9);
-
-		// create test file first
-		$stream = $instance->fopen('files/foo', 'w+');
-		fwrite($stream, 'blablacontent');
-		fclose($stream);
-
-		$stream = $instance->fopen('files/foo', 'r');
-		$meta = stream_get_meta_data($stream);
-		$this->assertEquals('plainfile', $meta['wrapper_type']);
-		fclose($stream);
-
-		$stream = $instance->fopen('files/foo', 'rb');
-		$meta = stream_get_meta_data($stream);
-		$this->assertEquals('plainfile', $meta['wrapper_type']);
-		fclose($stream);
-	}
-
-	public function testReturnRegularStreamWhenOutsideFiles(): void {
-		$instance = $this->getLimitedStorage(9);
-		$instance->mkdir('files_other');
-
-		// create test file first
-		$stream = $instance->fopen('files_other/foo', 'w+');
-		$meta = stream_get_meta_data($stream);
-		$this->assertEquals('plainfile', $meta['wrapper_type']);
-		fclose($stream);
-	}
-
-	public function testReturnQuotaStreamOnWrite(): void {
-		$instance = $this->getLimitedStorage(9);
-		$stream = $instance->fopen('files/foo', 'w+');
-		$meta = stream_get_meta_data($stream);
-		$expected_type = 'user-space';
-		$this->assertEquals($expected_type, $meta['wrapper_type']);
-		fclose($stream);
-	}
-
-	public function testSpaceRoot(): void {
-		$storage = $this->getMockBuilder(Local::class)->disableOriginalConstructor()->getMock();
-		$cache = $this->getMockBuilder('\OC\Files\Cache\Cache')->disableOriginalConstructor()->getMock();
-		$storage->expects($this->once())
-			->method('getCache')
-			->willReturn($cache);
-		$storage->expects($this->once())
-			->method('free_space')
-			->willReturn(2048);
-		$cache->expects($this->once())
-			->method('get')
-			->with('files')
-			->willReturn(new CacheEntry(['size' => 50]));
-
-		$instance = new \OC\Files\Storage\Wrapper\Quota(['storage' => $storage, 'quota' => 1024, 'root' => 'files']);
-
-		$this->assertEquals(1024 - 50, $instance->free_space(''));
-	}
-
-	public function testInstanceOfStorageWrapper(): void {
-		$this->assertTrue($this->instance->instanceOfStorage('\OC\Files\Storage\Local'));
-		$this->assertTrue($this->instance->instanceOfStorage('\OC\Files\Storage\Wrapper\Wrapper'));
-		$this->assertTrue($this->instance->instanceOfStorage('\OC\Files\Storage\Wrapper\Quota'));
-	}
-
-	public function testNoMkdirQuotaZero(): void {
-		$instance = $this->getLimitedStorage(0.0);
-		$this->assertFalse($instance->mkdir('files'));
-		$this->assertFalse($instance->mkdir('files/foobar'));
-	}
-
-	public function testMkdirQuotaZeroTrashbin(): void {
-		$instance = $this->getLimitedStorage(0.0);
-		$this->assertTrue($instance->mkdir('files_trashbin'));
-		$this->assertTrue($instance->mkdir('files_trashbin/files'));
-		$this->assertTrue($instance->mkdir('files_versions'));
-		$this->assertTrue($instance->mkdir('cache'));
-	}
-
-	public function testNoTouchQuotaZero(): void {
-		$instance = $this->getLimitedStorage(0.0);
-		$this->assertFalse($instance->touch('foobar'));
-	}
+    /**
+     * @var string tmpDir
+     */
+    private $tmpDir;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->tmpDir = \OC::$server->getTempManager()->getTemporaryFolder();
+        $storage = new \OC\Files\Storage\Local(['datadir' => $this->tmpDir]);
+        $this->instance = new \OC\Files\Storage\Wrapper\Quota(['storage' => $storage, 'quota' => 10000000]);
+    }
+
+    protected function tearDown(): void {
+        \OC_Helper::rmdirr($this->tmpDir);
+        parent::tearDown();
+    }
+
+    /**
+     * @param integer $limit
+     */
+    protected function getLimitedStorage($limit) {
+        $storage = new \OC\Files\Storage\Local(['datadir' => $this->tmpDir]);
+        $storage->mkdir('files');
+        $storage->getScanner()->scan('');
+        return new \OC\Files\Storage\Wrapper\Quota(['storage' => $storage, 'quota' => $limit]);
+    }
+
+    public function testFilePutContentsNotEnoughSpace(): void {
+        $instance = $this->getLimitedStorage(3);
+        $this->assertFalse($instance->file_put_contents('files/foo', 'foobar'));
+    }
+
+    public function testCopyNotEnoughSpace(): void {
+        $instance = $this->getLimitedStorage(9);
+        $this->assertEquals(6, $instance->file_put_contents('files/foo', 'foobar'));
+        $instance->getScanner()->scan('');
+        $this->assertFalse($instance->copy('files/foo', 'files/bar'));
+    }
+
+    public function testFreeSpace(): void {
+        $instance = $this->getLimitedStorage(9);
+        $this->assertEquals(9, $instance->free_space(''));
+    }
+
+    public function testFreeSpaceWithUsedSpace(): void {
+        $instance = $this->getLimitedStorage(9);
+        $instance->getCache()->put(
+            '', ['size' => 3]
+        );
+        $this->assertEquals(6, $instance->free_space(''));
+    }
+
+    public function testFreeSpaceWithUnknownDiskSpace(): void {
+        $storage = $this->getMockBuilder(Local::class)
+            ->onlyMethods(['free_space'])
+            ->setConstructorArgs([['datadir' => $this->tmpDir]])
+            ->getMock();
+        $storage->expects($this->any())
+            ->method('free_space')
+            ->willReturn(-2);
+        $storage->getScanner()->scan('');
+
+        $instance = new \OC\Files\Storage\Wrapper\Quota(['storage' => $storage, 'quota' => 9]);
+        $instance->getCache()->put(
+            '', ['size' => 3]
+        );
+        $this->assertEquals(6, $instance->free_space(''));
+    }
+
+    public function testFreeSpaceWithUsedSpaceAndEncryption(): void {
+        $instance = $this->getLimitedStorage(9);
+        $instance->getCache()->put(
+            '', ['size' => 7]
+        );
+        $this->assertEquals(2, $instance->free_space(''));
+    }
+
+    public function testFWriteNotEnoughSpace(): void {
+        $instance = $this->getLimitedStorage(9);
+        $stream = $instance->fopen('files/foo', 'w+');
+        $this->assertEquals(6, fwrite($stream, 'foobar'));
+        $this->assertEquals(3, fwrite($stream, 'qwerty'));
+        fclose($stream);
+        $this->assertEquals('foobarqwe', $instance->file_get_contents('files/foo'));
+    }
+
+    public function testStreamCopyWithEnoughSpace(): void {
+        $instance = $this->getLimitedStorage(16);
+        $inputStream = fopen('data://text/plain,foobarqwerty', 'r');
+        $outputStream = $instance->fopen('files/foo', 'w+');
+        [$count, $result] = \OC_Helper::streamCopy($inputStream, $outputStream);
+        $this->assertEquals(12, $count);
+        $this->assertTrue($result);
+        fclose($inputStream);
+        fclose($outputStream);
+    }
+
+    public function testStreamCopyNotEnoughSpace(): void {
+        $instance = $this->getLimitedStorage(9);
+        $inputStream = fopen('data://text/plain,foobarqwerty', 'r');
+        $outputStream = $instance->fopen('files/foo', 'w+');
+        [$count, $result] = \OC_Helper::streamCopy($inputStream, $outputStream);
+        $this->assertEquals(9, $count);
+        $this->assertFalse($result);
+        fclose($inputStream);
+        fclose($outputStream);
+    }
+
+    public function testReturnFalseWhenFopenFailed(): void {
+        $failStorage = $this->getMockBuilder(Local::class)
+            ->onlyMethods(['fopen'])
+            ->setConstructorArgs([['datadir' => $this->tmpDir]])
+            ->getMock();
+        $failStorage->expects($this->any())
+            ->method('fopen')
+            ->willReturn(false);
+
+        $instance = new \OC\Files\Storage\Wrapper\Quota(['storage' => $failStorage, 'quota' => 1000]);
+
+        $this->assertFalse($instance->fopen('failedfopen', 'r'));
+    }
+
+    public function testReturnRegularStreamOnRead(): void {
+        $instance = $this->getLimitedStorage(9);
+
+        // create test file first
+        $stream = $instance->fopen('files/foo', 'w+');
+        fwrite($stream, 'blablacontent');
+        fclose($stream);
+
+        $stream = $instance->fopen('files/foo', 'r');
+        $meta = stream_get_meta_data($stream);
+        $this->assertEquals('plainfile', $meta['wrapper_type']);
+        fclose($stream);
+
+        $stream = $instance->fopen('files/foo', 'rb');
+        $meta = stream_get_meta_data($stream);
+        $this->assertEquals('plainfile', $meta['wrapper_type']);
+        fclose($stream);
+    }
+
+    public function testReturnRegularStreamWhenOutsideFiles(): void {
+        $instance = $this->getLimitedStorage(9);
+        $instance->mkdir('files_other');
+
+        // create test file first
+        $stream = $instance->fopen('files_other/foo', 'w+');
+        $meta = stream_get_meta_data($stream);
+        $this->assertEquals('plainfile', $meta['wrapper_type']);
+        fclose($stream);
+    }
+
+    public function testReturnQuotaStreamOnWrite(): void {
+        $instance = $this->getLimitedStorage(9);
+        $stream = $instance->fopen('files/foo', 'w+');
+        $meta = stream_get_meta_data($stream);
+        $expected_type = 'user-space';
+        $this->assertEquals($expected_type, $meta['wrapper_type']);
+        fclose($stream);
+    }
+
+    public function testSpaceRoot(): void {
+        $storage = $this->getMockBuilder(Local::class)->disableOriginalConstructor()->getMock();
+        $cache = $this->getMockBuilder('\OC\Files\Cache\Cache')->disableOriginalConstructor()->getMock();
+        $storage->expects($this->once())
+            ->method('getCache')
+            ->willReturn($cache);
+        $storage->expects($this->once())
+            ->method('free_space')
+            ->willReturn(2048);
+        $cache->expects($this->once())
+            ->method('get')
+            ->with('files')
+            ->willReturn(new CacheEntry(['size' => 50]));
+
+        $instance = new \OC\Files\Storage\Wrapper\Quota(['storage' => $storage, 'quota' => 1024, 'root' => 'files']);
+
+        $this->assertEquals(1024 - 50, $instance->free_space(''));
+    }
+
+    public function testInstanceOfStorageWrapper(): void {
+        $this->assertTrue($this->instance->instanceOfStorage('\OC\Files\Storage\Local'));
+        $this->assertTrue($this->instance->instanceOfStorage('\OC\Files\Storage\Wrapper\Wrapper'));
+        $this->assertTrue($this->instance->instanceOfStorage('\OC\Files\Storage\Wrapper\Quota'));
+    }
+
+    public function testNoMkdirQuotaZero(): void {
+        $instance = $this->getLimitedStorage(0.0);
+        $this->assertFalse($instance->mkdir('files'));
+        $this->assertFalse($instance->mkdir('files/foobar'));
+    }
+
+    public function testMkdirQuotaZeroTrashbin(): void {
+        $instance = $this->getLimitedStorage(0.0);
+        $this->assertTrue($instance->mkdir('files_trashbin'));
+        $this->assertTrue($instance->mkdir('files_trashbin/files'));
+        $this->assertTrue($instance->mkdir('files_versions'));
+        $this->assertTrue($instance->mkdir('cache'));
+    }
+
+    public function testNoTouchQuotaZero(): void {
+        $instance = $this->getLimitedStorage(0.0);
+        $this->assertFalse($instance->touch('foobar'));
+    }
 }

tests/lib/Files/Config/UserMountCacheTest.php

Indentation +397 added lines, -397 removed lines

@@ -30,519 +30,519 @@
  * @group DB
  */
 class UserMountCacheTest extends TestCase {
-	/**
-	 * @var IDBConnection
-	 */
-	private $connection;
-
-	/**
-	 * @var IUserManager
-	 */
-	private $userManager;
-
-	/**
-	 * @var \OC\Files\Config\UserMountCache
-	 */
-	private $cache;
-
-	private $fileIds = [];
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->fileIds = [];
-		$this->connection = \OC::$server->getDatabaseConnection();
-		$config = $this->getMockBuilder(IConfig::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$config
-			->expects($this->any())
-			->method('getUserValue')
-			->willReturnArgument(3);
-		$config
-			->expects($this->any())
-			->method('getAppValue')
-			->willReturnArgument(2);
-		$this->userManager = new Manager($config, $this->createMock(ICacheFactory::class), $this->createMock(IEventDispatcher::class), $this->createMock(LoggerInterface::class));
-		$userBackend = new Dummy();
-		$userBackend->createUser('u1', '');
-		$userBackend->createUser('u2', '');
-		$userBackend->createUser('u3', '');
-		$this->userManager->registerBackend($userBackend);
-		$this->cache = new \OC\Files\Config\UserMountCache($this->connection, $this->userManager, $this->createMock(LoggerInterface::class), $this->createMock(IEventLogger::class));
-	}
-
-	protected function tearDown(): void {
-		$builder = $this->connection->getQueryBuilder();
-
-		$builder->delete('mounts')->execute();
+    /**
+     * @var IDBConnection
+     */
+    private $connection;
+
+    /**
+     * @var IUserManager
+     */
+    private $userManager;
+
+    /**
+     * @var \OC\Files\Config\UserMountCache
+     */
+    private $cache;
+
+    private $fileIds = [];
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->fileIds = [];
+        $this->connection = \OC::$server->getDatabaseConnection();
+        $config = $this->getMockBuilder(IConfig::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $config
+            ->expects($this->any())
+            ->method('getUserValue')
+            ->willReturnArgument(3);
+        $config
+            ->expects($this->any())
+            ->method('getAppValue')
+            ->willReturnArgument(2);
+        $this->userManager = new Manager($config, $this->createMock(ICacheFactory::class), $this->createMock(IEventDispatcher::class), $this->createMock(LoggerInterface::class));
+        $userBackend = new Dummy();
+        $userBackend->createUser('u1', '');
+        $userBackend->createUser('u2', '');
+        $userBackend->createUser('u3', '');
+        $this->userManager->registerBackend($userBackend);
+        $this->cache = new \OC\Files\Config\UserMountCache($this->connection, $this->userManager, $this->createMock(LoggerInterface::class), $this->createMock(IEventLogger::class));
+    }
+
+    protected function tearDown(): void {
+        $builder = $this->connection->getQueryBuilder();
+
+        $builder->delete('mounts')->execute();
 
-		$builder = $this->connection->getQueryBuilder();
+        $builder = $this->connection->getQueryBuilder();
 
-		foreach ($this->fileIds as $fileId) {
-			$builder->delete('filecache')
-				->where($builder->expr()->eq('fileid', new Literal($fileId)))
-				->execute();
-		}
-	}
+        foreach ($this->fileIds as $fileId) {
+            $builder->delete('filecache')
+                ->where($builder->expr()->eq('fileid', new Literal($fileId)))
+                ->execute();
+        }
+    }
 
-	private function getStorage($storageId, $rootInternalPath = '') {
-		$rootId = $this->createCacheEntry($rootInternalPath, $storageId);
+    private function getStorage($storageId, $rootInternalPath = '') {
+        $rootId = $this->createCacheEntry($rootInternalPath, $storageId);
 
-		$storageCache = $this->createMock(\OC\Files\Cache\Storage::class);
-		$storageCache->expects($this->any())
-			->method('getNumericId')
-			->willReturn($storageId);
+        $storageCache = $this->createMock(\OC\Files\Cache\Storage::class);
+        $storageCache->expects($this->any())
+            ->method('getNumericId')
+            ->willReturn($storageId);
 
-		$cache = $this->createMock(Cache::class);
-		$cache->expects($this->any())
-			->method('getId')
-			->willReturn($rootId);
-		$cache->method('getNumericStorageId')
-			->willReturn($storageId);
+        $cache = $this->createMock(Cache::class);
+        $cache->expects($this->any())
+            ->method('getId')
+            ->willReturn($rootId);
+        $cache->method('getNumericStorageId')
+            ->willReturn($storageId);
 
-		$storage = $this->createMock(Storage::class);
-		$storage->expects($this->any())
-			->method('getStorageCache')
-			->willReturn($storageCache);
-		$storage->expects($this->any())
-			->method('getCache')
-			->willReturn($cache);
+        $storage = $this->createMock(Storage::class);
+        $storage->expects($this->any())
+            ->method('getStorageCache')
+            ->willReturn($storageCache);
+        $storage->expects($this->any())
+            ->method('getCache')
+            ->willReturn($cache);
 
-		return [$storage, $rootId];
-	}
+        return [$storage, $rootId];
+    }
 
-	private function clearCache() {
-		$this->invokePrivate($this->cache, 'mountsForUsers', [new CappedMemoryCache()]);
-	}
+    private function clearCache() {
+        $this->invokePrivate($this->cache, 'mountsForUsers', [new CappedMemoryCache()]);
+    }
 
-	private function keyForMount(MountPoint $mount): string {
-		return $mount->getStorageRootId() . '::' . $mount->getMountPoint();
-	}
+    private function keyForMount(MountPoint $mount): string {
+        return $mount->getStorageRootId() . '::' . $mount->getMountPoint();
+    }
 
-	public function testNewMounts(): void {
-		$user = $this->userManager->get('u1');
+    public function testNewMounts(): void {
+        $user = $this->userManager->get('u1');
 
-		[$storage] = $this->getStorage(10);
-		$mount = new MountPoint($storage, '/asd/');
+        [$storage] = $this->getStorage(10);
+        $mount = new MountPoint($storage, '/asd/');
 
-		$this->cache->registerMounts($user, [$mount]);
+        $this->cache->registerMounts($user, [$mount]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$cachedMounts = $this->cache->getMountsForUser($user);
+        $cachedMounts = $this->cache->getMountsForUser($user);
 
-		$this->assertCount(1, $cachedMounts);
-		$cachedMount = $cachedMounts[$this->keyForMount($mount)];
-		$this->assertEquals('/asd/', $cachedMount->getMountPoint());
-		$this->assertEquals($user->getUID(), $cachedMount->getUser()->getUID());
-		$this->assertEquals($storage->getCache()->getId(''), $cachedMount->getRootId());
-		$this->assertEquals($storage->getStorageCache()->getNumericId(), $cachedMount->getStorageId());
-	}
+        $this->assertCount(1, $cachedMounts);
+        $cachedMount = $cachedMounts[$this->keyForMount($mount)];
+        $this->assertEquals('/asd/', $cachedMount->getMountPoint());
+        $this->assertEquals($user->getUID(), $cachedMount->getUser()->getUID());
+        $this->assertEquals($storage->getCache()->getId(''), $cachedMount->getRootId());
+        $this->assertEquals($storage->getStorageCache()->getNumericId(), $cachedMount->getStorageId());
+    }
 
-	public function testSameMounts(): void {
-		$user = $this->userManager->get('u1');
+    public function testSameMounts(): void {
+        $user = $this->userManager->get('u1');
 
-		[$storage] = $this->getStorage(10);
-		$mount = new MountPoint($storage, '/asd/');
+        [$storage] = $this->getStorage(10);
+        $mount = new MountPoint($storage, '/asd/');
 
-		$this->cache->registerMounts($user, [$mount]);
+        $this->cache->registerMounts($user, [$mount]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$this->cache->registerMounts($user, [$mount]);
+        $this->cache->registerMounts($user, [$mount]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$cachedMounts = $this->cache->getMountsForUser($user);
+        $cachedMounts = $this->cache->getMountsForUser($user);
 
-		$this->assertCount(1, $cachedMounts);
-		$cachedMount = $cachedMounts[$this->keyForMount($mount)];
-		$this->assertEquals('/asd/', $cachedMount->getMountPoint());
-		$this->assertEquals($user->getUID(), $cachedMount->getUser()->getUID());
-		$this->assertEquals($storage->getCache()->getId(''), $cachedMount->getRootId());
-		$this->assertEquals($storage->getStorageCache()->getNumericId(), $cachedMount->getStorageId());
-	}
+        $this->assertCount(1, $cachedMounts);
+        $cachedMount = $cachedMounts[$this->keyForMount($mount)];
+        $this->assertEquals('/asd/', $cachedMount->getMountPoint());
+        $this->assertEquals($user->getUID(), $cachedMount->getUser()->getUID());
+        $this->assertEquals($storage->getCache()->getId(''), $cachedMount->getRootId());
+        $this->assertEquals($storage->getStorageCache()->getNumericId(), $cachedMount->getStorageId());
+    }
 
-	public function testRemoveMounts(): void {
-		$user = $this->userManager->get('u1');
+    public function testRemoveMounts(): void {
+        $user = $this->userManager->get('u1');
 
-		[$storage] = $this->getStorage(10);
-		$mount = new MountPoint($storage, '/asd/');
+        [$storage] = $this->getStorage(10);
+        $mount = new MountPoint($storage, '/asd/');
 
-		$this->cache->registerMounts($user, [$mount]);
+        $this->cache->registerMounts($user, [$mount]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$this->cache->registerMounts($user, []);
+        $this->cache->registerMounts($user, []);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$cachedMounts = $this->cache->getMountsForUser($user);
+        $cachedMounts = $this->cache->getMountsForUser($user);
 
-		$this->assertCount(0, $cachedMounts);
-	}
+        $this->assertCount(0, $cachedMounts);
+    }
 
-	public function testChangeMounts(): void {
-		$user = $this->userManager->get('u1');
+    public function testChangeMounts(): void {
+        $user = $this->userManager->get('u1');
 
-		[$storage] = $this->getStorage(10);
-		$mount = new MountPoint($storage, '/bar/');
+        [$storage] = $this->getStorage(10);
+        $mount = new MountPoint($storage, '/bar/');
 
-		$this->cache->registerMounts($user, [$mount]);
+        $this->cache->registerMounts($user, [$mount]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$mount = new MountPoint($storage, '/foo/');
+        $mount = new MountPoint($storage, '/foo/');
 
-		$this->cache->registerMounts($user, [$mount]);
+        $this->cache->registerMounts($user, [$mount]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$cachedMounts = $this->cache->getMountsForUser($user);
+        $cachedMounts = $this->cache->getMountsForUser($user);
 
-		$this->assertCount(1, $cachedMounts);
-		$cachedMount = $cachedMounts[$this->keyForMount($mount)];
-		$this->assertEquals('/foo/', $cachedMount->getMountPoint());
-	}
+        $this->assertCount(1, $cachedMounts);
+        $cachedMount = $cachedMounts[$this->keyForMount($mount)];
+        $this->assertEquals('/foo/', $cachedMount->getMountPoint());
+    }
 
-	public function testChangeMountId(): void {
-		$user = $this->userManager->get('u1');
+    public function testChangeMountId(): void {
+        $user = $this->userManager->get('u1');
 
-		[$storage] = $this->getStorage(10);
-		$mount = new MountPoint($storage, '/foo/', null, null, null, null);
+        [$storage] = $this->getStorage(10);
+        $mount = new MountPoint($storage, '/foo/', null, null, null, null);
 
-		$this->cache->registerMounts($user, [$mount]);
+        $this->cache->registerMounts($user, [$mount]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$mount = new MountPoint($storage, '/foo/', null, null, null, 1);
+        $mount = new MountPoint($storage, '/foo/', null, null, null, 1);
 
-		$this->cache->registerMounts($user, [$mount]);
+        $this->cache->registerMounts($user, [$mount]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$cachedMounts = $this->cache->getMountsForUser($user);
+        $cachedMounts = $this->cache->getMountsForUser($user);
 
-		$this->assertCount(1, $cachedMounts);
-		$cachedMount = $cachedMounts[$this->keyForMount($mount)];
-		$this->assertEquals(1, $cachedMount->getMountId());
-	}
+        $this->assertCount(1, $cachedMounts);
+        $cachedMount = $cachedMounts[$this->keyForMount($mount)];
+        $this->assertEquals(1, $cachedMount->getMountId());
+    }
 
-	public function testGetMountsForUser(): void {
-		$user1 = $this->userManager->get('u1');
-		$user2 = $this->userManager->get('u2');
-		$user3 = $this->userManager->get('u3');
+    public function testGetMountsForUser(): void {
+        $user1 = $this->userManager->get('u1');
+        $user2 = $this->userManager->get('u2');
+        $user3 = $this->userManager->get('u3');
 
-		[$storage1, $id1] = $this->getStorage(1);
-		[$storage2, $id2] = $this->getStorage(2, 'foo/bar');
-		$mount1 = new MountPoint($storage1, '/foo/');
-		$mount2 = new MountPoint($storage2, '/bar/');
+        [$storage1, $id1] = $this->getStorage(1);
+        [$storage2, $id2] = $this->getStorage(2, 'foo/bar');
+        $mount1 = new MountPoint($storage1, '/foo/');
+        $mount2 = new MountPoint($storage2, '/bar/');
 
-		$this->cache->registerMounts($user1, [$mount1, $mount2]);
-		$this->cache->registerMounts($user2, [$mount2]);
-		$this->cache->registerMounts($user3, [$mount2]);
+        $this->cache->registerMounts($user1, [$mount1, $mount2]);
+        $this->cache->registerMounts($user2, [$mount2]);
+        $this->cache->registerMounts($user3, [$mount2]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$user3->delete();
+        $user3->delete();
 
-		$cachedMounts = $this->cache->getMountsForUser($user1);
+        $cachedMounts = $this->cache->getMountsForUser($user1);
 
-		$this->assertCount(2, $cachedMounts);
-		$this->assertEquals('/foo/', $cachedMounts[$this->keyForMount($mount1)]->getMountPoint());
-		$this->assertEquals($user1->getUID(), $cachedMounts[$this->keyForMount($mount1)]->getUser()->getUID());
-		$this->assertEquals($id1, $cachedMounts[$this->keyForMount($mount1)]->getRootId());
-		$this->assertEquals(1, $cachedMounts[$this->keyForMount($mount1)]->getStorageId());
-		$this->assertEquals('', $cachedMounts[$this->keyForMount($mount1)]->getRootInternalPath());
+        $this->assertCount(2, $cachedMounts);
+        $this->assertEquals('/foo/', $cachedMounts[$this->keyForMount($mount1)]->getMountPoint());
+        $this->assertEquals($user1->getUID(), $cachedMounts[$this->keyForMount($mount1)]->getUser()->getUID());
+        $this->assertEquals($id1, $cachedMounts[$this->keyForMount($mount1)]->getRootId());
+        $this->assertEquals(1, $cachedMounts[$this->keyForMount($mount1)]->getStorageId());
+        $this->assertEquals('', $cachedMounts[$this->keyForMount($mount1)]->getRootInternalPath());
 
-		$this->assertEquals('/bar/', $cachedMounts[$this->keyForMount($mount2)]->getMountPoint());
-		$this->assertEquals($user1->getUID(), $cachedMounts[$this->keyForMount($mount2)]->getUser()->getUID());
-		$this->assertEquals($id2, $cachedMounts[$this->keyForMount($mount2)]->getRootId());
-		$this->assertEquals(2, $cachedMounts[$this->keyForMount($mount2)]->getStorageId());
-		$this->assertEquals('foo/bar', $cachedMounts[$this->keyForMount($mount2)]->getRootInternalPath());
+        $this->assertEquals('/bar/', $cachedMounts[$this->keyForMount($mount2)]->getMountPoint());
+        $this->assertEquals($user1->getUID(), $cachedMounts[$this->keyForMount($mount2)]->getUser()->getUID());
+        $this->assertEquals($id2, $cachedMounts[$this->keyForMount($mount2)]->getRootId());
+        $this->assertEquals(2, $cachedMounts[$this->keyForMount($mount2)]->getStorageId());
+        $this->assertEquals('foo/bar', $cachedMounts[$this->keyForMount($mount2)]->getRootInternalPath());
 
-		$cachedMounts = $this->cache->getMountsForUser($user3);
-		$this->assertEmpty($cachedMounts);
-	}
+        $cachedMounts = $this->cache->getMountsForUser($user3);
+        $this->assertEmpty($cachedMounts);
+    }
 
-	public function testGetMountsByStorageId(): void {
-		$user1 = $this->userManager->get('u1');
-		$user2 = $this->userManager->get('u2');
+    public function testGetMountsByStorageId(): void {
+        $user1 = $this->userManager->get('u1');
+        $user2 = $this->userManager->get('u2');
 
-		[$storage1, $id1] = $this->getStorage(1);
-		[$storage2, $id2] = $this->getStorage(2);
-		$mount1 = new MountPoint($storage1, '/foo/');
-		$mount2 = new MountPoint($storage2, '/bar/');
+        [$storage1, $id1] = $this->getStorage(1);
+        [$storage2, $id2] = $this->getStorage(2);
+        $mount1 = new MountPoint($storage1, '/foo/');
+        $mount2 = new MountPoint($storage2, '/bar/');
 
-		$this->cache->registerMounts($user1, [$mount1, $mount2]);
-		$this->cache->registerMounts($user2, [$mount2]);
+        $this->cache->registerMounts($user1, [$mount1, $mount2]);
+        $this->cache->registerMounts($user2, [$mount2]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$cachedMounts = $this->cache->getMountsForStorageId(2);
-		$this->sortMounts($cachedMounts);
+        $cachedMounts = $this->cache->getMountsForStorageId(2);
+        $this->sortMounts($cachedMounts);
 
-		$this->assertCount(2, $cachedMounts);
+        $this->assertCount(2, $cachedMounts);
 
-		$this->assertEquals('/bar/', $cachedMounts[0]->getMountPoint());
-		$this->assertEquals($user1->getUID(), $cachedMounts[0]->getUser()->getUID());
-		$this->assertEquals($id2, $cachedMounts[0]->getRootId());
-		$this->assertEquals(2, $cachedMounts[0]->getStorageId());
+        $this->assertEquals('/bar/', $cachedMounts[0]->getMountPoint());
+        $this->assertEquals($user1->getUID(), $cachedMounts[0]->getUser()->getUID());
+        $this->assertEquals($id2, $cachedMounts[0]->getRootId());
+        $this->assertEquals(2, $cachedMounts[0]->getStorageId());
 
-		$this->assertEquals('/bar/', $cachedMounts[1]->getMountPoint());
-		$this->assertEquals($user2->getUID(), $cachedMounts[1]->getUser()->getUID());
-		$this->assertEquals($id2, $cachedMounts[1]->getRootId());
-		$this->assertEquals(2, $cachedMounts[1]->getStorageId());
-	}
-
-	public function testGetMountsByRootId(): void {
-		$user1 = $this->userManager->get('u1');
-		$user2 = $this->userManager->get('u2');
-
-		[$storage1, $id1] = $this->getStorage(1);
-		[$storage2, $id2] = $this->getStorage(2);
-		$mount1 = new MountPoint($storage1, '/foo/');
-		$mount2 = new MountPoint($storage2, '/bar/');
+        $this->assertEquals('/bar/', $cachedMounts[1]->getMountPoint());
+        $this->assertEquals($user2->getUID(), $cachedMounts[1]->getUser()->getUID());
+        $this->assertEquals($id2, $cachedMounts[1]->getRootId());
+        $this->assertEquals(2, $cachedMounts[1]->getStorageId());
+    }
+
+    public function testGetMountsByRootId(): void {
+        $user1 = $this->userManager->get('u1');
+        $user2 = $this->userManager->get('u2');
+
+        [$storage1, $id1] = $this->getStorage(1);
+        [$storage2, $id2] = $this->getStorage(2);
+        $mount1 = new MountPoint($storage1, '/foo/');
+        $mount2 = new MountPoint($storage2, '/bar/');
 
-		$this->cache->registerMounts($user1, [$mount1, $mount2]);
-		$this->cache->registerMounts($user2, [$mount2]);
+        $this->cache->registerMounts($user1, [$mount1, $mount2]);
+        $this->cache->registerMounts($user2, [$mount2]);
 
-		$this->clearCache();
-
-		$cachedMounts = $this->cache->getMountsForRootId($id2);
-		$this->sortMounts($cachedMounts);
-
-		$this->assertCount(2, $cachedMounts);
-
-		$this->assertEquals('/bar/', $cachedMounts[0]->getMountPoint());
-		$this->assertEquals($user1->getUID(), $cachedMounts[0]->getUser()->getUID());
-		$this->assertEquals($id2, $cachedMounts[0]->getRootId());
-		$this->assertEquals(2, $cachedMounts[0]->getStorageId());
-
-		$this->assertEquals('/bar/', $cachedMounts[1]->getMountPoint());
-		$this->assertEquals($user2->getUID(), $cachedMounts[1]->getUser()->getUID());
-		$this->assertEquals($id2, $cachedMounts[1]->getRootId());
-		$this->assertEquals(2, $cachedMounts[1]->getStorageId());
-	}
-
-	private function sortMounts(&$mounts) {
-		usort($mounts, function (ICachedMountInfo $a, ICachedMountInfo $b) {
-			return strcmp($a->getUser()->getUID(), $b->getUser()->getUID());
-		});
-	}
-
-	private function createCacheEntry($internalPath, $storageId, $size = 0) {
-		$internalPath = trim($internalPath, '/');
-		try {
-			$query = $this->connection->getQueryBuilder();
-			$query->insert('filecache')
-				->values([
-					'storage' => $query->createNamedParameter($storageId),
-					'path' => $query->createNamedParameter($internalPath),
-					'path_hash' => $query->createNamedParameter(md5($internalPath)),
-					'parent' => $query->createNamedParameter(-1, IQueryBuilder::PARAM_INT),
-					'name' => $query->createNamedParameter(basename($internalPath)),
-					'mimetype' => $query->createNamedParameter(0, IQueryBuilder::PARAM_INT),
-					'mimepart' => $query->createNamedParameter(0, IQueryBuilder::PARAM_INT),
-					'size' => $query->createNamedParameter($size),
-					'storage_mtime' => $query->createNamedParameter(0, IQueryBuilder::PARAM_INT),
-					'encrypted' => $query->createNamedParameter(0, IQueryBuilder::PARAM_INT),
-					'unencrypted_size' => $query->createNamedParameter(0, IQueryBuilder::PARAM_INT),
-					'etag' => $query->createNamedParameter(''),
-					'permissions' => $query->createNamedParameter(31, IQueryBuilder::PARAM_INT),
-				]);
-			$query->executeStatement();
-			$id = $query->getLastInsertId();
-			$this->fileIds[] = $id;
-		} catch (DbalException $e) {
-			if ($e->getReason() === DbalException::REASON_UNIQUE_CONSTRAINT_VIOLATION) {
-				$query = $this->connection->getQueryBuilder();
-				$query->select('fileid')
-					->from('filecache')
-					->where($query->expr()->eq('storage', $query->createNamedParameter($storageId)))
-					->andWhere($query->expr()->eq('path_hash', $query->createNamedParameter(md5($internalPath))));
-				$id = (int)$query->execute()->fetchColumn();
-			} else {
-				throw $e;
-			}
-		}
-		return $id;
-	}
+        $this->clearCache();
+
+        $cachedMounts = $this->cache->getMountsForRootId($id2);
+        $this->sortMounts($cachedMounts);
+
+        $this->assertCount(2, $cachedMounts);
+
+        $this->assertEquals('/bar/', $cachedMounts[0]->getMountPoint());
+        $this->assertEquals($user1->getUID(), $cachedMounts[0]->getUser()->getUID());
+        $this->assertEquals($id2, $cachedMounts[0]->getRootId());
+        $this->assertEquals(2, $cachedMounts[0]->getStorageId());
+
+        $this->assertEquals('/bar/', $cachedMounts[1]->getMountPoint());
+        $this->assertEquals($user2->getUID(), $cachedMounts[1]->getUser()->getUID());
+        $this->assertEquals($id2, $cachedMounts[1]->getRootId());
+        $this->assertEquals(2, $cachedMounts[1]->getStorageId());
+    }
+
+    private function sortMounts(&$mounts) {
+        usort($mounts, function (ICachedMountInfo $a, ICachedMountInfo $b) {
+            return strcmp($a->getUser()->getUID(), $b->getUser()->getUID());
+        });
+    }
+
+    private function createCacheEntry($internalPath, $storageId, $size = 0) {
+        $internalPath = trim($internalPath, '/');
+        try {
+            $query = $this->connection->getQueryBuilder();
+            $query->insert('filecache')
+                ->values([
+                    'storage' => $query->createNamedParameter($storageId),
+                    'path' => $query->createNamedParameter($internalPath),
+                    'path_hash' => $query->createNamedParameter(md5($internalPath)),
+                    'parent' => $query->createNamedParameter(-1, IQueryBuilder::PARAM_INT),
+                    'name' => $query->createNamedParameter(basename($internalPath)),
+                    'mimetype' => $query->createNamedParameter(0, IQueryBuilder::PARAM_INT),
+                    'mimepart' => $query->createNamedParameter(0, IQueryBuilder::PARAM_INT),
+                    'size' => $query->createNamedParameter($size),
+                    'storage_mtime' => $query->createNamedParameter(0, IQueryBuilder::PARAM_INT),
+                    'encrypted' => $query->createNamedParameter(0, IQueryBuilder::PARAM_INT),
+                    'unencrypted_size' => $query->createNamedParameter(0, IQueryBuilder::PARAM_INT),
+                    'etag' => $query->createNamedParameter(''),
+                    'permissions' => $query->createNamedParameter(31, IQueryBuilder::PARAM_INT),
+                ]);
+            $query->executeStatement();
+            $id = $query->getLastInsertId();
+            $this->fileIds[] = $id;
+        } catch (DbalException $e) {
+            if ($e->getReason() === DbalException::REASON_UNIQUE_CONSTRAINT_VIOLATION) {
+                $query = $this->connection->getQueryBuilder();
+                $query->select('fileid')
+                    ->from('filecache')
+                    ->where($query->expr()->eq('storage', $query->createNamedParameter($storageId)))
+                    ->andWhere($query->expr()->eq('path_hash', $query->createNamedParameter(md5($internalPath))));
+                $id = (int)$query->execute()->fetchColumn();
+            } else {
+                throw $e;
+            }
+        }
+        return $id;
+    }
 
-	public function testGetMountsForFileIdRootId(): void {
-		$user1 = $this->userManager->get('u1');
+    public function testGetMountsForFileIdRootId(): void {
+        $user1 = $this->userManager->get('u1');
 
-		[$storage1, $rootId] = $this->getStorage(2);
-		$mount1 = new MountPoint($storage1, '/foo/');
+        [$storage1, $rootId] = $this->getStorage(2);
+        $mount1 = new MountPoint($storage1, '/foo/');
 
-		$this->cache->registerMounts($user1, [$mount1]);
+        $this->cache->registerMounts($user1, [$mount1]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$cachedMounts = $this->cache->getMountsForFileId($rootId);
+        $cachedMounts = $this->cache->getMountsForFileId($rootId);
 
-		$this->assertCount(1, $cachedMounts);
+        $this->assertCount(1, $cachedMounts);
 
-		$this->assertEquals('/foo/', $cachedMounts[0]->getMountPoint());
-		$this->assertEquals($user1->getUID(), $cachedMounts[0]->getUser()->getUID());
-		$this->assertEquals($rootId, $cachedMounts[0]->getRootId());
-		$this->assertEquals(2, $cachedMounts[0]->getStorageId());
-	}
+        $this->assertEquals('/foo/', $cachedMounts[0]->getMountPoint());
+        $this->assertEquals($user1->getUID(), $cachedMounts[0]->getUser()->getUID());
+        $this->assertEquals($rootId, $cachedMounts[0]->getRootId());
+        $this->assertEquals(2, $cachedMounts[0]->getStorageId());
+    }
 
-	public function testGetMountsForFileIdSubFolder(): void {
-		$user1 = $this->userManager->get('u1');
+    public function testGetMountsForFileIdSubFolder(): void {
+        $user1 = $this->userManager->get('u1');
 
-		$fileId = $this->createCacheEntry('/foo/bar', 2);
+        $fileId = $this->createCacheEntry('/foo/bar', 2);
 
-		[$storage1, $rootId] = $this->getStorage(2);
-		$mount1 = new MountPoint($storage1, '/foo/');
+        [$storage1, $rootId] = $this->getStorage(2);
+        $mount1 = new MountPoint($storage1, '/foo/');
 
-		$this->cache->registerMounts($user1, [$mount1]);
+        $this->cache->registerMounts($user1, [$mount1]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$cachedMounts = $this->cache->getMountsForFileId($fileId);
-
-		$this->assertCount(1, $cachedMounts);
-
-		$this->assertEquals('/foo/', $cachedMounts[0]->getMountPoint());
-		$this->assertEquals($user1->getUID(), $cachedMounts[0]->getUser()->getUID());
-		$this->assertEquals($rootId, $cachedMounts[0]->getRootId());
-		$this->assertEquals(2, $cachedMounts[0]->getStorageId());
-		$this->assertEquals('foo/bar', $cachedMounts[0]->getInternalPath());
-		$this->assertEquals('/foo/foo/bar', $cachedMounts[0]->getPath());
-	}
-
-	public function testGetMountsForFileIdSubFolderMount(): void {
-		$user1 = $this->userManager->get('u1');
-
-		[$storage1, $rootId] = $this->getStorage(2);
-		$folderId = $this->createCacheEntry('/foo', 2);
-		$fileId = $this->createCacheEntry('/foo/bar', 2);
+        $cachedMounts = $this->cache->getMountsForFileId($fileId);
+
+        $this->assertCount(1, $cachedMounts);
+
+        $this->assertEquals('/foo/', $cachedMounts[0]->getMountPoint());
+        $this->assertEquals($user1->getUID(), $cachedMounts[0]->getUser()->getUID());
+        $this->assertEquals($rootId, $cachedMounts[0]->getRootId());
+        $this->assertEquals(2, $cachedMounts[0]->getStorageId());
+        $this->assertEquals('foo/bar', $cachedMounts[0]->getInternalPath());
+        $this->assertEquals('/foo/foo/bar', $cachedMounts[0]->getPath());
+    }
+
+    public function testGetMountsForFileIdSubFolderMount(): void {
+        $user1 = $this->userManager->get('u1');
+
+        [$storage1, $rootId] = $this->getStorage(2);
+        $folderId = $this->createCacheEntry('/foo', 2);
+        $fileId = $this->createCacheEntry('/foo/bar', 2);
 
 
-		$mount1 = $this->getMockBuilder(MountPoint::class)
-			->setConstructorArgs([$storage1, '/'])
-			->onlyMethods(['getStorageRootId'])
-			->getMock();
+        $mount1 = $this->getMockBuilder(MountPoint::class)
+            ->setConstructorArgs([$storage1, '/'])
+            ->onlyMethods(['getStorageRootId'])
+            ->getMock();
 
-		$mount1->expects($this->any())
-			->method('getStorageRootId')
-			->willReturn($folderId);
+        $mount1->expects($this->any())
+            ->method('getStorageRootId')
+            ->willReturn($folderId);
 
-		$this->cache->registerMounts($user1, [$mount1]);
+        $this->cache->registerMounts($user1, [$mount1]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$cachedMounts = $this->cache->getMountsForFileId($fileId);
+        $cachedMounts = $this->cache->getMountsForFileId($fileId);
 
-		$this->assertCount(1, $cachedMounts);
+        $this->assertCount(1, $cachedMounts);
 
-		$this->assertEquals('/', $cachedMounts[0]->getMountPoint());
-		$this->assertEquals($user1->getUID(), $cachedMounts[0]->getUser()->getUID());
-		$this->assertEquals($folderId, $cachedMounts[0]->getRootId());
-		$this->assertEquals(2, $cachedMounts[0]->getStorageId());
-		$this->assertEquals('foo', $cachedMounts[0]->getRootInternalPath());
-		$this->assertEquals('bar', $cachedMounts[0]->getInternalPath());
-		$this->assertEquals('/bar', $cachedMounts[0]->getPath());
-	}
+        $this->assertEquals('/', $cachedMounts[0]->getMountPoint());
+        $this->assertEquals($user1->getUID(), $cachedMounts[0]->getUser()->getUID());
+        $this->assertEquals($folderId, $cachedMounts[0]->getRootId());
+        $this->assertEquals(2, $cachedMounts[0]->getStorageId());
+        $this->assertEquals('foo', $cachedMounts[0]->getRootInternalPath());
+        $this->assertEquals('bar', $cachedMounts[0]->getInternalPath());
+        $this->assertEquals('/bar', $cachedMounts[0]->getPath());
+    }
 
-	public function testGetMountsForFileIdSubFolderMountOutside(): void {
-		$user1 = $this->userManager->get('u1');
+    public function testGetMountsForFileIdSubFolderMountOutside(): void {
+        $user1 = $this->userManager->get('u1');
 
-		[$storage1, $rootId] = $this->getStorage(2);
-		$folderId = $this->createCacheEntry('/foo', 2);
-		$fileId = $this->createCacheEntry('/bar/asd', 2);
+        [$storage1, $rootId] = $this->getStorage(2);
+        $folderId = $this->createCacheEntry('/foo', 2);
+        $fileId = $this->createCacheEntry('/bar/asd', 2);
 
-		$mount1 = $this->getMockBuilder(MountPoint::class)
-			->setConstructorArgs([$storage1, '/foo/'])
-			->onlyMethods(['getStorageRootId'])
-			->getMock();
+        $mount1 = $this->getMockBuilder(MountPoint::class)
+            ->setConstructorArgs([$storage1, '/foo/'])
+            ->onlyMethods(['getStorageRootId'])
+            ->getMock();
 
-		$mount1->expects($this->any())
-			->method('getStorageRootId')
-			->willReturn($folderId);
+        $mount1->expects($this->any())
+            ->method('getStorageRootId')
+            ->willReturn($folderId);
 
-		$this->cache->registerMounts($user1, [$mount1]);
+        $this->cache->registerMounts($user1, [$mount1]);
 
-		$this->cache->registerMounts($user1, [$mount1]);
+        $this->cache->registerMounts($user1, [$mount1]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$cachedMounts = $this->cache->getMountsForFileId($fileId);
+        $cachedMounts = $this->cache->getMountsForFileId($fileId);
 
-		$this->assertCount(0, $cachedMounts);
-	}
+        $this->assertCount(0, $cachedMounts);
+    }
 
 
-	public function testGetMountsForFileIdDeletedUser(): void {
-		$user1 = $this->userManager->get('u1');
+    public function testGetMountsForFileIdDeletedUser(): void {
+        $user1 = $this->userManager->get('u1');
 
-		[$storage1, $rootId] = $this->getStorage(2);
-		$rootId = $this->createCacheEntry('', 2);
-		$mount1 = new MountPoint($storage1, '/foo/');
-		$this->cache->registerMounts($user1, [$mount1]);
+        [$storage1, $rootId] = $this->getStorage(2);
+        $rootId = $this->createCacheEntry('', 2);
+        $mount1 = new MountPoint($storage1, '/foo/');
+        $this->cache->registerMounts($user1, [$mount1]);
 
-		$user1->delete();
-		$this->clearCache();
+        $user1->delete();
+        $this->clearCache();
 
-		$cachedMounts = $this->cache->getMountsForFileId($rootId);
-		$this->assertEmpty($cachedMounts);
-	}
+        $cachedMounts = $this->cache->getMountsForFileId($rootId);
+        $this->assertEmpty($cachedMounts);
+    }
 
-	public function testGetUsedSpaceForUsers(): void {
-		$user1 = $this->userManager->get('u1');
-		$user2 = $this->userManager->get('u2');
+    public function testGetUsedSpaceForUsers(): void {
+        $user1 = $this->userManager->get('u1');
+        $user2 = $this->userManager->get('u2');
 
-		/** @var Storage $storage1 */
-		[$storage1, $rootId] = $this->getStorage(2);
-		$folderId = $this->createCacheEntry('files', 2, 100);
-		$fileId = $this->createCacheEntry('files/foo', 2, 7);
-		$storage1->getCache()->put($folderId, ['size' => 100]);
-		$storage1->getCache()->update($fileId, ['size' => 70]);
+        /** @var Storage $storage1 */
+        [$storage1, $rootId] = $this->getStorage(2);
+        $folderId = $this->createCacheEntry('files', 2, 100);
+        $fileId = $this->createCacheEntry('files/foo', 2, 7);
+        $storage1->getCache()->put($folderId, ['size' => 100]);
+        $storage1->getCache()->update($fileId, ['size' => 70]);
 
-		$mount1 = $this->getMockBuilder(MountPoint::class)
-			->setConstructorArgs([$storage1, '/u1/'])
-			->onlyMethods(['getStorageRootId', 'getNumericStorageId'])
-			->getMock();
+        $mount1 = $this->getMockBuilder(MountPoint::class)
+            ->setConstructorArgs([$storage1, '/u1/'])
+            ->onlyMethods(['getStorageRootId', 'getNumericStorageId'])
+            ->getMock();
 
-		$mount1->expects($this->any())
-			->method('getStorageRootId')
-			->willReturn($rootId);
+        $mount1->expects($this->any())
+            ->method('getStorageRootId')
+            ->willReturn($rootId);
 
-		$mount1->expects($this->any())
-			->method('getNumericStorageId')
-			->willReturn(2);
+        $mount1->expects($this->any())
+            ->method('getNumericStorageId')
+            ->willReturn(2);
 
-		$this->cache->registerMounts($user1, [$mount1]);
+        $this->cache->registerMounts($user1, [$mount1]);
 
-		$result = $this->cache->getUsedSpaceForUsers([$user1, $user2]);
-		$this->assertEquals(['u1' => 100], $result);
-	}
+        $result = $this->cache->getUsedSpaceForUsers([$user1, $user2]);
+        $this->assertEquals(['u1' => 100], $result);
+    }
 
 
-	public function testMigrateMountProvider(): void {
-		$user1 = $this->userManager->get('u1');
+    public function testMigrateMountProvider(): void {
+        $user1 = $this->userManager->get('u1');
 
-		[$storage1, $rootId] = $this->getStorage(2);
-		$rootId = $this->createCacheEntry('', 2);
-		$mount1 = new MountPoint($storage1, '/foo/');
-		$this->cache->registerMounts($user1, [$mount1]);
+        [$storage1, $rootId] = $this->getStorage(2);
+        $rootId = $this->createCacheEntry('', 2);
+        $mount1 = new MountPoint($storage1, '/foo/');
+        $this->cache->registerMounts($user1, [$mount1]);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$cachedMounts = $this->cache->getMountsForUser($user1);
-		$this->assertCount(1, $cachedMounts);
-		$this->assertEquals('', $cachedMounts[$this->keyForMount($mount1)]->getMountProvider());
+        $cachedMounts = $this->cache->getMountsForUser($user1);
+        $this->assertCount(1, $cachedMounts);
+        $this->assertEquals('', $cachedMounts[$this->keyForMount($mount1)]->getMountProvider());
 
-		$mount1 = new MountPoint($storage1, '/foo/', null, null, null, null, 'dummy');
-		$this->cache->registerMounts($user1, [$mount1], ['dummy']);
+        $mount1 = new MountPoint($storage1, '/foo/', null, null, null, null, 'dummy');
+        $this->cache->registerMounts($user1, [$mount1], ['dummy']);
 
-		$this->clearCache();
+        $this->clearCache();
 
-		$cachedMounts = $this->cache->getMountsForUser($user1);
-		$this->assertCount(1, $cachedMounts);
-		$this->assertEquals('dummy', $cachedMounts[$this->keyForMount($mount1)]->getMountProvider());
-	}
+        $cachedMounts = $this->cache->getMountsForUser($user1);
+        $this->assertCount(1, $cachedMounts);
+        $this->assertEquals('dummy', $cachedMounts[$this->keyForMount($mount1)]->getMountProvider());
+    }
 }