nextcloud / server

lib/private/Files/SetupManager.php

Indentation +675 added lines, -675 removed lines

@@ -62,681 +62,681 @@
 use function in_array;
 
 class SetupManager {
-	private bool $rootSetup = false;
-	// List of users for which at least one mount is setup
-	private array $setupUsers = [];
-	// List of users for which all mounts are setup
-	private array $setupUsersComplete = [];
-	/**
-	 * An array of provider classes that have been set up, indexed by UserUID.
-	 *
-	 * @var array<string, class-string<IMountProvider>[]>
-	 */
-	private array $setupUserMountProviders = [];
-	/**
-	 * An array of paths that have already been set up
-	 *
-	 * @var array<string, int>
-	 */
-	private array $setupMountProviderPaths = [];
-	private ICache $cache;
-	private bool $listeningForProviders;
-	private array $fullSetupRequired = [];
-	private bool $setupBuiltinWrappersDone = false;
-	private bool $forceFullSetup = false;
-	private const SETUP_WITH_CHILDREN = 1;
-	private const SETUP_WITHOUT_CHILDREN = 0;
-
-	public function __construct(
-		private IEventLogger $eventLogger,
-		private MountProviderCollection $mountProviderCollection,
-		private IMountManager $mountManager,
-		private IUserManager $userManager,
-		private IEventDispatcher $eventDispatcher,
-		private IUserMountCache $userMountCache,
-		private ILockdownManager $lockdownManager,
-		private IUserSession $userSession,
-		ICacheFactory $cacheFactory,
-		private LoggerInterface $logger,
-		private IConfig $config,
-		private ShareDisableChecker $shareDisableChecker,
-		private IAppManager $appManager,
-		private FileAccess $fileAccess,
-	) {
-		$this->cache = $cacheFactory->createDistributed('setupmanager::');
-		$this->listeningForProviders = false;
-		$this->forceFullSetup = $this->config->getSystemValueBool('debug.force-full-fs-setup');
-
-		$this->setupListeners();
-	}
-
-	private function isSetupStarted(IUser $user): bool {
-		return in_array($user->getUID(), $this->setupUsers, true);
-	}
-
-	public function isSetupComplete(IUser $user): bool {
-		return in_array($user->getUID(), $this->setupUsersComplete, true);
-	}
-
-	/**
-	 * Checks if a path has been cached either directly or through a full setup
-	 * of one of its parents.
-	 */
-	private function isPathSetup(string $path): bool {
-		// if the exact path was already setup with or without children
-		if (array_key_exists($path, $this->setupMountProviderPaths)) {
-			return true;
-		}
-
-		// or if any of the ancestors was fully setup
-		while (($path = dirname($path)) !== '/') {
-			$setupPath = $this->setupMountProviderPaths[$path . '/'] ?? null;
-			if ($setupPath === self::SETUP_WITH_CHILDREN) {
-				return true;
-			}
-		}
-
-		return false;
-	}
-
-	private function setupBuiltinWrappers() {
-		if ($this->setupBuiltinWrappersDone) {
-			return;
-		}
-		$this->setupBuiltinWrappersDone = true;
-
-		// load all filesystem apps before, so no setup-hook gets lost
-		$this->appManager->loadApps(['filesystem']);
-		$prevLogging = Filesystem::logWarningWhenAddingStorageWrapper(false);
-
-		Filesystem::addStorageWrapper('mount_options', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
-			if ($storage->instanceOfStorage(Common::class)) {
-				$options = array_merge($mount->getOptions(), ['mount_point' => $mountPoint]);
-				$storage->setMountOptions($options);
-			}
-			return $storage;
-		});
-
-		$reSharingEnabled = Share::isResharingAllowed();
-		$user = $this->userSession->getUser();
-		$sharingEnabledForUser = $user ? !$this->shareDisableChecker->sharingDisabledForUser($user->getUID()) : true;
-		Filesystem::addStorageWrapper(
-			'sharing_mask',
-			function ($mountPoint, IStorage $storage, IMountPoint $mount) use ($reSharingEnabled, $sharingEnabledForUser) {
-				$sharingEnabledForMount = $mount->getOption('enable_sharing', true);
-				$isShared = $mount instanceof ISharedMountPoint;
-				if (!$sharingEnabledForMount || !$sharingEnabledForUser || (!$reSharingEnabled && $isShared)) {
-					return new PermissionsMask([
-						'storage' => $storage,
-						'mask' => Constants::PERMISSION_ALL - Constants::PERMISSION_SHARE,
-					]);
-				}
-				return $storage;
-			}
-		);
-
-		// install storage availability wrapper, before most other wrappers
-		Filesystem::addStorageWrapper('oc_availability', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
-			$externalMount = $mount instanceof ExternalMountPoint || $mount instanceof Mount;
-			if ($externalMount && !$storage->isLocal()) {
-				return new Availability(['storage' => $storage]);
-			}
-			return $storage;
-		});
-
-		Filesystem::addStorageWrapper('oc_encoding', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
-			if ($mount->getOption('encoding_compatibility', false) && !$mount instanceof SharedMount) {
-				return new Encoding(['storage' => $storage]);
-			}
-			return $storage;
-		});
-
-		$quotaIncludeExternal = $this->config->getSystemValue('quota_include_external_storage', false);
-		Filesystem::addStorageWrapper('oc_quota', function ($mountPoint, $storage, IMountPoint $mount) use ($quotaIncludeExternal) {
-			// set up quota for home storages, even for other users
-			// which can happen when using sharing
-			if ($mount instanceof HomeMountPoint) {
-				$user = $mount->getUser();
-				return new Quota(['storage' => $storage, 'quotaCallback' => function () use ($user) {
-					return $user->getQuotaBytes();
-				}, 'root' => 'files', 'include_external_storage' => $quotaIncludeExternal]);
-			}
-
-			return $storage;
-		});
-
-		Filesystem::addStorageWrapper('readonly', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
-			/*
+    private bool $rootSetup = false;
+    // List of users for which at least one mount is setup
+    private array $setupUsers = [];
+    // List of users for which all mounts are setup
+    private array $setupUsersComplete = [];
+    /**
+     * An array of provider classes that have been set up, indexed by UserUID.
+     *
+     * @var array<string, class-string<IMountProvider>[]>
+     */
+    private array $setupUserMountProviders = [];
+    /**
+     * An array of paths that have already been set up
+     *
+     * @var array<string, int>
+     */
+    private array $setupMountProviderPaths = [];
+    private ICache $cache;
+    private bool $listeningForProviders;
+    private array $fullSetupRequired = [];
+    private bool $setupBuiltinWrappersDone = false;
+    private bool $forceFullSetup = false;
+    private const SETUP_WITH_CHILDREN = 1;
+    private const SETUP_WITHOUT_CHILDREN = 0;
+
+    public function __construct(
+        private IEventLogger $eventLogger,
+        private MountProviderCollection $mountProviderCollection,
+        private IMountManager $mountManager,
+        private IUserManager $userManager,
+        private IEventDispatcher $eventDispatcher,
+        private IUserMountCache $userMountCache,
+        private ILockdownManager $lockdownManager,
+        private IUserSession $userSession,
+        ICacheFactory $cacheFactory,
+        private LoggerInterface $logger,
+        private IConfig $config,
+        private ShareDisableChecker $shareDisableChecker,
+        private IAppManager $appManager,
+        private FileAccess $fileAccess,
+    ) {
+        $this->cache = $cacheFactory->createDistributed('setupmanager::');
+        $this->listeningForProviders = false;
+        $this->forceFullSetup = $this->config->getSystemValueBool('debug.force-full-fs-setup');
+
+        $this->setupListeners();
+    }
+
+    private function isSetupStarted(IUser $user): bool {
+        return in_array($user->getUID(), $this->setupUsers, true);
+    }
+
+    public function isSetupComplete(IUser $user): bool {
+        return in_array($user->getUID(), $this->setupUsersComplete, true);
+    }
+
+    /**
+     * Checks if a path has been cached either directly or through a full setup
+     * of one of its parents.
+     */
+    private function isPathSetup(string $path): bool {
+        // if the exact path was already setup with or without children
+        if (array_key_exists($path, $this->setupMountProviderPaths)) {
+            return true;
+        }
+
+        // or if any of the ancestors was fully setup
+        while (($path = dirname($path)) !== '/') {
+            $setupPath = $this->setupMountProviderPaths[$path . '/'] ?? null;
+            if ($setupPath === self::SETUP_WITH_CHILDREN) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private function setupBuiltinWrappers() {
+        if ($this->setupBuiltinWrappersDone) {
+            return;
+        }
+        $this->setupBuiltinWrappersDone = true;
+
+        // load all filesystem apps before, so no setup-hook gets lost
+        $this->appManager->loadApps(['filesystem']);
+        $prevLogging = Filesystem::logWarningWhenAddingStorageWrapper(false);
+
+        Filesystem::addStorageWrapper('mount_options', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
+            if ($storage->instanceOfStorage(Common::class)) {
+                $options = array_merge($mount->getOptions(), ['mount_point' => $mountPoint]);
+                $storage->setMountOptions($options);
+            }
+            return $storage;
+        });
+
+        $reSharingEnabled = Share::isResharingAllowed();
+        $user = $this->userSession->getUser();
+        $sharingEnabledForUser = $user ? !$this->shareDisableChecker->sharingDisabledForUser($user->getUID()) : true;
+        Filesystem::addStorageWrapper(
+            'sharing_mask',
+            function ($mountPoint, IStorage $storage, IMountPoint $mount) use ($reSharingEnabled, $sharingEnabledForUser) {
+                $sharingEnabledForMount = $mount->getOption('enable_sharing', true);
+                $isShared = $mount instanceof ISharedMountPoint;
+                if (!$sharingEnabledForMount || !$sharingEnabledForUser || (!$reSharingEnabled && $isShared)) {
+                    return new PermissionsMask([
+                        'storage' => $storage,
+                        'mask' => Constants::PERMISSION_ALL - Constants::PERMISSION_SHARE,
+                    ]);
+                }
+                return $storage;
+            }
+        );
+
+        // install storage availability wrapper, before most other wrappers
+        Filesystem::addStorageWrapper('oc_availability', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
+            $externalMount = $mount instanceof ExternalMountPoint || $mount instanceof Mount;
+            if ($externalMount && !$storage->isLocal()) {
+                return new Availability(['storage' => $storage]);
+            }
+            return $storage;
+        });
+
+        Filesystem::addStorageWrapper('oc_encoding', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
+            if ($mount->getOption('encoding_compatibility', false) && !$mount instanceof SharedMount) {
+                return new Encoding(['storage' => $storage]);
+            }
+            return $storage;
+        });
+
+        $quotaIncludeExternal = $this->config->getSystemValue('quota_include_external_storage', false);
+        Filesystem::addStorageWrapper('oc_quota', function ($mountPoint, $storage, IMountPoint $mount) use ($quotaIncludeExternal) {
+            // set up quota for home storages, even for other users
+            // which can happen when using sharing
+            if ($mount instanceof HomeMountPoint) {
+                $user = $mount->getUser();
+                return new Quota(['storage' => $storage, 'quotaCallback' => function () use ($user) {
+                    return $user->getQuotaBytes();
+                }, 'root' => 'files', 'include_external_storage' => $quotaIncludeExternal]);
+            }
+
+            return $storage;
+        });
+
+        Filesystem::addStorageWrapper('readonly', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
+            /*
 			 * Do not allow any operations that modify the storage
 			 */
-			if ($mount->getOption('readonly', false)) {
-				return new PermissionsMask([
-					'storage' => $storage,
-					'mask' => Constants::PERMISSION_ALL & ~(
-						Constants::PERMISSION_UPDATE
-						| Constants::PERMISSION_CREATE
-						| Constants::PERMISSION_DELETE
-					),
-				]);
-			}
-			return $storage;
-		});
-
-		Filesystem::logWarningWhenAddingStorageWrapper($prevLogging);
-	}
-
-	/**
-	 * Setup the full filesystem for the specified user
-	 */
-	public function setupForUser(IUser $user): void {
-		if ($this->isSetupComplete($user)) {
-			return;
-		}
-		$this->setupUsersComplete[] = $user->getUID();
-
-		$this->eventLogger->start('fs:setup:user:full', 'Setup full filesystem for user');
-
-		$this->setupUserMountProviders[$user->getUID()] ??= [];
-		$previouslySetupProviders = $this->setupUserMountProviders[$user->getUID()];
-
-		$this->setupForUserWith($user, function () use ($user) {
-			$this->mountProviderCollection->addMountForUser($user, $this->mountManager, function (
-				string $providerClass,
-			) use ($user) {
-				return !in_array($providerClass, $this->setupUserMountProviders[$user->getUID()]);
-			});
-		});
-		$this->afterUserFullySetup($user, $previouslySetupProviders);
-		$this->eventLogger->end('fs:setup:user:full');
-	}
-
-	/**
-	 * Part of the user setup that is run only once per user.
-	 */
-	private function oneTimeUserSetup(IUser $user) {
-		if ($this->isSetupStarted($user)) {
-			return;
-		}
-		$this->setupUsers[] = $user->getUID();
-
-		$this->setupRoot();
-
-		$this->eventLogger->start('fs:setup:user:onetime', 'Onetime filesystem for user');
-
-		$this->setupBuiltinWrappers();
-
-		$prevLogging = Filesystem::logWarningWhenAddingStorageWrapper(false);
-
-		// TODO remove hook
-		OC_Hook::emit('OC_Filesystem', 'preSetup', ['user' => $user->getUID()]);
-
-		$event = new BeforeFileSystemSetupEvent($user);
-		$this->eventDispatcher->dispatchTyped($event);
-
-		Filesystem::logWarningWhenAddingStorageWrapper($prevLogging);
-
-		$userDir = '/' . $user->getUID() . '/files';
-
-		Filesystem::initInternal($userDir);
-
-		if ($this->lockdownManager->canAccessFilesystem()) {
-			$this->eventLogger->start('fs:setup:user:home', 'Setup home filesystem for user');
-			// home mounts are handled separate since we need to ensure this is mounted before we call the other mount providers
-			$homeMount = $this->mountProviderCollection->getHomeMountForUser($user);
-			$this->mountManager->addMount($homeMount);
-
-			if ($homeMount->getStorageRootId() === -1) {
-				$this->eventLogger->start('fs:setup:user:home:scan', 'Scan home filesystem for user');
-				$homeMount->getStorage()->mkdir('');
-				$homeMount->getStorage()->getScanner()->scan('');
-				$this->eventLogger->end('fs:setup:user:home:scan');
-			}
-			$this->eventLogger->end('fs:setup:user:home');
-		} else {
-			$this->mountManager->addMount(new MountPoint(
-				new NullStorage([]),
-				'/' . $user->getUID()
-			));
-			$this->mountManager->addMount(new MountPoint(
-				new NullStorage([]),
-				'/' . $user->getUID() . '/files'
-			));
-			$this->setupUsersComplete[] = $user->getUID();
-		}
-
-		$this->listenForNewMountProviders();
-
-		$this->eventLogger->end('fs:setup:user:onetime');
-	}
-
-	/**
-	 * Final housekeeping after a user has been fully setup
-	 */
-	private function afterUserFullySetup(IUser $user, array $previouslySetupProviders): void {
-		$this->eventLogger->start('fs:setup:user:full:post', 'Housekeeping after user is setup');
-		$userRoot = '/' . $user->getUID() . '/';
-		$mounts = $this->mountManager->getAll();
-		$mounts = array_filter($mounts, function (IMountPoint $mount) use ($userRoot) {
-			return str_starts_with($mount->getMountPoint(), $userRoot);
-		});
-		$allProviders = array_map(function (IMountProvider|IHomeMountProvider|IRootMountProvider $provider) {
-			return get_class($provider);
-		}, array_merge(
-			$this->mountProviderCollection->getProviders(),
-			$this->mountProviderCollection->getHomeProviders(),
-			$this->mountProviderCollection->getRootProviders(),
-		));
-		$newProviders = array_diff($allProviders, $previouslySetupProviders);
-		$mounts = array_filter($mounts, function (IMountPoint $mount) use ($previouslySetupProviders) {
-			return !in_array($mount->getMountProvider(), $previouslySetupProviders);
-		});
-		$this->registerMounts($user, $mounts, $newProviders);
-
-		$cacheDuration = $this->config->getSystemValueInt('fs_mount_cache_duration', 5 * 60);
-		if ($cacheDuration > 0) {
-			$this->cache->set($user->getUID(), true, $cacheDuration);
-			$this->fullSetupRequired[$user->getUID()] = false;
-		}
-		$this->eventLogger->end('fs:setup:user:full:post');
-	}
-
-	/**
-	 * Executes the one-time user setup and, if the user can access the
-	 * filesystem, executes $mountCallback.
-	 *
-	 * @param IUser $user
-	 * @param IMountPoint $mounts
-	 * @return void
-	 * @throws \OCP\HintException
-	 * @throws \OC\ServerNotAvailableException
-	 * @see self::oneTimeUserSetup()
-	 *
-	 */
-	private function setupForUserWith(IUser $user, callable $mountCallback): void {
-		$this->oneTimeUserSetup($user);
-
-		if ($this->lockdownManager->canAccessFilesystem()) {
-			$mountCallback();
-		}
-		$this->eventLogger->start('fs:setup:user:post-init-mountpoint', 'post_initMountPoints legacy hook');
-		\OC_Hook::emit('OC_Filesystem', 'post_initMountPoints', ['user' => $user->getUID()]);
-		$this->eventLogger->end('fs:setup:user:post-init-mountpoint');
-
-		$userDir = '/' . $user->getUID() . '/files';
-		$this->eventLogger->start('fs:setup:user:setup-hook', 'setup legacy hook');
-		OC_Hook::emit('OC_Filesystem', 'setup', ['user' => $user->getUID(), 'user_dir' => $userDir]);
-		$this->eventLogger->end('fs:setup:user:setup-hook');
-	}
-
-	/**
-	 * Set up the root filesystem
-	 */
-	public function setupRoot(): void {
-		//setting up the filesystem twice can only lead to trouble
-		if ($this->rootSetup) {
-			return;
-		}
-
-		$this->setupBuiltinWrappers();
-
-		$this->rootSetup = true;
-
-		$this->eventLogger->start('fs:setup:root', 'Setup root filesystem');
-
-		$rootMounts = $this->mountProviderCollection->getRootMounts();
-		foreach ($rootMounts as $rootMountProvider) {
-			$this->mountManager->addMount($rootMountProvider);
-		}
-
-		$this->eventLogger->end('fs:setup:root');
-	}
-
-	/**
-	 * Get the user to setup for a path or `null` if the root needs to be setup
-	 *
-	 * @param string $path
-	 * @return IUser|null
-	 */
-	private function getUserForPath(string $path) {
-		if (str_starts_with($path, '/__groupfolders')) {
-			return null;
-		} elseif (substr_count($path, '/') < 2) {
-			if ($user = $this->userSession->getUser()) {
-				return $user;
-			} else {
-				return null;
-			}
-		} elseif (str_starts_with($path, '/appdata_' . \OC_Util::getInstanceId()) || str_starts_with($path, '/files_external/')) {
-			return null;
-		} else {
-			[, $userId] = explode('/', $path);
-		}
-
-		return $this->userManager->get($userId);
-	}
-
-	/**
-	 * Set up the filesystem for the specified path, optionally including all
-	 * children mounts.
-	 */
-	public function setupForPath(string $path, bool $includeChildren = false): void {
-		$user = $this->getUserForPath($path);
-		if (!$user) {
-			$this->setupRoot();
-			return;
-		}
-
-		if ($this->isSetupComplete($user)) {
-			return;
-		}
-
-		if ($this->fullSetupRequired($user)) {
-			$this->setupForUser($user);
-			return;
-		}
-
-		// for the user's home folder, and includes children we need everything always
-		if (rtrim($path) === '/' . $user->getUID() . '/files' && $includeChildren) {
-			$this->setupForUser($user);
-			return;
-		}
-
-		if (!isset($this->setupUserMountProviders[$user->getUID()])) {
-			$this->setupUserMountProviders[$user->getUID()] = [];
-		}
-		$setupProviders = &$this->setupUserMountProviders[$user->getUID()];
-		$currentProviders = [];
-
-		try {
-			$cachedMount = $this->userMountCache->getMountForPath($user, $path);
-		} catch (NotFoundException $e) {
-			$this->setupForUser($user);
-			return;
-		}
-
-		$this->oneTimeUserSetup($user);
-
-		$this->eventLogger->start('fs:setup:user:path', "Setup $path filesystem for user");
-		$this->eventLogger->start('fs:setup:user:path:find', "Find mountpoint for $path");
-
-		$fullProviderMounts = [];
-		$authoritativeMounts = [];
-
-		$mountProvider = $cachedMount->getMountProvider();
-		$mountPoint = $cachedMount->getMountPoint();
-		$isMountProviderSetup = in_array($mountProvider, $setupProviders);
-		$isPathSetupAsAuthoritative
-			= $this->isPathSetup($mountPoint);
-		if (!$isMountProviderSetup && !$isPathSetupAsAuthoritative) {
-			if ($mountProvider === '') {
-				$this->logger->debug('mount at ' . $cachedMount->getMountPoint() . ' has no provider set, performing full setup');
-				$this->eventLogger->end('fs:setup:user:path:find');
-				$this->setupForUser($user);
-				$this->eventLogger->end('fs:setup:user:path');
-				return;
-			}
-
-			if (is_a($mountProvider, IPartialMountProvider::class, true)) {
-				$rootId = $cachedMount->getRootId();
-				$rootMetadata = $this->fileAccess->getByFileId($rootId);
-				$providerArgs = new IMountProviderArgs($cachedMount, $rootMetadata);
-				// mark the path as cached (without children for now...)
-				$this->setupMountProviderPaths[$mountPoint] = self::SETUP_WITHOUT_CHILDREN;
-				$authoritativeMounts[] = array_values(
-					$this->mountProviderCollection->getUserMountsFromProviderByPath(
-						$mountProvider,
-						$path,
-						[$providerArgs]
-					)
-				);
-			} else {
-				$currentProviders[] = $mountProvider;
-				$setupProviders[] = $mountProvider;
-				$fullProviderMounts[]
-					= $this->mountProviderCollection->getUserMountsForProviderClasses($user, [$mountProvider]);
-			}
-		}
-
-		if ($includeChildren) {
-			$subCachedMounts = $this->userMountCache->getMountsInPath($user, $path);
-			$this->eventLogger->end('fs:setup:user:path:find');
-
-			$needsFullSetup
-				= array_any(
-					$subCachedMounts,
-					fn (ICachedMountInfo $info) => $info->getMountProvider() === ''
-				);
-
-			if ($needsFullSetup) {
-				$this->logger->debug('mount has no provider set, performing full setup');
-				$this->setupForUser($user);
-				$this->eventLogger->end('fs:setup:user:path');
-				return;
-			}
-
-			/** @var array<class-string<IMountProvider>, ICachedMountInfo[]> $authoritativeCachedMounts */
-			$authoritativeCachedMounts = [];
-			foreach ($subCachedMounts as $cachedMount) {
-				/** @var class-string<IMountProvider> $mountProvider */
-				$mountProvider = $cachedMount->getMountProvider();
-
-				// skip setup for already set up providers
-				if (in_array($mountProvider, $setupProviders)) {
-					continue;
-				}
-
-				if (is_a($mountProvider, IPartialMountProvider::class, true)) {
-					// skip setup if path was set up as authoritative before
-					if ($this->isPathSetup($cachedMount->getMountPoint())) {
-						continue;
-					}
-					// collect cached mount points for authoritative providers
-					$authoritativeCachedMounts[$mountProvider] ??= [];
-					$authoritativeCachedMounts[$mountProvider][] = $cachedMount;
-					continue;
-				}
-
-				$currentProviders[] = $mountProvider;
-				$setupProviders[] = $mountProvider;
-				$fullProviderMounts[]
-					= $this->mountProviderCollection->getUserMountsForProviderClasses(
-						$user,
-						[$mountProvider]
-					);
-			}
-
-			if (!empty($authoritativeCachedMounts)) {
-				$rootIds = array_map(
-					fn (ICachedMountInfo $mount) => $mount->getRootId(),
-					array_merge(...array_values($authoritativeCachedMounts)),
-				);
-
-				$rootsMetadata = [];
-				foreach (array_chunk($rootIds, 1000) as $chunk) {
-					foreach ($this->fileAccess->getByFileIds($chunk) as $id => $fileMetadata) {
-						$rootsMetadata[$id] = $fileMetadata;
-					}
-				}
-				$this->setupMountProviderPaths[$mountPoint] = self::SETUP_WITH_CHILDREN;
-				foreach ($authoritativeCachedMounts as $providerClass => $cachedMounts) {
-					$providerArgs = array_filter(array_map(
-						static function (ICachedMountInfo $info) use ($rootsMetadata) {
-							$rootMetadata = $rootsMetadata[$info->getRootId()] ?? null;
-
-							return $rootMetadata
-								? new IMountProviderArgs($info, $rootMetadata)
-								: null;
-						},
-						$cachedMounts
-					));
-					$authoritativeMounts[]
-						= $this->mountProviderCollection->getUserMountsFromProviderByPath(
-							$providerClass,
-							$path,
-							$providerArgs,
-						);
-				}
-			}
-		} else {
-			$this->eventLogger->end('fs:setup:user:path:find');
-		}
-
-		$fullProviderMounts = array_merge(...$fullProviderMounts);
-		$authoritativeMounts = array_merge(...$authoritativeMounts);
-
-		if (count($fullProviderMounts) || count($authoritativeMounts)) {
-			if (count($fullProviderMounts)) {
-				$this->registerMounts($user, $fullProviderMounts, $currentProviders);
-			}
-
-			$this->setupForUserWith($user, function () use ($fullProviderMounts, $authoritativeMounts) {
-				$allMounts = [...$fullProviderMounts, ...$authoritativeMounts];
-				array_walk($allMounts, $this->mountManager->addMount(...));
-			});
-		} elseif (!$this->isSetupStarted($user)) {
-			$this->oneTimeUserSetup($user);
-		}
-		$this->eventLogger->end('fs:setup:user:path');
-	}
-
-	private function fullSetupRequired(IUser $user): bool {
-		if ($this->forceFullSetup) {
-			return true;
-		}
-
-		// we perform a "cached" setup only after having done the full setup recently
-		// this is also used to trigger a full setup after handling events that are likely
-		// to change the available mounts
-		if (!isset($this->fullSetupRequired[$user->getUID()])) {
-			$this->fullSetupRequired[$user->getUID()] = !$this->cache->get($user->getUID());
-		}
-		return $this->fullSetupRequired[$user->getUID()];
-	}
-
-	/**
-	 * @param string $path
-	 * @param string[] $providers
-	 */
-	public function setupForProvider(string $path, array $providers): void {
-		$user = $this->getUserForPath($path);
-		if (!$user) {
-			$this->setupRoot();
-			return;
-		}
-
-		if ($this->isSetupComplete($user)) {
-			return;
-		}
-
-		if ($this->fullSetupRequired($user)) {
-			$this->setupForUser($user);
-			return;
-		}
-
-		$this->eventLogger->start('fs:setup:user:providers', 'Setup filesystem for ' . implode(', ', $providers));
-
-		$this->oneTimeUserSetup($user);
-
-		// home providers are always used
-		$providers = array_filter($providers, function (string $provider) {
-			return !is_subclass_of($provider, IHomeMountProvider::class);
-		});
-
-		if (in_array('', $providers)) {
-			$this->setupForUser($user);
-			return;
-		}
-		$setupProviders = $this->setupUserMountProviders[$user->getUID()] ?? [];
-
-		$providers = array_diff($providers, $setupProviders);
-		if (count($providers) === 0) {
-			if (!$this->isSetupStarted($user)) {
-				$this->oneTimeUserSetup($user);
-			}
-			$this->eventLogger->end('fs:setup:user:providers');
-			return;
-		} else {
-			$this->setupUserMountProviders[$user->getUID()] = array_merge($setupProviders, $providers);
-			$mounts = $this->mountProviderCollection->getUserMountsForProviderClasses($user, $providers);
-		}
-
-		$this->registerMounts($user, $mounts, $providers);
-		$this->setupForUserWith($user, function () use ($mounts) {
-			array_walk($mounts, [$this->mountManager, 'addMount']);
-		});
-		$this->eventLogger->end('fs:setup:user:providers');
-	}
-
-	public function tearDown() {
-		$this->setupUsers = [];
-		$this->setupUsersComplete = [];
-		$this->setupUserMountProviders = [];
-		$this->setupMountProviderPaths = [];
-		$this->fullSetupRequired = [];
-		$this->rootSetup = false;
-		$this->mountManager->clear();
-		$this->eventDispatcher->dispatchTyped(new FilesystemTornDownEvent());
-	}
-
-	/**
-	 * Get mounts from mount providers that are registered after setup
-	 */
-	private function listenForNewMountProviders() {
-		if (!$this->listeningForProviders) {
-			$this->listeningForProviders = true;
-			$this->mountProviderCollection->listen('\OC\Files\Config', 'registerMountProvider', function (
-				IMountProvider $provider,
-			) {
-				foreach ($this->setupUsers as $userId) {
-					$user = $this->userManager->get($userId);
-					if ($user) {
-						$mounts = $provider->getMountsForUser($user, Filesystem::getLoader());
-						array_walk($mounts, [$this->mountManager, 'addMount']);
-					}
-				}
-			});
-		}
-	}
-
-	private function setupListeners() {
-		// note that this event handling is intentionally pessimistic
-		// clearing the cache to often is better than not enough
-
-		$this->eventDispatcher->addListener(UserAddedEvent::class, function (UserAddedEvent $event) {
-			$this->cache->remove($event->getUser()->getUID());
-		});
-		$this->eventDispatcher->addListener(UserRemovedEvent::class, function (UserRemovedEvent $event) {
-			$this->cache->remove($event->getUser()->getUID());
-		});
-		$this->eventDispatcher->addListener(ShareCreatedEvent::class, function (ShareCreatedEvent $event) {
-			$this->cache->remove($event->getShare()->getSharedWith());
-		});
-		$this->eventDispatcher->addListener(InvalidateMountCacheEvent::class, function (InvalidateMountCacheEvent $event,
-		) {
-			if ($user = $event->getUser()) {
-				$this->cache->remove($user->getUID());
-			} else {
-				$this->cache->clear();
-			}
-		});
-
-		$genericEvents = [
-			'OCA\Circles\Events\CreatingCircleEvent',
-			'OCA\Circles\Events\DestroyingCircleEvent',
-			'OCA\Circles\Events\AddingCircleMemberEvent',
-			'OCA\Circles\Events\RemovingCircleMemberEvent',
-		];
-
-		foreach ($genericEvents as $genericEvent) {
-			$this->eventDispatcher->addListener($genericEvent, function ($event) {
-				$this->cache->clear();
-			});
-		}
-	}
-
-	private function registerMounts(IUser $user, array $mounts, ?array $mountProviderClasses = null): void {
-		if ($this->lockdownManager->canAccessFilesystem()) {
-			$this->userMountCache->registerMounts($user, $mounts, $mountProviderClasses);
-		}
-	}
+            if ($mount->getOption('readonly', false)) {
+                return new PermissionsMask([
+                    'storage' => $storage,
+                    'mask' => Constants::PERMISSION_ALL & ~(
+                        Constants::PERMISSION_UPDATE
+                        | Constants::PERMISSION_CREATE
+                        | Constants::PERMISSION_DELETE
+                    ),
+                ]);
+            }
+            return $storage;
+        });
+
+        Filesystem::logWarningWhenAddingStorageWrapper($prevLogging);
+    }
+
+    /**
+     * Setup the full filesystem for the specified user
+     */
+    public function setupForUser(IUser $user): void {
+        if ($this->isSetupComplete($user)) {
+            return;
+        }
+        $this->setupUsersComplete[] = $user->getUID();
+
+        $this->eventLogger->start('fs:setup:user:full', 'Setup full filesystem for user');
+
+        $this->setupUserMountProviders[$user->getUID()] ??= [];
+        $previouslySetupProviders = $this->setupUserMountProviders[$user->getUID()];
+
+        $this->setupForUserWith($user, function () use ($user) {
+            $this->mountProviderCollection->addMountForUser($user, $this->mountManager, function (
+                string $providerClass,
+            ) use ($user) {
+                return !in_array($providerClass, $this->setupUserMountProviders[$user->getUID()]);
+            });
+        });
+        $this->afterUserFullySetup($user, $previouslySetupProviders);
+        $this->eventLogger->end('fs:setup:user:full');
+    }
+
+    /**
+     * Part of the user setup that is run only once per user.
+     */
+    private function oneTimeUserSetup(IUser $user) {
+        if ($this->isSetupStarted($user)) {
+            return;
+        }
+        $this->setupUsers[] = $user->getUID();
+
+        $this->setupRoot();
+
+        $this->eventLogger->start('fs:setup:user:onetime', 'Onetime filesystem for user');
+
+        $this->setupBuiltinWrappers();
+
+        $prevLogging = Filesystem::logWarningWhenAddingStorageWrapper(false);
+
+        // TODO remove hook
+        OC_Hook::emit('OC_Filesystem', 'preSetup', ['user' => $user->getUID()]);
+
+        $event = new BeforeFileSystemSetupEvent($user);
+        $this->eventDispatcher->dispatchTyped($event);
+
+        Filesystem::logWarningWhenAddingStorageWrapper($prevLogging);
+
+        $userDir = '/' . $user->getUID() . '/files';
+
+        Filesystem::initInternal($userDir);
+
+        if ($this->lockdownManager->canAccessFilesystem()) {
+            $this->eventLogger->start('fs:setup:user:home', 'Setup home filesystem for user');
+            // home mounts are handled separate since we need to ensure this is mounted before we call the other mount providers
+            $homeMount = $this->mountProviderCollection->getHomeMountForUser($user);
+            $this->mountManager->addMount($homeMount);
+
+            if ($homeMount->getStorageRootId() === -1) {
+                $this->eventLogger->start('fs:setup:user:home:scan', 'Scan home filesystem for user');
+                $homeMount->getStorage()->mkdir('');
+                $homeMount->getStorage()->getScanner()->scan('');
+                $this->eventLogger->end('fs:setup:user:home:scan');
+            }
+            $this->eventLogger->end('fs:setup:user:home');
+        } else {
+            $this->mountManager->addMount(new MountPoint(
+                new NullStorage([]),
+                '/' . $user->getUID()
+            ));
+            $this->mountManager->addMount(new MountPoint(
+                new NullStorage([]),
+                '/' . $user->getUID() . '/files'
+            ));
+            $this->setupUsersComplete[] = $user->getUID();
+        }
+
+        $this->listenForNewMountProviders();
+
+        $this->eventLogger->end('fs:setup:user:onetime');
+    }
+
+    /**
+     * Final housekeeping after a user has been fully setup
+     */
+    private function afterUserFullySetup(IUser $user, array $previouslySetupProviders): void {
+        $this->eventLogger->start('fs:setup:user:full:post', 'Housekeeping after user is setup');
+        $userRoot = '/' . $user->getUID() . '/';
+        $mounts = $this->mountManager->getAll();
+        $mounts = array_filter($mounts, function (IMountPoint $mount) use ($userRoot) {
+            return str_starts_with($mount->getMountPoint(), $userRoot);
+        });
+        $allProviders = array_map(function (IMountProvider|IHomeMountProvider|IRootMountProvider $provider) {
+            return get_class($provider);
+        }, array_merge(
+            $this->mountProviderCollection->getProviders(),
+            $this->mountProviderCollection->getHomeProviders(),
+            $this->mountProviderCollection->getRootProviders(),
+        ));
+        $newProviders = array_diff($allProviders, $previouslySetupProviders);
+        $mounts = array_filter($mounts, function (IMountPoint $mount) use ($previouslySetupProviders) {
+            return !in_array($mount->getMountProvider(), $previouslySetupProviders);
+        });
+        $this->registerMounts($user, $mounts, $newProviders);
+
+        $cacheDuration = $this->config->getSystemValueInt('fs_mount_cache_duration', 5 * 60);
+        if ($cacheDuration > 0) {
+            $this->cache->set($user->getUID(), true, $cacheDuration);
+            $this->fullSetupRequired[$user->getUID()] = false;
+        }
+        $this->eventLogger->end('fs:setup:user:full:post');
+    }
+
+    /**
+     * Executes the one-time user setup and, if the user can access the
+     * filesystem, executes $mountCallback.
+     *
+     * @param IUser $user
+     * @param IMountPoint $mounts
+     * @return void
+     * @throws \OCP\HintException
+     * @throws \OC\ServerNotAvailableException
+     * @see self::oneTimeUserSetup()
+     *
+     */
+    private function setupForUserWith(IUser $user, callable $mountCallback): void {
+        $this->oneTimeUserSetup($user);
+
+        if ($this->lockdownManager->canAccessFilesystem()) {
+            $mountCallback();
+        }
+        $this->eventLogger->start('fs:setup:user:post-init-mountpoint', 'post_initMountPoints legacy hook');
+        \OC_Hook::emit('OC_Filesystem', 'post_initMountPoints', ['user' => $user->getUID()]);
+        $this->eventLogger->end('fs:setup:user:post-init-mountpoint');
+
+        $userDir = '/' . $user->getUID() . '/files';
+        $this->eventLogger->start('fs:setup:user:setup-hook', 'setup legacy hook');
+        OC_Hook::emit('OC_Filesystem', 'setup', ['user' => $user->getUID(), 'user_dir' => $userDir]);
+        $this->eventLogger->end('fs:setup:user:setup-hook');
+    }
+
+    /**
+     * Set up the root filesystem
+     */
+    public function setupRoot(): void {
+        //setting up the filesystem twice can only lead to trouble
+        if ($this->rootSetup) {
+            return;
+        }
+
+        $this->setupBuiltinWrappers();
+
+        $this->rootSetup = true;
+
+        $this->eventLogger->start('fs:setup:root', 'Setup root filesystem');
+
+        $rootMounts = $this->mountProviderCollection->getRootMounts();
+        foreach ($rootMounts as $rootMountProvider) {
+            $this->mountManager->addMount($rootMountProvider);
+        }
+
+        $this->eventLogger->end('fs:setup:root');
+    }
+
+    /**
+     * Get the user to setup for a path or `null` if the root needs to be setup
+     *
+     * @param string $path
+     * @return IUser|null
+     */
+    private function getUserForPath(string $path) {
+        if (str_starts_with($path, '/__groupfolders')) {
+            return null;
+        } elseif (substr_count($path, '/') < 2) {
+            if ($user = $this->userSession->getUser()) {
+                return $user;
+            } else {
+                return null;
+            }
+        } elseif (str_starts_with($path, '/appdata_' . \OC_Util::getInstanceId()) || str_starts_with($path, '/files_external/')) {
+            return null;
+        } else {
+            [, $userId] = explode('/', $path);
+        }
+
+        return $this->userManager->get($userId);
+    }
+
+    /**
+     * Set up the filesystem for the specified path, optionally including all
+     * children mounts.
+     */
+    public function setupForPath(string $path, bool $includeChildren = false): void {
+        $user = $this->getUserForPath($path);
+        if (!$user) {
+            $this->setupRoot();
+            return;
+        }
+
+        if ($this->isSetupComplete($user)) {
+            return;
+        }
+
+        if ($this->fullSetupRequired($user)) {
+            $this->setupForUser($user);
+            return;
+        }
+
+        // for the user's home folder, and includes children we need everything always
+        if (rtrim($path) === '/' . $user->getUID() . '/files' && $includeChildren) {
+            $this->setupForUser($user);
+            return;
+        }
+
+        if (!isset($this->setupUserMountProviders[$user->getUID()])) {
+            $this->setupUserMountProviders[$user->getUID()] = [];
+        }
+        $setupProviders = &$this->setupUserMountProviders[$user->getUID()];
+        $currentProviders = [];
+
+        try {
+            $cachedMount = $this->userMountCache->getMountForPath($user, $path);
+        } catch (NotFoundException $e) {
+            $this->setupForUser($user);
+            return;
+        }
+
+        $this->oneTimeUserSetup($user);
+
+        $this->eventLogger->start('fs:setup:user:path', "Setup $path filesystem for user");
+        $this->eventLogger->start('fs:setup:user:path:find', "Find mountpoint for $path");
+
+        $fullProviderMounts = [];
+        $authoritativeMounts = [];
+
+        $mountProvider = $cachedMount->getMountProvider();
+        $mountPoint = $cachedMount->getMountPoint();
+        $isMountProviderSetup = in_array($mountProvider, $setupProviders);
+        $isPathSetupAsAuthoritative
+            = $this->isPathSetup($mountPoint);
+        if (!$isMountProviderSetup && !$isPathSetupAsAuthoritative) {
+            if ($mountProvider === '') {
+                $this->logger->debug('mount at ' . $cachedMount->getMountPoint() . ' has no provider set, performing full setup');
+                $this->eventLogger->end('fs:setup:user:path:find');
+                $this->setupForUser($user);
+                $this->eventLogger->end('fs:setup:user:path');
+                return;
+            }
+
+            if (is_a($mountProvider, IPartialMountProvider::class, true)) {
+                $rootId = $cachedMount->getRootId();
+                $rootMetadata = $this->fileAccess->getByFileId($rootId);
+                $providerArgs = new IMountProviderArgs($cachedMount, $rootMetadata);
+                // mark the path as cached (without children for now...)
+                $this->setupMountProviderPaths[$mountPoint] = self::SETUP_WITHOUT_CHILDREN;
+                $authoritativeMounts[] = array_values(
+                    $this->mountProviderCollection->getUserMountsFromProviderByPath(
+                        $mountProvider,
+                        $path,
+                        [$providerArgs]
+                    )
+                );
+            } else {
+                $currentProviders[] = $mountProvider;
+                $setupProviders[] = $mountProvider;
+                $fullProviderMounts[]
+                    = $this->mountProviderCollection->getUserMountsForProviderClasses($user, [$mountProvider]);
+            }
+        }
+
+        if ($includeChildren) {
+            $subCachedMounts = $this->userMountCache->getMountsInPath($user, $path);
+            $this->eventLogger->end('fs:setup:user:path:find');
+
+            $needsFullSetup
+                = array_any(
+                    $subCachedMounts,
+                    fn (ICachedMountInfo $info) => $info->getMountProvider() === ''
+                );
+
+            if ($needsFullSetup) {
+                $this->logger->debug('mount has no provider set, performing full setup');
+                $this->setupForUser($user);
+                $this->eventLogger->end('fs:setup:user:path');
+                return;
+            }
+
+            /** @var array<class-string<IMountProvider>, ICachedMountInfo[]> $authoritativeCachedMounts */
+            $authoritativeCachedMounts = [];
+            foreach ($subCachedMounts as $cachedMount) {
+                /** @var class-string<IMountProvider> $mountProvider */
+                $mountProvider = $cachedMount->getMountProvider();
+
+                // skip setup for already set up providers
+                if (in_array($mountProvider, $setupProviders)) {
+                    continue;
+                }
+
+                if (is_a($mountProvider, IPartialMountProvider::class, true)) {
+                    // skip setup if path was set up as authoritative before
+                    if ($this->isPathSetup($cachedMount->getMountPoint())) {
+                        continue;
+                    }
+                    // collect cached mount points for authoritative providers
+                    $authoritativeCachedMounts[$mountProvider] ??= [];
+                    $authoritativeCachedMounts[$mountProvider][] = $cachedMount;
+                    continue;
+                }
+
+                $currentProviders[] = $mountProvider;
+                $setupProviders[] = $mountProvider;
+                $fullProviderMounts[]
+                    = $this->mountProviderCollection->getUserMountsForProviderClasses(
+                        $user,
+                        [$mountProvider]
+                    );
+            }
+
+            if (!empty($authoritativeCachedMounts)) {
+                $rootIds = array_map(
+                    fn (ICachedMountInfo $mount) => $mount->getRootId(),
+                    array_merge(...array_values($authoritativeCachedMounts)),
+                );
+
+                $rootsMetadata = [];
+                foreach (array_chunk($rootIds, 1000) as $chunk) {
+                    foreach ($this->fileAccess->getByFileIds($chunk) as $id => $fileMetadata) {
+                        $rootsMetadata[$id] = $fileMetadata;
+                    }
+                }
+                $this->setupMountProviderPaths[$mountPoint] = self::SETUP_WITH_CHILDREN;
+                foreach ($authoritativeCachedMounts as $providerClass => $cachedMounts) {
+                    $providerArgs = array_filter(array_map(
+                        static function (ICachedMountInfo $info) use ($rootsMetadata) {
+                            $rootMetadata = $rootsMetadata[$info->getRootId()] ?? null;
+
+                            return $rootMetadata
+                                ? new IMountProviderArgs($info, $rootMetadata)
+                                : null;
+                        },
+                        $cachedMounts
+                    ));
+                    $authoritativeMounts[]
+                        = $this->mountProviderCollection->getUserMountsFromProviderByPath(
+                            $providerClass,
+                            $path,
+                            $providerArgs,
+                        );
+                }
+            }
+        } else {
+            $this->eventLogger->end('fs:setup:user:path:find');
+        }
+
+        $fullProviderMounts = array_merge(...$fullProviderMounts);
+        $authoritativeMounts = array_merge(...$authoritativeMounts);
+
+        if (count($fullProviderMounts) || count($authoritativeMounts)) {
+            if (count($fullProviderMounts)) {
+                $this->registerMounts($user, $fullProviderMounts, $currentProviders);
+            }
+
+            $this->setupForUserWith($user, function () use ($fullProviderMounts, $authoritativeMounts) {
+                $allMounts = [...$fullProviderMounts, ...$authoritativeMounts];
+                array_walk($allMounts, $this->mountManager->addMount(...));
+            });
+        } elseif (!$this->isSetupStarted($user)) {
+            $this->oneTimeUserSetup($user);
+        }
+        $this->eventLogger->end('fs:setup:user:path');
+    }
+
+    private function fullSetupRequired(IUser $user): bool {
+        if ($this->forceFullSetup) {
+            return true;
+        }
+
+        // we perform a "cached" setup only after having done the full setup recently
+        // this is also used to trigger a full setup after handling events that are likely
+        // to change the available mounts
+        if (!isset($this->fullSetupRequired[$user->getUID()])) {
+            $this->fullSetupRequired[$user->getUID()] = !$this->cache->get($user->getUID());
+        }
+        return $this->fullSetupRequired[$user->getUID()];
+    }
+
+    /**
+     * @param string $path
+     * @param string[] $providers
+     */
+    public function setupForProvider(string $path, array $providers): void {
+        $user = $this->getUserForPath($path);
+        if (!$user) {
+            $this->setupRoot();
+            return;
+        }
+
+        if ($this->isSetupComplete($user)) {
+            return;
+        }
+
+        if ($this->fullSetupRequired($user)) {
+            $this->setupForUser($user);
+            return;
+        }
+
+        $this->eventLogger->start('fs:setup:user:providers', 'Setup filesystem for ' . implode(', ', $providers));
+
+        $this->oneTimeUserSetup($user);
+
+        // home providers are always used
+        $providers = array_filter($providers, function (string $provider) {
+            return !is_subclass_of($provider, IHomeMountProvider::class);
+        });
+
+        if (in_array('', $providers)) {
+            $this->setupForUser($user);
+            return;
+        }
+        $setupProviders = $this->setupUserMountProviders[$user->getUID()] ?? [];
+
+        $providers = array_diff($providers, $setupProviders);
+        if (count($providers) === 0) {
+            if (!$this->isSetupStarted($user)) {
+                $this->oneTimeUserSetup($user);
+            }
+            $this->eventLogger->end('fs:setup:user:providers');
+            return;
+        } else {
+            $this->setupUserMountProviders[$user->getUID()] = array_merge($setupProviders, $providers);
+            $mounts = $this->mountProviderCollection->getUserMountsForProviderClasses($user, $providers);
+        }
+
+        $this->registerMounts($user, $mounts, $providers);
+        $this->setupForUserWith($user, function () use ($mounts) {
+            array_walk($mounts, [$this->mountManager, 'addMount']);
+        });
+        $this->eventLogger->end('fs:setup:user:providers');
+    }
+
+    public function tearDown() {
+        $this->setupUsers = [];
+        $this->setupUsersComplete = [];
+        $this->setupUserMountProviders = [];
+        $this->setupMountProviderPaths = [];
+        $this->fullSetupRequired = [];
+        $this->rootSetup = false;
+        $this->mountManager->clear();
+        $this->eventDispatcher->dispatchTyped(new FilesystemTornDownEvent());
+    }
+
+    /**
+     * Get mounts from mount providers that are registered after setup
+     */
+    private function listenForNewMountProviders() {
+        if (!$this->listeningForProviders) {
+            $this->listeningForProviders = true;
+            $this->mountProviderCollection->listen('\OC\Files\Config', 'registerMountProvider', function (
+                IMountProvider $provider,
+            ) {
+                foreach ($this->setupUsers as $userId) {
+                    $user = $this->userManager->get($userId);
+                    if ($user) {
+                        $mounts = $provider->getMountsForUser($user, Filesystem::getLoader());
+                        array_walk($mounts, [$this->mountManager, 'addMount']);
+                    }
+                }
+            });
+        }
+    }
+
+    private function setupListeners() {
+        // note that this event handling is intentionally pessimistic
+        // clearing the cache to often is better than not enough
+
+        $this->eventDispatcher->addListener(UserAddedEvent::class, function (UserAddedEvent $event) {
+            $this->cache->remove($event->getUser()->getUID());
+        });
+        $this->eventDispatcher->addListener(UserRemovedEvent::class, function (UserRemovedEvent $event) {
+            $this->cache->remove($event->getUser()->getUID());
+        });
+        $this->eventDispatcher->addListener(ShareCreatedEvent::class, function (ShareCreatedEvent $event) {
+            $this->cache->remove($event->getShare()->getSharedWith());
+        });
+        $this->eventDispatcher->addListener(InvalidateMountCacheEvent::class, function (InvalidateMountCacheEvent $event,
+        ) {
+            if ($user = $event->getUser()) {
+                $this->cache->remove($user->getUID());
+            } else {
+                $this->cache->clear();
+            }
+        });
+
+        $genericEvents = [
+            'OCA\Circles\Events\CreatingCircleEvent',
+            'OCA\Circles\Events\DestroyingCircleEvent',
+            'OCA\Circles\Events\AddingCircleMemberEvent',
+            'OCA\Circles\Events\RemovingCircleMemberEvent',
+        ];
+
+        foreach ($genericEvents as $genericEvent) {
+            $this->eventDispatcher->addListener($genericEvent, function ($event) {
+                $this->cache->clear();
+            });
+        }
+    }
+
+    private function registerMounts(IUser $user, array $mounts, ?array $mountProviderClasses = null): void {
+        if ($this->lockdownManager->canAccessFilesystem()) {
+            $this->userMountCache->registerMounts($user, $mounts, $mountProviderClasses);
+        }
+    }
 }

Spacing +32 added lines, -32 removed lines

@@ -130,7 +130,7 @@ 
 
 		// or if any of the ancestors was fully setup
 		while (($path = dirname($path)) !== '/') {
-			$setupPath = $this->setupMountProviderPaths[$path . '/'] ?? null;
+			$setupPath = $this->setupMountProviderPaths[$path.'/'] ?? null;
 			if ($setupPath === self::SETUP_WITH_CHILDREN) {
 				return true;
 			}
@@ -149,7 +149,7 @@ 
 		$this->appManager->loadApps(['filesystem']);
 		$prevLogging = Filesystem::logWarningWhenAddingStorageWrapper(false);
 
-		Filesystem::addStorageWrapper('mount_options', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
+		Filesystem::addStorageWrapper('mount_options', function($mountPoint, IStorage $storage, IMountPoint $mount) {
 			if ($storage->instanceOfStorage(Common::class)) {
 				$options = array_merge($mount->getOptions(), ['mount_point' => $mountPoint]);
 				$storage->setMountOptions($options);
@@ -162,7 +162,7 @@ 
 		$sharingEnabledForUser = $user ? !$this->shareDisableChecker->sharingDisabledForUser($user->getUID()) : true;
 		Filesystem::addStorageWrapper(
 			'sharing_mask',
-			function ($mountPoint, IStorage $storage, IMountPoint $mount) use ($reSharingEnabled, $sharingEnabledForUser) {
+			function($mountPoint, IStorage $storage, IMountPoint $mount) use ($reSharingEnabled, $sharingEnabledForUser) {
 				$sharingEnabledForMount = $mount->getOption('enable_sharing', true);
 				$isShared = $mount instanceof ISharedMountPoint;
 				if (!$sharingEnabledForMount || !$sharingEnabledForUser || (!$reSharingEnabled && $isShared)) {
@@ -176,7 +176,7 @@ 
 		);
 
 		// install storage availability wrapper, before most other wrappers
-		Filesystem::addStorageWrapper('oc_availability', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
+		Filesystem::addStorageWrapper('oc_availability', function($mountPoint, IStorage $storage, IMountPoint $mount) {
 			$externalMount = $mount instanceof ExternalMountPoint || $mount instanceof Mount;
 			if ($externalMount && !$storage->isLocal()) {
 				return new Availability(['storage' => $storage]);
@@ -184,7 +184,7 @@ 
 			return $storage;
 		});
 
-		Filesystem::addStorageWrapper('oc_encoding', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
+		Filesystem::addStorageWrapper('oc_encoding', function($mountPoint, IStorage $storage, IMountPoint $mount) {
 			if ($mount->getOption('encoding_compatibility', false) && !$mount instanceof SharedMount) {
 				return new Encoding(['storage' => $storage]);
 			}
@@ -192,12 +192,12 @@ 
 		});
 
 		$quotaIncludeExternal = $this->config->getSystemValue('quota_include_external_storage', false);
-		Filesystem::addStorageWrapper('oc_quota', function ($mountPoint, $storage, IMountPoint $mount) use ($quotaIncludeExternal) {
+		Filesystem::addStorageWrapper('oc_quota', function($mountPoint, $storage, IMountPoint $mount) use ($quotaIncludeExternal) {
 			// set up quota for home storages, even for other users
 			// which can happen when using sharing
 			if ($mount instanceof HomeMountPoint) {
 				$user = $mount->getUser();
-				return new Quota(['storage' => $storage, 'quotaCallback' => function () use ($user) {
+				return new Quota(['storage' => $storage, 'quotaCallback' => function() use ($user) {
 					return $user->getQuotaBytes();
 				}, 'root' => 'files', 'include_external_storage' => $quotaIncludeExternal]);
 			}
@@ -205,7 +205,7 @@ 
 			return $storage;
 		});
 
-		Filesystem::addStorageWrapper('readonly', function ($mountPoint, IStorage $storage, IMountPoint $mount) {
+		Filesystem::addStorageWrapper('readonly', function($mountPoint, IStorage $storage, IMountPoint $mount) {
 			/*
 			 * Do not allow any operations that modify the storage
 			 */
@@ -239,8 +239,8 @@ 
 		$this->setupUserMountProviders[$user->getUID()] ??= [];
 		$previouslySetupProviders = $this->setupUserMountProviders[$user->getUID()];
 
-		$this->setupForUserWith($user, function () use ($user) {
-			$this->mountProviderCollection->addMountForUser($user, $this->mountManager, function (
+		$this->setupForUserWith($user, function() use ($user) {
+			$this->mountProviderCollection->addMountForUser($user, $this->mountManager, function(
 				string $providerClass,
 			) use ($user) {
 				return !in_array($providerClass, $this->setupUserMountProviders[$user->getUID()]);
@@ -275,7 +275,7 @@ 
 
 		Filesystem::logWarningWhenAddingStorageWrapper($prevLogging);
 
-		$userDir = '/' . $user->getUID() . '/files';
+		$userDir = '/'.$user->getUID().'/files';
 
 		Filesystem::initInternal($userDir);
 
@@ -295,11 +295,11 @@ 
 		} else {
 			$this->mountManager->addMount(new MountPoint(
 				new NullStorage([]),
-				'/' . $user->getUID()
+				'/'.$user->getUID()
 			));
 			$this->mountManager->addMount(new MountPoint(
 				new NullStorage([]),
-				'/' . $user->getUID() . '/files'
+				'/'.$user->getUID().'/files'
 			));
 			$this->setupUsersComplete[] = $user->getUID();
 		}
@@ -314,12 +314,12 @@ 
 	 */
 	private function afterUserFullySetup(IUser $user, array $previouslySetupProviders): void {
 		$this->eventLogger->start('fs:setup:user:full:post', 'Housekeeping after user is setup');
-		$userRoot = '/' . $user->getUID() . '/';
+		$userRoot = '/'.$user->getUID().'/';
 		$mounts = $this->mountManager->getAll();
-		$mounts = array_filter($mounts, function (IMountPoint $mount) use ($userRoot) {
+		$mounts = array_filter($mounts, function(IMountPoint $mount) use ($userRoot) {
 			return str_starts_with($mount->getMountPoint(), $userRoot);
 		});
-		$allProviders = array_map(function (IMountProvider|IHomeMountProvider|IRootMountProvider $provider) {
+		$allProviders = array_map(function(IMountProvider | IHomeMountProvider | IRootMountProvider $provider) {
 			return get_class($provider);
 		}, array_merge(
 			$this->mountProviderCollection->getProviders(),
@@ -327,7 +327,7 @@ 
 			$this->mountProviderCollection->getRootProviders(),
 		));
 		$newProviders = array_diff($allProviders, $previouslySetupProviders);
-		$mounts = array_filter($mounts, function (IMountPoint $mount) use ($previouslySetupProviders) {
+		$mounts = array_filter($mounts, function(IMountPoint $mount) use ($previouslySetupProviders) {
 			return !in_array($mount->getMountProvider(), $previouslySetupProviders);
 		});
 		$this->registerMounts($user, $mounts, $newProviders);
@@ -362,7 +362,7 @@ 
 		\OC_Hook::emit('OC_Filesystem', 'post_initMountPoints', ['user' => $user->getUID()]);
 		$this->eventLogger->end('fs:setup:user:post-init-mountpoint');
 
-		$userDir = '/' . $user->getUID() . '/files';
+		$userDir = '/'.$user->getUID().'/files';
 		$this->eventLogger->start('fs:setup:user:setup-hook', 'setup legacy hook');
 		OC_Hook::emit('OC_Filesystem', 'setup', ['user' => $user->getUID(), 'user_dir' => $userDir]);
 		$this->eventLogger->end('fs:setup:user:setup-hook');
@@ -406,7 +406,7 @@ 
 			} else {
 				return null;
 			}
-		} elseif (str_starts_with($path, '/appdata_' . \OC_Util::getInstanceId()) || str_starts_with($path, '/files_external/')) {
+		} elseif (str_starts_with($path, '/appdata_'.\OC_Util::getInstanceId()) || str_starts_with($path, '/files_external/')) {
 			return null;
 		} else {
 			[, $userId] = explode('/', $path);
@@ -436,7 +436,7 @@ 
 		}
 
 		// for the user's home folder, and includes children we need everything always
-		if (rtrim($path) === '/' . $user->getUID() . '/files' && $includeChildren) {
+		if (rtrim($path) === '/'.$user->getUID().'/files' && $includeChildren) {
 			$this->setupForUser($user);
 			return;
 		}
@@ -469,7 +469,7 @@ 
 			= $this->isPathSetup($mountPoint);
 		if (!$isMountProviderSetup && !$isPathSetupAsAuthoritative) {
 			if ($mountProvider === '') {
-				$this->logger->debug('mount at ' . $cachedMount->getMountPoint() . ' has no provider set, performing full setup');
+				$this->logger->debug('mount at '.$cachedMount->getMountPoint().' has no provider set, performing full setup');
 				$this->eventLogger->end('fs:setup:user:path:find');
 				$this->setupForUser($user);
 				$this->eventLogger->end('fs:setup:user:path');
@@ -560,7 +560,7 @@ 
 				$this->setupMountProviderPaths[$mountPoint] = self::SETUP_WITH_CHILDREN;
 				foreach ($authoritativeCachedMounts as $providerClass => $cachedMounts) {
 					$providerArgs = array_filter(array_map(
-						static function (ICachedMountInfo $info) use ($rootsMetadata) {
+						static function(ICachedMountInfo $info) use ($rootsMetadata) {
 							$rootMetadata = $rootsMetadata[$info->getRootId()] ?? null;
 
 							return $rootMetadata
@@ -589,7 +589,7 @@ 
 				$this->registerMounts($user, $fullProviderMounts, $currentProviders);
 			}
 
-			$this->setupForUserWith($user, function () use ($fullProviderMounts, $authoritativeMounts) {
+			$this->setupForUserWith($user, function() use ($fullProviderMounts, $authoritativeMounts) {
 				$allMounts = [...$fullProviderMounts, ...$authoritativeMounts];
 				array_walk($allMounts, $this->mountManager->addMount(...));
 			});
@@ -633,12 +633,12 @@ 
 			return;
 		}
 
-		$this->eventLogger->start('fs:setup:user:providers', 'Setup filesystem for ' . implode(', ', $providers));
+		$this->eventLogger->start('fs:setup:user:providers', 'Setup filesystem for '.implode(', ', $providers));
 
 		$this->oneTimeUserSetup($user);
 
 		// home providers are always used
-		$providers = array_filter($providers, function (string $provider) {
+		$providers = array_filter($providers, function(string $provider) {
 			return !is_subclass_of($provider, IHomeMountProvider::class);
 		});
 
@@ -661,7 +661,7 @@ 
 		}
 
 		$this->registerMounts($user, $mounts, $providers);
-		$this->setupForUserWith($user, function () use ($mounts) {
+		$this->setupForUserWith($user, function() use ($mounts) {
 			array_walk($mounts, [$this->mountManager, 'addMount']);
 		});
 		$this->eventLogger->end('fs:setup:user:providers');
@@ -684,7 +684,7 @@ 
 	private function listenForNewMountProviders() {
 		if (!$this->listeningForProviders) {
 			$this->listeningForProviders = true;
-			$this->mountProviderCollection->listen('\OC\Files\Config', 'registerMountProvider', function (
+			$this->mountProviderCollection->listen('\OC\Files\Config', 'registerMountProvider', function(
 				IMountProvider $provider,
 			) {
 				foreach ($this->setupUsers as $userId) {
@@ -702,16 +702,16 @@ 
 		// note that this event handling is intentionally pessimistic
 		// clearing the cache to often is better than not enough
 
-		$this->eventDispatcher->addListener(UserAddedEvent::class, function (UserAddedEvent $event) {
+		$this->eventDispatcher->addListener(UserAddedEvent::class, function(UserAddedEvent $event) {
 			$this->cache->remove($event->getUser()->getUID());
 		});
-		$this->eventDispatcher->addListener(UserRemovedEvent::class, function (UserRemovedEvent $event) {
+		$this->eventDispatcher->addListener(UserRemovedEvent::class, function(UserRemovedEvent $event) {
 			$this->cache->remove($event->getUser()->getUID());
 		});
-		$this->eventDispatcher->addListener(ShareCreatedEvent::class, function (ShareCreatedEvent $event) {
+		$this->eventDispatcher->addListener(ShareCreatedEvent::class, function(ShareCreatedEvent $event) {
 			$this->cache->remove($event->getShare()->getSharedWith());
 		});
-		$this->eventDispatcher->addListener(InvalidateMountCacheEvent::class, function (InvalidateMountCacheEvent $event,
+		$this->eventDispatcher->addListener(InvalidateMountCacheEvent::class, function(InvalidateMountCacheEvent $event,
 		) {
 			if ($user = $event->getUser()) {
 				$this->cache->remove($user->getUID());
@@ -728,7 +728,7 @@ 
 		];
 
 		foreach ($genericEvents as $genericEvent) {
-			$this->eventDispatcher->addListener($genericEvent, function ($event) {
+			$this->eventDispatcher->addListener($genericEvent, function($event) {
 				$this->cache->clear();
 			});
 		}

tests/lib/Files/SetupManagerTest.php

Indentation +453 added lines, -453 removed lines

@@ -37,464 +37,464 @@
 
 class SetupManagerTest extends TestCase {
 
-	/**
-	 * @var (object&\PHPUnit\Framework\MockObject\MockObject)|IUserManager|(IUserManager&object&\PHPUnit\Framework\MockObject\MockObject)|(IUserManager&\PHPUnit\Framework\MockObject\MockObject)|\PHPUnit\Framework\MockObject\MockObject
-	 */
-	private IUserManager&MockObject $userManager;
-	private IUserMountCache&MockObject $userMountCache;
-	private ICache&MockObject $cache;
-	private FileAccess&MockObject $fileAccess;
-	private MountProviderCollection&MockObject $mountProviderCollection;
-	private IMountManager&MockObject $mountManager;
-	private SetupManager $setupManager;
-	private IUser&MockObject $user;
-	private string $userId;
-	private string $path;
-	private string $mountPoint;
-
-	protected function setUp(): void {
-		$eventLogger = $this->createMock(IEventLogger::class);
-		$eventLogger->method('start');
-		$eventLogger->method('end');
-
-		$this->userManager = $this->createMock(IUserManager::class);
-		$this->cache = $this->createMock(ICache::class);
-
-		$this->userId = 'alice';
-		$this->path = "/{$this->userId}/files/folder";
-		$this->mountPoint = "{$this->path}/";
-
-		$this->user = $this->createMock(IUser::class);
-		$this->user->method('getUID')->willReturn($this->userId);
-		$this->userManager->method('get')
-			->with($this->userId)
-			->willReturn($this->user);
-
-		// avoid triggering full setup required check
-		$this->cache->method('get')
-			->with($this->userId)
-			->willReturn(true);
-
-		$this->mountProviderCollection = $this->createMock(MountProviderCollection::class);
-		$this->mountManager = $this->createMock(IMountManager::class);
-		$eventDispatcher = $this->createMock(IEventDispatcher::class);
-		$eventDispatcher->method('addListener');
-		$this->userMountCache = $this->createMock(IUserMountCache::class);
-		$lockdownManager = $this->createMock(ILockdownManager::class);
-		$userSession = $this->createMock(IUserSession::class);
-		$cacheFactory = $this->createMock(ICacheFactory::class);
-		$cacheFactory->expects($this->once())
-			->method('createDistributed')
-			->with('setupmanager::')
-			->willReturn($this->cache);
-		$logger = $this->createMock(LoggerInterface::class);
-		$config = $this->createMock(IConfig::class);
-		$config->method('getSystemValueBool')->willReturn(false);
-		$shareDisableChecker = $this->createMock(ShareDisableChecker::class);
-		$appManager = $this->createMock(IAppManager::class);
-		$this->fileAccess = $this->createMock(FileAccess::class);
-
-		$lockdownManager->method('canAccessFilesystem')->willReturn(true);
-
-		$this->setupManager = new SetupManager(
-			$eventLogger,
-			$this->mountProviderCollection,
-			$this->mountManager,
-			$this->userManager,
-			$eventDispatcher,
-			$this->userMountCache,
-			$lockdownManager,
-			$userSession,
-			$cacheFactory,
-			$logger,
-			$config,
-			$shareDisableChecker,
-			$appManager,
-			$this->fileAccess,
-		);
-	}
-
-	public function testTearDown(): void {
-		$this->setupManager->tearDown();
-	}
-
-	public function testSetupForPathWithPartialProviderSkipsAlreadySetupPath(): void {
-		$cachedMount = $this->getCachedMountInfo($this->mountPoint, 42);
-
-		$this->userMountCache->expects($this->exactly(2))
-			->method('getMountForPath')
-			->with($this->user, $this->path)
-			->willReturn($cachedMount);
-		$this->userMountCache->expects($this->never())->method('registerMounts');
-		$this->userMountCache->expects($this->never())->method('getMountsInPath');
-
-		$this->fileAccess->expects($this->once())
-			->method('getByFileId')
-			->with(42)
-			->willReturn($this->createMock(CacheEntry::class));
-
-		$partialMount = $this->createMock(IMountPoint::class);
-
-		$this->mountProviderCollection->expects($this->once())
-			->method('getUserMountsFromProviderByPath')
-			->with(
-				SetupManagerTestPartialMountProvider::class,
-				$this->path,
-				$this->callback(function (array $args) use ($cachedMount) {
-					$this->assertCount(1, $args);
-					$this->assertInstanceOf(IMountProviderArgs::class, $args[0]);
-					$this->assertSame($cachedMount, $args[0]->mountInfo);
-					return true;
-				})
-			)
-			->willReturn([$partialMount]);
-
-		$homeMount = $this->createMock(IMountPoint::class);
-
-		$this->mountProviderCollection->expects($this->once())
-			->method('getHomeMountForUser')
-			->willReturn($homeMount);
-
-		$this->mountProviderCollection->expects($this->never())
-			->method('getUserMountsForProviderClasses');
-
-		$invokedCount = $this->exactly(2);
-		$addMountExpectations = [
-			1 => $homeMount,
-			2 => $partialMount,
-		];
-		$this->mountManager->expects($invokedCount)
-			->method('addMount')
-			->willReturnCallback($this->getAddMountCheckCallback($invokedCount, $addMountExpectations));
-
-		// setup called twice, provider should only be called once
-		$this->setupManager->setupForPath($this->path, false);
-		$this->setupManager->setupForPath($this->path, false);
-	}
-
-	public function testSetupForPathWithNonPartialProviderSkipsAlreadySetupProvider(): void {
-		$cachedMount = $this->getCachedMountInfo($this->mountPoint, 42,
-			IMountProvider::class);
-
-		$this->userMountCache->expects($this->exactly(2))
-			->method('getMountForPath')
-			->with($this->user, $this->path)
-			->willReturn($cachedMount);
-
-		$this->userMountCache->expects($this->once())->method('registerMounts');
-		$this->userMountCache->expects($this->never())->method('getMountsInPath');
-
-		$providerMount = $this->createMock(IMountPoint::class);
-
-		$this->mountProviderCollection->expects($this->once())
-			->method('getUserMountsForProviderClasses')
-			->with($this->user, [IMountProvider::class])
-			->willReturn([$providerMount]);
-
-		$homeMount = $this->createMock(IMountPoint::class);
-
-		$this->mountProviderCollection->expects($this->once())
-			->method('getHomeMountForUser')
-			->willReturn($homeMount);
-
-		$invokedCount = $this->exactly(2);
-		$addMountExpectations = [
-			1 => $homeMount,
-			2 => $providerMount,
-		];
-		$this->mountManager->expects($invokedCount)
-			->method('addMount')
-			->willReturnCallback($this->getAddMountCheckCallback($invokedCount, $addMountExpectations));
-
-		// setup called twice, provider should only be called once
-		$this->setupManager->setupForPath($this->path, false);
-		$this->setupManager->setupForPath($this->path, false);
-	}
-
-	public function testSetupForPathWithChildrenAndNonPartialProviderSkipsAlreadySetupProvider(): void {
-		$cachedMount = $this->getCachedMountInfo($this->mountPoint, 42, IMountProvider::class);
-		$additionalCachedMount = $this->getCachedMountInfo($this->mountPoint . 'additional/', 43, SetupManagerTestFullMountProvider::class);
-
-		$this->userMountCache->expects($this->exactly(2))
-			->method('getMountForPath')
-			->with($this->user, $this->path)
-			->willReturn($cachedMount);
-
-		$this->userMountCache->expects($this->once())->method('registerMounts');
-		$this->userMountCache->expects($this->once())->method('getMountsInPath')
-			->willReturn([$additionalCachedMount]);
-
-		$mount = $this->createMock(IMountPoint::class);
-		$additionalMount = $this->createMock(IMountPoint::class);
-
-		$invokedCount = $this->exactly(2);
-		$this->mountProviderCollection->expects($invokedCount)
-			->method('getUserMountsForProviderClasses')
-			->willReturnCallback(function (IUser $userArg, array $providersArg) use (
-				$additionalMount,
-				$mount,
-				$invokedCount) {
-				if ($invokedCount->numberOfInvocations() === 1) {
-					$providers = [IMountProvider::class];
-					$returnMounts = [$mount];
-				} else {
-					$providers = [SetupManagerTestFullMountProvider::class];
-					$returnMounts = [$additionalMount];
-				}
-
-				$this->assertSame($this->user, $userArg);
-				$this->assertSame($providersArg, $providers);
-
-				return $returnMounts;
-			});
-
-		$homeMount = $this->createMock(IMountPoint::class);
-
-		$this->mountProviderCollection->expects($this->once())
-			->method('getHomeMountForUser')
-			->willReturn($homeMount);
-
-		$invokedCount = $this->exactly(3);
-		$addMountExpectations = [
-			1 => $homeMount,
-			2 => $mount,
-			3 => $additionalMount,
-		];
-		$this->mountManager->expects($invokedCount)
-			->method('addMount')
-			->willReturnCallback($this->getAddMountCheckCallback($invokedCount, $addMountExpectations));
-
-		// setup called twice, provider should only be called once
-		$this->setupManager->setupForPath($this->path, true);
-		$this->setupManager->setupForPath($this->path, false);
-	}
-
-	public function testSetupForPathWithChildrenAndPartialProviderSkipsIfParentAlreadySetup():	void {
-		$childPath = "{$this->path}/child";
-		$childMountPoint = "{$childPath}/";
-
-		$cachedMount = $this->getCachedMountInfo($this->mountPoint, 42);
-		$cachedChildMount = $this->getCachedMountInfo($childMountPoint, 43);
-
-		$invokedCount = $this->exactly(3);
-		$this->userMountCache->expects($invokedCount)
-			->method('getMountForPath')
-			->willReturnCallback(function (IUser $userArg, string $pathArg) use (
-				$cachedChildMount,
-				$cachedMount,
-				$childPath,
-				$invokedCount) {
-				if ($invokedCount->numberOfInvocations() === 1) {
-					$expectedPath = $this->path;
-					$returnMount = $cachedMount;
-				} else {
-					$expectedPath = $childPath;
-					$returnMount = $cachedChildMount;
-				}
-
-				$this->assertSame($this->user, $userArg);
-				$this->assertSame($expectedPath, $pathArg);
-
-				return $returnMount;
-			});
-
-		$this->userMountCache->expects($this->never())->method('registerMounts');
-		$this->userMountCache->expects($this->exactly(2))
-			->method('getMountsInPath')
-			->willReturn([$cachedChildMount]);
-
-		$this->fileAccess->expects($this->once())
-			->method('getByFileId')
-			->with(42)
-			->willReturn($this->createMock(CacheEntry::class));
-
-		$this->fileAccess->expects($this->once())
-			->method('getByFileIds')
-			->with([43])
-			->willReturn([43 => $this->createMock(CacheEntry::class)]);
-
-		$partialMount = $this->createMock(IMountPoint::class);
-		$partialChildMount = $this->createMock(IMountPoint::class);
-
-		$invokedCount = $this->exactly(2);
-		$this->mountProviderCollection->expects($invokedCount)
-			->method('getUserMountsFromProviderByPath')
-			->willReturnCallback(function (
-				string $providerClass,
-				string $pathArg,
-				array $mountProviderArgs,
-			) use (
-				$cachedChildMount,
-				$partialMount,
-				$partialChildMount,
-				$cachedMount,
-				$invokedCount
-			) {
-				$expectedPath = $this->path;
-				if ($invokedCount->numberOfInvocations() === 1) {
-					// call for the parent
-					$expectedCachedMount = $cachedMount;
-					$mountPoints = [$partialMount];
-				} else {
-					// call for the children
-					$expectedCachedMount = $cachedChildMount;
-					$mountPoints = [$partialChildMount];
-				}
-
-				$this->assertSame(SetupManagerTestPartialMountProvider::class, $providerClass);
-				$this->assertSame($expectedPath, $pathArg);
-				$this->assertCount(1, $mountProviderArgs);
-				$this->assertInstanceOf(IMountProviderArgs::class, $mountProviderArgs[0]);
-				$this->assertSame($expectedCachedMount, $mountProviderArgs[0]->mountInfo);
-
-				return $mountPoints;
-			});
-
-		$homeMount = $this->createMock(IMountPoint::class);
-
-		$this->mountProviderCollection->expects($this->once())
-			->method('getHomeMountForUser')
-			->willReturn($homeMount);
-
-		$this->mountProviderCollection->expects($this->never())
-			->method('getUserMountsForProviderClasses');
-
-		$invokedCount = $this->exactly(3);
-		$addMountExpectations = [
-			1 => $homeMount,
-			2 => $partialMount,
-			3 => $partialChildMount,
-		];
-		$this->mountManager->expects($invokedCount)
-			->method('addMount')
-			->willReturnCallback($this->getAddMountCheckCallback($invokedCount, $addMountExpectations));
-
-		// once the setup for a path has been done with children, setup for sub
-		// paths should not create the same new mounts again
-		$this->setupManager->setupForPath($this->path, true);
-		$this->setupManager->setupForPath($childPath, false);
-		$this->setupManager->setupForPath($childPath, true);
-	}
-
-	public function testSetupForPathHandlesPartialAndFullProvidersWithChildren(): void {
-		$parentPartialCachedMount = $this->getCachedMountInfo($this->mountPoint, 42);
-		$childCachedPartialMount = $this->getCachedMountInfo("{$this->mountPoint}partial/", 43);
-		$childCachedFullMount = $this->getCachedMountInfo("{$this->mountPoint}full/", 44, SetupManagerTestFullMountProvider::class);
-
-		$this->userMountCache->expects($this->exactly(2))
-			->method('getMountForPath')
-			->with($this->user, $this->path)
-			->willReturn($parentPartialCachedMount);
-		$this->userMountCache->expects($this->exactly(2))
-			->method('getMountsInPath')
-			->with($this->user, $this->path)
-			->willReturn([$childCachedPartialMount, $childCachedFullMount]);
-
-		$homeMount = $this->createMock(IMountPoint::class);
-		$parentPartialMount = $this->createMock(IMountPoint::class);
-		$childPartialMount = $this->createMock(IMountPoint::class);
-		$childFullProviderMount = $this->createMock(IMountPoint::class);
-
-		$this->mountProviderCollection->expects($this->once())
-			->method('getHomeMountForUser')
-			->willReturn($homeMount);
-
-		$this->userMountCache->expects($this->once())
-			->method('registerMounts')
-			->with(
-				$this->user, [$childFullProviderMount],
-				[SetupManagerTestFullMountProvider::class],
-			);
-
-		$this->fileAccess->expects($this->once())
-			->method('getByFileId')
-			->with(42)
-			->willReturn($this->createMock(CacheEntry::class));
-		$childMetadata = $this->createMock(CacheEntry::class);
-		$this->fileAccess->expects($this->once())
-			->method('getByFileIds')
-			->with([43])
-			->willReturn([43 => $childMetadata]);
-
-		$invokedCount = $this->exactly(2);
-		$this->mountProviderCollection->expects($invokedCount)
-			->method('getUserMountsFromProviderByPath')
-			->willReturnCallback(function (string $providerClass, string $pathArg, array $mountProviderArgs) use (
-				$childCachedPartialMount,
-				$childPartialMount,
-				$parentPartialMount,
-				$parentPartialCachedMount,
-				$invokedCount) {
-				$expectedPath = $this->path;
-				if ($invokedCount->numberOfInvocations() === 1) {
-					// call for the parent
-					$expectedCachedMount = $parentPartialCachedMount;
-					$mountPoints = [$parentPartialMount];
-				} else {
-					// call for the children
-					$expectedCachedMount = $childCachedPartialMount;
-					$mountPoints = [$childPartialMount];
-				}
-
-				$this->assertSame(SetupManagerTestPartialMountProvider::class, $providerClass);
-				$this->assertSame($expectedPath, $pathArg);
-				$this->assertCount(1, $mountProviderArgs);
-				$this->assertInstanceOf(IMountProviderArgs::class, $mountProviderArgs[0]);
-				$this->assertSame($expectedCachedMount, $mountProviderArgs[0]->mountInfo);
-
-				return $mountPoints;
-			});
-
-		$this->mountProviderCollection->expects($this->once())
-			->method('getUserMountsForProviderClasses')
-			->with($this->user, [SetupManagerTestFullMountProvider::class])
-			->willReturn([$childFullProviderMount]);
-
-		$invokedCount = $this->exactly(4);
-		$addMountExpectations = [
-			1 => $homeMount,
-			2 => $childFullProviderMount,
-			3 => $parentPartialMount,
-			4 => $childPartialMount,
-		];
-		$this->mountManager->expects($invokedCount)
-			->method('addMount')
-			->willReturnCallback($this->getAddMountCheckCallback($invokedCount, $addMountExpectations));
-
-		// call twice to test that providers and mounts are only called once
-		$this->setupManager->setupForPath($this->path, true);
-		$this->setupManager->setupForPath($this->path, true);
-	}
-
-	private function getAddMountCheckCallback(InvokedCount $invokedCount, $expectations): \Closure {
-		return function (IMountPoint $actualMount) use ($invokedCount, $expectations) {
-			$expectedMount = $expectations[$invokedCount->numberOfInvocations()] ?? null;
-			$this->assertSame($expectedMount, $actualMount);
-		};
-	}
-
-	public function getCachedMountInfo(string $mountPoint, int $rootId, string $providerClass = SetupManagerTestPartialMountProvider::class): ICachedMountInfo&MockObject {
-		$cachedMount = $this->createMock(ICachedMountInfo::class);
-		$cachedMount->method('getMountProvider')->willReturn($providerClass);
-		$cachedMount->method('getMountPoint')->willReturn($mountPoint);
-		$cachedMount->method('getRootId')->willReturn($rootId);
-
-		return $cachedMount;
-	}
+    /**
+     * @var (object&\PHPUnit\Framework\MockObject\MockObject)|IUserManager|(IUserManager&object&\PHPUnit\Framework\MockObject\MockObject)|(IUserManager&\PHPUnit\Framework\MockObject\MockObject)|\PHPUnit\Framework\MockObject\MockObject
+     */
+    private IUserManager&MockObject $userManager;
+    private IUserMountCache&MockObject $userMountCache;
+    private ICache&MockObject $cache;
+    private FileAccess&MockObject $fileAccess;
+    private MountProviderCollection&MockObject $mountProviderCollection;
+    private IMountManager&MockObject $mountManager;
+    private SetupManager $setupManager;
+    private IUser&MockObject $user;
+    private string $userId;
+    private string $path;
+    private string $mountPoint;
+
+    protected function setUp(): void {
+        $eventLogger = $this->createMock(IEventLogger::class);
+        $eventLogger->method('start');
+        $eventLogger->method('end');
+
+        $this->userManager = $this->createMock(IUserManager::class);
+        $this->cache = $this->createMock(ICache::class);
+
+        $this->userId = 'alice';
+        $this->path = "/{$this->userId}/files/folder";
+        $this->mountPoint = "{$this->path}/";
+
+        $this->user = $this->createMock(IUser::class);
+        $this->user->method('getUID')->willReturn($this->userId);
+        $this->userManager->method('get')
+            ->with($this->userId)
+            ->willReturn($this->user);
+
+        // avoid triggering full setup required check
+        $this->cache->method('get')
+            ->with($this->userId)
+            ->willReturn(true);
+
+        $this->mountProviderCollection = $this->createMock(MountProviderCollection::class);
+        $this->mountManager = $this->createMock(IMountManager::class);
+        $eventDispatcher = $this->createMock(IEventDispatcher::class);
+        $eventDispatcher->method('addListener');
+        $this->userMountCache = $this->createMock(IUserMountCache::class);
+        $lockdownManager = $this->createMock(ILockdownManager::class);
+        $userSession = $this->createMock(IUserSession::class);
+        $cacheFactory = $this->createMock(ICacheFactory::class);
+        $cacheFactory->expects($this->once())
+            ->method('createDistributed')
+            ->with('setupmanager::')
+            ->willReturn($this->cache);
+        $logger = $this->createMock(LoggerInterface::class);
+        $config = $this->createMock(IConfig::class);
+        $config->method('getSystemValueBool')->willReturn(false);
+        $shareDisableChecker = $this->createMock(ShareDisableChecker::class);
+        $appManager = $this->createMock(IAppManager::class);
+        $this->fileAccess = $this->createMock(FileAccess::class);
+
+        $lockdownManager->method('canAccessFilesystem')->willReturn(true);
+
+        $this->setupManager = new SetupManager(
+            $eventLogger,
+            $this->mountProviderCollection,
+            $this->mountManager,
+            $this->userManager,
+            $eventDispatcher,
+            $this->userMountCache,
+            $lockdownManager,
+            $userSession,
+            $cacheFactory,
+            $logger,
+            $config,
+            $shareDisableChecker,
+            $appManager,
+            $this->fileAccess,
+        );
+    }
+
+    public function testTearDown(): void {
+        $this->setupManager->tearDown();
+    }
+
+    public function testSetupForPathWithPartialProviderSkipsAlreadySetupPath(): void {
+        $cachedMount = $this->getCachedMountInfo($this->mountPoint, 42);
+
+        $this->userMountCache->expects($this->exactly(2))
+            ->method('getMountForPath')
+            ->with($this->user, $this->path)
+            ->willReturn($cachedMount);
+        $this->userMountCache->expects($this->never())->method('registerMounts');
+        $this->userMountCache->expects($this->never())->method('getMountsInPath');
+
+        $this->fileAccess->expects($this->once())
+            ->method('getByFileId')
+            ->with(42)
+            ->willReturn($this->createMock(CacheEntry::class));
+
+        $partialMount = $this->createMock(IMountPoint::class);
+
+        $this->mountProviderCollection->expects($this->once())
+            ->method('getUserMountsFromProviderByPath')
+            ->with(
+                SetupManagerTestPartialMountProvider::class,
+                $this->path,
+                $this->callback(function (array $args) use ($cachedMount) {
+                    $this->assertCount(1, $args);
+                    $this->assertInstanceOf(IMountProviderArgs::class, $args[0]);
+                    $this->assertSame($cachedMount, $args[0]->mountInfo);
+                    return true;
+                })
+            )
+            ->willReturn([$partialMount]);
+
+        $homeMount = $this->createMock(IMountPoint::class);
+
+        $this->mountProviderCollection->expects($this->once())
+            ->method('getHomeMountForUser')
+            ->willReturn($homeMount);
+
+        $this->mountProviderCollection->expects($this->never())
+            ->method('getUserMountsForProviderClasses');
+
+        $invokedCount = $this->exactly(2);
+        $addMountExpectations = [
+            1 => $homeMount,
+            2 => $partialMount,
+        ];
+        $this->mountManager->expects($invokedCount)
+            ->method('addMount')
+            ->willReturnCallback($this->getAddMountCheckCallback($invokedCount, $addMountExpectations));
+
+        // setup called twice, provider should only be called once
+        $this->setupManager->setupForPath($this->path, false);
+        $this->setupManager->setupForPath($this->path, false);
+    }
+
+    public function testSetupForPathWithNonPartialProviderSkipsAlreadySetupProvider(): void {
+        $cachedMount = $this->getCachedMountInfo($this->mountPoint, 42,
+            IMountProvider::class);
+
+        $this->userMountCache->expects($this->exactly(2))
+            ->method('getMountForPath')
+            ->with($this->user, $this->path)
+            ->willReturn($cachedMount);
+
+        $this->userMountCache->expects($this->once())->method('registerMounts');
+        $this->userMountCache->expects($this->never())->method('getMountsInPath');
+
+        $providerMount = $this->createMock(IMountPoint::class);
+
+        $this->mountProviderCollection->expects($this->once())
+            ->method('getUserMountsForProviderClasses')
+            ->with($this->user, [IMountProvider::class])
+            ->willReturn([$providerMount]);
+
+        $homeMount = $this->createMock(IMountPoint::class);
+
+        $this->mountProviderCollection->expects($this->once())
+            ->method('getHomeMountForUser')
+            ->willReturn($homeMount);
+
+        $invokedCount = $this->exactly(2);
+        $addMountExpectations = [
+            1 => $homeMount,
+            2 => $providerMount,
+        ];
+        $this->mountManager->expects($invokedCount)
+            ->method('addMount')
+            ->willReturnCallback($this->getAddMountCheckCallback($invokedCount, $addMountExpectations));
+
+        // setup called twice, provider should only be called once
+        $this->setupManager->setupForPath($this->path, false);
+        $this->setupManager->setupForPath($this->path, false);
+    }
+
+    public function testSetupForPathWithChildrenAndNonPartialProviderSkipsAlreadySetupProvider(): void {
+        $cachedMount = $this->getCachedMountInfo($this->mountPoint, 42, IMountProvider::class);
+        $additionalCachedMount = $this->getCachedMountInfo($this->mountPoint . 'additional/', 43, SetupManagerTestFullMountProvider::class);
+
+        $this->userMountCache->expects($this->exactly(2))
+            ->method('getMountForPath')
+            ->with($this->user, $this->path)
+            ->willReturn($cachedMount);
+
+        $this->userMountCache->expects($this->once())->method('registerMounts');
+        $this->userMountCache->expects($this->once())->method('getMountsInPath')
+            ->willReturn([$additionalCachedMount]);
+
+        $mount = $this->createMock(IMountPoint::class);
+        $additionalMount = $this->createMock(IMountPoint::class);
+
+        $invokedCount = $this->exactly(2);
+        $this->mountProviderCollection->expects($invokedCount)
+            ->method('getUserMountsForProviderClasses')
+            ->willReturnCallback(function (IUser $userArg, array $providersArg) use (
+                $additionalMount,
+                $mount,
+                $invokedCount) {
+                if ($invokedCount->numberOfInvocations() === 1) {
+                    $providers = [IMountProvider::class];
+                    $returnMounts = [$mount];
+                } else {
+                    $providers = [SetupManagerTestFullMountProvider::class];
+                    $returnMounts = [$additionalMount];
+                }
+
+                $this->assertSame($this->user, $userArg);
+                $this->assertSame($providersArg, $providers);
+
+                return $returnMounts;
+            });
+
+        $homeMount = $this->createMock(IMountPoint::class);
+
+        $this->mountProviderCollection->expects($this->once())
+            ->method('getHomeMountForUser')
+            ->willReturn($homeMount);
+
+        $invokedCount = $this->exactly(3);
+        $addMountExpectations = [
+            1 => $homeMount,
+            2 => $mount,
+            3 => $additionalMount,
+        ];
+        $this->mountManager->expects($invokedCount)
+            ->method('addMount')
+            ->willReturnCallback($this->getAddMountCheckCallback($invokedCount, $addMountExpectations));
+
+        // setup called twice, provider should only be called once
+        $this->setupManager->setupForPath($this->path, true);
+        $this->setupManager->setupForPath($this->path, false);
+    }
+
+    public function testSetupForPathWithChildrenAndPartialProviderSkipsIfParentAlreadySetup():	void {
+        $childPath = "{$this->path}/child";
+        $childMountPoint = "{$childPath}/";
+
+        $cachedMount = $this->getCachedMountInfo($this->mountPoint, 42);
+        $cachedChildMount = $this->getCachedMountInfo($childMountPoint, 43);
+
+        $invokedCount = $this->exactly(3);
+        $this->userMountCache->expects($invokedCount)
+            ->method('getMountForPath')
+            ->willReturnCallback(function (IUser $userArg, string $pathArg) use (
+                $cachedChildMount,
+                $cachedMount,
+                $childPath,
+                $invokedCount) {
+                if ($invokedCount->numberOfInvocations() === 1) {
+                    $expectedPath = $this->path;
+                    $returnMount = $cachedMount;
+                } else {
+                    $expectedPath = $childPath;
+                    $returnMount = $cachedChildMount;
+                }
+
+                $this->assertSame($this->user, $userArg);
+                $this->assertSame($expectedPath, $pathArg);
+
+                return $returnMount;
+            });
+
+        $this->userMountCache->expects($this->never())->method('registerMounts');
+        $this->userMountCache->expects($this->exactly(2))
+            ->method('getMountsInPath')
+            ->willReturn([$cachedChildMount]);
+
+        $this->fileAccess->expects($this->once())
+            ->method('getByFileId')
+            ->with(42)
+            ->willReturn($this->createMock(CacheEntry::class));
+
+        $this->fileAccess->expects($this->once())
+            ->method('getByFileIds')
+            ->with([43])
+            ->willReturn([43 => $this->createMock(CacheEntry::class)]);
+
+        $partialMount = $this->createMock(IMountPoint::class);
+        $partialChildMount = $this->createMock(IMountPoint::class);
+
+        $invokedCount = $this->exactly(2);
+        $this->mountProviderCollection->expects($invokedCount)
+            ->method('getUserMountsFromProviderByPath')
+            ->willReturnCallback(function (
+                string $providerClass,
+                string $pathArg,
+                array $mountProviderArgs,
+            ) use (
+                $cachedChildMount,
+                $partialMount,
+                $partialChildMount,
+                $cachedMount,
+                $invokedCount
+            ) {
+                $expectedPath = $this->path;
+                if ($invokedCount->numberOfInvocations() === 1) {
+                    // call for the parent
+                    $expectedCachedMount = $cachedMount;
+                    $mountPoints = [$partialMount];
+                } else {
+                    // call for the children
+                    $expectedCachedMount = $cachedChildMount;
+                    $mountPoints = [$partialChildMount];
+                }
+
+                $this->assertSame(SetupManagerTestPartialMountProvider::class, $providerClass);
+                $this->assertSame($expectedPath, $pathArg);
+                $this->assertCount(1, $mountProviderArgs);
+                $this->assertInstanceOf(IMountProviderArgs::class, $mountProviderArgs[0]);
+                $this->assertSame($expectedCachedMount, $mountProviderArgs[0]->mountInfo);
+
+                return $mountPoints;
+            });
+
+        $homeMount = $this->createMock(IMountPoint::class);
+
+        $this->mountProviderCollection->expects($this->once())
+            ->method('getHomeMountForUser')
+            ->willReturn($homeMount);
+
+        $this->mountProviderCollection->expects($this->never())
+            ->method('getUserMountsForProviderClasses');
+
+        $invokedCount = $this->exactly(3);
+        $addMountExpectations = [
+            1 => $homeMount,
+            2 => $partialMount,
+            3 => $partialChildMount,
+        ];
+        $this->mountManager->expects($invokedCount)
+            ->method('addMount')
+            ->willReturnCallback($this->getAddMountCheckCallback($invokedCount, $addMountExpectations));
+
+        // once the setup for a path has been done with children, setup for sub
+        // paths should not create the same new mounts again
+        $this->setupManager->setupForPath($this->path, true);
+        $this->setupManager->setupForPath($childPath, false);
+        $this->setupManager->setupForPath($childPath, true);
+    }
+
+    public function testSetupForPathHandlesPartialAndFullProvidersWithChildren(): void {
+        $parentPartialCachedMount = $this->getCachedMountInfo($this->mountPoint, 42);
+        $childCachedPartialMount = $this->getCachedMountInfo("{$this->mountPoint}partial/", 43);
+        $childCachedFullMount = $this->getCachedMountInfo("{$this->mountPoint}full/", 44, SetupManagerTestFullMountProvider::class);
+
+        $this->userMountCache->expects($this->exactly(2))
+            ->method('getMountForPath')
+            ->with($this->user, $this->path)
+            ->willReturn($parentPartialCachedMount);
+        $this->userMountCache->expects($this->exactly(2))
+            ->method('getMountsInPath')
+            ->with($this->user, $this->path)
+            ->willReturn([$childCachedPartialMount, $childCachedFullMount]);
+
+        $homeMount = $this->createMock(IMountPoint::class);
+        $parentPartialMount = $this->createMock(IMountPoint::class);
+        $childPartialMount = $this->createMock(IMountPoint::class);
+        $childFullProviderMount = $this->createMock(IMountPoint::class);
+
+        $this->mountProviderCollection->expects($this->once())
+            ->method('getHomeMountForUser')
+            ->willReturn($homeMount);
+
+        $this->userMountCache->expects($this->once())
+            ->method('registerMounts')
+            ->with(
+                $this->user, [$childFullProviderMount],
+                [SetupManagerTestFullMountProvider::class],
+            );
+
+        $this->fileAccess->expects($this->once())
+            ->method('getByFileId')
+            ->with(42)
+            ->willReturn($this->createMock(CacheEntry::class));
+        $childMetadata = $this->createMock(CacheEntry::class);
+        $this->fileAccess->expects($this->once())
+            ->method('getByFileIds')
+            ->with([43])
+            ->willReturn([43 => $childMetadata]);
+
+        $invokedCount = $this->exactly(2);
+        $this->mountProviderCollection->expects($invokedCount)
+            ->method('getUserMountsFromProviderByPath')
+            ->willReturnCallback(function (string $providerClass, string $pathArg, array $mountProviderArgs) use (
+                $childCachedPartialMount,
+                $childPartialMount,
+                $parentPartialMount,
+                $parentPartialCachedMount,
+                $invokedCount) {
+                $expectedPath = $this->path;
+                if ($invokedCount->numberOfInvocations() === 1) {
+                    // call for the parent
+                    $expectedCachedMount = $parentPartialCachedMount;
+                    $mountPoints = [$parentPartialMount];
+                } else {
+                    // call for the children
+                    $expectedCachedMount = $childCachedPartialMount;
+                    $mountPoints = [$childPartialMount];
+                }
+
+                $this->assertSame(SetupManagerTestPartialMountProvider::class, $providerClass);
+                $this->assertSame($expectedPath, $pathArg);
+                $this->assertCount(1, $mountProviderArgs);
+                $this->assertInstanceOf(IMountProviderArgs::class, $mountProviderArgs[0]);
+                $this->assertSame($expectedCachedMount, $mountProviderArgs[0]->mountInfo);
+
+                return $mountPoints;
+            });
+
+        $this->mountProviderCollection->expects($this->once())
+            ->method('getUserMountsForProviderClasses')
+            ->with($this->user, [SetupManagerTestFullMountProvider::class])
+            ->willReturn([$childFullProviderMount]);
+
+        $invokedCount = $this->exactly(4);
+        $addMountExpectations = [
+            1 => $homeMount,
+            2 => $childFullProviderMount,
+            3 => $parentPartialMount,
+            4 => $childPartialMount,
+        ];
+        $this->mountManager->expects($invokedCount)
+            ->method('addMount')
+            ->willReturnCallback($this->getAddMountCheckCallback($invokedCount, $addMountExpectations));
+
+        // call twice to test that providers and mounts are only called once
+        $this->setupManager->setupForPath($this->path, true);
+        $this->setupManager->setupForPath($this->path, true);
+    }
+
+    private function getAddMountCheckCallback(InvokedCount $invokedCount, $expectations): \Closure {
+        return function (IMountPoint $actualMount) use ($invokedCount, $expectations) {
+            $expectedMount = $expectations[$invokedCount->numberOfInvocations()] ?? null;
+            $this->assertSame($expectedMount, $actualMount);
+        };
+    }
+
+    public function getCachedMountInfo(string $mountPoint, int $rootId, string $providerClass = SetupManagerTestPartialMountProvider::class): ICachedMountInfo&MockObject {
+        $cachedMount = $this->createMock(ICachedMountInfo::class);
+        $cachedMount->method('getMountProvider')->willReturn($providerClass);
+        $cachedMount->method('getMountPoint')->willReturn($mountPoint);
+        $cachedMount->method('getRootId')->willReturn($rootId);
+
+        return $cachedMount;
+    }
 }
 
 class SetupManagerTestPartialMountProvider implements IPartialMountProvider {
-	public function getMountsForUser(IUser $user, IStorageFactory $loader): array {
-		return [];
-	}
+    public function getMountsForUser(IUser $user, IStorageFactory $loader): array {
+        return [];
+    }
 
-	public function getMountsForPath(string $path, array $mountProviderArgs, IStorageFactory $loader): array {
-		return [];
-	}
+    public function getMountsForPath(string $path, array $mountProviderArgs, IStorageFactory $loader): array {
+        return [];
+    }
 }
 
 class SetupManagerTestFullMountProvider implements IMountProvider {
-	public function getMountsForUser(IUser $user, IStorageFactory $loader): array {
-		return [];
-	}
+    public function getMountsForUser(IUser $user, IStorageFactory $loader): array {
+        return [];
+    }
 }

Spacing +7 added lines, -7 removed lines

@@ -140,7 +140,7 @@ 
 			->with(
 				SetupManagerTestPartialMountProvider::class,
 				$this->path,
-				$this->callback(function (array $args) use ($cachedMount) {
+				$this->callback(function(array $args) use ($cachedMount) {
 					$this->assertCount(1, $args);
 					$this->assertInstanceOf(IMountProviderArgs::class, $args[0]);
 					$this->assertSame($cachedMount, $args[0]->mountInfo);
@@ -213,7 +213,7 @@ 
 
 	public function testSetupForPathWithChildrenAndNonPartialProviderSkipsAlreadySetupProvider(): void {
 		$cachedMount = $this->getCachedMountInfo($this->mountPoint, 42, IMountProvider::class);
-		$additionalCachedMount = $this->getCachedMountInfo($this->mountPoint . 'additional/', 43, SetupManagerTestFullMountProvider::class);
+		$additionalCachedMount = $this->getCachedMountInfo($this->mountPoint.'additional/', 43, SetupManagerTestFullMountProvider::class);
 
 		$this->userMountCache->expects($this->exactly(2))
 			->method('getMountForPath')
@@ -230,7 +230,7 @@ 
 		$invokedCount = $this->exactly(2);
 		$this->mountProviderCollection->expects($invokedCount)
 			->method('getUserMountsForProviderClasses')
-			->willReturnCallback(function (IUser $userArg, array $providersArg) use (
+			->willReturnCallback(function(IUser $userArg, array $providersArg) use (
 				$additionalMount,
 				$mount,
 				$invokedCount) {
@@ -279,7 +279,7 @@ 
 		$invokedCount = $this->exactly(3);
 		$this->userMountCache->expects($invokedCount)
 			->method('getMountForPath')
-			->willReturnCallback(function (IUser $userArg, string $pathArg) use (
+			->willReturnCallback(function(IUser $userArg, string $pathArg) use (
 				$cachedChildMount,
 				$cachedMount,
 				$childPath,
@@ -319,7 +319,7 @@ 
 		$invokedCount = $this->exactly(2);
 		$this->mountProviderCollection->expects($invokedCount)
 			->method('getUserMountsFromProviderByPath')
-			->willReturnCallback(function (
+			->willReturnCallback(function(
 				string $providerClass,
 				string $pathArg,
 				array $mountProviderArgs,
@@ -419,7 +419,7 @@ 
 		$invokedCount = $this->exactly(2);
 		$this->mountProviderCollection->expects($invokedCount)
 			->method('getUserMountsFromProviderByPath')
-			->willReturnCallback(function (string $providerClass, string $pathArg, array $mountProviderArgs) use (
+			->willReturnCallback(function(string $providerClass, string $pathArg, array $mountProviderArgs) use (
 				$childCachedPartialMount,
 				$childPartialMount,
 				$parentPartialMount,
@@ -467,7 +467,7 @@ 
 	}
 
 	private function getAddMountCheckCallback(InvokedCount $invokedCount, $expectations): \Closure {
-		return function (IMountPoint $actualMount) use ($invokedCount, $expectations) {
+		return function(IMountPoint $actualMount) use ($invokedCount, $expectations) {
 			$expectedMount = $expectations[$invokedCount->numberOfInvocations()] ?? null;
 			$this->assertSame($expectedMount, $actualMount);
 		};