nextcloud / server

tests/lib/Lockdown/Filesystem/NullCacheTest.php

Indentation +89 added lines, -89 removed lines

@@ -13,123 +13,123 @@
 use OCP\Files\FileInfo;
 
 class NulLCacheTest extends \Test\TestCase {
-	/** @var NullCache */
-	private $cache;
+    /** @var NullCache */
+    private $cache;
 
-	protected function setUp(): void {
-		parent::setUp();
+    protected function setUp(): void {
+        parent::setUp();
 
-		$this->cache = new NullCache();
-	}
+        $this->cache = new NullCache();
+    }
 
-	public function testGetNumericStorageId(): void {
-		$this->assertSame(-1, $this->cache->getNumericStorageId());
-	}
+    public function testGetNumericStorageId(): void {
+        $this->assertSame(-1, $this->cache->getNumericStorageId());
+    }
 
-	public function testGetEmpty(): void {
-		$this->assertFalse($this->cache->get('foo'));
-	}
+    public function testGetEmpty(): void {
+        $this->assertFalse($this->cache->get('foo'));
+    }
 
-	public function testGet(): void {
-		$data = $this->cache->get('');
+    public function testGet(): void {
+        $data = $this->cache->get('');
 
-		$this->assertEquals(-1, $data['fileid']);
-		$this->assertEquals(-1, $data['parent']);
-		$this->assertEquals('', $data['name']);
-		$this->assertEquals('', $data['path']);
-		$this->assertEquals('0', $data['size']);
-		$this->assertEquals('', $data['etag']);
-		$this->assertEquals(FileInfo::MIMETYPE_FOLDER, $data['mimetype']);
-		$this->assertEquals('httpd', $data['mimepart']);
-		$this->assertEquals(Constants::PERMISSION_READ, $data['permissions']);
-	}
+        $this->assertEquals(-1, $data['fileid']);
+        $this->assertEquals(-1, $data['parent']);
+        $this->assertEquals('', $data['name']);
+        $this->assertEquals('', $data['path']);
+        $this->assertEquals('0', $data['size']);
+        $this->assertEquals('', $data['etag']);
+        $this->assertEquals(FileInfo::MIMETYPE_FOLDER, $data['mimetype']);
+        $this->assertEquals('httpd', $data['mimepart']);
+        $this->assertEquals(Constants::PERMISSION_READ, $data['permissions']);
+    }
 
-	public function testGetFolderContents(): void {
-		$this->assertSame([], $this->cache->getFolderContents('foo'));
-	}
+    public function testGetFolderContents(): void {
+        $this->assertSame([], $this->cache->getFolderContents('foo'));
+    }
 
-	public function testGetFolderContentsById(): void {
-		$this->assertSame([], $this->cache->getFolderContentsById(42));
-	}
+    public function testGetFolderContentsById(): void {
+        $this->assertSame([], $this->cache->getFolderContentsById(42));
+    }
 
-	public function testPut(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testPut(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->cache->put('foo', ['size' => 100]);
-	}
+        $this->cache->put('foo', ['size' => 100]);
+    }
 
-	public function testInsert(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testInsert(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->cache->insert('foo', ['size' => 100]);
-	}
+        $this->cache->insert('foo', ['size' => 100]);
+    }
 
-	public function testUpdate(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testUpdate(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->cache->update('foo', ['size' => 100]);
-	}
+        $this->cache->update('foo', ['size' => 100]);
+    }
 
-	public function testGetId(): void {
-		$this->assertSame(-1, $this->cache->getId('foo'));
-	}
+    public function testGetId(): void {
+        $this->assertSame(-1, $this->cache->getId('foo'));
+    }
 
-	public function testGetParentId(): void {
-		$this->assertSame(-1, $this->cache->getParentId('foo'));
-	}
+    public function testGetParentId(): void {
+        $this->assertSame(-1, $this->cache->getParentId('foo'));
+    }
 
-	public function testInCache(): void {
-		$this->assertTrue($this->cache->inCache(''));
-		$this->assertFalse($this->cache->inCache('foo'));
-	}
+    public function testInCache(): void {
+        $this->assertTrue($this->cache->inCache(''));
+        $this->assertFalse($this->cache->inCache('foo'));
+    }
 
-	public function testRemove(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testRemove(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->cache->remove('foo');
-	}
+        $this->cache->remove('foo');
+    }
 
-	public function testMove(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testMove(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->cache->move('foo', 'bar');
-	}
+        $this->cache->move('foo', 'bar');
+    }
 
-	public function testMoveFromCache(): void {
-		$sourceCache = $this->createMock(ICache::class);
+    public function testMoveFromCache(): void {
+        $sourceCache = $this->createMock(ICache::class);
 
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->cache->moveFromCache($sourceCache, 'foo', 'bar');
-	}
+        $this->cache->moveFromCache($sourceCache, 'foo', 'bar');
+    }
 
-	public function testGetStatus(): void {
-		$this->assertSame(ICache::COMPLETE, $this->cache->getStatus('foo'));
-	}
+    public function testGetStatus(): void {
+        $this->assertSame(ICache::COMPLETE, $this->cache->getStatus('foo'));
+    }
 
-	public function testSearch(): void {
-		$this->assertSame([], $this->cache->search('foo'));
-	}
+    public function testSearch(): void {
+        $this->assertSame([], $this->cache->search('foo'));
+    }
 
-	public function testSearchByMime(): void {
-		$this->assertSame([], $this->cache->searchByMime('foo'));
-	}
+    public function testSearchByMime(): void {
+        $this->assertSame([], $this->cache->searchByMime('foo'));
+    }
 
-	public function testGetIncomplete(): void {
-		$this->assertSame([], $this->cache->getIncomplete());
-	}
+    public function testGetIncomplete(): void {
+        $this->assertSame([], $this->cache->getIncomplete());
+    }
 
-	public function testGetPathById(): void {
-		$this->assertSame('', $this->cache->getPathById(42));
-	}
+    public function testGetPathById(): void {
+        $this->assertSame('', $this->cache->getPathById(42));
+    }
 
-	public function testNormalize(): void {
-		$this->assertSame('foo/ bar /', $this->cache->normalize('foo/ bar /'));
-	}
+    public function testNormalize(): void {
+        $this->assertSame('foo/ bar /', $this->cache->normalize('foo/ bar /'));
+    }
 }

lib/private/Lockdown/Filesystem/NullCache.php

Indentation +107 added lines, -107 removed lines

@@ -16,111 +16,111 @@
 use OCP\Files\Search\ISearchQuery;
 
 class NullCache implements ICache {
-	public function getNumericStorageId() {
-		return -1;
-	}
-
-	public function get($file) {
-		if ($file !== '') {
-			return false;
-		}
-
-		return 	new CacheEntry([
-			'fileid' => -1,
-			'parent' => -1,
-			'name' => '',
-			'path' => '',
-			'size' => '0',
-			'mtime' => time(),
-			'storage_mtime' => time(),
-			'etag' => '',
-			'mimetype' => FileInfo::MIMETYPE_FOLDER,
-			'mimepart' => 'httpd',
-			'permissions' => Constants::PERMISSION_READ
-		]);
-	}
-
-	public function getFolderContents($folder) {
-		return [];
-	}
-
-	public function getFolderContentsById($fileId) {
-		return [];
-	}
-
-	public function put($file, array $data) {
-		throw new \OC\ForbiddenException('This request is not allowed to access the filesystem');
-	}
-
-	public function insert($file, array $data) {
-		throw new \OC\ForbiddenException('This request is not allowed to access the filesystem');
-	}
-
-	public function update($id, array $data) {
-		throw new \OC\ForbiddenException('This request is not allowed to access the filesystem');
-	}
-
-	public function getId($file) {
-		return -1;
-	}
-
-	public function getParentId($file) {
-		return -1;
-	}
-
-	public function inCache($file) {
-		return $file === '';
-	}
-
-	public function remove($file) {
-		throw new \OC\ForbiddenException('This request is not allowed to access the filesystem');
-	}
-
-	public function move($source, $target) {
-		throw new \OC\ForbiddenException('This request is not allowed to access the filesystem');
-	}
-
-	public function moveFromCache(ICache $sourceCache, $sourcePath, $targetPath) {
-		throw new \OC\ForbiddenException('This request is not allowed to access the filesystem');
-	}
-
-	public function getStatus($file) {
-		return ICache::COMPLETE;
-	}
-
-	public function search($pattern) {
-		return [];
-	}
-
-	public function searchByMime($mimetype) {
-		return [];
-	}
-
-	public function searchQuery(ISearchQuery $query) {
-		return [];
-	}
-
-	public function getIncomplete() {
-		return [];
-	}
-
-	public function getPathById($id) {
-		return '';
-	}
-
-	public function normalize($path) {
-		return $path;
-	}
-
-	public function copyFromCache(ICache $sourceCache, ICacheEntry $sourceEntry, string $targetPath): int {
-		throw new \OC\ForbiddenException('This request is not allowed to access the filesystem');
-	}
-
-	public function getQueryFilterForStorage(): ISearchOperator {
-		return new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'storage', -1);
-	}
-
-	public function getCacheEntryFromSearchResult(ICacheEntry $rawEntry): ?ICacheEntry {
-		return null;
-	}
+    public function getNumericStorageId() {
+        return -1;
+    }
+
+    public function get($file) {
+        if ($file !== '') {
+            return false;
+        }
+
+        return 	new CacheEntry([
+            'fileid' => -1,
+            'parent' => -1,
+            'name' => '',
+            'path' => '',
+            'size' => '0',
+            'mtime' => time(),
+            'storage_mtime' => time(),
+            'etag' => '',
+            'mimetype' => FileInfo::MIMETYPE_FOLDER,
+            'mimepart' => 'httpd',
+            'permissions' => Constants::PERMISSION_READ
+        ]);
+    }
+
+    public function getFolderContents($folder) {
+        return [];
+    }
+
+    public function getFolderContentsById($fileId) {
+        return [];
+    }
+
+    public function put($file, array $data) {
+        throw new \OC\ForbiddenException('This request is not allowed to access the filesystem');
+    }
+
+    public function insert($file, array $data) {
+        throw new \OC\ForbiddenException('This request is not allowed to access the filesystem');
+    }
+
+    public function update($id, array $data) {
+        throw new \OC\ForbiddenException('This request is not allowed to access the filesystem');
+    }
+
+    public function getId($file) {
+        return -1;
+    }
+
+    public function getParentId($file) {
+        return -1;
+    }
+
+    public function inCache($file) {
+        return $file === '';
+    }
+
+    public function remove($file) {
+        throw new \OC\ForbiddenException('This request is not allowed to access the filesystem');
+    }
+
+    public function move($source, $target) {
+        throw new \OC\ForbiddenException('This request is not allowed to access the filesystem');
+    }
+
+    public function moveFromCache(ICache $sourceCache, $sourcePath, $targetPath) {
+        throw new \OC\ForbiddenException('This request is not allowed to access the filesystem');
+    }
+
+    public function getStatus($file) {
+        return ICache::COMPLETE;
+    }
+
+    public function search($pattern) {
+        return [];
+    }
+
+    public function searchByMime($mimetype) {
+        return [];
+    }
+
+    public function searchQuery(ISearchQuery $query) {
+        return [];
+    }
+
+    public function getIncomplete() {
+        return [];
+    }
+
+    public function getPathById($id) {
+        return '';
+    }
+
+    public function normalize($path) {
+        return $path;
+    }
+
+    public function copyFromCache(ICache $sourceCache, ICacheEntry $sourceEntry, string $targetPath): int {
+        throw new \OC\ForbiddenException('This request is not allowed to access the filesystem');
+    }
+
+    public function getQueryFilterForStorage(): ISearchOperator {
+        return new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'storage', -1);
+    }
+
+    public function getCacheEntryFromSearchResult(ICacheEntry $rawEntry): ?ICacheEntry {
+        return null;
+    }
 }