nextcloud / server

apps/files_versions/lib/Listener/FileEventsListener.php

Indentation +362 added lines, -362 removed lines

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

apps/files_versions/tests/VersioningTest.php

Indentation +871 added lines, -871 removed lines

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

Spacing +59 added lines, -59 removed lines

@@ -86,7 +86,7 @@ 
 		$mockConfig = $this->createMock(IConfig::class);
 		$mockConfig->expects($this->any())
 			->method('getSystemValue')
-			->willReturnCallback(function ($key, $default) use ($config) {
+			->willReturnCallback(function($key, $default) use ($config) {
 				if ($key === 'filesystem_check_changes') {
 					return Watcher::CHECK_ONCE;
 				} else {
@@ -121,10 +121,10 @@ 
 		$this->restoreService(AllConfig::class);
 
 		if ($this->rootView) {
-			$this->rootView->deleteAll(self::TEST_VERSIONS_USER . '/files/');
-			$this->rootView->deleteAll(self::TEST_VERSIONS_USER2 . '/files/');
-			$this->rootView->deleteAll(self::TEST_VERSIONS_USER . '/files_versions/');
-			$this->rootView->deleteAll(self::TEST_VERSIONS_USER2 . '/files_versions/');
+			$this->rootView->deleteAll(self::TEST_VERSIONS_USER.'/files/');
+			$this->rootView->deleteAll(self::TEST_VERSIONS_USER2.'/files/');
+			$this->rootView->deleteAll(self::TEST_VERSIONS_USER.'/files_versions/');
+			$this->rootView->deleteAll(self::TEST_VERSIONS_USER2.'/files_versions/');
 		}
 
 		\OC_Hook::clear();
@@ -292,10 +292,10 @@ 
 		$t2 = $t1 - 60 * 60 * 24 * 14;
 
 		// create some versions
-		$v1 = self::USERS_VERSIONS_ROOT . '/test.txt.v' . $t1;
-		$v2 = self::USERS_VERSIONS_ROOT . '/test.txt.v' . $t2;
-		$v1Renamed = self::USERS_VERSIONS_ROOT . '/test2.txt.v' . $t1;
-		$v2Renamed = self::USERS_VERSIONS_ROOT . '/test2.txt.v' . $t2;
+		$v1 = self::USERS_VERSIONS_ROOT.'/test.txt.v'.$t1;
+		$v2 = self::USERS_VERSIONS_ROOT.'/test.txt.v'.$t2;
+		$v1Renamed = self::USERS_VERSIONS_ROOT.'/test2.txt.v'.$t1;
+		$v2Renamed = self::USERS_VERSIONS_ROOT.'/test2.txt.v'.$t2;
 
 		$this->rootView->file_put_contents($v1, 'version1');
 		$this->rootView->file_put_contents($v2, 'version2');
@@ -322,12 +322,12 @@ 
 		// version will be expired
 		$t2 = $t1 - 60 * 60 * 24 * 14;
 
-		$this->rootView->mkdir(self::USERS_VERSIONS_ROOT . '/folder1');
+		$this->rootView->mkdir(self::USERS_VERSIONS_ROOT.'/folder1');
 		// create some versions
-		$v1 = self::USERS_VERSIONS_ROOT . '/folder1/test.txt.v' . $t1;
-		$v2 = self::USERS_VERSIONS_ROOT . '/folder1/test.txt.v' . $t2;
-		$v1Renamed = self::USERS_VERSIONS_ROOT . '/folder1/folder2/test.txt.v' . $t1;
-		$v2Renamed = self::USERS_VERSIONS_ROOT . '/folder1/folder2/test.txt.v' . $t2;
+		$v1 = self::USERS_VERSIONS_ROOT.'/folder1/test.txt.v'.$t1;
+		$v2 = self::USERS_VERSIONS_ROOT.'/folder1/test.txt.v'.$t2;
+		$v1Renamed = self::USERS_VERSIONS_ROOT.'/folder1/folder2/test.txt.v'.$t1;
+		$v2Renamed = self::USERS_VERSIONS_ROOT.'/folder1/folder2/test.txt.v'.$t2;
 
 		$this->rootView->file_put_contents($v1, 'version1');
 		$this->rootView->file_put_contents($v2, 'version2');
@@ -373,11 +373,11 @@ 
 		$t2 = $t1 - 60 * 60 * 24 * 14;
 
 		// create some versions
-		$this->rootView->mkdir(self::USERS_VERSIONS_ROOT . '/folder1');
-		$v1 = self::USERS_VERSIONS_ROOT . '/folder1/test.txt.v' . $t1;
-		$v2 = self::USERS_VERSIONS_ROOT . '/folder1/test.txt.v' . $t2;
-		$v1Renamed = self::USERS_VERSIONS_ROOT . '/folder2/folder1/test.txt.v' . $t1;
-		$v2Renamed = self::USERS_VERSIONS_ROOT . '/folder2/folder1/test.txt.v' . $t2;
+		$this->rootView->mkdir(self::USERS_VERSIONS_ROOT.'/folder1');
+		$v1 = self::USERS_VERSIONS_ROOT.'/folder1/test.txt.v'.$t1;
+		$v2 = self::USERS_VERSIONS_ROOT.'/folder1/test.txt.v'.$t2;
+		$v1Renamed = self::USERS_VERSIONS_ROOT.'/folder2/folder1/test.txt.v'.$t1;
+		$v2Renamed = self::USERS_VERSIONS_ROOT.'/folder2/folder1/test.txt.v'.$t2;
 
 		$this->rootView->file_put_contents($v1, 'version1');
 		$this->rootView->file_put_contents($v2, 'version2');
@@ -410,7 +410,7 @@ 
 		Server::get(\OCP\Share\IManager::class)->acceptShare($share, self::TEST_VERSIONS_USER2);
 
 		self::loginHelper(self::TEST_VERSIONS_USER2);
-		$versionsFolder2 = '/' . self::TEST_VERSIONS_USER2 . '/files_versions';
+		$versionsFolder2 = '/'.self::TEST_VERSIONS_USER2.'/files_versions';
 		Filesystem::file_put_contents('test.txt', 'test file');
 
 		$t1 = time();
@@ -420,8 +420,8 @@ 
 
 		$this->rootView->mkdir($versionsFolder2);
 		// create some versions
-		$v1 = $versionsFolder2 . '/test.txt.v' . $t1;
-		$v2 = $versionsFolder2 . '/test.txt.v' . $t2;
+		$v1 = $versionsFolder2.'/test.txt.v'.$t1;
+		$v2 = $versionsFolder2.'/test.txt.v'.$t2;
 
 		$this->rootView->file_put_contents($v1, 'version1');
 		$this->rootView->file_put_contents($v2, 'version2');
@@ -434,10 +434,10 @@ 
 
 		self::loginHelper(self::TEST_VERSIONS_USER);
 
-		$versionsFolder1 = '/' . self::TEST_VERSIONS_USER . '/files_versions';
+		$versionsFolder1 = '/'.self::TEST_VERSIONS_USER.'/files_versions';
 
-		$v1Renamed = $versionsFolder1 . '/folder1/test.txt.v' . $t1;
-		$v2Renamed = $versionsFolder1 . '/folder1/test.txt.v' . $t2;
+		$v1Renamed = $versionsFolder1.'/folder1/test.txt.v'.$t1;
+		$v2Renamed = $versionsFolder1.'/folder1/test.txt.v'.$t2;
 
 		$this->assertTrue($this->rootView->file_exists($v1Renamed));
 		$this->assertTrue($this->rootView->file_exists($v2Renamed));
@@ -459,7 +459,7 @@ 
 		Server::get(\OCP\Share\IManager::class)->acceptShare($share, self::TEST_VERSIONS_USER2);
 
 		self::loginHelper(self::TEST_VERSIONS_USER2);
-		$versionsFolder2 = '/' . self::TEST_VERSIONS_USER2 . '/files_versions';
+		$versionsFolder2 = '/'.self::TEST_VERSIONS_USER2.'/files_versions';
 		Filesystem::mkdir('folder2');
 		Filesystem::file_put_contents('folder2/test.txt', 'test file');
 
@@ -469,10 +469,10 @@ 
 		$t2 = $t1 - 60 * 60 * 24 * 14;
 
 		$this->rootView->mkdir($versionsFolder2);
-		$this->rootView->mkdir($versionsFolder2 . '/folder2');
+		$this->rootView->mkdir($versionsFolder2.'/folder2');
 		// create some versions
-		$v1 = $versionsFolder2 . '/folder2/test.txt.v' . $t1;
-		$v2 = $versionsFolder2 . '/folder2/test.txt.v' . $t2;
+		$v1 = $versionsFolder2.'/folder2/test.txt.v'.$t1;
+		$v2 = $versionsFolder2.'/folder2/test.txt.v'.$t2;
 
 		$this->rootView->file_put_contents($v1, 'version1');
 		$this->rootView->file_put_contents($v2, 'version2');
@@ -485,10 +485,10 @@ 
 
 		self::loginHelper(self::TEST_VERSIONS_USER);
 
-		$versionsFolder1 = '/' . self::TEST_VERSIONS_USER . '/files_versions';
+		$versionsFolder1 = '/'.self::TEST_VERSIONS_USER.'/files_versions';
 
-		$v1Renamed = $versionsFolder1 . '/folder1/folder2/test.txt.v' . $t1;
-		$v2Renamed = $versionsFolder1 . '/folder1/folder2/test.txt.v' . $t2;
+		$v1Renamed = $versionsFolder1.'/folder1/folder2/test.txt.v'.$t1;
+		$v2Renamed = $versionsFolder1.'/folder1/folder2/test.txt.v'.$t2;
 
 		$this->assertTrue($this->rootView->file_exists($v1Renamed));
 		$this->assertTrue($this->rootView->file_exists($v2Renamed));
@@ -506,11 +506,11 @@ 
 
 		$this->rootView->mkdir(self::USERS_VERSIONS_ROOT);
 		// create some versions
-		$v1 = self::USERS_VERSIONS_ROOT . '/test.txt.v' . $t1;
-		$v2 = self::USERS_VERSIONS_ROOT . '/test.txt.v' . $t2;
+		$v1 = self::USERS_VERSIONS_ROOT.'/test.txt.v'.$t1;
+		$v2 = self::USERS_VERSIONS_ROOT.'/test.txt.v'.$t2;
 		// the renamed versions should not exist! Because we only moved the mount point!
-		$v1Renamed = self::USERS_VERSIONS_ROOT . '/test2.txt.v' . $t1;
-		$v2Renamed = self::USERS_VERSIONS_ROOT . '/test2.txt.v' . $t2;
+		$v1Renamed = self::USERS_VERSIONS_ROOT.'/test2.txt.v'.$t1;
+		$v2Renamed = self::USERS_VERSIONS_ROOT.'/test2.txt.v'.$t2;
 
 		$this->rootView->file_put_contents($v1, 'version1');
 		$this->rootView->file_put_contents($v2, 'version2');
@@ -554,10 +554,10 @@ 
 		$t2 = $t1 - 60 * 60 * 24 * 14;
 
 		// create some versions
-		$v1 = self::USERS_VERSIONS_ROOT . '/test.txt.v' . $t1;
-		$v2 = self::USERS_VERSIONS_ROOT . '/test.txt.v' . $t2;
-		$v1Copied = self::USERS_VERSIONS_ROOT . '/test2.txt.v' . $t1;
-		$v2Copied = self::USERS_VERSIONS_ROOT . '/test2.txt.v' . $t2;
+		$v1 = self::USERS_VERSIONS_ROOT.'/test.txt.v'.$t1;
+		$v2 = self::USERS_VERSIONS_ROOT.'/test.txt.v'.$t2;
+		$v1Copied = self::USERS_VERSIONS_ROOT.'/test2.txt.v'.$t1;
+		$v2Copied = self::USERS_VERSIONS_ROOT.'/test2.txt.v'.$t2;
 
 		$this->rootView->file_put_contents($v1, 'version1');
 		$this->rootView->file_put_contents($v2, 'version2');
@@ -585,10 +585,10 @@ 
 		$t2 = $t1 - 60 * 60 * 24 * 14;
 
 		// create some versions
-		$v1 = self::USERS_VERSIONS_ROOT . '/subfolder/test.txt.v' . $t1;
-		$v2 = self::USERS_VERSIONS_ROOT . '/subfolder/test.txt.v' . $t2;
+		$v1 = self::USERS_VERSIONS_ROOT.'/subfolder/test.txt.v'.$t1;
+		$v2 = self::USERS_VERSIONS_ROOT.'/subfolder/test.txt.v'.$t2;
 
-		$this->rootView->mkdir(self::USERS_VERSIONS_ROOT . '/subfolder/');
+		$this->rootView->mkdir(self::USERS_VERSIONS_ROOT.'/subfolder/');
 
 		$this->rootView->file_put_contents($v1, 'version1');
 		$this->rootView->file_put_contents($v2, 'version2');
@@ -604,7 +604,7 @@ 
 		}
 
 		//cleanup
-		$this->rootView->deleteAll(self::USERS_VERSIONS_ROOT . '/subfolder');
+		$this->rootView->deleteAll(self::USERS_VERSIONS_ROOT.'/subfolder');
 	}
 
 	/**
@@ -647,7 +647,7 @@ 
 
 	public function testRestoreCrossStorage(): void {
 		$storage2 = new Temporary([]);
-		Filesystem::mount($storage2, [], self::TEST_VERSIONS_USER . '/files/sub');
+		Filesystem::mount($storage2, [], self::TEST_VERSIONS_USER.'/files/sub');
 
 		$this->doTestRestore();
 	}
@@ -746,7 +746,7 @@ 
 		$eventHandler->expects($this->any())
 			->method('callback')
 			->willReturnCallback(
-				function ($p) use (&$params): void {
+				function($p) use (&$params): void {
 					$params = $p;
 				}
 			);
@@ -760,7 +760,7 @@ 
 	}
 
 	private function doTestRestore() {
-		$filePath = self::TEST_VERSIONS_USER . '/files/sub/test.txt';
+		$filePath = self::TEST_VERSIONS_USER.'/files/sub/test.txt';
 		$this->rootView->file_put_contents($filePath, 'test file');
 
 		$fileInfo = $this->rootView->getFileInfo($filePath);
@@ -772,10 +772,10 @@ 
 		$t2 = $t1 - 60 * 60 * 24 * 14;
 
 		// create some versions
-		$v1 = self::USERS_VERSIONS_ROOT . '/sub/test.txt.v' . $t1;
-		$v2 = self::USERS_VERSIONS_ROOT . '/sub/test.txt.v' . $t2;
+		$v1 = self::USERS_VERSIONS_ROOT.'/sub/test.txt.v'.$t1;
+		$v2 = self::USERS_VERSIONS_ROOT.'/sub/test.txt.v'.$t2;
 
-		$this->rootView->mkdir(self::USERS_VERSIONS_ROOT . '/sub');
+		$this->rootView->mkdir(self::USERS_VERSIONS_ROOT.'/sub');
 
 		$this->rootView->file_put_contents($v1, 'version1');
 		$fileInfoV1 = $this->rootView->getFileInfo($v1);
@@ -808,7 +808,7 @@ 
 
 		$eventDispatcher = Server::get(IEventDispatcher::class);
 		$eventFired = false;
-		$eventDispatcher->addListener(VersionRestoredEvent::class, function ($event) use (&$eventFired, $t2): void {
+		$eventDispatcher->addListener(VersionRestoredEvent::class, function($event) use (&$eventFired, $t2): void {
 			$eventFired = true;
 			$this->assertEquals('/sub/test.txt', $event->getVersion()->getVersionPath());
 			$this->assertTrue($event->getVersion()->getRevisionId() > 0);
@@ -816,7 +816,7 @@ 
 
 		$versionManager = Server::get(IVersionManager::class);
 		$versions = $versionManager->getVersionsForFile($this->user1, $info1);
-		$version = array_filter($versions, function ($version) use ($t2) {
+		$version = array_filter($versions, function($version) use ($t2) {
 			return $version->getRevisionId() === $t2;
 		});
 		$this->assertTrue($versionManager->rollback(current($version)));
@@ -847,7 +847,7 @@ 
 		);
 
 		$this->assertTrue(
-			$this->rootView->file_exists(self::USERS_VERSIONS_ROOT . '/sub/test.txt.v' . $t0),
+			$this->rootView->file_exists(self::USERS_VERSIONS_ROOT.'/sub/test.txt.v'.$t0),
 			'A version file was created for the file before restoration'
 		);
 		$this->assertTrue(
@@ -862,15 +862,15 @@ 
 		$this->assertCount(2, $newVersions, 'Additional version created');
 
 		$this->assertTrue(
-			isset($newVersions[$t0 . '#' . 'test.txt']),
+			isset($newVersions[$t0.'#'.'test.txt']),
 			'A version was created for the file before restoration'
 		);
 		$this->assertTrue(
-			isset($newVersions[$t1 . '#' . 'test.txt']),
+			isset($newVersions[$t1.'#'.'test.txt']),
 			'Untouched version is still there'
 		);
 		$this->assertFalse(
-			isset($newVersions[$t2 . '#' . 'test.txt']),
+			isset($newVersions[$t2.'#'.'test.txt']),
 			'Restored version is not in the list any more'
 		);
 	}
@@ -930,7 +930,7 @@ 
 		// needed to make the hooks fire
 		\OC_Util::setupFS(self::TEST_VERSIONS_USER);
 
-		$userView = new View('/' . self::TEST_VERSIONS_USER . '/files');
+		$userView = new View('/'.self::TEST_VERSIONS_USER.'/files');
 		$this->createAndCheckVersions(
 			$userView,
 			'test.txt'
@@ -949,11 +949,11 @@ 
 		$this->loginAsUser(self::TEST_VERSIONS_USER);
 
 		// need to scan for the versions
-		[$rootStorage,] = $this->rootView->resolvePath(self::TEST_VERSIONS_USER . '/files_versions');
+		[$rootStorage, ] = $this->rootView->resolvePath(self::TEST_VERSIONS_USER.'/files_versions');
 		$rootStorage->getScanner()->scan('files_versions');
 
 		$versions = Storage::getVersions(
-			self::TEST_VERSIONS_USER, '/' . $path
+			self::TEST_VERSIONS_USER, '/'.$path
 		);
 
 		// note: we cannot predict how many versions are created due to

apps/settings/lib/Settings/Admin/Mail.php

Indentation +58 added lines, -58 removed lines

@@ -13,71 +13,71 @@
 use OCP\Settings\IDelegatedSettings;
 
 class Mail implements IDelegatedSettings {
-	/**
-	 * @param IConfig $config
-	 * @param IL10N $l
-	 */
-	public function __construct(
-		private IConfig $config,
-		private IL10N $l,
-	) {
-	}
+    /**
+     * @param IConfig $config
+     * @param IL10N $l
+     */
+    public function __construct(
+        private IConfig $config,
+        private IL10N $l,
+    ) {
+    }
 
-	/**
-	 * @return TemplateResponse
-	 */
-	public function getForm() {
-		$finder = Server::get(IBinaryFinder::class);
+    /**
+     * @return TemplateResponse
+     */
+    public function getForm() {
+        $finder = Server::get(IBinaryFinder::class);
 
-		$parameters = [
-			// Mail
-			'sendmail_is_available' => $finder->findBinaryPath('sendmail') !== false,
-			'mail_domain' => $this->config->getSystemValue('mail_domain', ''),
-			'mail_from_address' => $this->config->getSystemValue('mail_from_address', ''),
-			'mail_smtpmode' => $this->config->getSystemValue('mail_smtpmode', ''),
-			'mail_smtpsecure' => $this->config->getSystemValue('mail_smtpsecure', ''),
-			'mail_smtphost' => $this->config->getSystemValue('mail_smtphost', ''),
-			'mail_smtpport' => $this->config->getSystemValue('mail_smtpport', ''),
-			'mail_smtpauth' => $this->config->getSystemValue('mail_smtpauth', false),
-			'mail_smtpname' => $this->config->getSystemValue('mail_smtpname', ''),
-			'mail_smtppassword' => $this->config->getSystemValue('mail_smtppassword', ''),
-			'mail_sendmailmode' => $this->config->getSystemValue('mail_sendmailmode', 'smtp'),
-		];
+        $parameters = [
+            // Mail
+            'sendmail_is_available' => $finder->findBinaryPath('sendmail') !== false,
+            'mail_domain' => $this->config->getSystemValue('mail_domain', ''),
+            'mail_from_address' => $this->config->getSystemValue('mail_from_address', ''),
+            'mail_smtpmode' => $this->config->getSystemValue('mail_smtpmode', ''),
+            'mail_smtpsecure' => $this->config->getSystemValue('mail_smtpsecure', ''),
+            'mail_smtphost' => $this->config->getSystemValue('mail_smtphost', ''),
+            'mail_smtpport' => $this->config->getSystemValue('mail_smtpport', ''),
+            'mail_smtpauth' => $this->config->getSystemValue('mail_smtpauth', false),
+            'mail_smtpname' => $this->config->getSystemValue('mail_smtpname', ''),
+            'mail_smtppassword' => $this->config->getSystemValue('mail_smtppassword', ''),
+            'mail_sendmailmode' => $this->config->getSystemValue('mail_sendmailmode', 'smtp'),
+        ];
 
-		if ($parameters['mail_smtppassword'] !== '') {
-			$parameters['mail_smtppassword'] = '********';
-		}
+        if ($parameters['mail_smtppassword'] !== '') {
+            $parameters['mail_smtppassword'] = '********';
+        }
 
-		if ($parameters['mail_smtpmode'] === '' || $parameters['mail_smtpmode'] === 'php') {
-			$parameters['mail_smtpmode'] = 'smtp';
-		}
+        if ($parameters['mail_smtpmode'] === '' || $parameters['mail_smtpmode'] === 'php') {
+            $parameters['mail_smtpmode'] = 'smtp';
+        }
 
-		return new TemplateResponse('settings', 'settings/admin/additional-mail', $parameters, '');
-	}
+        return new TemplateResponse('settings', 'settings/admin/additional-mail', $parameters, '');
+    }
 
-	/**
-	 * @return string the section ID, e.g. 'sharing'
-	 */
-	public function getSection() {
-		return 'server';
-	}
+    /**
+     * @return string the section ID, e.g. 'sharing'
+     */
+    public function getSection() {
+        return 'server';
+    }
 
-	/**
-	 * @return int whether the form should be rather on the top or bottom of
-	 *             the admin section. The forms are arranged in ascending order of the
-	 *             priority values. It is required to return a value between 0 and 100.
-	 *
-	 * E.g.: 70
-	 */
-	public function getPriority() {
-		return 10;
-	}
+    /**
+     * @return int whether the form should be rather on the top or bottom of
+     *             the admin section. The forms are arranged in ascending order of the
+     *             priority values. It is required to return a value between 0 and 100.
+     *
+     * E.g.: 70
+     */
+    public function getPriority() {
+        return 10;
+    }
 
-	public function getName(): ?string {
-		return $this->l->t('Email server');
-	}
+    public function getName(): ?string {
+        return $this->l->t('Email server');
+    }
 
-	public function getAuthorizedAppConfig(): array {
-		return [];
-	}
+    public function getAuthorizedAppConfig(): array {
+        return [];
+    }
 }

apps/settings/lib/Settings/Personal/PersonalInfo.php

Indentation +283 added lines, -283 removed lines

@@ -33,287 +33,287 @@
 
 class PersonalInfo implements ISettings {
 
-	/** @var ProfileManager */
-	private $profileManager;
-
-	public function __construct(
-		private IConfig $config,
-		private IUserManager $userManager,
-		private IGroupManager $groupManager,
-		private IAccountManager $accountManager,
-		ProfileManager $profileManager,
-		private IAppManager $appManager,
-		private IFactory $l10nFactory,
-		private IL10N $l,
-		private IInitialState $initialStateService,
-		private IManager $manager,
-	) {
-		$this->profileManager = $profileManager;
-	}
-
-	public function getForm(): TemplateResponse {
-		$federationEnabled = $this->appManager->isEnabledForUser('federation');
-		$federatedFileSharingEnabled = $this->appManager->isEnabledForUser('federatedfilesharing');
-		$lookupServerUploadEnabled = false;
-		if ($federatedFileSharingEnabled) {
-			/** @var FederatedShareProvider $shareProvider */
-			$shareProvider = Server::get(FederatedShareProvider::class);
-			$lookupServerUploadEnabled = $shareProvider->isLookupServerUploadEnabled();
-		}
-
-		$uid = \OC_User::getUser();
-		$user = $this->userManager->get($uid);
-		$account = $this->accountManager->getAccount($user);
-
-		// make sure FS is setup before querying storage related stuff...
-		\OC_Util::setupFS($user->getUID());
-
-		$storageInfo = \OC_Helper::getStorageInfo('/');
-		if ($storageInfo['quota'] === FileInfo::SPACE_UNLIMITED) {
-			$totalSpace = $this->l->t('Unlimited');
-		} else {
-			$totalSpace = Util::humanFileSize($storageInfo['total']);
-		}
-
-		$messageParameters = $this->getMessageParameters($account);
-
-		$parameters = [
-			'lookupServerUploadEnabled' => $lookupServerUploadEnabled,
-			'isFairUseOfFreePushService' => $this->isFairUseOfFreePushService(),
-			'profileEnabledGlobally' => $this->profileManager->isProfileEnabled(),
-		] + $messageParameters;
-
-		$personalInfoParameters = [
-			'userId' => $uid,
-			'avatar' => $this->getProperty($account, IAccountManager::PROPERTY_AVATAR),
-			'groups' => $this->getGroups($user),
-			'quota' => $storageInfo['quota'],
-			'totalSpace' => $totalSpace,
-			'usage' => Util::humanFileSize($storageInfo['used']),
-			'usageRelative' => round($storageInfo['relative']),
-			'displayName' => $this->getProperty($account, IAccountManager::PROPERTY_DISPLAYNAME),
-			'emailMap' => $this->getEmailMap($account),
-			'phone' => $this->getProperty($account, IAccountManager::PROPERTY_PHONE),
-			'defaultPhoneRegion' => $this->config->getSystemValueString('default_phone_region'),
-			'location' => $this->getProperty($account, IAccountManager::PROPERTY_ADDRESS),
-			'website' => $this->getProperty($account, IAccountManager::PROPERTY_WEBSITE),
-			'twitter' => $this->getProperty($account, IAccountManager::PROPERTY_TWITTER),
-			'fediverse' => $this->getProperty($account, IAccountManager::PROPERTY_FEDIVERSE),
-			'languageMap' => $this->getLanguageMap($user),
-			'localeMap' => $this->getLocaleMap($user),
-			'profileEnabledGlobally' => $this->profileManager->isProfileEnabled(),
-			'profileEnabled' => $this->profileManager->isProfileEnabled($user),
-			'organisation' => $this->getProperty($account, IAccountManager::PROPERTY_ORGANISATION),
-			'role' => $this->getProperty($account, IAccountManager::PROPERTY_ROLE),
-			'headline' => $this->getProperty($account, IAccountManager::PROPERTY_HEADLINE),
-			'biography' => $this->getProperty($account, IAccountManager::PROPERTY_BIOGRAPHY),
-			'birthdate' => $this->getProperty($account, IAccountManager::PROPERTY_BIRTHDATE),
-			'firstDayOfWeek' => $this->config->getUserValue($uid, 'core', AUserDataOCSController::USER_FIELD_FIRST_DAY_OF_WEEK),
-			'pronouns' => $this->getProperty($account, IAccountManager::PROPERTY_PRONOUNS),
-		];
-
-		$accountParameters = [
-			'avatarChangeSupported' => $user->canChangeAvatar(),
-			'displayNameChangeSupported' => $user->canChangeDisplayName(),
-			'emailChangeSupported' => $user->canChangeEmail(),
-			'federationEnabled' => $federationEnabled,
-			'lookupServerUploadEnabled' => $lookupServerUploadEnabled,
-		];
-
-		$profileParameters = [
-			'profileConfig' => $this->profileManager->getProfileConfigWithMetadata($user, $user),
-		];
-
-		$this->initialStateService->provideInitialState('profileEnabledGlobally', $this->profileManager->isProfileEnabled());
-		$this->initialStateService->provideInitialState('personalInfoParameters', $personalInfoParameters);
-		$this->initialStateService->provideInitialState('accountParameters', $accountParameters);
-		$this->initialStateService->provideInitialState('profileParameters', $profileParameters);
-
-		return new TemplateResponse('settings', 'settings/personal/personal.info', $parameters, '');
-	}
-
-	/**
-	 * Check if is fair use of free push service
-	 * @return boolean
-	 */
-	private function isFairUseOfFreePushService(): bool {
-		return $this->manager->isFairUseOfFreePushService();
-	}
-
-	/**
-	 * returns the property data in an
-	 * associative array
-	 */
-	private function getProperty(IAccount $account, string $property): array {
-		$property = [
-			'name' => $account->getProperty($property)->getName(),
-			'value' => $account->getProperty($property)->getValue(),
-			'scope' => $account->getProperty($property)->getScope(),
-			'verified' => $account->getProperty($property)->getVerified(),
-		];
-
-		return $property;
-	}
-
-	/**
-	 * returns the section ID string, e.g. 'sharing'
-	 * @since 9.1
-	 */
-	public function getSection(): string {
-		return 'personal-info';
-	}
-
-	/**
-	 * @return int whether the form should be rather on the top or bottom of
-	 *             the admin section. The forms are arranged in ascending order of the
-	 *             priority values. It is required to return a value between 0 and 100.
-	 *
-	 * E.g.: 70
-	 * @since 9.1
-	 */
-	public function getPriority(): int {
-		return 10;
-	}
-
-	/**
-	 * returns a sorted list of the user's group GIDs
-	 */
-	private function getGroups(IUser $user): array {
-		$groups = array_map(
-			static function (IGroup $group) {
-				return $group->getDisplayName();
-			},
-			$this->groupManager->getUserGroups($user)
-		);
-		sort($groups);
-
-		return $groups;
-	}
-
-	/**
-	 * returns the primary email and additional emails in an
-	 * associative array
-	 */
-	private function getEmailMap(IAccount $account): array {
-		$systemEmail = [
-			'name' => $account->getProperty(IAccountManager::PROPERTY_EMAIL)->getName(),
-			'value' => $account->getProperty(IAccountManager::PROPERTY_EMAIL)->getValue(),
-			'scope' => $account->getProperty(IAccountManager::PROPERTY_EMAIL)->getScope(),
-			'verified' => $account->getProperty(IAccountManager::PROPERTY_EMAIL)->getVerified(),
-		];
-
-		$additionalEmails = array_map(
-			function (IAccountProperty $property) {
-				return [
-					'name' => $property->getName(),
-					'value' => $property->getValue(),
-					'scope' => $property->getScope(),
-					'verified' => $property->getVerified(),
-					'locallyVerified' => $property->getLocallyVerified(),
-				];
-			},
-			$account->getPropertyCollection(IAccountManager::COLLECTION_EMAIL)->getProperties(),
-		);
-
-		$emailMap = [
-			'primaryEmail' => $systemEmail,
-			'additionalEmails' => $additionalEmails,
-			'notificationEmail' => (string)$account->getUser()->getPrimaryEMailAddress(),
-		];
-
-		return $emailMap;
-	}
-
-	/**
-	 * returns the user's active language, common languages, and other languages in an
-	 * associative array
-	 */
-	private function getLanguageMap(IUser $user): array {
-		$forceLanguage = $this->config->getSystemValue('force_language', false);
-		if ($forceLanguage !== false) {
-			return [];
-		}
-
-		$uid = $user->getUID();
-
-		$userConfLang = $this->config->getUserValue($uid, 'core', 'lang', $this->l10nFactory->findLanguage());
-		$languages = $this->l10nFactory->getLanguages();
-
-		// associate the user language with the proper array
-		$userLangIndex = array_search($userConfLang, array_column($languages['commonLanguages'], 'code'));
-		$userLang = $languages['commonLanguages'][$userLangIndex];
-		// search in the other languages
-		if ($userLangIndex === false) {
-			$userLangIndex = array_search($userConfLang, array_column($languages['otherLanguages'], 'code'));
-			$userLang = $languages['otherLanguages'][$userLangIndex];
-		}
-		// if user language is not available but set somehow: show the actual code as name
-		if (!is_array($userLang)) {
-			$userLang = [
-				'code' => $userConfLang,
-				'name' => $userConfLang,
-			];
-		}
-
-		return array_merge(
-			['activeLanguage' => $userLang],
-			$languages
-		);
-	}
-
-	private function getLocaleMap(IUser $user): array {
-		$forceLanguage = $this->config->getSystemValue('force_locale', false);
-		if ($forceLanguage !== false) {
-			return [];
-		}
-
-		$uid = $user->getUID();
-		$userLang = $this->config->getUserValue($uid, 'core', 'lang', $this->l10nFactory->findLanguage());
-		$userLocaleString = $this->config->getUserValue($uid, 'core', 'locale', $this->l10nFactory->findLocale($userLang));
-		$localeCodes = $this->l10nFactory->findAvailableLocales();
-		$userLocale = array_filter($localeCodes, fn ($value) => $userLocaleString === $value['code']);
-
-		if (!empty($userLocale)) {
-			$userLocale = reset($userLocale);
-		}
-
-		$localesForLanguage = array_values(array_filter($localeCodes, fn ($localeCode) => str_starts_with($localeCode['code'], $userLang)));
-		$otherLocales = array_values(array_filter($localeCodes, fn ($localeCode) => !str_starts_with($localeCode['code'], $userLang)));
-
-		if (!$userLocale) {
-			$userLocale = [
-				'code' => 'en',
-				'name' => 'English'
-			];
-		}
-
-		return [
-			'activeLocaleLang' => $userLocaleString,
-			'activeLocale' => $userLocale,
-			'localesForLanguage' => $localesForLanguage,
-			'otherLocales' => $otherLocales,
-		];
-	}
-
-	/**
-	 * returns the message parameters
-	 */
-	private function getMessageParameters(IAccount $account): array {
-		$needVerifyMessage = [IAccountManager::PROPERTY_EMAIL, IAccountManager::PROPERTY_WEBSITE, IAccountManager::PROPERTY_TWITTER];
-		$messageParameters = [];
-		foreach ($needVerifyMessage as $property) {
-			switch ($account->getProperty($property)->getVerified()) {
-				case IAccountManager::VERIFIED:
-					$message = $this->l->t('Verifying');
-					break;
-				case IAccountManager::VERIFICATION_IN_PROGRESS:
-					$message = $this->l->t('Verifying …');
-					break;
-				default:
-					$message = $this->l->t('Verify');
-			}
-			$messageParameters[$property . 'Message'] = $message;
-		}
-		return $messageParameters;
-	}
+    /** @var ProfileManager */
+    private $profileManager;
+
+    public function __construct(
+        private IConfig $config,
+        private IUserManager $userManager,
+        private IGroupManager $groupManager,
+        private IAccountManager $accountManager,
+        ProfileManager $profileManager,
+        private IAppManager $appManager,
+        private IFactory $l10nFactory,
+        private IL10N $l,
+        private IInitialState $initialStateService,
+        private IManager $manager,
+    ) {
+        $this->profileManager = $profileManager;
+    }
+
+    public function getForm(): TemplateResponse {
+        $federationEnabled = $this->appManager->isEnabledForUser('federation');
+        $federatedFileSharingEnabled = $this->appManager->isEnabledForUser('federatedfilesharing');
+        $lookupServerUploadEnabled = false;
+        if ($federatedFileSharingEnabled) {
+            /** @var FederatedShareProvider $shareProvider */
+            $shareProvider = Server::get(FederatedShareProvider::class);
+            $lookupServerUploadEnabled = $shareProvider->isLookupServerUploadEnabled();
+        }
+
+        $uid = \OC_User::getUser();
+        $user = $this->userManager->get($uid);
+        $account = $this->accountManager->getAccount($user);
+
+        // make sure FS is setup before querying storage related stuff...
+        \OC_Util::setupFS($user->getUID());
+
+        $storageInfo = \OC_Helper::getStorageInfo('/');
+        if ($storageInfo['quota'] === FileInfo::SPACE_UNLIMITED) {
+            $totalSpace = $this->l->t('Unlimited');
+        } else {
+            $totalSpace = Util::humanFileSize($storageInfo['total']);
+        }
+
+        $messageParameters = $this->getMessageParameters($account);
+
+        $parameters = [
+            'lookupServerUploadEnabled' => $lookupServerUploadEnabled,
+            'isFairUseOfFreePushService' => $this->isFairUseOfFreePushService(),
+            'profileEnabledGlobally' => $this->profileManager->isProfileEnabled(),
+        ] + $messageParameters;
+
+        $personalInfoParameters = [
+            'userId' => $uid,
+            'avatar' => $this->getProperty($account, IAccountManager::PROPERTY_AVATAR),
+            'groups' => $this->getGroups($user),
+            'quota' => $storageInfo['quota'],
+            'totalSpace' => $totalSpace,
+            'usage' => Util::humanFileSize($storageInfo['used']),
+            'usageRelative' => round($storageInfo['relative']),
+            'displayName' => $this->getProperty($account, IAccountManager::PROPERTY_DISPLAYNAME),
+            'emailMap' => $this->getEmailMap($account),
+            'phone' => $this->getProperty($account, IAccountManager::PROPERTY_PHONE),
+            'defaultPhoneRegion' => $this->config->getSystemValueString('default_phone_region'),
+            'location' => $this->getProperty($account, IAccountManager::PROPERTY_ADDRESS),
+            'website' => $this->getProperty($account, IAccountManager::PROPERTY_WEBSITE),
+            'twitter' => $this->getProperty($account, IAccountManager::PROPERTY_TWITTER),
+            'fediverse' => $this->getProperty($account, IAccountManager::PROPERTY_FEDIVERSE),
+            'languageMap' => $this->getLanguageMap($user),
+            'localeMap' => $this->getLocaleMap($user),
+            'profileEnabledGlobally' => $this->profileManager->isProfileEnabled(),
+            'profileEnabled' => $this->profileManager->isProfileEnabled($user),
+            'organisation' => $this->getProperty($account, IAccountManager::PROPERTY_ORGANISATION),
+            'role' => $this->getProperty($account, IAccountManager::PROPERTY_ROLE),
+            'headline' => $this->getProperty($account, IAccountManager::PROPERTY_HEADLINE),
+            'biography' => $this->getProperty($account, IAccountManager::PROPERTY_BIOGRAPHY),
+            'birthdate' => $this->getProperty($account, IAccountManager::PROPERTY_BIRTHDATE),
+            'firstDayOfWeek' => $this->config->getUserValue($uid, 'core', AUserDataOCSController::USER_FIELD_FIRST_DAY_OF_WEEK),
+            'pronouns' => $this->getProperty($account, IAccountManager::PROPERTY_PRONOUNS),
+        ];
+
+        $accountParameters = [
+            'avatarChangeSupported' => $user->canChangeAvatar(),
+            'displayNameChangeSupported' => $user->canChangeDisplayName(),
+            'emailChangeSupported' => $user->canChangeEmail(),
+            'federationEnabled' => $federationEnabled,
+            'lookupServerUploadEnabled' => $lookupServerUploadEnabled,
+        ];
+
+        $profileParameters = [
+            'profileConfig' => $this->profileManager->getProfileConfigWithMetadata($user, $user),
+        ];
+
+        $this->initialStateService->provideInitialState('profileEnabledGlobally', $this->profileManager->isProfileEnabled());
+        $this->initialStateService->provideInitialState('personalInfoParameters', $personalInfoParameters);
+        $this->initialStateService->provideInitialState('accountParameters', $accountParameters);
+        $this->initialStateService->provideInitialState('profileParameters', $profileParameters);
+
+        return new TemplateResponse('settings', 'settings/personal/personal.info', $parameters, '');
+    }
+
+    /**
+     * Check if is fair use of free push service
+     * @return boolean
+     */
+    private function isFairUseOfFreePushService(): bool {
+        return $this->manager->isFairUseOfFreePushService();
+    }
+
+    /**
+     * returns the property data in an
+     * associative array
+     */
+    private function getProperty(IAccount $account, string $property): array {
+        $property = [
+            'name' => $account->getProperty($property)->getName(),
+            'value' => $account->getProperty($property)->getValue(),
+            'scope' => $account->getProperty($property)->getScope(),
+            'verified' => $account->getProperty($property)->getVerified(),
+        ];
+
+        return $property;
+    }
+
+    /**
+     * returns the section ID string, e.g. 'sharing'
+     * @since 9.1
+     */
+    public function getSection(): string {
+        return 'personal-info';
+    }
+
+    /**
+     * @return int whether the form should be rather on the top or bottom of
+     *             the admin section. The forms are arranged in ascending order of the
+     *             priority values. It is required to return a value between 0 and 100.
+     *
+     * E.g.: 70
+     * @since 9.1
+     */
+    public function getPriority(): int {
+        return 10;
+    }
+
+    /**
+     * returns a sorted list of the user's group GIDs
+     */
+    private function getGroups(IUser $user): array {
+        $groups = array_map(
+            static function (IGroup $group) {
+                return $group->getDisplayName();
+            },
+            $this->groupManager->getUserGroups($user)
+        );
+        sort($groups);
+
+        return $groups;
+    }
+
+    /**
+     * returns the primary email and additional emails in an
+     * associative array
+     */
+    private function getEmailMap(IAccount $account): array {
+        $systemEmail = [
+            'name' => $account->getProperty(IAccountManager::PROPERTY_EMAIL)->getName(),
+            'value' => $account->getProperty(IAccountManager::PROPERTY_EMAIL)->getValue(),
+            'scope' => $account->getProperty(IAccountManager::PROPERTY_EMAIL)->getScope(),
+            'verified' => $account->getProperty(IAccountManager::PROPERTY_EMAIL)->getVerified(),
+        ];
+
+        $additionalEmails = array_map(
+            function (IAccountProperty $property) {
+                return [
+                    'name' => $property->getName(),
+                    'value' => $property->getValue(),
+                    'scope' => $property->getScope(),
+                    'verified' => $property->getVerified(),
+                    'locallyVerified' => $property->getLocallyVerified(),
+                ];
+            },
+            $account->getPropertyCollection(IAccountManager::COLLECTION_EMAIL)->getProperties(),
+        );
+
+        $emailMap = [
+            'primaryEmail' => $systemEmail,
+            'additionalEmails' => $additionalEmails,
+            'notificationEmail' => (string)$account->getUser()->getPrimaryEMailAddress(),
+        ];
+
+        return $emailMap;
+    }
+
+    /**
+     * returns the user's active language, common languages, and other languages in an
+     * associative array
+     */
+    private function getLanguageMap(IUser $user): array {
+        $forceLanguage = $this->config->getSystemValue('force_language', false);
+        if ($forceLanguage !== false) {
+            return [];
+        }
+
+        $uid = $user->getUID();
+
+        $userConfLang = $this->config->getUserValue($uid, 'core', 'lang', $this->l10nFactory->findLanguage());
+        $languages = $this->l10nFactory->getLanguages();
+
+        // associate the user language with the proper array
+        $userLangIndex = array_search($userConfLang, array_column($languages['commonLanguages'], 'code'));
+        $userLang = $languages['commonLanguages'][$userLangIndex];
+        // search in the other languages
+        if ($userLangIndex === false) {
+            $userLangIndex = array_search($userConfLang, array_column($languages['otherLanguages'], 'code'));
+            $userLang = $languages['otherLanguages'][$userLangIndex];
+        }
+        // if user language is not available but set somehow: show the actual code as name
+        if (!is_array($userLang)) {
+            $userLang = [
+                'code' => $userConfLang,
+                'name' => $userConfLang,
+            ];
+        }
+
+        return array_merge(
+            ['activeLanguage' => $userLang],
+            $languages
+        );
+    }
+
+    private function getLocaleMap(IUser $user): array {
+        $forceLanguage = $this->config->getSystemValue('force_locale', false);
+        if ($forceLanguage !== false) {
+            return [];
+        }
+
+        $uid = $user->getUID();
+        $userLang = $this->config->getUserValue($uid, 'core', 'lang', $this->l10nFactory->findLanguage());
+        $userLocaleString = $this->config->getUserValue($uid, 'core', 'locale', $this->l10nFactory->findLocale($userLang));
+        $localeCodes = $this->l10nFactory->findAvailableLocales();
+        $userLocale = array_filter($localeCodes, fn ($value) => $userLocaleString === $value['code']);
+
+        if (!empty($userLocale)) {
+            $userLocale = reset($userLocale);
+        }
+
+        $localesForLanguage = array_values(array_filter($localeCodes, fn ($localeCode) => str_starts_with($localeCode['code'], $userLang)));
+        $otherLocales = array_values(array_filter($localeCodes, fn ($localeCode) => !str_starts_with($localeCode['code'], $userLang)));
+
+        if (!$userLocale) {
+            $userLocale = [
+                'code' => 'en',
+                'name' => 'English'
+            ];
+        }
+
+        return [
+            'activeLocaleLang' => $userLocaleString,
+            'activeLocale' => $userLocale,
+            'localesForLanguage' => $localesForLanguage,
+            'otherLocales' => $otherLocales,
+        ];
+    }
+
+    /**
+     * returns the message parameters
+     */
+    private function getMessageParameters(IAccount $account): array {
+        $needVerifyMessage = [IAccountManager::PROPERTY_EMAIL, IAccountManager::PROPERTY_WEBSITE, IAccountManager::PROPERTY_TWITTER];
+        $messageParameters = [];
+        foreach ($needVerifyMessage as $property) {
+            switch ($account->getProperty($property)->getVerified()) {
+                case IAccountManager::VERIFIED:
+                    $message = $this->l->t('Verifying');
+                    break;
+                case IAccountManager::VERIFICATION_IN_PROGRESS:
+                    $message = $this->l->t('Verifying …');
+                    break;
+                default:
+                    $message = $this->l->t('Verify');
+            }
+            $messageParameters[$property . 'Message'] = $message;
+        }
+        return $messageParameters;
+    }
 }

apps/files_sharing/lib/External/Scanner.php

Indentation +36 added lines, -36 removed lines

@@ -13,42 +13,42 @@
 use OCP\Files\StorageNotAvailableException;
 
 class Scanner extends \OC\Files\Cache\Scanner {
-	/** @var Storage */
-	protected $storage;
+    /** @var Storage */
+    protected $storage;
 
-	public function scan($path, $recursive = self::SCAN_RECURSIVE, $reuse = -1, $lock = true) {
-		// Disable locking for federated shares
-		parent::scan($path, $recursive, $reuse, false);
-	}
+    public function scan($path, $recursive = self::SCAN_RECURSIVE, $reuse = -1, $lock = true) {
+        // Disable locking for federated shares
+        parent::scan($path, $recursive, $reuse, false);
+    }
 
-	/**
-	 * Scan a single file and store it in the cache.
-	 * If an exception happened while accessing the external storage,
-	 * the storage will be checked for availability and removed
-	 * if it is not available any more.
-	 *
-	 * @param string $file file to scan
-	 * @param int $reuseExisting
-	 * @param int $parentId
-	 * @param CacheEntry|array|null|false $cacheData existing data in the cache for the file to be scanned
-	 * @param bool $lock set to false to disable getting an additional read lock during scanning
-	 * @param array|null $data the metadata for the file, as returned by the storage
-	 * @return array|null an array of metadata of the scanned file
-	 */
-	public function scanFile($file, $reuseExisting = 0, $parentId = -1, $cacheData = null, $lock = true, $data = null) {
-		try {
-			return parent::scanFile($file, $reuseExisting, $parentId, $cacheData, $lock, $data);
-		} catch (ForbiddenException $e) {
-			$this->storage->checkStorageAvailability();
-		} catch (NotFoundException $e) {
-			// if the storage isn't found, the call to
-			// checkStorageAvailable() will verify it and remove it
-			// if appropriate
-			$this->storage->checkStorageAvailability();
-		} catch (StorageInvalidException $e) {
-			$this->storage->checkStorageAvailability();
-		} catch (StorageNotAvailableException $e) {
-			$this->storage->checkStorageAvailability();
-		}
-	}
+    /**
+     * Scan a single file and store it in the cache.
+     * If an exception happened while accessing the external storage,
+     * the storage will be checked for availability and removed
+     * if it is not available any more.
+     *
+     * @param string $file file to scan
+     * @param int $reuseExisting
+     * @param int $parentId
+     * @param CacheEntry|array|null|false $cacheData existing data in the cache for the file to be scanned
+     * @param bool $lock set to false to disable getting an additional read lock during scanning
+     * @param array|null $data the metadata for the file, as returned by the storage
+     * @return array|null an array of metadata of the scanned file
+     */
+    public function scanFile($file, $reuseExisting = 0, $parentId = -1, $cacheData = null, $lock = true, $data = null) {
+        try {
+            return parent::scanFile($file, $reuseExisting, $parentId, $cacheData, $lock, $data);
+        } catch (ForbiddenException $e) {
+            $this->storage->checkStorageAvailability();
+        } catch (NotFoundException $e) {
+            // if the storage isn't found, the call to
+            // checkStorageAvailable() will verify it and remove it
+            // if appropriate
+            $this->storage->checkStorageAvailability();
+        } catch (StorageInvalidException $e) {
+            $this->storage->checkStorageAvailability();
+        } catch (StorageNotAvailableException $e) {
+            $this->storage->checkStorageAvailability();
+        }
+    }
 }

apps/files_trashbin/lib/Command/CleanUp.php

Indentation +90 added lines, -90 removed lines

@@ -21,98 +21,98 @@
 
 class CleanUp extends Command {
 
-	public function __construct(
-		protected IRootFolder $rootFolder,
-		protected IUserManager $userManager,
-		protected IDBConnection $dbConnection,
-	) {
-		parent::__construct();
-	}
+    public function __construct(
+        protected IRootFolder $rootFolder,
+        protected IUserManager $userManager,
+        protected IDBConnection $dbConnection,
+    ) {
+        parent::__construct();
+    }
 
-	protected function configure() {
-		$this
-			->setName('trashbin:cleanup')
-			->setDescription('Remove deleted files')
-			->addArgument(
-				'user_id',
-				InputArgument::OPTIONAL | InputArgument::IS_ARRAY,
-				'remove deleted files of the given user(s)'
-			)
-			->addOption(
-				'all-users',
-				null,
-				InputOption::VALUE_NONE,
-				'run action on all users'
-			);
-	}
+    protected function configure() {
+        $this
+            ->setName('trashbin:cleanup')
+            ->setDescription('Remove deleted files')
+            ->addArgument(
+                'user_id',
+                InputArgument::OPTIONAL | InputArgument::IS_ARRAY,
+                'remove deleted files of the given user(s)'
+            )
+            ->addOption(
+                'all-users',
+                null,
+                InputOption::VALUE_NONE,
+                'run action on all users'
+            );
+    }
 
-	protected function execute(InputInterface $input, OutputInterface $output): int {
-		$users = $input->getArgument('user_id');
-		$verbose = $input->getOption('verbose');
-		if ((!empty($users)) and ($input->getOption('all-users'))) {
-			throw new InvalidOptionException('Either specify a user_id or --all-users');
-		} elseif (!empty($users)) {
-			foreach ($users as $user) {
-				if ($this->userManager->userExists($user)) {
-					$output->writeln("Remove deleted files of   <info>$user</info>");
-					$this->removeDeletedFiles($user, $output, $verbose);
-				} else {
-					$output->writeln("<error>Unknown user $user</error>");
-					return 1;
-				}
-			}
-		} elseif ($input->getOption('all-users')) {
-			$output->writeln('Remove deleted files for all users');
-			foreach ($this->userManager->getBackends() as $backend) {
-				$name = get_class($backend);
-				if ($backend instanceof IUserBackend) {
-					$name = $backend->getBackendName();
-				}
-				$output->writeln("Remove deleted files for users on backend <info>$name</info>");
-				$limit = 500;
-				$offset = 0;
-				do {
-					$users = $backend->getUsers('', $limit, $offset);
-					foreach ($users as $user) {
-						$output->writeln("   <info>$user</info>");
-						$this->removeDeletedFiles($user, $output, $verbose);
-					}
-					$offset += $limit;
-				} while (count($users) >= $limit);
-			}
-		} else {
-			throw new InvalidOptionException('Either specify a user_id or --all-users');
-		}
-		return 0;
-	}
+    protected function execute(InputInterface $input, OutputInterface $output): int {
+        $users = $input->getArgument('user_id');
+        $verbose = $input->getOption('verbose');
+        if ((!empty($users)) and ($input->getOption('all-users'))) {
+            throw new InvalidOptionException('Either specify a user_id or --all-users');
+        } elseif (!empty($users)) {
+            foreach ($users as $user) {
+                if ($this->userManager->userExists($user)) {
+                    $output->writeln("Remove deleted files of   <info>$user</info>");
+                    $this->removeDeletedFiles($user, $output, $verbose);
+                } else {
+                    $output->writeln("<error>Unknown user $user</error>");
+                    return 1;
+                }
+            }
+        } elseif ($input->getOption('all-users')) {
+            $output->writeln('Remove deleted files for all users');
+            foreach ($this->userManager->getBackends() as $backend) {
+                $name = get_class($backend);
+                if ($backend instanceof IUserBackend) {
+                    $name = $backend->getBackendName();
+                }
+                $output->writeln("Remove deleted files for users on backend <info>$name</info>");
+                $limit = 500;
+                $offset = 0;
+                do {
+                    $users = $backend->getUsers('', $limit, $offset);
+                    foreach ($users as $user) {
+                        $output->writeln("   <info>$user</info>");
+                        $this->removeDeletedFiles($user, $output, $verbose);
+                    }
+                    $offset += $limit;
+                } while (count($users) >= $limit);
+            }
+        } else {
+            throw new InvalidOptionException('Either specify a user_id or --all-users');
+        }
+        return 0;
+    }
 
-	/**
-	 * remove deleted files for the given user
-	 */
-	protected function removeDeletedFiles(string $uid, OutputInterface $output, bool $verbose): void {
-		\OC_Util::tearDownFS();
-		\OC_Util::setupFS($uid);
-		$path = '/' . $uid . '/files_trashbin';
-		if ($this->rootFolder->nodeExists($path)) {
-			$node = $this->rootFolder->get($path);
+    /**
+     * remove deleted files for the given user
+     */
+    protected function removeDeletedFiles(string $uid, OutputInterface $output, bool $verbose): void {
+        \OC_Util::tearDownFS();
+        \OC_Util::setupFS($uid);
+        $path = '/' . $uid . '/files_trashbin';
+        if ($this->rootFolder->nodeExists($path)) {
+            $node = $this->rootFolder->get($path);
 
-			if ($verbose) {
-				$output->writeln('Deleting <info>' . Util::humanFileSize($node->getSize()) . "</info> in trash for <info>$uid</info>.");
-			}
-			$node->delete();
-			if ($this->rootFolder->nodeExists($path)) {
-				$output->writeln('<error>Trash folder sill exists after attempting to delete it</error>');
-				return;
-			}
-			$query = $this->dbConnection->getQueryBuilder();
-			$query->delete('files_trash')
-				->where($query->expr()->eq('user', $query->createParameter('uid')))
-				->setParameter('uid', $uid);
-			$query->executeStatement();
-		} else {
-			if ($verbose) {
-				$output->writeln("No trash found for <info>$uid</info>");
-			}
-		}
-	}
+            if ($verbose) {
+                $output->writeln('Deleting <info>' . Util::humanFileSize($node->getSize()) . "</info> in trash for <info>$uid</info>.");
+            }
+            $node->delete();
+            if ($this->rootFolder->nodeExists($path)) {
+                $output->writeln('<error>Trash folder sill exists after attempting to delete it</error>');
+                return;
+            }
+            $query = $this->dbConnection->getQueryBuilder();
+            $query->delete('files_trash')
+                ->where($query->expr()->eq('user', $query->createParameter('uid')))
+                ->setParameter('uid', $uid);
+            $query->executeStatement();
+        } else {
+            if ($verbose) {
+                $output->writeln("No trash found for <info>$uid</info>");
+            }
+        }
+    }
 }

Spacing +2 added lines, -2 removed lines

@@ -92,12 +92,12 @@
 	protected function removeDeletedFiles(string $uid, OutputInterface $output, bool $verbose): void {
 		\OC_Util::tearDownFS();
 		\OC_Util::setupFS($uid);
-		$path = '/' . $uid . '/files_trashbin';
+		$path = '/'.$uid.'/files_trashbin';
 		if ($this->rootFolder->nodeExists($path)) {
 			$node = $this->rootFolder->get($path);
 
 			if ($verbose) {
-				$output->writeln('Deleting <info>' . Util::humanFileSize($node->getSize()) . "</info> in trash for <info>$uid</info>.");
+				$output->writeln('Deleting <info>'.Util::humanFileSize($node->getSize())."</info> in trash for <info>$uid</info>.");
 			}
 			$node->delete();
 			if ($this->rootFolder->nodeExists($path)) {

apps/files_trashbin/lib/Command/Size.php

Indentation +92 added lines, -92 removed lines

@@ -20,105 +20,105 @@
 use Symfony\Component\Console\Output\OutputInterface;
 
 class Size extends Base {
-	public function __construct(
-		private IConfig $config,
-		private IUserManager $userManager,
-		private IBus $commandBus,
-	) {
-		parent::__construct();
-	}
+    public function __construct(
+        private IConfig $config,
+        private IUserManager $userManager,
+        private IBus $commandBus,
+    ) {
+        parent::__construct();
+    }
 
-	protected function configure() {
-		parent::configure();
-		$this
-			->setName('trashbin:size')
-			->setDescription('Configure the target trashbin size')
-			->addOption('user', 'u', InputOption::VALUE_REQUIRED, 'configure the target size for the provided user, if no user is given the default size is configured')
-			->addArgument(
-				'size',
-				InputArgument::OPTIONAL,
-				'the target size for the trashbin, if not provided the current trashbin size will be returned'
-			);
-	}
+    protected function configure() {
+        parent::configure();
+        $this
+            ->setName('trashbin:size')
+            ->setDescription('Configure the target trashbin size')
+            ->addOption('user', 'u', InputOption::VALUE_REQUIRED, 'configure the target size for the provided user, if no user is given the default size is configured')
+            ->addArgument(
+                'size',
+                InputArgument::OPTIONAL,
+                'the target size for the trashbin, if not provided the current trashbin size will be returned'
+            );
+    }
 
-	protected function execute(InputInterface $input, OutputInterface $output): int {
-		$user = $input->getOption('user');
-		$size = $input->getArgument('size');
+    protected function execute(InputInterface $input, OutputInterface $output): int {
+        $user = $input->getOption('user');
+        $size = $input->getArgument('size');
 
-		if ($size) {
-			$parsedSize = Util::computerFileSize($size);
-			if ($parsedSize === false) {
-				$output->writeln('<error>Failed to parse input size</error>');
-				return -1;
-			}
-			if ($user) {
-				$this->config->setUserValue($user, 'files_trashbin', 'trashbin_size', (string)$parsedSize);
-				$this->commandBus->push(new Expire($user));
-			} else {
-				$this->config->setAppValue('files_trashbin', 'trashbin_size', (string)$parsedSize);
-				$output->writeln('<info>Warning: changing the default trashbin size will automatically trigger cleanup of existing trashbins,</info>');
-				$output->writeln('<info>a users trashbin can exceed the configured size until they move a new file to the trashbin.</info>');
-			}
-		} else {
-			$this->printTrashbinSize($input, $output, $user);
-		}
+        if ($size) {
+            $parsedSize = Util::computerFileSize($size);
+            if ($parsedSize === false) {
+                $output->writeln('<error>Failed to parse input size</error>');
+                return -1;
+            }
+            if ($user) {
+                $this->config->setUserValue($user, 'files_trashbin', 'trashbin_size', (string)$parsedSize);
+                $this->commandBus->push(new Expire($user));
+            } else {
+                $this->config->setAppValue('files_trashbin', 'trashbin_size', (string)$parsedSize);
+                $output->writeln('<info>Warning: changing the default trashbin size will automatically trigger cleanup of existing trashbins,</info>');
+                $output->writeln('<info>a users trashbin can exceed the configured size until they move a new file to the trashbin.</info>');
+            }
+        } else {
+            $this->printTrashbinSize($input, $output, $user);
+        }
 
-		return 0;
-	}
+        return 0;
+    }
 
-	private function printTrashbinSize(InputInterface $input, OutputInterface $output, ?string $user) {
-		$globalSize = (int)$this->config->getAppValue('files_trashbin', 'trashbin_size', '-1');
-		if ($globalSize < 0) {
-			$globalHumanSize = 'default (50% of available space)';
-		} else {
-			$globalHumanSize = Util::humanFileSize($globalSize);
-		}
+    private function printTrashbinSize(InputInterface $input, OutputInterface $output, ?string $user) {
+        $globalSize = (int)$this->config->getAppValue('files_trashbin', 'trashbin_size', '-1');
+        if ($globalSize < 0) {
+            $globalHumanSize = 'default (50% of available space)';
+        } else {
+            $globalHumanSize = Util::humanFileSize($globalSize);
+        }
 
-		if ($user) {
-			$userSize = (int)$this->config->getUserValue($user, 'files_trashbin', 'trashbin_size', '-1');
+        if ($user) {
+            $userSize = (int)$this->config->getUserValue($user, 'files_trashbin', 'trashbin_size', '-1');
 
-			if ($userSize < 0) {
-				$userHumanSize = ($globalSize < 0) ? $globalHumanSize : "default($globalHumanSize)";
-			} else {
-				$userHumanSize = Util::humanFileSize($userSize);
-			}
+            if ($userSize < 0) {
+                $userHumanSize = ($globalSize < 0) ? $globalHumanSize : "default($globalHumanSize)";
+            } else {
+                $userHumanSize = Util::humanFileSize($userSize);
+            }
 
-			if ($input->getOption('output') == self::OUTPUT_FORMAT_PLAIN) {
-				$output->writeln($userHumanSize);
-			} else {
-				$userValue = ($userSize < 0) ? 'default' : $userSize;
-				$globalValue = ($globalSize < 0) ? 'default' : $globalSize;
-				$this->writeArrayInOutputFormat($input, $output, [
-					'user_size' => $userValue,
-					'global_size' => $globalValue,
-					'effective_size' => ($userSize < 0) ? $globalValue : $userValue,
-				]);
-			}
-		} else {
-			$users = [];
-			$this->userManager->callForSeenUsers(function (IUser $user) use (&$users): void {
-				$users[] = $user->getUID();
-			});
-			$userValues = $this->config->getUserValueForUsers('files_trashbin', 'trashbin_size', $users);
+            if ($input->getOption('output') == self::OUTPUT_FORMAT_PLAIN) {
+                $output->writeln($userHumanSize);
+            } else {
+                $userValue = ($userSize < 0) ? 'default' : $userSize;
+                $globalValue = ($globalSize < 0) ? 'default' : $globalSize;
+                $this->writeArrayInOutputFormat($input, $output, [
+                    'user_size' => $userValue,
+                    'global_size' => $globalValue,
+                    'effective_size' => ($userSize < 0) ? $globalValue : $userValue,
+                ]);
+            }
+        } else {
+            $users = [];
+            $this->userManager->callForSeenUsers(function (IUser $user) use (&$users): void {
+                $users[] = $user->getUID();
+            });
+            $userValues = $this->config->getUserValueForUsers('files_trashbin', 'trashbin_size', $users);
 
-			if ($input->getOption('output') == self::OUTPUT_FORMAT_PLAIN) {
-				$output->writeln("Default size: $globalHumanSize");
-				$output->writeln('');
-				if (count($userValues)) {
-					$output->writeln('Per-user sizes:');
-					$this->writeArrayInOutputFormat($input, $output, array_map(function ($size) {
-						return Util::humanFileSize($size);
-					}, $userValues));
-				} else {
-					$output->writeln('No per-user sizes configured');
-				}
-			} else {
-				$globalValue = ($globalSize < 0) ? 'default' : $globalSize;
-				$this->writeArrayInOutputFormat($input, $output, [
-					'global_size' => $globalValue,
-					'user_sizes' => $userValues,
-				]);
-			}
-		}
-	}
+            if ($input->getOption('output') == self::OUTPUT_FORMAT_PLAIN) {
+                $output->writeln("Default size: $globalHumanSize");
+                $output->writeln('');
+                if (count($userValues)) {
+                    $output->writeln('Per-user sizes:');
+                    $this->writeArrayInOutputFormat($input, $output, array_map(function ($size) {
+                        return Util::humanFileSize($size);
+                    }, $userValues));
+                } else {
+                    $output->writeln('No per-user sizes configured');
+                }
+            } else {
+                $globalValue = ($globalSize < 0) ? 'default' : $globalSize;
+                $this->writeArrayInOutputFormat($input, $output, [
+                    'global_size' => $globalValue,
+                    'user_sizes' => $userValues,
+                ]);
+            }
+        }
+    }
 }

Spacing +6 added lines, -6 removed lines

@@ -52,10 +52,10 @@ 
 				return -1;
 			}
 			if ($user) {
-				$this->config->setUserValue($user, 'files_trashbin', 'trashbin_size', (string)$parsedSize);
+				$this->config->setUserValue($user, 'files_trashbin', 'trashbin_size', (string) $parsedSize);
 				$this->commandBus->push(new Expire($user));
 			} else {
-				$this->config->setAppValue('files_trashbin', 'trashbin_size', (string)$parsedSize);
+				$this->config->setAppValue('files_trashbin', 'trashbin_size', (string) $parsedSize);
 				$output->writeln('<info>Warning: changing the default trashbin size will automatically trigger cleanup of existing trashbins,</info>');
 				$output->writeln('<info>a users trashbin can exceed the configured size until they move a new file to the trashbin.</info>');
 			}
@@ -67,7 +67,7 @@ 
 	}
 
 	private function printTrashbinSize(InputInterface $input, OutputInterface $output, ?string $user) {
-		$globalSize = (int)$this->config->getAppValue('files_trashbin', 'trashbin_size', '-1');
+		$globalSize = (int) $this->config->getAppValue('files_trashbin', 'trashbin_size', '-1');
 		if ($globalSize < 0) {
 			$globalHumanSize = 'default (50% of available space)';
 		} else {
@@ -75,7 +75,7 @@ 
 		}
 
 		if ($user) {
-			$userSize = (int)$this->config->getUserValue($user, 'files_trashbin', 'trashbin_size', '-1');
+			$userSize = (int) $this->config->getUserValue($user, 'files_trashbin', 'trashbin_size', '-1');
 
 			if ($userSize < 0) {
 				$userHumanSize = ($globalSize < 0) ? $globalHumanSize : "default($globalHumanSize)";
@@ -96,7 +96,7 @@ 
 			}
 		} else {
 			$users = [];
-			$this->userManager->callForSeenUsers(function (IUser $user) use (&$users): void {
+			$this->userManager->callForSeenUsers(function(IUser $user) use (&$users): void {
 				$users[] = $user->getUID();
 			});
 			$userValues = $this->config->getUserValueForUsers('files_trashbin', 'trashbin_size', $users);
@@ -106,7 +106,7 @@ 
 				$output->writeln('');
 				if (count($userValues)) {
 					$output->writeln('Per-user sizes:');
-					$this->writeArrayInOutputFormat($input, $output, array_map(function ($size) {
+					$this->writeArrayInOutputFormat($input, $output, array_map(function($size) {
 						return Util::humanFileSize($size);
 					}, $userValues));
 				} else {

apps/files_trashbin/tests/TrashbinTest.php

Indentation +661 added lines, -661 removed lines

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

apps/dav/lib/Events/CalendarShareUpdatedEvent.php

Indentation +55 added lines, -55 removed lines

@@ -20,64 +20,64 @@
  * @psalm-import-type CalendarInfo from CalDavBackend
  */
 class CalendarShareUpdatedEvent extends Event {
-	/**
-	 * CalendarShareUpdatedEvent constructor.
-	 *
-	 * @param int $calendarId
-	 * @psalm-param CalendarInfo $calendarData
-	 * @param array $calendarData
-	 * @param list<array{href: string, commonName: string, status: int, readOnly: bool, '{http://owncloud.org/ns}principal': string, '{http://owncloud.org/ns}group-share': bool}> $oldShares
-	 * @param list<array{href: string, commonName: string, readOnly: bool}> $added
-	 * @param list<string> $removed
-	 * @since 20.0.0
-	 */
-	public function __construct(
-		private int $calendarId,
-		private array $calendarData,
-		private array $oldShares,
-		private array $added,
-		private array $removed,
-	) {
-		parent::__construct();
-	}
+    /**
+     * CalendarShareUpdatedEvent constructor.
+     *
+     * @param int $calendarId
+     * @psalm-param CalendarInfo $calendarData
+     * @param array $calendarData
+     * @param list<array{href: string, commonName: string, status: int, readOnly: bool, '{http://owncloud.org/ns}principal': string, '{http://owncloud.org/ns}group-share': bool}> $oldShares
+     * @param list<array{href: string, commonName: string, readOnly: bool}> $added
+     * @param list<string> $removed
+     * @since 20.0.0
+     */
+    public function __construct(
+        private int $calendarId,
+        private array $calendarData,
+        private array $oldShares,
+        private array $added,
+        private array $removed,
+    ) {
+        parent::__construct();
+    }
 
-	/**
-	 * @since 20.0.0
-	 */
-	public function getCalendarId(): int {
-		return $this->calendarId;
-	}
+    /**
+     * @since 20.0.0
+     */
+    public function getCalendarId(): int {
+        return $this->calendarId;
+    }
 
-	/**
-	 * @psalm-return CalendarInfo
-	 * @return array
-	 * @since 20.0.0
-	 */
-	public function getCalendarData(): array {
-		return $this->calendarData;
-	}
+    /**
+     * @psalm-return CalendarInfo
+     * @return array
+     * @since 20.0.0
+     */
+    public function getCalendarData(): array {
+        return $this->calendarData;
+    }
 
-	/**
-	 * @return list<array{href: string, commonName: string, status: int, readOnly: bool, '{http://owncloud.org/ns}principal': string, '{http://owncloud.org/ns}group-share': bool}>
-	 * @since 20.0.0
-	 */
-	public function getOldShares(): array {
-		return $this->oldShares;
-	}
+    /**
+     * @return list<array{href: string, commonName: string, status: int, readOnly: bool, '{http://owncloud.org/ns}principal': string, '{http://owncloud.org/ns}group-share': bool}>
+     * @since 20.0.0
+     */
+    public function getOldShares(): array {
+        return $this->oldShares;
+    }
 
-	/**
-	 * @return list<array{href: string, commonName: string, readOnly: bool}>
-	 * @since 20.0.0
-	 */
-	public function getAdded(): array {
-		return $this->added;
-	}
+    /**
+     * @return list<array{href: string, commonName: string, readOnly: bool}>
+     * @since 20.0.0
+     */
+    public function getAdded(): array {
+        return $this->added;
+    }
 
-	/**
-	 * @return list<string>
-	 * @since 20.0.0
-	 */
-	public function getRemoved(): array {
-		return $this->removed;
-	}
+    /**
+     * @return list<string>
+     * @since 20.0.0
+     */
+    public function getRemoved(): array {
+        return $this->removed;
+    }
 }