nextcloud / server

apps/dav/tests/unit/Connector/Sabre/DirectoryTest.php

Indentation +576 added lines, -576 removed lines

@@ -29,585 +29,585 @@
 use Test\Traits\UserTrait;
 
 class TestViewDirectory extends View {
-	public function __construct(
-		private $updatables,
-		private $deletables,
-		private $canRename = true,
-	) {
-	}
-
-	public function isUpdatable($path) {
-		return $this->updatables[$path];
-	}
-
-	public function isCreatable($path) {
-		return $this->updatables[$path];
-	}
-
-	public function isDeletable($path) {
-		return $this->deletables[$path];
-	}
-
-	public function rename($source, $target, array $options = []) {
-		return $this->canRename;
-	}
-
-	public function getRelativePath($path): ?string {
-		return $path;
-	}
+    public function __construct(
+        private $updatables,
+        private $deletables,
+        private $canRename = true,
+    ) {
+    }
+
+    public function isUpdatable($path) {
+        return $this->updatables[$path];
+    }
+
+    public function isCreatable($path) {
+        return $this->updatables[$path];
+    }
+
+    public function isDeletable($path) {
+        return $this->deletables[$path];
+    }
+
+    public function rename($source, $target, array $options = []) {
+        return $this->canRename;
+    }
+
+    public function getRelativePath($path): ?string {
+        return $path;
+    }
 }
 
 
 #[\PHPUnit\Framework\Attributes\Group('DB')]
 class DirectoryTest extends \Test\TestCase {
-	use UserTrait;
-
-	private View&MockObject $view;
-	private FileInfo&MockObject $info;
-	private IStorage&MockObject $storage;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->view = $this->createMock(View::class);
-		$this->info = $this->createMock(FileInfo::class);
-		$this->storage = $this->createMock(IStorage::class);
-		$this->info->method('getStorage')
-			->willReturn($this->storage);
-		$this->info->method('isReadable')
-			->willReturn(true);
-		$this->info->method('getType')
-			->willReturn(Node::TYPE_FOLDER);
-		$this->info->method('getName')
-			->willReturn('folder');
-		$this->info->method('getPath')
-			->willReturn('/admin/files/folder');
-		$this->info->method('getPermissions')
-			->willReturn(Constants::PERMISSION_READ);
-	}
-
-	private function getDir(string $path = '/'): Directory {
-		$this->view->expects($this->once())
-			->method('getRelativePath')
-			->willReturn($path);
-
-		$this->info->expects($this->once())
-			->method('getPath')
-			->willReturn($path);
-
-		return new Directory($this->view, $this->info);
-	}
-
-
-	public function testDeleteRootFolderFails(): void {
-		$this->expectException(\Sabre\DAV\Exception\Forbidden::class);
-
-		$this->info->expects($this->any())
-			->method('isDeletable')
-			->willReturn(true);
-		$this->view->expects($this->never())
-			->method('rmdir');
-		$dir = $this->getDir();
-		$dir->delete();
-	}
-
-
-	public function testDeleteForbidden(): void {
-		$this->expectException(Forbidden::class);
-
-		// deletion allowed
-		$this->info->expects($this->once())
-			->method('isDeletable')
-			->willReturn(true);
-
-		// but fails
-		$this->view->expects($this->once())
-			->method('rmdir')
-			->with('sub')
-			->willThrowException(new ForbiddenException('', true));
-
-		$dir = $this->getDir('sub');
-		$dir->delete();
-	}
-
-
-	public function testDeleteFolderWhenAllowed(): void {
-		// deletion allowed
-		$this->info->expects($this->once())
-			->method('isDeletable')
-			->willReturn(true);
-
-		// but fails
-		$this->view->expects($this->once())
-			->method('rmdir')
-			->with('sub')
-			->willReturn(true);
-
-		$dir = $this->getDir('sub');
-		$dir->delete();
-	}
-
-
-	public function testDeleteFolderFailsWhenNotAllowed(): void {
-		$this->expectException(\Sabre\DAV\Exception\Forbidden::class);
-
-		$this->info->expects($this->once())
-			->method('isDeletable')
-			->willReturn(false);
-
-		$dir = $this->getDir('sub');
-		$dir->delete();
-	}
-
-
-	public function testDeleteFolderThrowsWhenDeletionFailed(): void {
-		$this->expectException(\Sabre\DAV\Exception\Forbidden::class);
-
-		// deletion allowed
-		$this->info->expects($this->once())
-			->method('isDeletable')
-			->willReturn(true);
-
-		// but fails
-		$this->view->expects($this->once())
-			->method('rmdir')
-			->with('sub')
-			->willReturn(false);
-
-		$dir = $this->getDir('sub');
-		$dir->delete();
-	}
-
-	public function testGetChildren(): void {
-		$info1 = $this->createMock(FileInfo::class);
-		$info2 = $this->createMock(FileInfo::class);
-		$info1->method('getName')
-			->willReturn('first');
-		$info1->method('getPath')
-			->willReturn('folder/first');
-		$info1->method('getEtag')
-			->willReturn('abc');
-		$info2->method('getName')
-			->willReturn('second');
-		$info2->method('getPath')
-			->willReturn('folder/second');
-		$info2->method('getEtag')
-			->willReturn('def');
-
-		$this->view->expects($this->once())
-			->method('getDirectoryContent')
-			->willReturn([$info1, $info2]);
-
-		$this->view->expects($this->any())
-			->method('getRelativePath')
-			->willReturnCallback(function ($path) {
-				return str_replace('/admin/files/', '', $path);
-			});
-
-		$this->view->expects($this->any())
-			->method('getAbsolutePath')
-			->willReturnCallback(function ($path) {
-				return Filesystem::normalizePath('/admin/files' . $path);
-			});
-
-		$this->overwriteService(View::class, $this->view);
-
-		$dir = new Directory($this->view, $this->info);
-		$nodes = $dir->getChildren();
-
-		$this->assertCount(2, $nodes);
-
-		// calling a second time just returns the cached values,
-		// does not call getDirectoryContents again
-		$dir->getChildren();
-	}
-
-
-	public function testGetChildrenNoPermission(): void {
-		$this->expectException(\Sabre\DAV\Exception\Forbidden::class);
-
-		$info = $this->createMock(FileInfo::class);
-		$info->expects($this->any())
-			->method('isReadable')
-			->willReturn(false);
-
-		$dir = new Directory($this->view, $info);
-		$dir->getChildren();
-	}
-
-
-	public function testGetChildNoPermission(): void {
-		$this->expectException(\Sabre\DAV\Exception\NotFound::class);
-
-		$this->info->expects($this->any())
-			->method('isReadable')
-			->willReturn(false);
-
-		$dir = new Directory($this->view, $this->info);
-		$dir->getChild('test');
-	}
-
-
-	public function testGetChildThrowStorageNotAvailableException(): void {
-		$this->expectException(\Sabre\DAV\Exception\ServiceUnavailable::class);
-
-		$this->view->expects($this->once())
-			->method('getFileInfo')
-			->willThrowException(new StorageNotAvailableException());
-
-		$dir = new Directory($this->view, $this->info);
-		$dir->getChild('.');
-	}
-
-
-	public function testGetChildThrowInvalidPath(): void {
-		$this->expectException(InvalidPath::class);
-
-		$this->view->expects($this->once())
-			->method('verifyPath')
-			->willThrowException(new InvalidPathException());
-		$this->view->expects($this->never())
-			->method('getFileInfo');
-
-		$dir = new Directory($this->view, $this->info);
-		$dir->getChild('.');
-	}
-
-	public function testGetNodeForPath(): void {
-		$directoryNode = $this->createMock(Folder::class);
-		$pathNode = $this->createMock(Folder::class);
-		$pathParentNode = $this->createMock(Folder::class);
-		$storage = $this->createMock(IStorage::class);
-
-		$directoryNode->expects($this->once())
-			->method('getStorage')
-			->willReturn($storage);
-		$storage->expects($this->once())
-			->method('instanceOfStorage')
-			->willReturn(false);
-
-		$directoryNode->expects($this->once())
-			->method('isReadable')
-			->willReturn(true);
-		$directoryNode->expects($this->once())
-			->method('getPath')
-			->willReturn('/admin/files/');
-		$directoryNode->expects($this->once())
-			->method('get')
-			->willReturn($pathNode);
-
-		$pathNode->expects($this->once())
-			->method('getPath')
-			->willReturn('/admin/files/my/deep/folder/');
-		$pathNode->expects($this->once())
-			->method('isReadable')
-			->willReturn(true);
-		$pathNode->expects($this->once())
-			->method('getMimetype')
-			->willReturn(FileInfo::MIMETYPE_FOLDER);
-
-		$this->view->method('getRelativePath')
-			->willReturnCallback(function ($path) {
-				return str_replace('/admin/files/', '', $path);
-			});
-
-		$this->view->expects($this->exactly(2))
-			->method('getFileInfo')
-			->willReturn($pathParentNode);
-
-		$pathParentNode->expects($this->exactly(2))
-			->method('getPath')
-			->willReturnOnConsecutiveCalls('/my/deep', '/my');
-		$pathParentNode->expects($this->exactly(2))
-			->method('isReadable')
-			->willReturn(true);
-
-		$dir = new Directory($this->view, $directoryNode);
-		$dir->getNodeForPath('/my/deep/folder/');
-	}
-
-	public function testGetNodeForPathFailsWithNoReadPermissionsForParent(): void {
-		$directoryNode = $this->createMock(Folder::class);
-		$pathNode = $this->createMock(Folder::class);
-		$pathParentNode = $this->createMock(Folder::class);
-		$storage = $this->createMock(IStorage::class);
-
-		$directoryNode->expects($this->once())
-			->method('getStorage')
-			->willReturn($storage);
-		$storage->expects($this->once())
-			->method('instanceOfStorage')
-			->willReturn(false);
-
-		$directoryNode->expects($this->once())
-			->method('isReadable')
-			->willReturn(true);
-		$directoryNode->expects($this->once())
-			->method('getPath')
-			->willReturn('/admin/files/');
-		$directoryNode->expects($this->once())
-			->method('get')
-			->willReturn($pathNode);
-
-		$pathNode->expects($this->once())
-			->method('getPath')
-			->willReturn('/admin/files/my/deep/folder/');
-		$pathNode->expects($this->once())
-			->method('isReadable')
-			->willReturn(true);
-		$pathNode->expects($this->once())
-			->method('getMimetype')
-			->willReturn(FileInfo::MIMETYPE_FOLDER);
-
-		$this->view->method('getRelativePath')
-			->willReturnCallback(function ($path) {
-				return str_replace('/admin/files/', '', $path);
-			});
-
-		$this->view->expects($this->exactly(2))
-			->method('getFileInfo')
-			->willReturn($pathParentNode);
-
-		$pathParentNode->expects($this->exactly(2))
-			->method('getPath')
-			->willReturnOnConsecutiveCalls('/my/deep', '/my');
-		$pathParentNode->expects($this->exactly(2))
-			->method('isReadable')
-			->willReturnOnConsecutiveCalls(true, false);
-
-		$this->expectException(NotFound::class);
-
-		$dir = new Directory($this->view, $directoryNode);
-		$dir->getNodeForPath('/my/deep/folder/');
-	}
-
-	public function testGetNodeForPathFailsWithNoReadPermissionsForPath(): void {
-		$directoryNode = $this->createMock(Folder::class);
-		$pathNode = $this->createMock(Folder::class);
-		$storage = $this->createMock(IStorage::class);
-
-		$directoryNode->expects($this->once())
-			->method('getStorage')
-			->willReturn($storage);
-		$storage->expects($this->once())
-			->method('instanceOfStorage')
-			->willReturn(false);
-
-		$directoryNode->expects($this->once())
-			->method('isReadable')
-			->willReturn(true);
-		$directoryNode->expects($this->once())
-			->method('getPath')
-			->willReturn('/admin/files/');
-		$directoryNode->expects($this->once())
-			->method('get')
-			->willReturn($pathNode);
-
-		$pathNode->expects($this->once())
-			->method('isReadable')
-			->willReturn(false);
-
-		$this->expectException(\Sabre\DAV\Exception\Forbidden::class);
-
-		$dir = new Directory($this->view, $directoryNode);
-		$dir->getNodeForPath('/my/deep/folder/');
-	}
-
-	public function testGetQuotaInfoUnlimited(): void {
-		$this->createUser('user', 'password');
-		self::loginAsUser('user');
-		$mountPoint = $this->createMock(IMountPoint::class);
-		$storage = $this->createMock(Quota::class);
-		$mountPoint->method('getStorage')
-			->willReturn($storage);
-
-		$storage->expects($this->any())
-			->method('instanceOfStorage')
-			->willReturnMap([
-				['\OCA\Files_Sharing\SharedStorage', false],
-				['\OC\Files\Storage\Wrapper\Quota', false],
-				[Storage::class, false],
-			]);
-
-		$storage->expects($this->once())
-			->method('getOwner')
-			->willReturn('user');
-
-		$storage->expects($this->never())
-			->method('getQuota');
-
-		$storage->expects($this->once())
-			->method('free_space')
-			->willReturn(800);
-
-		$this->info->expects($this->any())
-			->method('getPath')
-			->willReturn('/admin/files/foo');
-
-		$this->info->expects($this->once())
-			->method('getSize')
-			->willReturn(200);
-
-		$this->info->expects($this->once())
-			->method('getMountPoint')
-			->willReturn($mountPoint);
-
-		$this->view->expects($this->any())
-			->method('getRelativePath')
-			->willReturn('/foo');
-
-		$this->info->expects($this->once())
-			->method('getInternalPath')
-			->willReturn('/foo');
-
-		$mountPoint->method('getMountPoint')
-			->willReturn('/user/files/mymountpoint');
-
-		$dir = new Directory($this->view, $this->info);
-		$this->assertEquals([200, -3], $dir->getQuotaInfo()); //200 used, unlimited
-	}
-
-	public function testGetQuotaInfoSpecific(): void {
-		$this->createUser('user', 'password');
-		self::loginAsUser('user');
-		$mountPoint = $this->createMock(IMountPoint::class);
-		$storage = $this->createMock(Quota::class);
-		$mountPoint->method('getStorage')
-			->willReturn($storage);
-
-		$storage->expects($this->any())
-			->method('instanceOfStorage')
-			->willReturnMap([
-				['\OCA\Files_Sharing\SharedStorage', false],
-				['\OC\Files\Storage\Wrapper\Quota', true],
-				[Storage::class, false],
-			]);
-
-		$storage->expects($this->once())
-			->method('getOwner')
-			->willReturn('user');
-
-		$storage->expects($this->once())
-			->method('getQuota')
-			->willReturn(1000);
-
-		$storage->expects($this->once())
-			->method('free_space')
-			->willReturn(800);
-
-		$this->info->expects($this->once())
-			->method('getSize')
-			->willReturn(200);
-
-		$this->info->expects($this->once())
-			->method('getMountPoint')
-			->willReturn($mountPoint);
-
-		$this->info->expects($this->once())
-			->method('getInternalPath')
-			->willReturn('/foo');
-
-		$mountPoint->method('getMountPoint')
-			->willReturn('/user/files/mymountpoint');
-
-		$this->view->expects($this->any())
-			->method('getRelativePath')
-			->willReturn('/foo');
-
-		$dir = new Directory($this->view, $this->info);
-		$this->assertEquals([200, 800], $dir->getQuotaInfo()); //200 used, 800 free
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('moveFailedProvider')]
-	public function testMoveFailed(string $source, string $destination, array $updatables, array $deletables): void {
-		$this->expectException(\Sabre\DAV\Exception\Forbidden::class);
-
-		$this->moveTest($source, $destination, $updatables, $deletables);
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('moveSuccessProvider')]
-	public function testMoveSuccess(string $source, string $destination, array $updatables, array $deletables): void {
-		$this->moveTest($source, $destination, $updatables, $deletables);
-		$this->addToAssertionCount(1);
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('moveFailedInvalidCharsProvider')]
-	public function testMoveFailedInvalidChars(string $source, string $destination, array $updatables, array $deletables): void {
-		$this->expectException(InvalidPath::class);
-
-		$this->moveTest($source, $destination, $updatables, $deletables);
-	}
-
-	public static function moveFailedInvalidCharsProvider(): array {
-		return [
-			['a/valid', "a/i\nvalid", ['a' => true, 'a/valid' => true, 'a/c*' => false], []],
-		];
-	}
-
-	public static function moveFailedProvider(): array {
-		return [
-			['a/b', 'a/c', ['a' => false, 'a/b' => false, 'a/c' => false], []],
-			['a/b', 'b/b', ['a' => false, 'a/b' => false, 'b' => false, 'b/b' => false], []],
-			['a/b', 'b/b', ['a' => false, 'a/b' => true, 'b' => false, 'b/b' => false], []],
-			['a/b', 'b/b', ['a' => true, 'a/b' => true, 'b' => false, 'b/b' => false], []],
-			['a/b', 'b/b', ['a' => true, 'a/b' => true, 'b' => true, 'b/b' => false], ['a/b' => false]],
-			['a/b', 'a/c', ['a' => false, 'a/b' => true, 'a/c' => false], []],
-		];
-	}
-
-	public static function moveSuccessProvider(): array {
-		return [
-			['a/b', 'b/b', ['a' => true, 'a/b' => true, 'b' => true, 'b/b' => false], ['a/b' => true]],
-			// older files with special chars can still be renamed to valid names
-			['a/b*', 'b/b', ['a' => true, 'a/b*' => true, 'b' => true, 'b/b' => false], ['a/b*' => true]],
-		];
-	}
-
-	private function moveTest(string $source, string $destination, array $updatables, array $deletables): void {
-		$view = new TestViewDirectory($updatables, $deletables);
-
-		$sourceInfo = new FileInfo($source, null, null, [
-			'type' => FileInfo::TYPE_FOLDER,
-		], null);
-		$targetInfo = new FileInfo(dirname($destination), null, null, [
-			'type' => FileInfo::TYPE_FOLDER,
-		], null);
-
-		$sourceNode = new Directory($view, $sourceInfo);
-		$targetNode = $this->getMockBuilder(Directory::class)
-			->onlyMethods(['childExists'])
-			->setConstructorArgs([$view, $targetInfo])
-			->getMock();
-		$targetNode->expects($this->any())->method('childExists')
-			->with(basename($destination))
-			->willReturn(false);
-		$this->assertTrue($targetNode->moveInto(basename($destination), $source, $sourceNode));
-	}
-
-
-	public function testFailingMove(): void {
-		$this->expectException(\Sabre\DAV\Exception\Forbidden::class);
-		$this->expectExceptionMessage('Could not copy directory b, target exists');
-
-		$source = 'a/b';
-		$destination = 'c/b';
-		$updatables = ['a' => true, 'a/b' => true, 'b' => true, 'c/b' => false];
-		$deletables = ['a/b' => true];
-
-		$view = new TestViewDirectory($updatables, $deletables);
-
-		$sourceInfo = new FileInfo($source, null, null, ['type' => FileInfo::TYPE_FOLDER], null);
-		$targetInfo = new FileInfo(dirname($destination), null, null, ['type' => FileInfo::TYPE_FOLDER], null);
-
-		$sourceNode = new Directory($view, $sourceInfo);
-		$targetNode = $this->getMockBuilder(Directory::class)
-			->onlyMethods(['childExists'])
-			->setConstructorArgs([$view, $targetInfo])
-			->getMock();
-		$targetNode->expects($this->once())->method('childExists')
-			->with(basename($destination))
-			->willReturn(true);
-
-		$targetNode->moveInto(basename($destination), $source, $sourceNode);
-	}
+    use UserTrait;
+
+    private View&MockObject $view;
+    private FileInfo&MockObject $info;
+    private IStorage&MockObject $storage;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->view = $this->createMock(View::class);
+        $this->info = $this->createMock(FileInfo::class);
+        $this->storage = $this->createMock(IStorage::class);
+        $this->info->method('getStorage')
+            ->willReturn($this->storage);
+        $this->info->method('isReadable')
+            ->willReturn(true);
+        $this->info->method('getType')
+            ->willReturn(Node::TYPE_FOLDER);
+        $this->info->method('getName')
+            ->willReturn('folder');
+        $this->info->method('getPath')
+            ->willReturn('/admin/files/folder');
+        $this->info->method('getPermissions')
+            ->willReturn(Constants::PERMISSION_READ);
+    }
+
+    private function getDir(string $path = '/'): Directory {
+        $this->view->expects($this->once())
+            ->method('getRelativePath')
+            ->willReturn($path);
+
+        $this->info->expects($this->once())
+            ->method('getPath')
+            ->willReturn($path);
+
+        return new Directory($this->view, $this->info);
+    }
+
+
+    public function testDeleteRootFolderFails(): void {
+        $this->expectException(\Sabre\DAV\Exception\Forbidden::class);
+
+        $this->info->expects($this->any())
+            ->method('isDeletable')
+            ->willReturn(true);
+        $this->view->expects($this->never())
+            ->method('rmdir');
+        $dir = $this->getDir();
+        $dir->delete();
+    }
+
+
+    public function testDeleteForbidden(): void {
+        $this->expectException(Forbidden::class);
+
+        // deletion allowed
+        $this->info->expects($this->once())
+            ->method('isDeletable')
+            ->willReturn(true);
+
+        // but fails
+        $this->view->expects($this->once())
+            ->method('rmdir')
+            ->with('sub')
+            ->willThrowException(new ForbiddenException('', true));
+
+        $dir = $this->getDir('sub');
+        $dir->delete();
+    }
+
+
+    public function testDeleteFolderWhenAllowed(): void {
+        // deletion allowed
+        $this->info->expects($this->once())
+            ->method('isDeletable')
+            ->willReturn(true);
+
+        // but fails
+        $this->view->expects($this->once())
+            ->method('rmdir')
+            ->with('sub')
+            ->willReturn(true);
+
+        $dir = $this->getDir('sub');
+        $dir->delete();
+    }
+
+
+    public function testDeleteFolderFailsWhenNotAllowed(): void {
+        $this->expectException(\Sabre\DAV\Exception\Forbidden::class);
+
+        $this->info->expects($this->once())
+            ->method('isDeletable')
+            ->willReturn(false);
+
+        $dir = $this->getDir('sub');
+        $dir->delete();
+    }
+
+
+    public function testDeleteFolderThrowsWhenDeletionFailed(): void {
+        $this->expectException(\Sabre\DAV\Exception\Forbidden::class);
+
+        // deletion allowed
+        $this->info->expects($this->once())
+            ->method('isDeletable')
+            ->willReturn(true);
+
+        // but fails
+        $this->view->expects($this->once())
+            ->method('rmdir')
+            ->with('sub')
+            ->willReturn(false);
+
+        $dir = $this->getDir('sub');
+        $dir->delete();
+    }
+
+    public function testGetChildren(): void {
+        $info1 = $this->createMock(FileInfo::class);
+        $info2 = $this->createMock(FileInfo::class);
+        $info1->method('getName')
+            ->willReturn('first');
+        $info1->method('getPath')
+            ->willReturn('folder/first');
+        $info1->method('getEtag')
+            ->willReturn('abc');
+        $info2->method('getName')
+            ->willReturn('second');
+        $info2->method('getPath')
+            ->willReturn('folder/second');
+        $info2->method('getEtag')
+            ->willReturn('def');
+
+        $this->view->expects($this->once())
+            ->method('getDirectoryContent')
+            ->willReturn([$info1, $info2]);
+
+        $this->view->expects($this->any())
+            ->method('getRelativePath')
+            ->willReturnCallback(function ($path) {
+                return str_replace('/admin/files/', '', $path);
+            });
+
+        $this->view->expects($this->any())
+            ->method('getAbsolutePath')
+            ->willReturnCallback(function ($path) {
+                return Filesystem::normalizePath('/admin/files' . $path);
+            });
+
+        $this->overwriteService(View::class, $this->view);
+
+        $dir = new Directory($this->view, $this->info);
+        $nodes = $dir->getChildren();
+
+        $this->assertCount(2, $nodes);
+
+        // calling a second time just returns the cached values,
+        // does not call getDirectoryContents again
+        $dir->getChildren();
+    }
+
+
+    public function testGetChildrenNoPermission(): void {
+        $this->expectException(\Sabre\DAV\Exception\Forbidden::class);
+
+        $info = $this->createMock(FileInfo::class);
+        $info->expects($this->any())
+            ->method('isReadable')
+            ->willReturn(false);
+
+        $dir = new Directory($this->view, $info);
+        $dir->getChildren();
+    }
+
+
+    public function testGetChildNoPermission(): void {
+        $this->expectException(\Sabre\DAV\Exception\NotFound::class);
+
+        $this->info->expects($this->any())
+            ->method('isReadable')
+            ->willReturn(false);
+
+        $dir = new Directory($this->view, $this->info);
+        $dir->getChild('test');
+    }
+
+
+    public function testGetChildThrowStorageNotAvailableException(): void {
+        $this->expectException(\Sabre\DAV\Exception\ServiceUnavailable::class);
+
+        $this->view->expects($this->once())
+            ->method('getFileInfo')
+            ->willThrowException(new StorageNotAvailableException());
+
+        $dir = new Directory($this->view, $this->info);
+        $dir->getChild('.');
+    }
+
+
+    public function testGetChildThrowInvalidPath(): void {
+        $this->expectException(InvalidPath::class);
+
+        $this->view->expects($this->once())
+            ->method('verifyPath')
+            ->willThrowException(new InvalidPathException());
+        $this->view->expects($this->never())
+            ->method('getFileInfo');
+
+        $dir = new Directory($this->view, $this->info);
+        $dir->getChild('.');
+    }
+
+    public function testGetNodeForPath(): void {
+        $directoryNode = $this->createMock(Folder::class);
+        $pathNode = $this->createMock(Folder::class);
+        $pathParentNode = $this->createMock(Folder::class);
+        $storage = $this->createMock(IStorage::class);
+
+        $directoryNode->expects($this->once())
+            ->method('getStorage')
+            ->willReturn($storage);
+        $storage->expects($this->once())
+            ->method('instanceOfStorage')
+            ->willReturn(false);
+
+        $directoryNode->expects($this->once())
+            ->method('isReadable')
+            ->willReturn(true);
+        $directoryNode->expects($this->once())
+            ->method('getPath')
+            ->willReturn('/admin/files/');
+        $directoryNode->expects($this->once())
+            ->method('get')
+            ->willReturn($pathNode);
+
+        $pathNode->expects($this->once())
+            ->method('getPath')
+            ->willReturn('/admin/files/my/deep/folder/');
+        $pathNode->expects($this->once())
+            ->method('isReadable')
+            ->willReturn(true);
+        $pathNode->expects($this->once())
+            ->method('getMimetype')
+            ->willReturn(FileInfo::MIMETYPE_FOLDER);
+
+        $this->view->method('getRelativePath')
+            ->willReturnCallback(function ($path) {
+                return str_replace('/admin/files/', '', $path);
+            });
+
+        $this->view->expects($this->exactly(2))
+            ->method('getFileInfo')
+            ->willReturn($pathParentNode);
+
+        $pathParentNode->expects($this->exactly(2))
+            ->method('getPath')
+            ->willReturnOnConsecutiveCalls('/my/deep', '/my');
+        $pathParentNode->expects($this->exactly(2))
+            ->method('isReadable')
+            ->willReturn(true);
+
+        $dir = new Directory($this->view, $directoryNode);
+        $dir->getNodeForPath('/my/deep/folder/');
+    }
+
+    public function testGetNodeForPathFailsWithNoReadPermissionsForParent(): void {
+        $directoryNode = $this->createMock(Folder::class);
+        $pathNode = $this->createMock(Folder::class);
+        $pathParentNode = $this->createMock(Folder::class);
+        $storage = $this->createMock(IStorage::class);
+
+        $directoryNode->expects($this->once())
+            ->method('getStorage')
+            ->willReturn($storage);
+        $storage->expects($this->once())
+            ->method('instanceOfStorage')
+            ->willReturn(false);
+
+        $directoryNode->expects($this->once())
+            ->method('isReadable')
+            ->willReturn(true);
+        $directoryNode->expects($this->once())
+            ->method('getPath')
+            ->willReturn('/admin/files/');
+        $directoryNode->expects($this->once())
+            ->method('get')
+            ->willReturn($pathNode);
+
+        $pathNode->expects($this->once())
+            ->method('getPath')
+            ->willReturn('/admin/files/my/deep/folder/');
+        $pathNode->expects($this->once())
+            ->method('isReadable')
+            ->willReturn(true);
+        $pathNode->expects($this->once())
+            ->method('getMimetype')
+            ->willReturn(FileInfo::MIMETYPE_FOLDER);
+
+        $this->view->method('getRelativePath')
+            ->willReturnCallback(function ($path) {
+                return str_replace('/admin/files/', '', $path);
+            });
+
+        $this->view->expects($this->exactly(2))
+            ->method('getFileInfo')
+            ->willReturn($pathParentNode);
+
+        $pathParentNode->expects($this->exactly(2))
+            ->method('getPath')
+            ->willReturnOnConsecutiveCalls('/my/deep', '/my');
+        $pathParentNode->expects($this->exactly(2))
+            ->method('isReadable')
+            ->willReturnOnConsecutiveCalls(true, false);
+
+        $this->expectException(NotFound::class);
+
+        $dir = new Directory($this->view, $directoryNode);
+        $dir->getNodeForPath('/my/deep/folder/');
+    }
+
+    public function testGetNodeForPathFailsWithNoReadPermissionsForPath(): void {
+        $directoryNode = $this->createMock(Folder::class);
+        $pathNode = $this->createMock(Folder::class);
+        $storage = $this->createMock(IStorage::class);
+
+        $directoryNode->expects($this->once())
+            ->method('getStorage')
+            ->willReturn($storage);
+        $storage->expects($this->once())
+            ->method('instanceOfStorage')
+            ->willReturn(false);
+
+        $directoryNode->expects($this->once())
+            ->method('isReadable')
+            ->willReturn(true);
+        $directoryNode->expects($this->once())
+            ->method('getPath')
+            ->willReturn('/admin/files/');
+        $directoryNode->expects($this->once())
+            ->method('get')
+            ->willReturn($pathNode);
+
+        $pathNode->expects($this->once())
+            ->method('isReadable')
+            ->willReturn(false);
+
+        $this->expectException(\Sabre\DAV\Exception\Forbidden::class);
+
+        $dir = new Directory($this->view, $directoryNode);
+        $dir->getNodeForPath('/my/deep/folder/');
+    }
+
+    public function testGetQuotaInfoUnlimited(): void {
+        $this->createUser('user', 'password');
+        self::loginAsUser('user');
+        $mountPoint = $this->createMock(IMountPoint::class);
+        $storage = $this->createMock(Quota::class);
+        $mountPoint->method('getStorage')
+            ->willReturn($storage);
+
+        $storage->expects($this->any())
+            ->method('instanceOfStorage')
+            ->willReturnMap([
+                ['\OCA\Files_Sharing\SharedStorage', false],
+                ['\OC\Files\Storage\Wrapper\Quota', false],
+                [Storage::class, false],
+            ]);
+
+        $storage->expects($this->once())
+            ->method('getOwner')
+            ->willReturn('user');
+
+        $storage->expects($this->never())
+            ->method('getQuota');
+
+        $storage->expects($this->once())
+            ->method('free_space')
+            ->willReturn(800);
+
+        $this->info->expects($this->any())
+            ->method('getPath')
+            ->willReturn('/admin/files/foo');
+
+        $this->info->expects($this->once())
+            ->method('getSize')
+            ->willReturn(200);
+
+        $this->info->expects($this->once())
+            ->method('getMountPoint')
+            ->willReturn($mountPoint);
+
+        $this->view->expects($this->any())
+            ->method('getRelativePath')
+            ->willReturn('/foo');
+
+        $this->info->expects($this->once())
+            ->method('getInternalPath')
+            ->willReturn('/foo');
+
+        $mountPoint->method('getMountPoint')
+            ->willReturn('/user/files/mymountpoint');
+
+        $dir = new Directory($this->view, $this->info);
+        $this->assertEquals([200, -3], $dir->getQuotaInfo()); //200 used, unlimited
+    }
+
+    public function testGetQuotaInfoSpecific(): void {
+        $this->createUser('user', 'password');
+        self::loginAsUser('user');
+        $mountPoint = $this->createMock(IMountPoint::class);
+        $storage = $this->createMock(Quota::class);
+        $mountPoint->method('getStorage')
+            ->willReturn($storage);
+
+        $storage->expects($this->any())
+            ->method('instanceOfStorage')
+            ->willReturnMap([
+                ['\OCA\Files_Sharing\SharedStorage', false],
+                ['\OC\Files\Storage\Wrapper\Quota', true],
+                [Storage::class, false],
+            ]);
+
+        $storage->expects($this->once())
+            ->method('getOwner')
+            ->willReturn('user');
+
+        $storage->expects($this->once())
+            ->method('getQuota')
+            ->willReturn(1000);
+
+        $storage->expects($this->once())
+            ->method('free_space')
+            ->willReturn(800);
+
+        $this->info->expects($this->once())
+            ->method('getSize')
+            ->willReturn(200);
+
+        $this->info->expects($this->once())
+            ->method('getMountPoint')
+            ->willReturn($mountPoint);
+
+        $this->info->expects($this->once())
+            ->method('getInternalPath')
+            ->willReturn('/foo');
+
+        $mountPoint->method('getMountPoint')
+            ->willReturn('/user/files/mymountpoint');
+
+        $this->view->expects($this->any())
+            ->method('getRelativePath')
+            ->willReturn('/foo');
+
+        $dir = new Directory($this->view, $this->info);
+        $this->assertEquals([200, 800], $dir->getQuotaInfo()); //200 used, 800 free
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('moveFailedProvider')]
+    public function testMoveFailed(string $source, string $destination, array $updatables, array $deletables): void {
+        $this->expectException(\Sabre\DAV\Exception\Forbidden::class);
+
+        $this->moveTest($source, $destination, $updatables, $deletables);
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('moveSuccessProvider')]
+    public function testMoveSuccess(string $source, string $destination, array $updatables, array $deletables): void {
+        $this->moveTest($source, $destination, $updatables, $deletables);
+        $this->addToAssertionCount(1);
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('moveFailedInvalidCharsProvider')]
+    public function testMoveFailedInvalidChars(string $source, string $destination, array $updatables, array $deletables): void {
+        $this->expectException(InvalidPath::class);
+
+        $this->moveTest($source, $destination, $updatables, $deletables);
+    }
+
+    public static function moveFailedInvalidCharsProvider(): array {
+        return [
+            ['a/valid', "a/i\nvalid", ['a' => true, 'a/valid' => true, 'a/c*' => false], []],
+        ];
+    }
+
+    public static function moveFailedProvider(): array {
+        return [
+            ['a/b', 'a/c', ['a' => false, 'a/b' => false, 'a/c' => false], []],
+            ['a/b', 'b/b', ['a' => false, 'a/b' => false, 'b' => false, 'b/b' => false], []],
+            ['a/b', 'b/b', ['a' => false, 'a/b' => true, 'b' => false, 'b/b' => false], []],
+            ['a/b', 'b/b', ['a' => true, 'a/b' => true, 'b' => false, 'b/b' => false], []],
+            ['a/b', 'b/b', ['a' => true, 'a/b' => true, 'b' => true, 'b/b' => false], ['a/b' => false]],
+            ['a/b', 'a/c', ['a' => false, 'a/b' => true, 'a/c' => false], []],
+        ];
+    }
+
+    public static function moveSuccessProvider(): array {
+        return [
+            ['a/b', 'b/b', ['a' => true, 'a/b' => true, 'b' => true, 'b/b' => false], ['a/b' => true]],
+            // older files with special chars can still be renamed to valid names
+            ['a/b*', 'b/b', ['a' => true, 'a/b*' => true, 'b' => true, 'b/b' => false], ['a/b*' => true]],
+        ];
+    }
+
+    private function moveTest(string $source, string $destination, array $updatables, array $deletables): void {
+        $view = new TestViewDirectory($updatables, $deletables);
+
+        $sourceInfo = new FileInfo($source, null, null, [
+            'type' => FileInfo::TYPE_FOLDER,
+        ], null);
+        $targetInfo = new FileInfo(dirname($destination), null, null, [
+            'type' => FileInfo::TYPE_FOLDER,
+        ], null);
+
+        $sourceNode = new Directory($view, $sourceInfo);
+        $targetNode = $this->getMockBuilder(Directory::class)
+            ->onlyMethods(['childExists'])
+            ->setConstructorArgs([$view, $targetInfo])
+            ->getMock();
+        $targetNode->expects($this->any())->method('childExists')
+            ->with(basename($destination))
+            ->willReturn(false);
+        $this->assertTrue($targetNode->moveInto(basename($destination), $source, $sourceNode));
+    }
+
+
+    public function testFailingMove(): void {
+        $this->expectException(\Sabre\DAV\Exception\Forbidden::class);
+        $this->expectExceptionMessage('Could not copy directory b, target exists');
+
+        $source = 'a/b';
+        $destination = 'c/b';
+        $updatables = ['a' => true, 'a/b' => true, 'b' => true, 'c/b' => false];
+        $deletables = ['a/b' => true];
+
+        $view = new TestViewDirectory($updatables, $deletables);
+
+        $sourceInfo = new FileInfo($source, null, null, ['type' => FileInfo::TYPE_FOLDER], null);
+        $targetInfo = new FileInfo(dirname($destination), null, null, ['type' => FileInfo::TYPE_FOLDER], null);
+
+        $sourceNode = new Directory($view, $sourceInfo);
+        $targetNode = $this->getMockBuilder(Directory::class)
+            ->onlyMethods(['childExists'])
+            ->setConstructorArgs([$view, $targetInfo])
+            ->getMock();
+        $targetNode->expects($this->once())->method('childExists')
+            ->with(basename($destination))
+            ->willReturn(true);
+
+        $targetNode->moveInto(basename($destination), $source, $sourceNode);
+    }
 }

Spacing +5 added lines, -5 removed lines

@@ -200,14 +200,14 @@ 
 
 		$this->view->expects($this->any())
 			->method('getRelativePath')
-			->willReturnCallback(function ($path) {
+			->willReturnCallback(function($path) {
 				return str_replace('/admin/files/', '', $path);
 			});
 
 		$this->view->expects($this->any())
 			->method('getAbsolutePath')
-			->willReturnCallback(function ($path) {
-				return Filesystem::normalizePath('/admin/files' . $path);
+			->willReturnCallback(function($path) {
+				return Filesystem::normalizePath('/admin/files'.$path);
 			});
 
 		$this->overwriteService(View::class, $this->view);
@@ -307,7 +307,7 @@ 
 			->willReturn(FileInfo::MIMETYPE_FOLDER);
 
 		$this->view->method('getRelativePath')
-			->willReturnCallback(function ($path) {
+			->willReturnCallback(function($path) {
 				return str_replace('/admin/files/', '', $path);
 			});
 
@@ -360,7 +360,7 @@ 
 			->willReturn(FileInfo::MIMETYPE_FOLDER);
 
 		$this->view->method('getRelativePath')
-			->willReturnCallback(function ($path) {
+			->willReturnCallback(function($path) {
 				return str_replace('/admin/files/', '', $path);
 			});
 

apps/dav/lib/Connector/Sabre/Directory.php

Indentation +530 added lines, -530 removed lines

@@ -42,534 +42,534 @@
 use Sabre\DAV\INodeByPath;
 
 class Directory extends Node implements
-	\Sabre\DAV\ICollection,
-	\Sabre\DAV\IQuota,
-	\Sabre\DAV\IMoveTarget,
-	\Sabre\DAV\ICopyTarget,
-	INodeByPath {
-	/**
-	 * Cached directory content
-	 * @var FileInfo[]
-	 */
-	private ?array $dirContent = null;
-
-	/** Cached quota info */
-	private ?array $quotaInfo = null;
-
-	/**
-	 * Sets up the node, expects a full path name
-	 */
-	public function __construct(
-		View $view,
-		FileInfo $info,
-		private ?CachingTree $tree = null,
-		?IShareManager $shareManager = null,
-	) {
-		parent::__construct($view, $info, $shareManager);
-	}
-
-	/**
-	 * Creates a new file in the directory
-	 *
-	 * Data will either be supplied as a stream resource, or in certain cases
-	 * as a string. Keep in mind that you may have to support either.
-	 *
-	 * After successful creation of the file, you may choose to return the ETag
-	 * of the new file here.
-	 *
-	 * The returned ETag must be surrounded by double-quotes (The quotes should
-	 * be part of the actual string).
-	 *
-	 * If you cannot accurately determine the ETag, you should not return it.
-	 * If you don't store the file exactly as-is (you're transforming it
-	 * somehow) you should also not return an ETag.
-	 *
-	 * This means that if a subsequent GET to this new file does not exactly
-	 * return the same contents of what was submitted here, you are strongly
-	 * recommended to omit the ETag.
-	 *
-	 * @param string $name Name of the file
-	 * @param resource|string $data Initial payload
-	 * @return null|string
-	 * @throws Exception\EntityTooLarge
-	 * @throws Exception\UnsupportedMediaType
-	 * @throws FileLocked
-	 * @throws InvalidPath
-	 * @throws \Sabre\DAV\Exception
-	 * @throws \Sabre\DAV\Exception\BadRequest
-	 * @throws \Sabre\DAV\Exception\Forbidden
-	 * @throws \Sabre\DAV\Exception\ServiceUnavailable
-	 */
-	public function createFile($name, $data = null) {
-		try {
-			if (!$this->fileView->isCreatable($this->path)) {
-				throw new \Sabre\DAV\Exception\Forbidden();
-			}
-
-			$this->fileView->verifyPath($this->path, $name);
-
-			$path = $this->fileView->getAbsolutePath($this->path) . '/' . $name;
-			// in case the file already exists/overwriting
-			$info = $this->fileView->getFileInfo($this->path . '/' . $name);
-			if (!$info) {
-				// use a dummy FileInfo which is acceptable here since it will be refreshed after the put is complete
-				$info = new \OC\Files\FileInfo($path, null, null, [
-					'type' => FileInfo::TYPE_FILE
-				], null);
-			}
-			$node = new File($this->fileView, $info);
-
-			// only allow 1 process to upload a file at once but still allow reading the file while writing the part file
-			$node->acquireLock(ILockingProvider::LOCK_SHARED);
-			$this->fileView->lockFile($this->path . '/' . $name . '.upload.part', ILockingProvider::LOCK_EXCLUSIVE);
-
-			$result = $node->put($data);
-
-			$this->fileView->unlockFile($this->path . '/' . $name . '.upload.part', ILockingProvider::LOCK_EXCLUSIVE);
-			$node->releaseLock(ILockingProvider::LOCK_SHARED);
-			return $result;
-		} catch (StorageNotAvailableException $e) {
-			throw new \Sabre\DAV\Exception\ServiceUnavailable($e->getMessage(), $e->getCode(), $e);
-		} catch (InvalidPathException $ex) {
-			throw new InvalidPath($ex->getMessage(), false, $ex);
-		} catch (ForbiddenException $ex) {
-			throw new Forbidden($ex->getMessage(), $ex->getRetry(), $ex);
-		} catch (LockedException $e) {
-			throw new FileLocked($e->getMessage(), $e->getCode(), $e);
-		}
-	}
-
-	/**
-	 * Creates a new subdirectory
-	 *
-	 * @param string $name
-	 * @throws FileLocked
-	 * @throws InvalidPath
-	 * @throws \Sabre\DAV\Exception\Forbidden
-	 * @throws \Sabre\DAV\Exception\ServiceUnavailable
-	 */
-	public function createDirectory($name) {
-		try {
-			if (!$this->info->isCreatable()) {
-				throw new \Sabre\DAV\Exception\Forbidden();
-			}
-
-			$this->fileView->verifyPath($this->path, $name);
-			$newPath = $this->path . '/' . $name;
-			if (!$this->fileView->mkdir($newPath)) {
-				throw new \Sabre\DAV\Exception\Forbidden('Could not create directory ' . $newPath);
-			}
-		} catch (StorageNotAvailableException $e) {
-			throw new \Sabre\DAV\Exception\ServiceUnavailable($e->getMessage(), 0, $e);
-		} catch (InvalidPathException $ex) {
-			throw new InvalidPath($ex->getMessage(), false, $ex);
-		} catch (ForbiddenException $ex) {
-			throw new Forbidden($ex->getMessage(), $ex->getRetry(), $ex);
-		} catch (LockedException $e) {
-			throw new FileLocked($e->getMessage(), $e->getCode(), $e);
-		}
-	}
-
-	/**
-	 * Returns a specific child node, referenced by its name
-	 *
-	 * @param string $name
-	 * @param FileInfo $info
-	 * @return \Sabre\DAV\INode
-	 * @throws InvalidPath
-	 * @throws \Sabre\DAV\Exception\NotFound
-	 * @throws \Sabre\DAV\Exception\ServiceUnavailable
-	 */
-	public function getChild($name, $info = null, ?IRequest $request = null, ?IL10N $l10n = null) {
-		$storage = $this->info->getStorage();
-		$allowDirectory = false;
-
-		// Checking if we're in a file drop
-		// If we are, then only PUT and MKCOL are allowed (see plugin)
-		// so we are safe to return the directory without a risk of
-		// leaking files and folders structure.
-		if ($storage->instanceOfStorage(PublicShareWrapper::class)) {
-			$share = $storage->getShare();
-			$allowDirectory = ($share->getPermissions() & Constants::PERMISSION_READ) !== Constants::PERMISSION_READ;
-		}
-
-		// For file drop we need to be allowed to read the directory with the nickname
-		if (!$allowDirectory && !$this->info->isReadable()) {
-			// avoid detecting files through this way
-			throw new NotFound();
-		}
-
-		$path = $this->path . '/' . $name;
-		if (is_null($info)) {
-			try {
-				$this->fileView->verifyPath($this->path, $name, true);
-				$info = $this->fileView->getFileInfo($path);
-			} catch (StorageNotAvailableException $e) {
-				throw new \Sabre\DAV\Exception\ServiceUnavailable($e->getMessage(), 0, $e);
-			} catch (InvalidPathException $ex) {
-				throw new InvalidPath($ex->getMessage(), false, $ex);
-			} catch (ForbiddenException $e) {
-				throw new \Sabre\DAV\Exception\Forbidden($e->getMessage(), $e->getCode(), $e);
-			}
-		}
-
-		if (!$info) {
-			throw new \Sabre\DAV\Exception\NotFound('File with name ' . $path . ' could not be located');
-		}
-
-		if ($info->getMimeType() === FileInfo::MIMETYPE_FOLDER) {
-			$node = new Directory($this->fileView, $info, $this->tree, $this->shareManager);
-		} else {
-			// In case reading a directory was allowed but it turns out the node was a not a directory, reject it now.
-			if (!$this->info->isReadable()) {
-				throw new NotFound();
-			}
-
-			$node = new File($this->fileView, $info, $this->shareManager, $request, $l10n);
-		}
-		if ($this->tree) {
-			$this->tree->cacheNode($node);
-		}
-		return $node;
-	}
-
-	/**
-	 * Returns an array with all the child nodes
-	 *
-	 * @return \Sabre\DAV\INode[]
-	 * @throws \Sabre\DAV\Exception\Locked
-	 * @throws Forbidden
-	 */
-	public function getChildren() {
-		if (!is_null($this->dirContent)) {
-			return $this->dirContent;
-		}
-		try {
-			if (!$this->info->isReadable()) {
-				// return 403 instead of 404 because a 404 would make
-				// the caller believe that the collection itself does not exist
-				if (Server::get(IAppManager::class)->isEnabledForAnyone('files_accesscontrol')) {
-					throw new Forbidden('No read permissions. This might be caused by files_accesscontrol, check your configured rules');
-				} else {
-					throw new Forbidden('No read permissions');
-				}
-			}
-			$folderContent = $this->getNode()->getDirectoryListing();
-		} catch (LockedException $e) {
-			throw new Locked();
-		}
-
-		$nodes = [];
-		$request = Server::get(IRequest::class);
-		$l10nFactory = Server::get(IFactory::class);
-		$l10n = $l10nFactory->get(Application::APP_ID);
-		foreach ($folderContent as $info) {
-			$node = $this->getChild($info->getName(), $info, $request, $l10n);
-			$nodes[] = $node;
-		}
-		$this->dirContent = $nodes;
-		return $this->dirContent;
-	}
-
-	/**
-	 * Checks if a child exists.
-	 *
-	 * @param string $name
-	 * @return bool
-	 */
-	public function childExists($name) {
-		// note: here we do NOT resolve the chunk file name to the real file name
-		// to make sure we return false when checking for file existence with a chunk
-		// file name.
-		// This is to make sure that "createFile" is still triggered
-		// (required old code) instead of "updateFile".
-		//
-		// TODO: resolve chunk file name here and implement "updateFile"
-		$path = $this->path . '/' . $name;
-		return $this->fileView->file_exists($path);
-	}
-
-	/**
-	 * Deletes all files in this directory, and then itself
-	 *
-	 * @return void
-	 * @throws FileLocked
-	 * @throws \Sabre\DAV\Exception\Forbidden
-	 */
-	public function delete() {
-		if ($this->path === '' || $this->path === '/' || !$this->info->isDeletable()) {
-			throw new \Sabre\DAV\Exception\Forbidden();
-		}
-
-		try {
-			if (!$this->fileView->rmdir($this->path)) {
-				// assume it wasn't possible to remove due to permission issue
-				throw new \Sabre\DAV\Exception\Forbidden();
-			}
-		} catch (ForbiddenException $ex) {
-			throw new Forbidden($ex->getMessage(), $ex->getRetry());
-		} catch (LockedException $e) {
-			throw new FileLocked($e->getMessage(), $e->getCode(), $e);
-		}
-	}
-
-	private function getLogger(): LoggerInterface {
-		return Server::get(LoggerInterface::class);
-	}
-
-	/**
-	 * Returns available diskspace information
-	 *
-	 * @return array
-	 */
-	public function getQuotaInfo() {
-		if ($this->quotaInfo) {
-			return $this->quotaInfo;
-		}
-		$relativePath = $this->fileView->getRelativePath($this->info->getPath());
-		if ($relativePath === null) {
-			$this->getLogger()->warning('error while getting quota as the relative path cannot be found');
-			return [0, 0];
-		}
-
-		try {
-			$storageInfo = \OC_Helper::getStorageInfo($relativePath, $this->info, false);
-			if ($storageInfo['quota'] === FileInfo::SPACE_UNLIMITED) {
-				$free = FileInfo::SPACE_UNLIMITED;
-			} else {
-				$free = $storageInfo['free'];
-			}
-			$this->quotaInfo = [
-				$storageInfo['used'],
-				$free
-			];
-			return $this->quotaInfo;
-		} catch (NotFoundException $e) {
-			$this->getLogger()->warning('error while getting quota into', ['exception' => $e]);
-			return [0, 0];
-		} catch (StorageNotAvailableException $e) {
-			$this->getLogger()->warning('error while getting quota into', ['exception' => $e]);
-			return [0, 0];
-		} catch (NotPermittedException $e) {
-			$this->getLogger()->warning('error while getting quota into', ['exception' => $e]);
-			return [0, 0];
-		}
-	}
-
-	/**
-	 * Moves a node into this collection.
-	 *
-	 * It is up to the implementors to:
-	 *   1. Create the new resource.
-	 *   2. Remove the old resource.
-	 *   3. Transfer any properties or other data.
-	 *
-	 * Generally you should make very sure that your collection can easily move
-	 * the move.
-	 *
-	 * If you don't, just return false, which will trigger sabre/dav to handle
-	 * the move itself. If you return true from this function, the assumption
-	 * is that the move was successful.
-	 *
-	 * @param string $targetName New local file/collection name.
-	 * @param string $fullSourcePath Full path to source node
-	 * @param INode $sourceNode Source node itself
-	 * @return bool
-	 * @throws BadRequest
-	 * @throws ServiceUnavailable
-	 * @throws Forbidden
-	 * @throws FileLocked
-	 * @throws \Sabre\DAV\Exception\Forbidden
-	 */
-	public function moveInto($targetName, $fullSourcePath, INode $sourceNode) {
-		if (!$sourceNode instanceof Node) {
-			// it's a file of another kind, like FutureFile
-			if ($sourceNode instanceof IFile) {
-				// fallback to default copy+delete handling
-				return false;
-			}
-			throw new BadRequest('Incompatible node types');
-		}
-
-		$destinationPath = $this->getPath() . '/' . $targetName;
-
-
-		$targetNodeExists = $this->childExists($targetName);
-
-		// at getNodeForPath we also check the path for isForbiddenFileOrDir
-		// with that we have covered both source and destination
-		if ($sourceNode instanceof Directory && $targetNodeExists) {
-			throw new \Sabre\DAV\Exception\Forbidden('Could not copy directory ' . $sourceNode->getName() . ', target exists');
-		}
-
-		[$sourceDir,] = \Sabre\Uri\split($sourceNode->getPath());
-		$destinationDir = $this->getPath();
-
-		$sourcePath = $sourceNode->getPath();
-
-		$isMovableMount = false;
-		$sourceMount = Server::get(IMountManager::class)->find($this->fileView->getAbsolutePath($sourcePath));
-		$internalPath = $sourceMount->getInternalPath($this->fileView->getAbsolutePath($sourcePath));
-		if ($sourceMount instanceof MoveableMount && $internalPath === '') {
-			$isMovableMount = true;
-		}
-
-		try {
-			$sameFolder = ($sourceDir === $destinationDir);
-			// if we're overwriting or same folder
-			if ($targetNodeExists || $sameFolder) {
-				// note that renaming a share mount point is always allowed
-				if (!$this->fileView->isUpdatable($destinationDir) && !$isMovableMount) {
-					throw new \Sabre\DAV\Exception\Forbidden();
-				}
-			} else {
-				if (!$this->fileView->isCreatable($destinationDir)) {
-					throw new \Sabre\DAV\Exception\Forbidden();
-				}
-			}
-
-			if (!$sameFolder) {
-				// moving to a different folder, source will be gone, like a deletion
-				// note that moving a share mount point is always allowed
-				if (!$this->fileView->isDeletable($sourcePath) && !$isMovableMount) {
-					throw new \Sabre\DAV\Exception\Forbidden();
-				}
-			}
-
-			$fileName = basename($destinationPath);
-			try {
-				$this->fileView->verifyPath($destinationDir, $fileName);
-			} catch (InvalidPathException $ex) {
-				throw new InvalidPath($ex->getMessage());
-			}
-
-			$renameOkay = $this->fileView->rename($sourcePath, $destinationPath);
-			if (!$renameOkay) {
-				throw new \Sabre\DAV\Exception\Forbidden('');
-			}
-		} catch (StorageNotAvailableException $e) {
-			throw new ServiceUnavailable($e->getMessage(), $e->getCode(), $e);
-		} catch (ForbiddenException $ex) {
-			throw new Forbidden($ex->getMessage(), $ex->getRetry(), $ex);
-		} catch (LockedException $e) {
-			throw new FileLocked($e->getMessage(), $e->getCode(), $e);
-		}
-
-		return true;
-	}
-
-
-	public function copyInto($targetName, $sourcePath, INode $sourceNode) {
-		if ($sourceNode instanceof File || $sourceNode instanceof Directory) {
-			try {
-				$destinationPath = $this->getPath() . '/' . $targetName;
-				$sourcePath = $sourceNode->getPath();
-
-				if (!$this->fileView->isCreatable($this->getPath())) {
-					throw new \Sabre\DAV\Exception\Forbidden();
-				}
-
-				try {
-					$this->fileView->verifyPath($this->getPath(), $targetName);
-				} catch (InvalidPathException $ex) {
-					throw new InvalidPath($ex->getMessage());
-				}
-
-				$copyOkay = $this->fileView->copy($sourcePath, $destinationPath);
-
-				if (!$copyOkay) {
-					throw new \Sabre\DAV\Exception\Forbidden('Copy did not proceed');
-				}
-
-				return true;
-			} catch (StorageNotAvailableException $e) {
-				throw new ServiceUnavailable($e->getMessage(), $e->getCode(), $e);
-			} catch (ForbiddenException $ex) {
-				throw new Forbidden($ex->getMessage(), $ex->getRetry(), $ex);
-			} catch (LockedException $e) {
-				throw new FileLocked($e->getMessage(), $e->getCode(), $e);
-			}
-		}
-
-		return false;
-	}
-
-	public function getNode(): Folder {
-		return $this->node;
-	}
-
-	public function getNodeForPath($path): INode {
-		$storage = $this->info->getStorage();
-		$allowDirectory = false;
-
-		// Checking if we're in a file drop
-		// If we are, then only PUT and MKCOL are allowed (see plugin)
-		// so we are safe to return the directory without a risk of
-		// leaking files and folders structure.
-		if ($storage->instanceOfStorage(PublicShareWrapper::class)) {
-			$share = $storage->getShare();
-			$allowDirectory = ($share->getPermissions() & Constants::PERMISSION_READ) !== Constants::PERMISSION_READ;
-		}
-
-		// For file drop we need to be allowed to read the directory with the nickname
-		if (!$allowDirectory && !$this->info->isReadable()) {
-			// avoid detecting files through this way
-			throw new NotFound();
-		}
-
-		$destinationPath = PathHelper::normalizePath($this->getPath() . '/' . $path);
-		$destinationDir = dirname($destinationPath);
-
-		try {
-			$info = $this->getNode()->get($path);
-		} catch (NotFoundException $e) {
-			throw new \Sabre\DAV\Exception\NotFound('File with name ' . $destinationPath
-				. ' could not be located');
-		} catch (StorageNotAvailableException $e) {
-			throw new \Sabre\DAV\Exception\ServiceUnavailable($e->getMessage(), 0, $e);
-		} catch (NotPermittedException $ex) {
-			throw new InvalidPath($ex->getMessage(), false, $ex);
-		}
-
-		// if not in a public share with no read permissions, throw Forbidden
-		if (!$allowDirectory && !$info->isReadable()) {
-			if (Server::get(IAppManager::class)->isEnabledForAnyone('files_accesscontrol')) {
-				throw new Forbidden('No read permissions. This might be caused by files_accesscontrol, check your configured rules');
-			}
-
-			throw new Forbidden('No read permissions');
-		}
-
-		if ($info->getMimeType() === FileInfo::MIMETYPE_FOLDER) {
-			$node = new \OCA\DAV\Connector\Sabre\Directory($this->fileView, $info, $this->tree, $this->shareManager);
-		} else {
-			// In case reading a directory was allowed but it turns out the node was a not a directory, reject it now.
-			if (!$this->info->isReadable()) {
-				throw new NotFound();
-			}
-
-			$node = new File($this->fileView, $info, $this->shareManager);
-		}
-		$this->tree?->cacheNode($node);
-
-		// recurse upwards until the root and check for read permissions to keep
-		// ACL checks working in files_accesscontrol
-		if (!$allowDirectory && $destinationDir !== '') {
-			$scanPath = $destinationPath;
-			while (($scanPath = dirname($scanPath)) !== '/') {
-				// fileView can get the parent info in a cheaper way compared
-				// to the node API
-				/** @psalm-suppress InternalMethod */
-				$info = $this->fileView->getFileInfo($scanPath, false);
-				$directory = new Directory($this->fileView, $info, $this->tree, $this->shareManager);
-				$readable = $directory->getNode()->isReadable();
-				if (!$readable) {
-					throw new \Sabre\DAV\Exception\NotFound('File with name ' . $destinationPath
-						. ' could not be located');
-				}
-			}
-		}
-
-		return $node;
-	}
+    \Sabre\DAV\ICollection,
+    \Sabre\DAV\IQuota,
+    \Sabre\DAV\IMoveTarget,
+    \Sabre\DAV\ICopyTarget,
+    INodeByPath {
+    /**
+     * Cached directory content
+     * @var FileInfo[]
+     */
+    private ?array $dirContent = null;
+
+    /** Cached quota info */
+    private ?array $quotaInfo = null;
+
+    /**
+     * Sets up the node, expects a full path name
+     */
+    public function __construct(
+        View $view,
+        FileInfo $info,
+        private ?CachingTree $tree = null,
+        ?IShareManager $shareManager = null,
+    ) {
+        parent::__construct($view, $info, $shareManager);
+    }
+
+    /**
+     * Creates a new file in the directory
+     *
+     * Data will either be supplied as a stream resource, or in certain cases
+     * as a string. Keep in mind that you may have to support either.
+     *
+     * After successful creation of the file, you may choose to return the ETag
+     * of the new file here.
+     *
+     * The returned ETag must be surrounded by double-quotes (The quotes should
+     * be part of the actual string).
+     *
+     * If you cannot accurately determine the ETag, you should not return it.
+     * If you don't store the file exactly as-is (you're transforming it
+     * somehow) you should also not return an ETag.
+     *
+     * This means that if a subsequent GET to this new file does not exactly
+     * return the same contents of what was submitted here, you are strongly
+     * recommended to omit the ETag.
+     *
+     * @param string $name Name of the file
+     * @param resource|string $data Initial payload
+     * @return null|string
+     * @throws Exception\EntityTooLarge
+     * @throws Exception\UnsupportedMediaType
+     * @throws FileLocked
+     * @throws InvalidPath
+     * @throws \Sabre\DAV\Exception
+     * @throws \Sabre\DAV\Exception\BadRequest
+     * @throws \Sabre\DAV\Exception\Forbidden
+     * @throws \Sabre\DAV\Exception\ServiceUnavailable
+     */
+    public function createFile($name, $data = null) {
+        try {
+            if (!$this->fileView->isCreatable($this->path)) {
+                throw new \Sabre\DAV\Exception\Forbidden();
+            }
+
+            $this->fileView->verifyPath($this->path, $name);
+
+            $path = $this->fileView->getAbsolutePath($this->path) . '/' . $name;
+            // in case the file already exists/overwriting
+            $info = $this->fileView->getFileInfo($this->path . '/' . $name);
+            if (!$info) {
+                // use a dummy FileInfo which is acceptable here since it will be refreshed after the put is complete
+                $info = new \OC\Files\FileInfo($path, null, null, [
+                    'type' => FileInfo::TYPE_FILE
+                ], null);
+            }
+            $node = new File($this->fileView, $info);
+
+            // only allow 1 process to upload a file at once but still allow reading the file while writing the part file
+            $node->acquireLock(ILockingProvider::LOCK_SHARED);
+            $this->fileView->lockFile($this->path . '/' . $name . '.upload.part', ILockingProvider::LOCK_EXCLUSIVE);
+
+            $result = $node->put($data);
+
+            $this->fileView->unlockFile($this->path . '/' . $name . '.upload.part', ILockingProvider::LOCK_EXCLUSIVE);
+            $node->releaseLock(ILockingProvider::LOCK_SHARED);
+            return $result;
+        } catch (StorageNotAvailableException $e) {
+            throw new \Sabre\DAV\Exception\ServiceUnavailable($e->getMessage(), $e->getCode(), $e);
+        } catch (InvalidPathException $ex) {
+            throw new InvalidPath($ex->getMessage(), false, $ex);
+        } catch (ForbiddenException $ex) {
+            throw new Forbidden($ex->getMessage(), $ex->getRetry(), $ex);
+        } catch (LockedException $e) {
+            throw new FileLocked($e->getMessage(), $e->getCode(), $e);
+        }
+    }
+
+    /**
+     * Creates a new subdirectory
+     *
+     * @param string $name
+     * @throws FileLocked
+     * @throws InvalidPath
+     * @throws \Sabre\DAV\Exception\Forbidden
+     * @throws \Sabre\DAV\Exception\ServiceUnavailable
+     */
+    public function createDirectory($name) {
+        try {
+            if (!$this->info->isCreatable()) {
+                throw new \Sabre\DAV\Exception\Forbidden();
+            }
+
+            $this->fileView->verifyPath($this->path, $name);
+            $newPath = $this->path . '/' . $name;
+            if (!$this->fileView->mkdir($newPath)) {
+                throw new \Sabre\DAV\Exception\Forbidden('Could not create directory ' . $newPath);
+            }
+        } catch (StorageNotAvailableException $e) {
+            throw new \Sabre\DAV\Exception\ServiceUnavailable($e->getMessage(), 0, $e);
+        } catch (InvalidPathException $ex) {
+            throw new InvalidPath($ex->getMessage(), false, $ex);
+        } catch (ForbiddenException $ex) {
+            throw new Forbidden($ex->getMessage(), $ex->getRetry(), $ex);
+        } catch (LockedException $e) {
+            throw new FileLocked($e->getMessage(), $e->getCode(), $e);
+        }
+    }
+
+    /**
+     * Returns a specific child node, referenced by its name
+     *
+     * @param string $name
+     * @param FileInfo $info
+     * @return \Sabre\DAV\INode
+     * @throws InvalidPath
+     * @throws \Sabre\DAV\Exception\NotFound
+     * @throws \Sabre\DAV\Exception\ServiceUnavailable
+     */
+    public function getChild($name, $info = null, ?IRequest $request = null, ?IL10N $l10n = null) {
+        $storage = $this->info->getStorage();
+        $allowDirectory = false;
+
+        // Checking if we're in a file drop
+        // If we are, then only PUT and MKCOL are allowed (see plugin)
+        // so we are safe to return the directory without a risk of
+        // leaking files and folders structure.
+        if ($storage->instanceOfStorage(PublicShareWrapper::class)) {
+            $share = $storage->getShare();
+            $allowDirectory = ($share->getPermissions() & Constants::PERMISSION_READ) !== Constants::PERMISSION_READ;
+        }
+
+        // For file drop we need to be allowed to read the directory with the nickname
+        if (!$allowDirectory && !$this->info->isReadable()) {
+            // avoid detecting files through this way
+            throw new NotFound();
+        }
+
+        $path = $this->path . '/' . $name;
+        if (is_null($info)) {
+            try {
+                $this->fileView->verifyPath($this->path, $name, true);
+                $info = $this->fileView->getFileInfo($path);
+            } catch (StorageNotAvailableException $e) {
+                throw new \Sabre\DAV\Exception\ServiceUnavailable($e->getMessage(), 0, $e);
+            } catch (InvalidPathException $ex) {
+                throw new InvalidPath($ex->getMessage(), false, $ex);
+            } catch (ForbiddenException $e) {
+                throw new \Sabre\DAV\Exception\Forbidden($e->getMessage(), $e->getCode(), $e);
+            }
+        }
+
+        if (!$info) {
+            throw new \Sabre\DAV\Exception\NotFound('File with name ' . $path . ' could not be located');
+        }
+
+        if ($info->getMimeType() === FileInfo::MIMETYPE_FOLDER) {
+            $node = new Directory($this->fileView, $info, $this->tree, $this->shareManager);
+        } else {
+            // In case reading a directory was allowed but it turns out the node was a not a directory, reject it now.
+            if (!$this->info->isReadable()) {
+                throw new NotFound();
+            }
+
+            $node = new File($this->fileView, $info, $this->shareManager, $request, $l10n);
+        }
+        if ($this->tree) {
+            $this->tree->cacheNode($node);
+        }
+        return $node;
+    }
+
+    /**
+     * Returns an array with all the child nodes
+     *
+     * @return \Sabre\DAV\INode[]
+     * @throws \Sabre\DAV\Exception\Locked
+     * @throws Forbidden
+     */
+    public function getChildren() {
+        if (!is_null($this->dirContent)) {
+            return $this->dirContent;
+        }
+        try {
+            if (!$this->info->isReadable()) {
+                // return 403 instead of 404 because a 404 would make
+                // the caller believe that the collection itself does not exist
+                if (Server::get(IAppManager::class)->isEnabledForAnyone('files_accesscontrol')) {
+                    throw new Forbidden('No read permissions. This might be caused by files_accesscontrol, check your configured rules');
+                } else {
+                    throw new Forbidden('No read permissions');
+                }
+            }
+            $folderContent = $this->getNode()->getDirectoryListing();
+        } catch (LockedException $e) {
+            throw new Locked();
+        }
+
+        $nodes = [];
+        $request = Server::get(IRequest::class);
+        $l10nFactory = Server::get(IFactory::class);
+        $l10n = $l10nFactory->get(Application::APP_ID);
+        foreach ($folderContent as $info) {
+            $node = $this->getChild($info->getName(), $info, $request, $l10n);
+            $nodes[] = $node;
+        }
+        $this->dirContent = $nodes;
+        return $this->dirContent;
+    }
+
+    /**
+     * Checks if a child exists.
+     *
+     * @param string $name
+     * @return bool
+     */
+    public function childExists($name) {
+        // note: here we do NOT resolve the chunk file name to the real file name
+        // to make sure we return false when checking for file existence with a chunk
+        // file name.
+        // This is to make sure that "createFile" is still triggered
+        // (required old code) instead of "updateFile".
+        //
+        // TODO: resolve chunk file name here and implement "updateFile"
+        $path = $this->path . '/' . $name;
+        return $this->fileView->file_exists($path);
+    }
+
+    /**
+     * Deletes all files in this directory, and then itself
+     *
+     * @return void
+     * @throws FileLocked
+     * @throws \Sabre\DAV\Exception\Forbidden
+     */
+    public function delete() {
+        if ($this->path === '' || $this->path === '/' || !$this->info->isDeletable()) {
+            throw new \Sabre\DAV\Exception\Forbidden();
+        }
+
+        try {
+            if (!$this->fileView->rmdir($this->path)) {
+                // assume it wasn't possible to remove due to permission issue
+                throw new \Sabre\DAV\Exception\Forbidden();
+            }
+        } catch (ForbiddenException $ex) {
+            throw new Forbidden($ex->getMessage(), $ex->getRetry());
+        } catch (LockedException $e) {
+            throw new FileLocked($e->getMessage(), $e->getCode(), $e);
+        }
+    }
+
+    private function getLogger(): LoggerInterface {
+        return Server::get(LoggerInterface::class);
+    }
+
+    /**
+     * Returns available diskspace information
+     *
+     * @return array
+     */
+    public function getQuotaInfo() {
+        if ($this->quotaInfo) {
+            return $this->quotaInfo;
+        }
+        $relativePath = $this->fileView->getRelativePath($this->info->getPath());
+        if ($relativePath === null) {
+            $this->getLogger()->warning('error while getting quota as the relative path cannot be found');
+            return [0, 0];
+        }
+
+        try {
+            $storageInfo = \OC_Helper::getStorageInfo($relativePath, $this->info, false);
+            if ($storageInfo['quota'] === FileInfo::SPACE_UNLIMITED) {
+                $free = FileInfo::SPACE_UNLIMITED;
+            } else {
+                $free = $storageInfo['free'];
+            }
+            $this->quotaInfo = [
+                $storageInfo['used'],
+                $free
+            ];
+            return $this->quotaInfo;
+        } catch (NotFoundException $e) {
+            $this->getLogger()->warning('error while getting quota into', ['exception' => $e]);
+            return [0, 0];
+        } catch (StorageNotAvailableException $e) {
+            $this->getLogger()->warning('error while getting quota into', ['exception' => $e]);
+            return [0, 0];
+        } catch (NotPermittedException $e) {
+            $this->getLogger()->warning('error while getting quota into', ['exception' => $e]);
+            return [0, 0];
+        }
+    }
+
+    /**
+     * Moves a node into this collection.
+     *
+     * It is up to the implementors to:
+     *   1. Create the new resource.
+     *   2. Remove the old resource.
+     *   3. Transfer any properties or other data.
+     *
+     * Generally you should make very sure that your collection can easily move
+     * the move.
+     *
+     * If you don't, just return false, which will trigger sabre/dav to handle
+     * the move itself. If you return true from this function, the assumption
+     * is that the move was successful.
+     *
+     * @param string $targetName New local file/collection name.
+     * @param string $fullSourcePath Full path to source node
+     * @param INode $sourceNode Source node itself
+     * @return bool
+     * @throws BadRequest
+     * @throws ServiceUnavailable
+     * @throws Forbidden
+     * @throws FileLocked
+     * @throws \Sabre\DAV\Exception\Forbidden
+     */
+    public function moveInto($targetName, $fullSourcePath, INode $sourceNode) {
+        if (!$sourceNode instanceof Node) {
+            // it's a file of another kind, like FutureFile
+            if ($sourceNode instanceof IFile) {
+                // fallback to default copy+delete handling
+                return false;
+            }
+            throw new BadRequest('Incompatible node types');
+        }
+
+        $destinationPath = $this->getPath() . '/' . $targetName;
+
+
+        $targetNodeExists = $this->childExists($targetName);
+
+        // at getNodeForPath we also check the path for isForbiddenFileOrDir
+        // with that we have covered both source and destination
+        if ($sourceNode instanceof Directory && $targetNodeExists) {
+            throw new \Sabre\DAV\Exception\Forbidden('Could not copy directory ' . $sourceNode->getName() . ', target exists');
+        }
+
+        [$sourceDir,] = \Sabre\Uri\split($sourceNode->getPath());
+        $destinationDir = $this->getPath();
+
+        $sourcePath = $sourceNode->getPath();
+
+        $isMovableMount = false;
+        $sourceMount = Server::get(IMountManager::class)->find($this->fileView->getAbsolutePath($sourcePath));
+        $internalPath = $sourceMount->getInternalPath($this->fileView->getAbsolutePath($sourcePath));
+        if ($sourceMount instanceof MoveableMount && $internalPath === '') {
+            $isMovableMount = true;
+        }
+
+        try {
+            $sameFolder = ($sourceDir === $destinationDir);
+            // if we're overwriting or same folder
+            if ($targetNodeExists || $sameFolder) {
+                // note that renaming a share mount point is always allowed
+                if (!$this->fileView->isUpdatable($destinationDir) && !$isMovableMount) {
+                    throw new \Sabre\DAV\Exception\Forbidden();
+                }
+            } else {
+                if (!$this->fileView->isCreatable($destinationDir)) {
+                    throw new \Sabre\DAV\Exception\Forbidden();
+                }
+            }
+
+            if (!$sameFolder) {
+                // moving to a different folder, source will be gone, like a deletion
+                // note that moving a share mount point is always allowed
+                if (!$this->fileView->isDeletable($sourcePath) && !$isMovableMount) {
+                    throw new \Sabre\DAV\Exception\Forbidden();
+                }
+            }
+
+            $fileName = basename($destinationPath);
+            try {
+                $this->fileView->verifyPath($destinationDir, $fileName);
+            } catch (InvalidPathException $ex) {
+                throw new InvalidPath($ex->getMessage());
+            }
+
+            $renameOkay = $this->fileView->rename($sourcePath, $destinationPath);
+            if (!$renameOkay) {
+                throw new \Sabre\DAV\Exception\Forbidden('');
+            }
+        } catch (StorageNotAvailableException $e) {
+            throw new ServiceUnavailable($e->getMessage(), $e->getCode(), $e);
+        } catch (ForbiddenException $ex) {
+            throw new Forbidden($ex->getMessage(), $ex->getRetry(), $ex);
+        } catch (LockedException $e) {
+            throw new FileLocked($e->getMessage(), $e->getCode(), $e);
+        }
+
+        return true;
+    }
+
+
+    public function copyInto($targetName, $sourcePath, INode $sourceNode) {
+        if ($sourceNode instanceof File || $sourceNode instanceof Directory) {
+            try {
+                $destinationPath = $this->getPath() . '/' . $targetName;
+                $sourcePath = $sourceNode->getPath();
+
+                if (!$this->fileView->isCreatable($this->getPath())) {
+                    throw new \Sabre\DAV\Exception\Forbidden();
+                }
+
+                try {
+                    $this->fileView->verifyPath($this->getPath(), $targetName);
+                } catch (InvalidPathException $ex) {
+                    throw new InvalidPath($ex->getMessage());
+                }
+
+                $copyOkay = $this->fileView->copy($sourcePath, $destinationPath);
+
+                if (!$copyOkay) {
+                    throw new \Sabre\DAV\Exception\Forbidden('Copy did not proceed');
+                }
+
+                return true;
+            } catch (StorageNotAvailableException $e) {
+                throw new ServiceUnavailable($e->getMessage(), $e->getCode(), $e);
+            } catch (ForbiddenException $ex) {
+                throw new Forbidden($ex->getMessage(), $ex->getRetry(), $ex);
+            } catch (LockedException $e) {
+                throw new FileLocked($e->getMessage(), $e->getCode(), $e);
+            }
+        }
+
+        return false;
+    }
+
+    public function getNode(): Folder {
+        return $this->node;
+    }
+
+    public function getNodeForPath($path): INode {
+        $storage = $this->info->getStorage();
+        $allowDirectory = false;
+
+        // Checking if we're in a file drop
+        // If we are, then only PUT and MKCOL are allowed (see plugin)
+        // so we are safe to return the directory without a risk of
+        // leaking files and folders structure.
+        if ($storage->instanceOfStorage(PublicShareWrapper::class)) {
+            $share = $storage->getShare();
+            $allowDirectory = ($share->getPermissions() & Constants::PERMISSION_READ) !== Constants::PERMISSION_READ;
+        }
+
+        // For file drop we need to be allowed to read the directory with the nickname
+        if (!$allowDirectory && !$this->info->isReadable()) {
+            // avoid detecting files through this way
+            throw new NotFound();
+        }
+
+        $destinationPath = PathHelper::normalizePath($this->getPath() . '/' . $path);
+        $destinationDir = dirname($destinationPath);
+
+        try {
+            $info = $this->getNode()->get($path);
+        } catch (NotFoundException $e) {
+            throw new \Sabre\DAV\Exception\NotFound('File with name ' . $destinationPath
+                . ' could not be located');
+        } catch (StorageNotAvailableException $e) {
+            throw new \Sabre\DAV\Exception\ServiceUnavailable($e->getMessage(), 0, $e);
+        } catch (NotPermittedException $ex) {
+            throw new InvalidPath($ex->getMessage(), false, $ex);
+        }
+
+        // if not in a public share with no read permissions, throw Forbidden
+        if (!$allowDirectory && !$info->isReadable()) {
+            if (Server::get(IAppManager::class)->isEnabledForAnyone('files_accesscontrol')) {
+                throw new Forbidden('No read permissions. This might be caused by files_accesscontrol, check your configured rules');
+            }
+
+            throw new Forbidden('No read permissions');
+        }
+
+        if ($info->getMimeType() === FileInfo::MIMETYPE_FOLDER) {
+            $node = new \OCA\DAV\Connector\Sabre\Directory($this->fileView, $info, $this->tree, $this->shareManager);
+        } else {
+            // In case reading a directory was allowed but it turns out the node was a not a directory, reject it now.
+            if (!$this->info->isReadable()) {
+                throw new NotFound();
+            }
+
+            $node = new File($this->fileView, $info, $this->shareManager);
+        }
+        $this->tree?->cacheNode($node);
+
+        // recurse upwards until the root and check for read permissions to keep
+        // ACL checks working in files_accesscontrol
+        if (!$allowDirectory && $destinationDir !== '') {
+            $scanPath = $destinationPath;
+            while (($scanPath = dirname($scanPath)) !== '/') {
+                // fileView can get the parent info in a cheaper way compared
+                // to the node API
+                /** @psalm-suppress InternalMethod */
+                $info = $this->fileView->getFileInfo($scanPath, false);
+                $directory = new Directory($this->fileView, $info, $this->tree, $this->shareManager);
+                $readable = $directory->getNode()->isReadable();
+                if (!$readable) {
+                    throw new \Sabre\DAV\Exception\NotFound('File with name ' . $destinationPath
+                        . ' could not be located');
+                }
+            }
+        }
+
+        return $node;
+    }
 }

Spacing +16 added lines, -16 removed lines

@@ -108,9 +108,9 @@ 
 
 			$this->fileView->verifyPath($this->path, $name);
 
-			$path = $this->fileView->getAbsolutePath($this->path) . '/' . $name;
+			$path = $this->fileView->getAbsolutePath($this->path).'/'.$name;
 			// in case the file already exists/overwriting
-			$info = $this->fileView->getFileInfo($this->path . '/' . $name);
+			$info = $this->fileView->getFileInfo($this->path.'/'.$name);
 			if (!$info) {
 				// use a dummy FileInfo which is acceptable here since it will be refreshed after the put is complete
 				$info = new \OC\Files\FileInfo($path, null, null, [
@@ -121,11 +121,11 @@ 
 
 			// only allow 1 process to upload a file at once but still allow reading the file while writing the part file
 			$node->acquireLock(ILockingProvider::LOCK_SHARED);
-			$this->fileView->lockFile($this->path . '/' . $name . '.upload.part', ILockingProvider::LOCK_EXCLUSIVE);
+			$this->fileView->lockFile($this->path.'/'.$name.'.upload.part', ILockingProvider::LOCK_EXCLUSIVE);
 
 			$result = $node->put($data);
 
-			$this->fileView->unlockFile($this->path . '/' . $name . '.upload.part', ILockingProvider::LOCK_EXCLUSIVE);
+			$this->fileView->unlockFile($this->path.'/'.$name.'.upload.part', ILockingProvider::LOCK_EXCLUSIVE);
 			$node->releaseLock(ILockingProvider::LOCK_SHARED);
 			return $result;
 		} catch (StorageNotAvailableException $e) {
@@ -155,9 +155,9 @@ 
 			}
 
 			$this->fileView->verifyPath($this->path, $name);
-			$newPath = $this->path . '/' . $name;
+			$newPath = $this->path.'/'.$name;
 			if (!$this->fileView->mkdir($newPath)) {
-				throw new \Sabre\DAV\Exception\Forbidden('Could not create directory ' . $newPath);
+				throw new \Sabre\DAV\Exception\Forbidden('Could not create directory '.$newPath);
 			}
 		} catch (StorageNotAvailableException $e) {
 			throw new \Sabre\DAV\Exception\ServiceUnavailable($e->getMessage(), 0, $e);
@@ -199,7 +199,7 @@ 
 			throw new NotFound();
 		}
 
-		$path = $this->path . '/' . $name;
+		$path = $this->path.'/'.$name;
 		if (is_null($info)) {
 			try {
 				$this->fileView->verifyPath($this->path, $name, true);
@@ -214,7 +214,7 @@ 
 		}
 
 		if (!$info) {
-			throw new \Sabre\DAV\Exception\NotFound('File with name ' . $path . ' could not be located');
+			throw new \Sabre\DAV\Exception\NotFound('File with name '.$path.' could not be located');
 		}
 
 		if ($info->getMimeType() === FileInfo::MIMETYPE_FOLDER) {
@@ -285,7 +285,7 @@ 
 		// (required old code) instead of "updateFile".
 		//
 		// TODO: resolve chunk file name here and implement "updateFile"
-		$path = $this->path . '/' . $name;
+		$path = $this->path.'/'.$name;
 		return $this->fileView->file_exists($path);
 	}
 
@@ -391,7 +391,7 @@ 
 			throw new BadRequest('Incompatible node types');
 		}
 
-		$destinationPath = $this->getPath() . '/' . $targetName;
+		$destinationPath = $this->getPath().'/'.$targetName;
 
 
 		$targetNodeExists = $this->childExists($targetName);
@@ -399,10 +399,10 @@ 
 		// at getNodeForPath we also check the path for isForbiddenFileOrDir
 		// with that we have covered both source and destination
 		if ($sourceNode instanceof Directory && $targetNodeExists) {
-			throw new \Sabre\DAV\Exception\Forbidden('Could not copy directory ' . $sourceNode->getName() . ', target exists');
+			throw new \Sabre\DAV\Exception\Forbidden('Could not copy directory '.$sourceNode->getName().', target exists');
 		}
 
-		[$sourceDir,] = \Sabre\Uri\split($sourceNode->getPath());
+		[$sourceDir, ] = \Sabre\Uri\split($sourceNode->getPath());
 		$destinationDir = $this->getPath();
 
 		$sourcePath = $sourceNode->getPath();
@@ -462,7 +462,7 @@ 
 	public function copyInto($targetName, $sourcePath, INode $sourceNode) {
 		if ($sourceNode instanceof File || $sourceNode instanceof Directory) {
 			try {
-				$destinationPath = $this->getPath() . '/' . $targetName;
+				$destinationPath = $this->getPath().'/'.$targetName;
 				$sourcePath = $sourceNode->getPath();
 
 				if (!$this->fileView->isCreatable($this->getPath())) {
@@ -517,13 +517,13 @@ 
 			throw new NotFound();
 		}
 
-		$destinationPath = PathHelper::normalizePath($this->getPath() . '/' . $path);
+		$destinationPath = PathHelper::normalizePath($this->getPath().'/'.$path);
 		$destinationDir = dirname($destinationPath);
 
 		try {
 			$info = $this->getNode()->get($path);
 		} catch (NotFoundException $e) {
-			throw new \Sabre\DAV\Exception\NotFound('File with name ' . $destinationPath
+			throw new \Sabre\DAV\Exception\NotFound('File with name '.$destinationPath
 				. ' could not be located');
 		} catch (StorageNotAvailableException $e) {
 			throw new \Sabre\DAV\Exception\ServiceUnavailable($e->getMessage(), 0, $e);
@@ -564,7 +564,7 @@ 
 				$directory = new Directory($this->fileView, $info, $this->tree, $this->shareManager);
 				$readable = $directory->getNode()->isReadable();
 				if (!$readable) {
-					throw new \Sabre\DAV\Exception\NotFound('File with name ' . $destinationPath
+					throw new \Sabre\DAV\Exception\NotFound('File with name '.$destinationPath
 						. ' could not be located');
 				}
 			}