3 files changed, 69 insertions, 65 deletions

diff --git a/tests/lib/Lockdown/Filesystem/NoFSTest.php b/tests/lib/Lockdown/Filesystem/NoFSTest.php
index 7a636fbaaaa..b471f573fb7 100644
--- a/tests/lib/Lockdown/Filesystem/NoFSTest.php
+++ b/tests/lib/Lockdown/Filesystem/NoFSTest.php
@@ -1,4 +1,5 @@
 <?php
+
 /**
  * SPDX-FileCopyrightText: 2016 Nextcloud GmbH and Nextcloud contributors
  * SPDX-License-Identifier: AGPL-3.0-or-later
@@ -10,6 +11,7 @@ use OC\Authentication\Token\PublicKeyToken;
 use OC\Files\Filesystem;
 use OC\Lockdown\Filesystem\NullStorage;
 use OCP\Authentication\Token\IToken;
+use OCP\Server;
 use Test\Traits\UserTrait;
 
 /**
@@ -23,7 +25,7 @@ class NoFSTest extends \Test\TestCase {
 		$token->setScope([
 			IToken::SCOPE_FILESYSTEM => true
 		]);
-		\OC::$server->get('LockdownManager')->setToken($token);
+		Server::get('LockdownManager')->setToken($token);
 		parent::tearDown();
 	}
 
@@ -34,11 +36,11 @@ class NoFSTest extends \Test\TestCase {
 			IToken::SCOPE_FILESYSTEM => false
 		]);
 
-		\OC::$server->get('LockdownManager')->setToken($token);
+		Server::get('LockdownManager')->setToken($token);
 		$this->createUser('foo', 'var');
 	}
 
-	public function testSetupFS() {
+	public function testSetupFS(): void {
 		\OC_Util::tearDownFS();
 		\OC_Util::setupFS('foo');
 
diff --git a/tests/lib/Lockdown/Filesystem/NullCacheTest.php b/tests/lib/Lockdown/Filesystem/NullCacheTest.php
index eda4e10b1a6..505951ea2ef 100644
--- a/tests/lib/Lockdown/Filesystem/NullCacheTest.php
+++ b/tests/lib/Lockdown/Filesystem/NullCacheTest.php
@@ -1,4 +1,5 @@
 <?php
+
 /**
  * SPDX-FileCopyrightText: 2016 Nextcloud GmbH and Nextcloud contributors
  * SPDX-License-Identifier: AGPL-3.0-or-later
@@ -22,15 +23,15 @@ class NulLCacheTest extends \Test\TestCase {
 		$this->cache = new NullCache();
 	}
 
-	public function testGetNumericStorageId() {
+	public function testGetNumericStorageId(): void {
 		$this->assertSame(-1, $this->cache->getNumericStorageId());
 	}
 
-	public function testGetEmpty() {
-		$this->assertNull($this->cache->get('foo'));
+	public function testGetEmpty(): void {
+		$this->assertFalse($this->cache->get('foo'));
 	}
 
-	public function testGet() {
+	public function testGet(): void {
 		$data = $this->cache->get('');
 
 		$this->assertEquals(-1, $data['fileid']);
@@ -44,63 +45,63 @@ class NulLCacheTest extends \Test\TestCase {
 		$this->assertEquals(Constants::PERMISSION_READ, $data['permissions']);
 	}
 
-	public function testGetFolderContents() {
+	public function testGetFolderContents(): void {
 		$this->assertSame([], $this->cache->getFolderContents('foo'));
 	}
 
-	public function testGetFolderContentsById() {
+	public function testGetFolderContentsById(): void {
 		$this->assertSame([], $this->cache->getFolderContentsById(42));
 	}
 
-	public function testPut() {
+	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]);
 	}
 
-	public function testInsert() {
+	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]);
 	}
 
-	public function testUpdate() {
+	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]);
 	}
 
-	public function testGetId() {
+	public function testGetId(): void {
 		$this->assertSame(-1, $this->cache->getId('foo'));
 	}
 
-	public function testGetParentId() {
+	public function testGetParentId(): void {
 		$this->assertSame(-1, $this->cache->getParentId('foo'));
 	}
 
-	public function testInCache() {
+	public function testInCache(): void {
 		$this->assertTrue($this->cache->inCache(''));
 		$this->assertFalse($this->cache->inCache('foo'));
 	}
 
-	public function testRemove() {
+	public function testRemove(): void {
 		$this->expectException(ForbiddenException::class);
 		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
 		$this->cache->remove('foo');
 	}
 
-	public function testMove() {
+	public function testMove(): void {
 		$this->expectException(ForbiddenException::class);
 		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
 		$this->cache->move('foo', 'bar');
 	}
 
-	public function testMoveFromCache() {
+	public function testMoveFromCache(): void {
 		$sourceCache = $this->createMock(ICache::class);
 
 		$this->expectException(ForbiddenException::class);
@@ -109,27 +110,27 @@ class NulLCacheTest extends \Test\TestCase {
 		$this->cache->moveFromCache($sourceCache, 'foo', 'bar');
 	}
 
-	public function testGetStatus() {
+	public function testGetStatus(): void {
 		$this->assertSame(ICache::COMPLETE, $this->cache->getStatus('foo'));
 	}
 
-	public function testSearch() {
+	public function testSearch(): void {
 		$this->assertSame([], $this->cache->search('foo'));
 	}
 
-	public function testSearchByMime() {
+	public function testSearchByMime(): void {
 		$this->assertSame([], $this->cache->searchByMime('foo'));
 	}
 
-	public function testGetIncomplete() {
+	public function testGetIncomplete(): void {
 		$this->assertSame([], $this->cache->getIncomplete());
 	}
 
-	public function testGetPathById() {
+	public function testGetPathById(): void {
 		$this->assertSame('', $this->cache->getPathById(42));
 	}
 
-	public function testNormalize() {
+	public function testNormalize(): void {
 		$this->assertSame('foo/ bar /', $this->cache->normalize('foo/ bar /'));
 	}
 }
diff --git a/tests/lib/Lockdown/Filesystem/NullStorageTest.php b/tests/lib/Lockdown/Filesystem/NullStorageTest.php
index 727ccb83e21..fa019ada4e5 100644
--- a/tests/lib/Lockdown/Filesystem/NullStorageTest.php
+++ b/tests/lib/Lockdown/Filesystem/NullStorageTest.php
@@ -1,4 +1,5 @@
 <?php
+
 /**
  * SPDX-FileCopyrightText: 2016 Nextcloud GmbH and Nextcloud contributors
  * SPDX-License-Identifier: AGPL-3.0-or-later
@@ -11,7 +12,7 @@ use OC\Files\FileInfo;
 use OC\ForbiddenException;
 use OC\Lockdown\Filesystem\NullCache;
 use OC\Lockdown\Filesystem\NullStorage;
-use OCP\Files\Storage;
+use OCP\Files\Storage\IStorage;
 use Test\TestCase;
 
 class NullStorageTest extends TestCase {
@@ -24,179 +25,179 @@ class NullStorageTest extends TestCase {
 		$this->storage = new NullStorage([]);
 	}
 
-	public function testGetId() {
+	public function testGetId(): void {
 		$this->assertSame('null', $this->storage->getId());
 	}
 
-	public function testMkdir() {
+	public function testMkdir(): void {
 		$this->expectException(ForbiddenException::class);
 		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
 		$this->storage->mkdir('foo');
 	}
 
-	public function testRmdir() {
+	public function testRmdir(): void {
 		$this->expectException(ForbiddenException::class);
 		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
 		$this->storage->rmdir('foo');
 	}
 
-	public function testOpendir() {
+	public function testOpendir(): void {
 		$this->assertInstanceOf(IteratorDirectory::class, $this->storage->opendir('foo'));
 	}
 
-	public function testIs_dir() {
+	public function testIs_dir(): void {
 		$this->assertTrue($this->storage->is_dir(''));
 		$this->assertFalse($this->storage->is_dir('foo'));
 	}
 
-	public function testIs_file() {
+	public function testIs_file(): void {
 		$this->assertFalse($this->storage->is_file('foo'));
 	}
 
-	public function testStat() {
+	public function testStat(): void {
 		$this->expectException(ForbiddenException::class);
 		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
 		$this->storage->stat('foo');
 	}
 
-	public function testFiletype() {
+	public function testFiletype(): void {
 		$this->assertSame('dir', $this->storage->filetype(''));
 		$this->assertFalse($this->storage->filetype('foo'));
 	}
 
-	public function testFilesize() {
+	public function testFilesize(): void {
 		$this->expectException(ForbiddenException::class);
 		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
 		$this->storage->filesize('foo');
 	}
 
-	public function testIsCreatable() {
+	public function testIsCreatable(): void {
 		$this->assertFalse($this->storage->isCreatable('foo'));
 	}
 
-	public function testIsReadable() {
+	public function testIsReadable(): void {
 		$this->assertTrue($this->storage->isReadable(''));
 		$this->assertFalse($this->storage->isReadable('foo'));
 	}
 
-	public function testIsUpdatable() {
+	public function testIsUpdatable(): void {
 		$this->assertFalse($this->storage->isUpdatable('foo'));
 	}
 
-	public function testIsDeletable() {
+	public function testIsDeletable(): void {
 		$this->assertFalse($this->storage->isDeletable('foo'));
 	}
 
-	public function testIsSharable() {
+	public function testIsSharable(): void {
 		$this->assertFalse($this->storage->isSharable('foo'));
 	}
 
-	public function testGetPermissions() {
-		$this->assertNull($this->storage->getPermissions('foo'));
+	public function testGetPermissions(): void {
+		$this->assertEquals(0, $this->storage->getPermissions('foo'));
 	}
 
-	public function testFile_exists() {
+	public function testFile_exists(): void {
 		$this->assertTrue($this->storage->file_exists(''));
 		$this->assertFalse($this->storage->file_exists('foo'));
 	}
 
-	public function testFilemtime() {
+	public function testFilemtime(): void {
 		$this->assertFalse($this->storage->filemtime('foo'));
 	}
 
-	public function testFile_get_contents() {
+	public function testFile_get_contents(): void {
 		$this->expectException(ForbiddenException::class);
 		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
 		$this->storage->file_get_contents('foo');
 	}
 
-	public function testFile_put_contents() {
+	public function testFile_put_contents(): void {
 		$this->expectException(ForbiddenException::class);
 		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
 		$this->storage->file_put_contents('foo', 'bar');
 	}
 
-	public function testUnlink() {
+	public function testUnlink(): void {
 		$this->expectException(ForbiddenException::class);
 		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
 		$this->storage->unlink('foo');
 	}
 
-	public function testRename() {
+	public function testRename(): void {
 		$this->expectException(ForbiddenException::class);
 		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
 		$this->storage->rename('foo', 'bar');
 	}
 
-	public function testCopy() {
+	public function testCopy(): void {
 		$this->expectException(ForbiddenException::class);
 		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
 		$this->storage->copy('foo', 'bar');
 	}
 
-	public function testFopen() {
+	public function testFopen(): void {
 		$this->expectException(ForbiddenException::class);
 		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
 		$this->storage->fopen('foo', 'R');
 	}
 
-	public function testGetMimeType() {
+	public function testGetMimeType(): void {
 		$this->expectException(ForbiddenException::class);
 		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
 		$this->storage->getMimeType('foo');
 	}
 
-	public function testHash() {
+	public function testHash(): void {
 		$this->expectException(ForbiddenException::class);
 		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
 		$this->storage->hash('md5', 'foo', true);
 	}
 
-	public function testFree_space() {
+	public function testFree_space(): void {
 		$this->assertSame(FileInfo::SPACE_UNKNOWN, $this->storage->free_space('foo'));
 	}
 
-	public function testTouch() {
+	public function testTouch(): void {
 		$this->expectException(ForbiddenException::class);
 		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
 		$this->storage->touch('foo');
 	}
 
-	public function testGetLocalFile() {
+	public function testGetLocalFile(): void {
 		$this->assertFalse($this->storage->getLocalFile('foo'));
 	}
 
-	public function testHasUpdated() {
+	public function testHasUpdated(): void {
 		$this->assertFalse($this->storage->hasUpdated('foo', 42));
 	}
 
-	public function testGetETag() {
+	public function testGetETag(): void {
 		$this->assertSame('', $this->storage->getETag('foo'));
 	}
 
-	public function testIsLocal() {
+	public function testIsLocal(): void {
 		$this->assertFalse($this->storage->isLocal());
 	}
 
-	public function testGetDirectDownload() {
+	public function testGetDirectDownload(): void {
 		$this->assertFalse($this->storage->getDirectDownload('foo'));
 	}
 
-	public function testCopyFromStorage() {
-		$sourceStorage = $this->createMock(Storage::class);
+	public function testCopyFromStorage(): void {
+		$sourceStorage = $this->createMock(IStorage::class);
 
 		$this->expectException(ForbiddenException::class);
 		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
@@ -204,8 +205,8 @@ class NullStorageTest extends TestCase {
 		$this->storage->copyFromStorage($sourceStorage, 'foo', 'bar');
 	}
 
-	public function testMoveFromStorage() {
-		$sourceStorage = $this->createMock(Storage::class);
+	public function testMoveFromStorage(): void {
+		$sourceStorage = $this->createMock(IStorage::class);
 
 		$this->expectException(ForbiddenException::class);
 		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
@@ -218,11 +219,11 @@ class NullStorageTest extends TestCase {
 		return true;
 	}
 
-	public function testGetOwner() {
-		$this->assertNull($this->storage->getOwner('foo'));
+	public function testGetOwner(): void {
+		$this->assertFalse($this->storage->getOwner('foo'));
 	}
 
-	public function testGetCache() {
+	public function testGetCache(): void {
 		$this->assertInstanceOf(NullCache::class, $this->storage->getCache('foo'));
 	}
 }