nextcloud / server

tests/lib/Cache/FileCacheTest.php

Indentation +129 added lines, -129 removed lines

@@ -29,133 +29,133 @@
  */
 #[\PHPUnit\Framework\Attributes\Group('DB')]
 class FileCacheTest extends TestCache {
-	use UserTrait;
-
-	/**
-	 * @var string
-	 * */
-	private $user;
-	/**
-	 * @var string
-	 * */
-	private $datadir;
-	/**
-	 * @var Storage
-	 * */
-	private $storage;
-	/**
-	 * @var View
-	 * */
-	private $rootView;
-
-	public function skip() {
-		//$this->skipUnless(OC_User::isLoggedIn());
-	}
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		//login
-		$this->createUser('test', 'test');
-
-		$this->user = \OC_User::getUser();
-		\OC_User::setUserId('test');
-
-		//clear all proxies and hooks so we can do clean testing
-		\OC_Hook::clear('OC_Filesystem');
-
-		/** @var IMountManager $manager */
-		$manager = Server::get(IMountManager::class);
-		$manager->removeMount('/test');
-
-		$storage = new Temporary([]);
-		Filesystem::mount($storage, [], '/test/cache');
-
-		//set up the users dir
-		$this->rootView = new View('');
-		$this->rootView->mkdir('/test');
-
-		$this->instance = new File();
-
-		// forces creation of cache folder for subsequent tests
-		$this->instance->set('hack', 'hack');
-	}
-
-	protected function tearDown(): void {
-		if ($this->instance) {
-			$this->instance->remove('hack', 'hack');
-		}
-
-		\OC_User::setUserId($this->user);
-
-		if ($this->instance) {
-			$this->instance->clear();
-			$this->instance = null;
-		}
-
-		parent::tearDown();
-	}
-
-	private function setupMockStorage() {
-		$mockStorage = $this->getMockBuilder(Local::class)
-			->onlyMethods(['filemtime', 'unlink'])
-			->setConstructorArgs([['datadir' => Server::get(ITempManager::class)->getTemporaryFolder()]])
-			->getMock();
-
-		Filesystem::mount($mockStorage, [], '/test/cache');
-
-		return $mockStorage;
-	}
-
-	public function testGarbageCollectOldKeys(): void {
-		$mockStorage = $this->setupMockStorage();
-
-		$mockStorage->expects($this->atLeastOnce())
-			->method('filemtime')
-			->willReturn(100);
-		$mockStorage->expects($this->once())
-			->method('unlink')
-			->with('key1')
-			->willReturn(true);
-
-		$this->instance->set('key1', 'value1');
-		$this->instance->gc();
-	}
-
-	public function testGarbageCollectLeaveRecentKeys(): void {
-		$mockStorage = $this->setupMockStorage();
-
-		$mockStorage->expects($this->atLeastOnce())
-			->method('filemtime')
-			->willReturn(time() + 3600);
-		$mockStorage->expects($this->never())
-			->method('unlink')
-			->with('key1');
-		$this->instance->set('key1', 'value1');
-		$this->instance->gc();
-	}
-
-	public static function lockExceptionProvider(): array {
-		return [
-			[new LockedException('key1')],
-			[new LockNotAcquiredException('key1', 1)],
-		];
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('lockExceptionProvider')]
-	public function testGarbageCollectIgnoreLockedKeys($testException): void {
-		$mockStorage = $this->setupMockStorage();
-
-		$mockStorage->expects($this->atLeastOnce())
-			->method('filemtime')
-			->willReturn(100);
-		$mockStorage->expects($this->atLeastOnce())
-			->method('unlink')
-			->willReturnOnConsecutiveCalls($this->throwException($testException), true);
-
-		$this->instance->set('key1', 'value1');
-		$this->instance->set('key2', 'value2');
-
-		$this->instance->gc();
-	}
+    use UserTrait;
+
+    /**
+     * @var string
+     * */
+    private $user;
+    /**
+     * @var string
+     * */
+    private $datadir;
+    /**
+     * @var Storage
+     * */
+    private $storage;
+    /**
+     * @var View
+     * */
+    private $rootView;
+
+    public function skip() {
+        //$this->skipUnless(OC_User::isLoggedIn());
+    }
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        //login
+        $this->createUser('test', 'test');
+
+        $this->user = \OC_User::getUser();
+        \OC_User::setUserId('test');
+
+        //clear all proxies and hooks so we can do clean testing
+        \OC_Hook::clear('OC_Filesystem');
+
+        /** @var IMountManager $manager */
+        $manager = Server::get(IMountManager::class);
+        $manager->removeMount('/test');
+
+        $storage = new Temporary([]);
+        Filesystem::mount($storage, [], '/test/cache');
+
+        //set up the users dir
+        $this->rootView = new View('');
+        $this->rootView->mkdir('/test');
+
+        $this->instance = new File();
+
+        // forces creation of cache folder for subsequent tests
+        $this->instance->set('hack', 'hack');
+    }
+
+    protected function tearDown(): void {
+        if ($this->instance) {
+            $this->instance->remove('hack', 'hack');
+        }
+
+        \OC_User::setUserId($this->user);
+
+        if ($this->instance) {
+            $this->instance->clear();
+            $this->instance = null;
+        }
+
+        parent::tearDown();
+    }
+
+    private function setupMockStorage() {
+        $mockStorage = $this->getMockBuilder(Local::class)
+            ->onlyMethods(['filemtime', 'unlink'])
+            ->setConstructorArgs([['datadir' => Server::get(ITempManager::class)->getTemporaryFolder()]])
+            ->getMock();
+
+        Filesystem::mount($mockStorage, [], '/test/cache');
+
+        return $mockStorage;
+    }
+
+    public function testGarbageCollectOldKeys(): void {
+        $mockStorage = $this->setupMockStorage();
+
+        $mockStorage->expects($this->atLeastOnce())
+            ->method('filemtime')
+            ->willReturn(100);
+        $mockStorage->expects($this->once())
+            ->method('unlink')
+            ->with('key1')
+            ->willReturn(true);
+
+        $this->instance->set('key1', 'value1');
+        $this->instance->gc();
+    }
+
+    public function testGarbageCollectLeaveRecentKeys(): void {
+        $mockStorage = $this->setupMockStorage();
+
+        $mockStorage->expects($this->atLeastOnce())
+            ->method('filemtime')
+            ->willReturn(time() + 3600);
+        $mockStorage->expects($this->never())
+            ->method('unlink')
+            ->with('key1');
+        $this->instance->set('key1', 'value1');
+        $this->instance->gc();
+    }
+
+    public static function lockExceptionProvider(): array {
+        return [
+            [new LockedException('key1')],
+            [new LockNotAcquiredException('key1', 1)],
+        ];
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('lockExceptionProvider')]
+    public function testGarbageCollectIgnoreLockedKeys($testException): void {
+        $mockStorage = $this->setupMockStorage();
+
+        $mockStorage->expects($this->atLeastOnce())
+            ->method('filemtime')
+            ->willReturn(100);
+        $mockStorage->expects($this->atLeastOnce())
+            ->method('unlink')
+            ->willReturnOnConsecutiveCalls($this->throwException($testException), true);
+
+        $this->instance->set('key1', 'value1');
+        $this->instance->set('key2', 'value2');
+
+        $this->instance->gc();
+    }
 }

tests/lib/User/ManagerTest.php

Indentation +766 added lines, -766 removed lines

@@ -32,770 +32,770 @@
  */
 #[\PHPUnit\Framework\Attributes\Group('DB')]
 class ManagerTest extends TestCase {
-	private IConfig&MockObject $config;
-	private IEventDispatcher&MockObject $eventDispatcher;
-	private ICacheFactory&MockObject $cacheFactory;
-	private ICache&MockObject $cache;
-	private LoggerInterface&MockObject $logger;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->config = $this->createMock(IConfig::class);
-		$this->eventDispatcher = $this->createMock(IEventDispatcher::class);
-		$this->cacheFactory = $this->createMock(ICacheFactory::class);
-		$this->cache = $this->createMock(ICache::class);
-		$this->logger = $this->createMock(LoggerInterface::class);
-
-		$this->cacheFactory->method('createDistributed')
-			->willReturn($this->cache);
-	}
-
-	public function testGetBackends(): void {
-		$userDummyBackend = $this->createMock(\Test\Util\User\Dummy::class);
-		$manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
-		$manager->registerBackend($userDummyBackend);
-		$this->assertEquals([$userDummyBackend], $manager->getBackends());
-		$dummyDatabaseBackend = $this->createMock(Database::class);
-		$manager->registerBackend($dummyDatabaseBackend);
-		$this->assertEquals([$userDummyBackend, $dummyDatabaseBackend], $manager->getBackends());
-	}
-
-
-	public function testUserExistsSingleBackendExists(): void {
-		/**
-		 * @var \Test\Util\User\Dummy&MockObject $backend
-		 */
-		$backend = $this->createMock(\Test\Util\User\Dummy::class);
-		$backend->expects($this->once())
-			->method('userExists')
-			->with($this->equalTo('foo'))
-			->willReturn(true);
-
-		$manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
-		$manager->registerBackend($backend);
-
-		$this->assertTrue($manager->userExists('foo'));
-	}
-
-	public function testUserExistsTooLong(): void {
-		/** @var \Test\Util\User\Dummy|MockObject $backend */
-		$backend = $this->createMock(\Test\Util\User\Dummy::class);
-		$backend->expects($this->never())
-			->method('userExists')
-			->with($this->equalTo('foo'))
-			->willReturn(true);
-
-		$manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
-		$manager->registerBackend($backend);
-
-		$this->assertFalse($manager->userExists('foo' . str_repeat('a', 62)));
-	}
-
-	public function testUserExistsSingleBackendNotExists(): void {
-		/**
-		 * @var \Test\Util\User\Dummy&MockObject $backend
-		 */
-		$backend = $this->createMock(\Test\Util\User\Dummy::class);
-		$backend->expects($this->once())
-			->method('userExists')
-			->with($this->equalTo('foo'))
-			->willReturn(false);
-
-		$manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
-		$manager->registerBackend($backend);
-
-		$this->assertFalse($manager->userExists('foo'));
-	}
-
-	public function testUserExistsNoBackends(): void {
-		$manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
-
-		$this->assertFalse($manager->userExists('foo'));
-	}
-
-	public function testUserExistsTwoBackendsSecondExists(): void {
-		/**
-		 * @var \Test\Util\User\Dummy&MockObject $backend1
-		 */
-		$backend1 = $this->createMock(\Test\Util\User\Dummy::class);
-		$backend1->expects($this->once())
-			->method('userExists')
-			->with($this->equalTo('foo'))
-			->willReturn(false);
-
-		/**
-		 * @var \Test\Util\User\Dummy&MockObject $backend2
-		 */
-		$backend2 = $this->createMock(\Test\Util\User\Dummy::class);
-		$backend2->expects($this->once())
-			->method('userExists')
-			->with($this->equalTo('foo'))
-			->willReturn(true);
-
-		$manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
-		$manager->registerBackend($backend1);
-		$manager->registerBackend($backend2);
-
-		$this->assertTrue($manager->userExists('foo'));
-	}
-
-	public function testUserExistsTwoBackendsFirstExists(): void {
-		/**
-		 * @var \Test\Util\User\Dummy&MockObject $backend1
-		 */
-		$backend1 = $this->createMock(\Test\Util\User\Dummy::class);
-		$backend1->expects($this->once())
-			->method('userExists')
-			->with($this->equalTo('foo'))
-			->willReturn(true);
-
-		/**
-		 * @var \Test\Util\User\Dummy&MockObject $backend2
-		 */
-		$backend2 = $this->createMock(\Test\Util\User\Dummy::class);
-		$backend2->expects($this->never())
-			->method('userExists');
-
-		$manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
-		$manager->registerBackend($backend1);
-		$manager->registerBackend($backend2);
-
-		$this->assertTrue($manager->userExists('foo'));
-	}
-
-	public function testCheckPassword(): void {
-		/**
-		 * @var \OC\User\Backend&MockObject $backend
-		 */
-		$backend = $this->createMock(\Test\Util\User\Dummy::class);
-		$backend->expects($this->once())
-			->method('checkPassword')
-			->with($this->equalTo('foo'), $this->equalTo('bar'))
-			->willReturn(true);
-
-		$backend->expects($this->any())
-			->method('implementsActions')
-			->willReturnCallback(function ($actions) {
-				if ($actions === BACKEND::CHECK_PASSWORD) {
-					return true;
-				} else {
-					return false;
-				}
-			});
-
-		$manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
-		$manager->registerBackend($backend);
-
-		$user = $manager->checkPassword('foo', 'bar');
-		$this->assertTrue($user instanceof User);
-	}
-
-	public function testCheckPasswordNotSupported(): void {
-		/**
-		 * @var \OC\User\Backend&MockObject $backend
-		 */
-		$backend = $this->createMock(\Test\Util\User\Dummy::class);
-		$backend->expects($this->never())
-			->method('checkPassword');
-
-		$backend->expects($this->any())
-			->method('implementsActions')
-			->willReturn(false);
-
-		$manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
-		$manager->registerBackend($backend);
-
-		$this->assertFalse($manager->checkPassword('foo', 'bar'));
-	}
-
-	public function testGetOneBackendExists(): void {
-		/**
-		 * @var \Test\Util\User\Dummy&MockObject $backend
-		 */
-		$backend = $this->createMock(\Test\Util\User\Dummy::class);
-		$backend->expects($this->once())
-			->method('userExists')
-			->with($this->equalTo('foo'))
-			->willReturn(true);
-		$backend->expects($this->never())
-			->method('loginName2UserName');
-
-		$manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
-		$manager->registerBackend($backend);
-
-		$this->assertEquals('foo', $manager->get('foo')->getUID());
-	}
-
-	public function testGetOneBackendNotExists(): void {
-		/**
-		 * @var \Test\Util\User\Dummy&MockObject $backend
-		 */
-		$backend = $this->createMock(\Test\Util\User\Dummy::class);
-		$backend->expects($this->once())
-			->method('userExists')
-			->with($this->equalTo('foo'))
-			->willReturn(false);
-
-		$manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
-		$manager->registerBackend($backend);
-
-		$this->assertEquals(null, $manager->get('foo'));
-	}
-
-	public function testGetTooLong(): void {
-		/** @var \Test\Util\User\Dummy|MockObject $backend */
-		$backend = $this->createMock(\Test\Util\User\Dummy::class);
-		$backend->expects($this->never())
-			->method('userExists')
-			->with($this->equalTo('foo'))
-			->willReturn(false);
-
-		$manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
-		$manager->registerBackend($backend);
-
-		$this->assertEquals(null, $manager->get('foo' . str_repeat('a', 62)));
-	}
-
-	public function testGetOneBackendDoNotTranslateLoginNames(): void {
-		/**
-		 * @var \Test\Util\User\Dummy&MockObject $backend
-		 */
-		$backend = $this->createMock(\Test\Util\User\Dummy::class);
-		$backend->expects($this->once())
-			->method('userExists')
-			->with($this->equalTo('bLeNdEr'))
-			->willReturn(true);
-		$backend->expects($this->never())
-			->method('loginName2UserName');
-
-		$manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
-		$manager->registerBackend($backend);
-
-		$this->assertEquals('bLeNdEr', $manager->get('bLeNdEr')->getUID());
-	}
-
-	public function testSearchOneBackend(): void {
-		/**
-		 * @var \Test\Util\User\Dummy&MockObject $backend
-		 */
-		$backend = $this->createMock(\Test\Util\User\Dummy::class);
-		$backend->expects($this->once())
-			->method('getUsers')
-			->with($this->equalTo('fo'))
-			->willReturn(['foo', 'afoo', 'Afoo1', 'Bfoo']);
-		$backend->expects($this->never())
-			->method('loginName2UserName');
-
-		$manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
-		$manager->registerBackend($backend);
-
-		$result = $manager->search('fo');
-		$this->assertEquals(4, count($result));
-		$this->assertEquals('afoo', array_shift($result)->getUID());
-		$this->assertEquals('Afoo1', array_shift($result)->getUID());
-		$this->assertEquals('Bfoo', array_shift($result)->getUID());
-		$this->assertEquals('foo', array_shift($result)->getUID());
-	}
-
-	public function testSearchTwoBackendLimitOffset(): void {
-		/**
-		 * @var \Test\Util\User\Dummy&MockObject $backend1
-		 */
-		$backend1 = $this->createMock(\Test\Util\User\Dummy::class);
-		$backend1->expects($this->once())
-			->method('getUsers')
-			->with($this->equalTo('fo'), $this->equalTo(3), $this->equalTo(1))
-			->willReturn(['foo1', 'foo2']);
-		$backend1->expects($this->never())
-			->method('loginName2UserName');
-
-		/**
-		 * @var \Test\Util\User\Dummy&MockObject $backend2
-		 */
-		$backend2 = $this->createMock(\Test\Util\User\Dummy::class);
-		$backend2->expects($this->once())
-			->method('getUsers')
-			->with($this->equalTo('fo'), $this->equalTo(3), $this->equalTo(1))
-			->willReturn(['foo3']);
-		$backend2->expects($this->never())
-			->method('loginName2UserName');
-
-		$manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
-		$manager->registerBackend($backend1);
-		$manager->registerBackend($backend2);
-
-		$result = $manager->search('fo', 3, 1);
-		$this->assertEquals(3, count($result));
-		$this->assertEquals('foo1', array_shift($result)->getUID());
-		$this->assertEquals('foo2', array_shift($result)->getUID());
-		$this->assertEquals('foo3', array_shift($result)->getUID());
-	}
-
-	public static function dataCreateUserInvalid(): array {
-		return [
-			['te?st', 'foo', 'Only the following characters are allowed in a username:'
-				. ' "a-z", "A-Z", "0-9", spaces and "_.@-\'"'],
-			["te\tst", '', 'Only the following characters are allowed in a username:'
-				. ' "a-z", "A-Z", "0-9", spaces and "_.@-\'"'],
-			["te\nst", '', 'Only the following characters are allowed in a username:'
-				. ' "a-z", "A-Z", "0-9", spaces and "_.@-\'"'],
-			["te\rst", '', 'Only the following characters are allowed in a username:'
-				. ' "a-z", "A-Z", "0-9", spaces and "_.@-\'"'],
-			["te\0st", '', 'Only the following characters are allowed in a username:'
-				. ' "a-z", "A-Z", "0-9", spaces and "_.@-\'"'],
-			["te\x0Bst", '', 'Only the following characters are allowed in a username:'
-				. ' "a-z", "A-Z", "0-9", spaces and "_.@-\'"'],
-			["te\xe2st", '', 'Only the following characters are allowed in a username:'
-				. ' "a-z", "A-Z", "0-9", spaces and "_.@-\'"'],
-			["te\x80st", '', 'Only the following characters are allowed in a username:'
-				. ' "a-z", "A-Z", "0-9", spaces and "_.@-\'"'],
-			["te\x8bst", '', 'Only the following characters are allowed in a username:'
-				. ' "a-z", "A-Z", "0-9", spaces and "_.@-\'"'],
-			['', 'foo', 'A valid username must be provided'],
-			[' ', 'foo', 'A valid username must be provided'],
-			[' test', 'foo', 'Username contains whitespace at the beginning or at the end'],
-			['test ', 'foo', 'Username contains whitespace at the beginning or at the end'],
-			['.', 'foo', 'Username must not consist of dots only'],
-			['..', 'foo', 'Username must not consist of dots only'],
-			['.test', '', 'A valid password must be provided'],
-			['test', '', 'A valid password must be provided'],
-			['test' . str_repeat('a', 61), '', 'Login is too long'],
-		];
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataCreateUserInvalid')]
-	public function testCreateUserInvalid($uid, $password, $exception): void {
-		/** @var \Test\Util\User\Dummy&MockObject $backend */
-		$backend = $this->createMock(\Test\Util\User\Dummy::class);
-		$backend->expects($this->once())
-			->method('implementsActions')
-			->with(\OC\User\Backend::CREATE_USER)
-			->willReturn(true);
-
-
-		$manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
-		$manager->registerBackend($backend);
-
-		$this->expectException(\InvalidArgumentException::class, $exception);
-		$manager->createUser($uid, $password);
-	}
-
-	public function testCreateUserSingleBackendNotExists(): void {
-		/**
-		 * @var \Test\Util\User\Dummy&MockObject $backend
-		 */
-		$backend = $this->createMock(\Test\Util\User\Dummy::class);
-		$backend->expects($this->any())
-			->method('implementsActions')
-			->willReturn(true);
-
-		$backend->expects($this->once())
-			->method('createUser')
-			->with($this->equalTo('foo'), $this->equalTo('bar'));
-
-		$backend->expects($this->once())
-			->method('userExists')
-			->with($this->equalTo('foo'))
-			->willReturn(false);
-		$backend->expects($this->never())
-			->method('loginName2UserName');
-
-		$manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
-		$manager->registerBackend($backend);
-
-		$user = $manager->createUser('foo', 'bar');
-		$this->assertEquals('foo', $user->getUID());
-	}
-
-
-	public function testCreateUserSingleBackendExists(): void {
-		$this->expectException(\Exception::class);
-
-		/**
-		 * @var \Test\Util\User\Dummy&MockObject $backend
-		 */
-		$backend = $this->createMock(\Test\Util\User\Dummy::class);
-		$backend->expects($this->any())
-			->method('implementsActions')
-			->willReturn(true);
-
-		$backend->expects($this->never())
-			->method('createUser');
-
-		$backend->expects($this->once())
-			->method('userExists')
-			->with($this->equalTo('foo'))
-			->willReturn(true);
-
-		$manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
-		$manager->registerBackend($backend);
-
-		$manager->createUser('foo', 'bar');
-	}
-
-	public function testCreateUserSingleBackendNotSupported(): void {
-		/**
-		 * @var \Test\Util\User\Dummy&MockObject $backend
-		 */
-		$backend = $this->createMock(\Test\Util\User\Dummy::class);
-		$backend->expects($this->any())
-			->method('implementsActions')
-			->willReturn(false);
-
-		$backend->expects($this->never())
-			->method('createUser');
-
-		$backend->expects($this->never())
-			->method('userExists');
-
-		$manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
-		$manager->registerBackend($backend);
-
-		$this->assertFalse($manager->createUser('foo', 'bar'));
-	}
-
-	public function testCreateUserNoBackends(): void {
-		$manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
-
-		$this->assertFalse($manager->createUser('foo', 'bar'));
-	}
-
-
-	public function testCreateUserFromBackendWithBackendError(): void {
-		$this->expectException(\InvalidArgumentException::class);
-		$this->expectExceptionMessage('Could not create account');
-
-		/** @var \Test\Util\User\Dummy&MockObject $backend */
-		$backend = $this->createMock(\Test\Util\User\Dummy::class);
-		$backend
-			->expects($this->once())
-			->method('createUser')
-			->with('MyUid', 'MyPassword')
-			->willReturn(false);
-
-		$manager = new Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
-		$manager->createUserFromBackend('MyUid', 'MyPassword', $backend);
-	}
-
-
-	public function testCreateUserTwoBackendExists(): void {
-		$this->expectException(\Exception::class);
-
-		/**
-		 * @var \Test\Util\User\Dummy&MockObject $backend1
-		 */
-		$backend1 = $this->createMock(\Test\Util\User\Dummy::class);
-		$backend1->expects($this->any())
-			->method('implementsActions')
-			->willReturn(true);
-
-		$backend1->expects($this->never())
-			->method('createUser');
-
-		$backend1->expects($this->once())
-			->method('userExists')
-			->with($this->equalTo('foo'))
-			->willReturn(false);
-
-		/**
-		 * @var \Test\Util\User\Dummy&MockObject $backend2
-		 */
-		$backend2 = $this->createMock(\Test\Util\User\Dummy::class);
-		$backend2->expects($this->any())
-			->method('implementsActions')
-			->willReturn(true);
-
-		$backend2->expects($this->never())
-			->method('createUser');
-
-		$backend2->expects($this->once())
-			->method('userExists')
-			->with($this->equalTo('foo'))
-			->willReturn(true);
-
-		$manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
-		$manager->registerBackend($backend1);
-		$manager->registerBackend($backend2);
-
-		$manager->createUser('foo', 'bar');
-	}
-
-	public function testCountUsersNoBackend(): void {
-		$manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
-
-		$result = $manager->countUsers();
-		$this->assertTrue(is_array($result));
-		$this->assertTrue(empty($result));
-	}
-
-	public function testCountUsersOneBackend(): void {
-		/**
-		 * @var \Test\Util\User\Dummy&MockObject $backend
-		 */
-		$backend = $this->createMock(\Test\Util\User\Dummy::class);
-		$backend->expects($this->once())
-			->method('countUsers')
-			->willReturn(7);
-
-		$backend->expects($this->once())
-			->method('implementsActions')
-			->with(BACKEND::COUNT_USERS)
-			->willReturn(true);
-
-		$backend->expects($this->once())
-			->method('getBackendName')
-			->willReturn('Mock_Test_Util_User_Dummy');
-
-		$manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
-		$manager->registerBackend($backend);
-
-		$result = $manager->countUsers();
-		$keys = array_keys($result);
-		$this->assertTrue(strpos($keys[0], 'Mock_Test_Util_User_Dummy') !== false);
-
-		$users = array_shift($result);
-		$this->assertEquals(7, $users);
-	}
-
-	public function testCountUsersTwoBackends(): void {
-		/**
-		 * @var \Test\Util\User\Dummy&MockObject $backend
-		 */
-		$backend1 = $this->createMock(\Test\Util\User\Dummy::class);
-		$backend1->expects($this->once())
-			->method('countUsers')
-			->willReturn(7);
-
-		$backend1->expects($this->once())
-			->method('implementsActions')
-			->with(BACKEND::COUNT_USERS)
-			->willReturn(true);
-		$backend1->expects($this->once())
-			->method('getBackendName')
-			->willReturn('Mock_Test_Util_User_Dummy');
-
-		$backend2 = $this->createMock(\Test\Util\User\Dummy::class);
-		$backend2->expects($this->once())
-			->method('countUsers')
-			->willReturn(16);
-
-		$backend2->expects($this->once())
-			->method('implementsActions')
-			->with(BACKEND::COUNT_USERS)
-			->willReturn(true);
-		$backend2->expects($this->once())
-			->method('getBackendName')
-			->willReturn('Mock_Test_Util_User_Dummy');
-
-		$manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
-		$manager->registerBackend($backend1);
-		$manager->registerBackend($backend2);
-
-		$result = $manager->countUsers();
-		//because the backends have the same class name, only one value expected
-		$this->assertEquals(1, count($result));
-		$keys = array_keys($result);
-		$this->assertTrue(strpos($keys[0], 'Mock_Test_Util_User_Dummy') !== false);
-
-		$users = array_shift($result);
-		//users from backends shall be summed up
-		$this->assertEquals(7 + 16, $users);
-	}
-
-	public function testCountUsersOnlyDisabled(): void {
-		$manager = Server::get(IUserManager::class);
-		// count other users in the db before adding our own
-		$countBefore = $manager->countDisabledUsers();
-
-		//Add test users
-		$user1 = $manager->createUser('testdisabledcount1', 'testdisabledcount1');
-
-		$user2 = $manager->createUser('testdisabledcount2', 'testdisabledcount2');
-		$user2->setEnabled(false);
-
-		$user3 = $manager->createUser('testdisabledcount3', 'testdisabledcount3');
-
-		$user4 = $manager->createUser('testdisabledcount4', 'testdisabledcount4');
-		$user4->setEnabled(false);
-
-		$this->assertEquals($countBefore + 2, $manager->countDisabledUsers());
-
-		//cleanup
-		$user1->delete();
-		$user2->delete();
-		$user3->delete();
-		$user4->delete();
-	}
-
-	public function testCountUsersOnlySeen(): void {
-		$manager = Server::get(IUserManager::class);
-		// count other users in the db before adding our own
-		$countBefore = $manager->countSeenUsers();
-
-		//Add test users
-		$user1 = $manager->createUser('testseencount1', 'testseencount1');
-		$user1->updateLastLoginTimestamp();
-
-		$user2 = $manager->createUser('testseencount2', 'testseencount2');
-		$user2->updateLastLoginTimestamp();
-
-		$user3 = $manager->createUser('testseencount3', 'testseencount3');
-
-		$user4 = $manager->createUser('testseencount4', 'testseencount4');
-		$user4->updateLastLoginTimestamp();
-
-		$this->assertEquals($countBefore + 3, $manager->countSeenUsers());
-
-		//cleanup
-		$user1->delete();
-		$user2->delete();
-		$user3->delete();
-		$user4->delete();
-	}
-
-	public function testCallForSeenUsers(): void {
-		$manager = Server::get(IUserManager::class);
-		// count other users in the db before adding our own
-		$count = 0;
-		$function = function (IUser $user) use (&$count): void {
-			$count++;
-		};
-		$manager->callForAllUsers($function, '', true);
-		$countBefore = $count;
-
-		//Add test users
-		$user1 = $manager->createUser('testseen1', 'testseen10');
-		$user1->updateLastLoginTimestamp();
-
-		$user2 = $manager->createUser('testseen2', 'testseen20');
-		$user2->updateLastLoginTimestamp();
-
-		$user3 = $manager->createUser('testseen3', 'testseen30');
-
-		$user4 = $manager->createUser('testseen4', 'testseen40');
-		$user4->updateLastLoginTimestamp();
-
-		$count = 0;
-		$manager->callForAllUsers($function, '', true);
-
-		$this->assertEquals($countBefore + 3, $count);
-
-		//cleanup
-		$user1->delete();
-		$user2->delete();
-		$user3->delete();
-		$user4->delete();
-	}
-
-	#[\PHPUnit\Framework\Attributes\RunInSeparateProcess]
-	#[\PHPUnit\Framework\Attributes\PreserveGlobalState(enabled: false)]
-	public function testRecentlyActive(): void {
-		$config = Server::get(IConfig::class);
-		$manager = Server::get(IUserManager::class);
-
-		// Create some users
-		$now = (string)time();
-		$user1 = $manager->createUser('test_active_1', 'test_active_1');
-		$config->setUserValue('test_active_1', 'login', 'lastLogin', $now);
-		$user1->setDisplayName('test active 1');
-		$user1->setSystemEMailAddress('roger@active.com');
-
-		$user2 = $manager->createUser('TEST_ACTIVE_2_FRED', 'TEST_ACTIVE_2');
-		$config->setUserValue('TEST_ACTIVE_2_FRED', 'login', 'lastLogin', $now);
-		$user2->setDisplayName('TEST ACTIVE 2 UPPER');
-		$user2->setSystemEMailAddress('Fred@Active.Com');
-
-		$user3 = $manager->createUser('test_active_3', 'test_active_3');
-		$config->setUserValue('test_active_3', 'login', 'lastLogin', $now + 1);
-		$user3->setDisplayName('test active 3');
-
-		$user4 = $manager->createUser('test_active_4', 'test_active_4');
-		$config->setUserValue('test_active_4', 'login', 'lastLogin', $now);
-		$user4->setDisplayName('Test Active 4');
-
-		$user5 = $manager->createUser('test_inactive_1', 'test_inactive_1');
-		$user5->setDisplayName('Test Inactive 1');
-		$user2->setSystemEMailAddress('jeanne@Active.Com');
-
-		// Search recently active
-		//  - No search, case-insensitive order
-		$users = $manager->getLastLoggedInUsers(4);
-		$this->assertEquals(['test_active_3', 'test_active_1', 'TEST_ACTIVE_2_FRED', 'test_active_4'], $users);
-		//  - Search, case-insensitive order
-		$users = $manager->getLastLoggedInUsers(search: 'act');
-		$this->assertEquals(['test_active_3', 'test_active_1', 'TEST_ACTIVE_2_FRED', 'test_active_4'], $users);
-		//  - No search with offset
-		$users = $manager->getLastLoggedInUsers(2, 2);
-		$this->assertEquals(['TEST_ACTIVE_2_FRED', 'test_active_4'], $users);
-		//  - Case insensitive search (email)
-		$users = $manager->getLastLoggedInUsers(search: 'active.com');
-		$this->assertEquals(['test_active_1', 'TEST_ACTIVE_2_FRED'], $users);
-		//  - Case insensitive search (display name)
-		$users = $manager->getLastLoggedInUsers(search: 'upper');
-		$this->assertEquals(['TEST_ACTIVE_2_FRED'], $users);
-		//  - Case insensitive search (uid)
-		$users = $manager->getLastLoggedInUsers(search: 'fred');
-		$this->assertEquals(['TEST_ACTIVE_2_FRED'], $users);
-
-		// Delete users and config keys
-		$user1->delete();
-		$user2->delete();
-		$user3->delete();
-		$user4->delete();
-		$user5->delete();
-	}
-
-	public function testDeleteUser(): void {
-		/** @var AllConfig&MockObject */
-		$config = $this->getMockBuilder(AllConfig::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$config
-			->expects($this->any())
-			->method('getUserValue')
-			->willReturnArgument(3);
-		$config
-			->expects($this->any())
-			->method('getAppValue')
-			->willReturnArgument(2);
-
-		$manager = new \OC\User\Manager($config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
-		$backend = new \Test\Util\User\Dummy();
-
-		$manager->registerBackend($backend);
-		$backend->createUser('foo', 'bar');
-		$this->assertTrue($manager->userExists('foo'));
-		$manager->get('foo')->delete();
-		$this->assertFalse($manager->userExists('foo'));
-	}
-
-	public function testGetByEmail(): void {
-		/** @var AllConfig&MockObject */
-		$config = $this->getMockBuilder(AllConfig::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$config
-			->expects($this->once())
-			->method('getUsersForUserValueCaseInsensitive')
-			->with('settings', 'email', 'test@example.com')
-			->willReturn(['uid1', 'uid99', 'uid2']);
-
-		$backend = $this->createMock(\Test\Util\User\Dummy::class);
-		$backend->expects($this->exactly(3))
-			->method('userExists')
-			->willReturnMap([
-				['uid1', true],
-				['uid99', false],
-				['uid2', true]
-			]);
-
-		$manager = new \OC\User\Manager($config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
-		$manager->registerBackend($backend);
-
-		$users = $manager->getByEmail('test@example.com');
-		$this->assertCount(2, $users);
-		$this->assertEquals('uid1', $users[0]->getUID());
-		$this->assertEquals('uid2', $users[1]->getUID());
-	}
+    private IConfig&MockObject $config;
+    private IEventDispatcher&MockObject $eventDispatcher;
+    private ICacheFactory&MockObject $cacheFactory;
+    private ICache&MockObject $cache;
+    private LoggerInterface&MockObject $logger;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->config = $this->createMock(IConfig::class);
+        $this->eventDispatcher = $this->createMock(IEventDispatcher::class);
+        $this->cacheFactory = $this->createMock(ICacheFactory::class);
+        $this->cache = $this->createMock(ICache::class);
+        $this->logger = $this->createMock(LoggerInterface::class);
+
+        $this->cacheFactory->method('createDistributed')
+            ->willReturn($this->cache);
+    }
+
+    public function testGetBackends(): void {
+        $userDummyBackend = $this->createMock(\Test\Util\User\Dummy::class);
+        $manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
+        $manager->registerBackend($userDummyBackend);
+        $this->assertEquals([$userDummyBackend], $manager->getBackends());
+        $dummyDatabaseBackend = $this->createMock(Database::class);
+        $manager->registerBackend($dummyDatabaseBackend);
+        $this->assertEquals([$userDummyBackend, $dummyDatabaseBackend], $manager->getBackends());
+    }
+
+
+    public function testUserExistsSingleBackendExists(): void {
+        /**
+         * @var \Test\Util\User\Dummy&MockObject $backend
+         */
+        $backend = $this->createMock(\Test\Util\User\Dummy::class);
+        $backend->expects($this->once())
+            ->method('userExists')
+            ->with($this->equalTo('foo'))
+            ->willReturn(true);
+
+        $manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
+        $manager->registerBackend($backend);
+
+        $this->assertTrue($manager->userExists('foo'));
+    }
+
+    public function testUserExistsTooLong(): void {
+        /** @var \Test\Util\User\Dummy|MockObject $backend */
+        $backend = $this->createMock(\Test\Util\User\Dummy::class);
+        $backend->expects($this->never())
+            ->method('userExists')
+            ->with($this->equalTo('foo'))
+            ->willReturn(true);
+
+        $manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
+        $manager->registerBackend($backend);
+
+        $this->assertFalse($manager->userExists('foo' . str_repeat('a', 62)));
+    }
+
+    public function testUserExistsSingleBackendNotExists(): void {
+        /**
+         * @var \Test\Util\User\Dummy&MockObject $backend
+         */
+        $backend = $this->createMock(\Test\Util\User\Dummy::class);
+        $backend->expects($this->once())
+            ->method('userExists')
+            ->with($this->equalTo('foo'))
+            ->willReturn(false);
+
+        $manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
+        $manager->registerBackend($backend);
+
+        $this->assertFalse($manager->userExists('foo'));
+    }
+
+    public function testUserExistsNoBackends(): void {
+        $manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
+
+        $this->assertFalse($manager->userExists('foo'));
+    }
+
+    public function testUserExistsTwoBackendsSecondExists(): void {
+        /**
+         * @var \Test\Util\User\Dummy&MockObject $backend1
+         */
+        $backend1 = $this->createMock(\Test\Util\User\Dummy::class);
+        $backend1->expects($this->once())
+            ->method('userExists')
+            ->with($this->equalTo('foo'))
+            ->willReturn(false);
+
+        /**
+         * @var \Test\Util\User\Dummy&MockObject $backend2
+         */
+        $backend2 = $this->createMock(\Test\Util\User\Dummy::class);
+        $backend2->expects($this->once())
+            ->method('userExists')
+            ->with($this->equalTo('foo'))
+            ->willReturn(true);
+
+        $manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
+        $manager->registerBackend($backend1);
+        $manager->registerBackend($backend2);
+
+        $this->assertTrue($manager->userExists('foo'));
+    }
+
+    public function testUserExistsTwoBackendsFirstExists(): void {
+        /**
+         * @var \Test\Util\User\Dummy&MockObject $backend1
+         */
+        $backend1 = $this->createMock(\Test\Util\User\Dummy::class);
+        $backend1->expects($this->once())
+            ->method('userExists')
+            ->with($this->equalTo('foo'))
+            ->willReturn(true);
+
+        /**
+         * @var \Test\Util\User\Dummy&MockObject $backend2
+         */
+        $backend2 = $this->createMock(\Test\Util\User\Dummy::class);
+        $backend2->expects($this->never())
+            ->method('userExists');
+
+        $manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
+        $manager->registerBackend($backend1);
+        $manager->registerBackend($backend2);
+
+        $this->assertTrue($manager->userExists('foo'));
+    }
+
+    public function testCheckPassword(): void {
+        /**
+         * @var \OC\User\Backend&MockObject $backend
+         */
+        $backend = $this->createMock(\Test\Util\User\Dummy::class);
+        $backend->expects($this->once())
+            ->method('checkPassword')
+            ->with($this->equalTo('foo'), $this->equalTo('bar'))
+            ->willReturn(true);
+
+        $backend->expects($this->any())
+            ->method('implementsActions')
+            ->willReturnCallback(function ($actions) {
+                if ($actions === BACKEND::CHECK_PASSWORD) {
+                    return true;
+                } else {
+                    return false;
+                }
+            });
+
+        $manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
+        $manager->registerBackend($backend);
+
+        $user = $manager->checkPassword('foo', 'bar');
+        $this->assertTrue($user instanceof User);
+    }
+
+    public function testCheckPasswordNotSupported(): void {
+        /**
+         * @var \OC\User\Backend&MockObject $backend
+         */
+        $backend = $this->createMock(\Test\Util\User\Dummy::class);
+        $backend->expects($this->never())
+            ->method('checkPassword');
+
+        $backend->expects($this->any())
+            ->method('implementsActions')
+            ->willReturn(false);
+
+        $manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
+        $manager->registerBackend($backend);
+
+        $this->assertFalse($manager->checkPassword('foo', 'bar'));
+    }
+
+    public function testGetOneBackendExists(): void {
+        /**
+         * @var \Test\Util\User\Dummy&MockObject $backend
+         */
+        $backend = $this->createMock(\Test\Util\User\Dummy::class);
+        $backend->expects($this->once())
+            ->method('userExists')
+            ->with($this->equalTo('foo'))
+            ->willReturn(true);
+        $backend->expects($this->never())
+            ->method('loginName2UserName');
+
+        $manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
+        $manager->registerBackend($backend);
+
+        $this->assertEquals('foo', $manager->get('foo')->getUID());
+    }
+
+    public function testGetOneBackendNotExists(): void {
+        /**
+         * @var \Test\Util\User\Dummy&MockObject $backend
+         */
+        $backend = $this->createMock(\Test\Util\User\Dummy::class);
+        $backend->expects($this->once())
+            ->method('userExists')
+            ->with($this->equalTo('foo'))
+            ->willReturn(false);
+
+        $manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
+        $manager->registerBackend($backend);
+
+        $this->assertEquals(null, $manager->get('foo'));
+    }
+
+    public function testGetTooLong(): void {
+        /** @var \Test\Util\User\Dummy|MockObject $backend */
+        $backend = $this->createMock(\Test\Util\User\Dummy::class);
+        $backend->expects($this->never())
+            ->method('userExists')
+            ->with($this->equalTo('foo'))
+            ->willReturn(false);
+
+        $manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
+        $manager->registerBackend($backend);
+
+        $this->assertEquals(null, $manager->get('foo' . str_repeat('a', 62)));
+    }
+
+    public function testGetOneBackendDoNotTranslateLoginNames(): void {
+        /**
+         * @var \Test\Util\User\Dummy&MockObject $backend
+         */
+        $backend = $this->createMock(\Test\Util\User\Dummy::class);
+        $backend->expects($this->once())
+            ->method('userExists')
+            ->with($this->equalTo('bLeNdEr'))
+            ->willReturn(true);
+        $backend->expects($this->never())
+            ->method('loginName2UserName');
+
+        $manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
+        $manager->registerBackend($backend);
+
+        $this->assertEquals('bLeNdEr', $manager->get('bLeNdEr')->getUID());
+    }
+
+    public function testSearchOneBackend(): void {
+        /**
+         * @var \Test\Util\User\Dummy&MockObject $backend
+         */
+        $backend = $this->createMock(\Test\Util\User\Dummy::class);
+        $backend->expects($this->once())
+            ->method('getUsers')
+            ->with($this->equalTo('fo'))
+            ->willReturn(['foo', 'afoo', 'Afoo1', 'Bfoo']);
+        $backend->expects($this->never())
+            ->method('loginName2UserName');
+
+        $manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
+        $manager->registerBackend($backend);
+
+        $result = $manager->search('fo');
+        $this->assertEquals(4, count($result));
+        $this->assertEquals('afoo', array_shift($result)->getUID());
+        $this->assertEquals('Afoo1', array_shift($result)->getUID());
+        $this->assertEquals('Bfoo', array_shift($result)->getUID());
+        $this->assertEquals('foo', array_shift($result)->getUID());
+    }
+
+    public function testSearchTwoBackendLimitOffset(): void {
+        /**
+         * @var \Test\Util\User\Dummy&MockObject $backend1
+         */
+        $backend1 = $this->createMock(\Test\Util\User\Dummy::class);
+        $backend1->expects($this->once())
+            ->method('getUsers')
+            ->with($this->equalTo('fo'), $this->equalTo(3), $this->equalTo(1))
+            ->willReturn(['foo1', 'foo2']);
+        $backend1->expects($this->never())
+            ->method('loginName2UserName');
+
+        /**
+         * @var \Test\Util\User\Dummy&MockObject $backend2
+         */
+        $backend2 = $this->createMock(\Test\Util\User\Dummy::class);
+        $backend2->expects($this->once())
+            ->method('getUsers')
+            ->with($this->equalTo('fo'), $this->equalTo(3), $this->equalTo(1))
+            ->willReturn(['foo3']);
+        $backend2->expects($this->never())
+            ->method('loginName2UserName');
+
+        $manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
+        $manager->registerBackend($backend1);
+        $manager->registerBackend($backend2);
+
+        $result = $manager->search('fo', 3, 1);
+        $this->assertEquals(3, count($result));
+        $this->assertEquals('foo1', array_shift($result)->getUID());
+        $this->assertEquals('foo2', array_shift($result)->getUID());
+        $this->assertEquals('foo3', array_shift($result)->getUID());
+    }
+
+    public static function dataCreateUserInvalid(): array {
+        return [
+            ['te?st', 'foo', 'Only the following characters are allowed in a username:'
+                . ' "a-z", "A-Z", "0-9", spaces and "_.@-\'"'],
+            ["te\tst", '', 'Only the following characters are allowed in a username:'
+                . ' "a-z", "A-Z", "0-9", spaces and "_.@-\'"'],
+            ["te\nst", '', 'Only the following characters are allowed in a username:'
+                . ' "a-z", "A-Z", "0-9", spaces and "_.@-\'"'],
+            ["te\rst", '', 'Only the following characters are allowed in a username:'
+                . ' "a-z", "A-Z", "0-9", spaces and "_.@-\'"'],
+            ["te\0st", '', 'Only the following characters are allowed in a username:'
+                . ' "a-z", "A-Z", "0-9", spaces and "_.@-\'"'],
+            ["te\x0Bst", '', 'Only the following characters are allowed in a username:'
+                . ' "a-z", "A-Z", "0-9", spaces and "_.@-\'"'],
+            ["te\xe2st", '', 'Only the following characters are allowed in a username:'
+                . ' "a-z", "A-Z", "0-9", spaces and "_.@-\'"'],
+            ["te\x80st", '', 'Only the following characters are allowed in a username:'
+                . ' "a-z", "A-Z", "0-9", spaces and "_.@-\'"'],
+            ["te\x8bst", '', 'Only the following characters are allowed in a username:'
+                . ' "a-z", "A-Z", "0-9", spaces and "_.@-\'"'],
+            ['', 'foo', 'A valid username must be provided'],
+            [' ', 'foo', 'A valid username must be provided'],
+            [' test', 'foo', 'Username contains whitespace at the beginning or at the end'],
+            ['test ', 'foo', 'Username contains whitespace at the beginning or at the end'],
+            ['.', 'foo', 'Username must not consist of dots only'],
+            ['..', 'foo', 'Username must not consist of dots only'],
+            ['.test', '', 'A valid password must be provided'],
+            ['test', '', 'A valid password must be provided'],
+            ['test' . str_repeat('a', 61), '', 'Login is too long'],
+        ];
+    }
+
+    #[\PHPUnit\Framework\Attributes\DataProvider('dataCreateUserInvalid')]
+    public function testCreateUserInvalid($uid, $password, $exception): void {
+        /** @var \Test\Util\User\Dummy&MockObject $backend */
+        $backend = $this->createMock(\Test\Util\User\Dummy::class);
+        $backend->expects($this->once())
+            ->method('implementsActions')
+            ->with(\OC\User\Backend::CREATE_USER)
+            ->willReturn(true);
+
+
+        $manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
+        $manager->registerBackend($backend);
+
+        $this->expectException(\InvalidArgumentException::class, $exception);
+        $manager->createUser($uid, $password);
+    }
+
+    public function testCreateUserSingleBackendNotExists(): void {
+        /**
+         * @var \Test\Util\User\Dummy&MockObject $backend
+         */
+        $backend = $this->createMock(\Test\Util\User\Dummy::class);
+        $backend->expects($this->any())
+            ->method('implementsActions')
+            ->willReturn(true);
+
+        $backend->expects($this->once())
+            ->method('createUser')
+            ->with($this->equalTo('foo'), $this->equalTo('bar'));
+
+        $backend->expects($this->once())
+            ->method('userExists')
+            ->with($this->equalTo('foo'))
+            ->willReturn(false);
+        $backend->expects($this->never())
+            ->method('loginName2UserName');
+
+        $manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
+        $manager->registerBackend($backend);
+
+        $user = $manager->createUser('foo', 'bar');
+        $this->assertEquals('foo', $user->getUID());
+    }
+
+
+    public function testCreateUserSingleBackendExists(): void {
+        $this->expectException(\Exception::class);
+
+        /**
+         * @var \Test\Util\User\Dummy&MockObject $backend
+         */
+        $backend = $this->createMock(\Test\Util\User\Dummy::class);
+        $backend->expects($this->any())
+            ->method('implementsActions')
+            ->willReturn(true);
+
+        $backend->expects($this->never())
+            ->method('createUser');
+
+        $backend->expects($this->once())
+            ->method('userExists')
+            ->with($this->equalTo('foo'))
+            ->willReturn(true);
+
+        $manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
+        $manager->registerBackend($backend);
+
+        $manager->createUser('foo', 'bar');
+    }
+
+    public function testCreateUserSingleBackendNotSupported(): void {
+        /**
+         * @var \Test\Util\User\Dummy&MockObject $backend
+         */
+        $backend = $this->createMock(\Test\Util\User\Dummy::class);
+        $backend->expects($this->any())
+            ->method('implementsActions')
+            ->willReturn(false);
+
+        $backend->expects($this->never())
+            ->method('createUser');
+
+        $backend->expects($this->never())
+            ->method('userExists');
+
+        $manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
+        $manager->registerBackend($backend);
+
+        $this->assertFalse($manager->createUser('foo', 'bar'));
+    }
+
+    public function testCreateUserNoBackends(): void {
+        $manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
+
+        $this->assertFalse($manager->createUser('foo', 'bar'));
+    }
+
+
+    public function testCreateUserFromBackendWithBackendError(): void {
+        $this->expectException(\InvalidArgumentException::class);
+        $this->expectExceptionMessage('Could not create account');
+
+        /** @var \Test\Util\User\Dummy&MockObject $backend */
+        $backend = $this->createMock(\Test\Util\User\Dummy::class);
+        $backend
+            ->expects($this->once())
+            ->method('createUser')
+            ->with('MyUid', 'MyPassword')
+            ->willReturn(false);
+
+        $manager = new Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
+        $manager->createUserFromBackend('MyUid', 'MyPassword', $backend);
+    }
+
+
+    public function testCreateUserTwoBackendExists(): void {
+        $this->expectException(\Exception::class);
+
+        /**
+         * @var \Test\Util\User\Dummy&MockObject $backend1
+         */
+        $backend1 = $this->createMock(\Test\Util\User\Dummy::class);
+        $backend1->expects($this->any())
+            ->method('implementsActions')
+            ->willReturn(true);
+
+        $backend1->expects($this->never())
+            ->method('createUser');
+
+        $backend1->expects($this->once())
+            ->method('userExists')
+            ->with($this->equalTo('foo'))
+            ->willReturn(false);
+
+        /**
+         * @var \Test\Util\User\Dummy&MockObject $backend2
+         */
+        $backend2 = $this->createMock(\Test\Util\User\Dummy::class);
+        $backend2->expects($this->any())
+            ->method('implementsActions')
+            ->willReturn(true);
+
+        $backend2->expects($this->never())
+            ->method('createUser');
+
+        $backend2->expects($this->once())
+            ->method('userExists')
+            ->with($this->equalTo('foo'))
+            ->willReturn(true);
+
+        $manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
+        $manager->registerBackend($backend1);
+        $manager->registerBackend($backend2);
+
+        $manager->createUser('foo', 'bar');
+    }
+
+    public function testCountUsersNoBackend(): void {
+        $manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
+
+        $result = $manager->countUsers();
+        $this->assertTrue(is_array($result));
+        $this->assertTrue(empty($result));
+    }
+
+    public function testCountUsersOneBackend(): void {
+        /**
+         * @var \Test\Util\User\Dummy&MockObject $backend
+         */
+        $backend = $this->createMock(\Test\Util\User\Dummy::class);
+        $backend->expects($this->once())
+            ->method('countUsers')
+            ->willReturn(7);
+
+        $backend->expects($this->once())
+            ->method('implementsActions')
+            ->with(BACKEND::COUNT_USERS)
+            ->willReturn(true);
+
+        $backend->expects($this->once())
+            ->method('getBackendName')
+            ->willReturn('Mock_Test_Util_User_Dummy');
+
+        $manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
+        $manager->registerBackend($backend);
+
+        $result = $manager->countUsers();
+        $keys = array_keys($result);
+        $this->assertTrue(strpos($keys[0], 'Mock_Test_Util_User_Dummy') !== false);
+
+        $users = array_shift($result);
+        $this->assertEquals(7, $users);
+    }
+
+    public function testCountUsersTwoBackends(): void {
+        /**
+         * @var \Test\Util\User\Dummy&MockObject $backend
+         */
+        $backend1 = $this->createMock(\Test\Util\User\Dummy::class);
+        $backend1->expects($this->once())
+            ->method('countUsers')
+            ->willReturn(7);
+
+        $backend1->expects($this->once())
+            ->method('implementsActions')
+            ->with(BACKEND::COUNT_USERS)
+            ->willReturn(true);
+        $backend1->expects($this->once())
+            ->method('getBackendName')
+            ->willReturn('Mock_Test_Util_User_Dummy');
+
+        $backend2 = $this->createMock(\Test\Util\User\Dummy::class);
+        $backend2->expects($this->once())
+            ->method('countUsers')
+            ->willReturn(16);
+
+        $backend2->expects($this->once())
+            ->method('implementsActions')
+            ->with(BACKEND::COUNT_USERS)
+            ->willReturn(true);
+        $backend2->expects($this->once())
+            ->method('getBackendName')
+            ->willReturn('Mock_Test_Util_User_Dummy');
+
+        $manager = new \OC\User\Manager($this->config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
+        $manager->registerBackend($backend1);
+        $manager->registerBackend($backend2);
+
+        $result = $manager->countUsers();
+        //because the backends have the same class name, only one value expected
+        $this->assertEquals(1, count($result));
+        $keys = array_keys($result);
+        $this->assertTrue(strpos($keys[0], 'Mock_Test_Util_User_Dummy') !== false);
+
+        $users = array_shift($result);
+        //users from backends shall be summed up
+        $this->assertEquals(7 + 16, $users);
+    }
+
+    public function testCountUsersOnlyDisabled(): void {
+        $manager = Server::get(IUserManager::class);
+        // count other users in the db before adding our own
+        $countBefore = $manager->countDisabledUsers();
+
+        //Add test users
+        $user1 = $manager->createUser('testdisabledcount1', 'testdisabledcount1');
+
+        $user2 = $manager->createUser('testdisabledcount2', 'testdisabledcount2');
+        $user2->setEnabled(false);
+
+        $user3 = $manager->createUser('testdisabledcount3', 'testdisabledcount3');
+
+        $user4 = $manager->createUser('testdisabledcount4', 'testdisabledcount4');
+        $user4->setEnabled(false);
+
+        $this->assertEquals($countBefore + 2, $manager->countDisabledUsers());
+
+        //cleanup
+        $user1->delete();
+        $user2->delete();
+        $user3->delete();
+        $user4->delete();
+    }
+
+    public function testCountUsersOnlySeen(): void {
+        $manager = Server::get(IUserManager::class);
+        // count other users in the db before adding our own
+        $countBefore = $manager->countSeenUsers();
+
+        //Add test users
+        $user1 = $manager->createUser('testseencount1', 'testseencount1');
+        $user1->updateLastLoginTimestamp();
+
+        $user2 = $manager->createUser('testseencount2', 'testseencount2');
+        $user2->updateLastLoginTimestamp();
+
+        $user3 = $manager->createUser('testseencount3', 'testseencount3');
+
+        $user4 = $manager->createUser('testseencount4', 'testseencount4');
+        $user4->updateLastLoginTimestamp();
+
+        $this->assertEquals($countBefore + 3, $manager->countSeenUsers());
+
+        //cleanup
+        $user1->delete();
+        $user2->delete();
+        $user3->delete();
+        $user4->delete();
+    }
+
+    public function testCallForSeenUsers(): void {
+        $manager = Server::get(IUserManager::class);
+        // count other users in the db before adding our own
+        $count = 0;
+        $function = function (IUser $user) use (&$count): void {
+            $count++;
+        };
+        $manager->callForAllUsers($function, '', true);
+        $countBefore = $count;
+
+        //Add test users
+        $user1 = $manager->createUser('testseen1', 'testseen10');
+        $user1->updateLastLoginTimestamp();
+
+        $user2 = $manager->createUser('testseen2', 'testseen20');
+        $user2->updateLastLoginTimestamp();
+
+        $user3 = $manager->createUser('testseen3', 'testseen30');
+
+        $user4 = $manager->createUser('testseen4', 'testseen40');
+        $user4->updateLastLoginTimestamp();
+
+        $count = 0;
+        $manager->callForAllUsers($function, '', true);
+
+        $this->assertEquals($countBefore + 3, $count);
+
+        //cleanup
+        $user1->delete();
+        $user2->delete();
+        $user3->delete();
+        $user4->delete();
+    }
+
+    #[\PHPUnit\Framework\Attributes\RunInSeparateProcess]
+    #[\PHPUnit\Framework\Attributes\PreserveGlobalState(enabled: false)]
+    public function testRecentlyActive(): void {
+        $config = Server::get(IConfig::class);
+        $manager = Server::get(IUserManager::class);
+
+        // Create some users
+        $now = (string)time();
+        $user1 = $manager->createUser('test_active_1', 'test_active_1');
+        $config->setUserValue('test_active_1', 'login', 'lastLogin', $now);
+        $user1->setDisplayName('test active 1');
+        $user1->setSystemEMailAddress('roger@active.com');
+
+        $user2 = $manager->createUser('TEST_ACTIVE_2_FRED', 'TEST_ACTIVE_2');
+        $config->setUserValue('TEST_ACTIVE_2_FRED', 'login', 'lastLogin', $now);
+        $user2->setDisplayName('TEST ACTIVE 2 UPPER');
+        $user2->setSystemEMailAddress('Fred@Active.Com');
+
+        $user3 = $manager->createUser('test_active_3', 'test_active_3');
+        $config->setUserValue('test_active_3', 'login', 'lastLogin', $now + 1);
+        $user3->setDisplayName('test active 3');
+
+        $user4 = $manager->createUser('test_active_4', 'test_active_4');
+        $config->setUserValue('test_active_4', 'login', 'lastLogin', $now);
+        $user4->setDisplayName('Test Active 4');
+
+        $user5 = $manager->createUser('test_inactive_1', 'test_inactive_1');
+        $user5->setDisplayName('Test Inactive 1');
+        $user2->setSystemEMailAddress('jeanne@Active.Com');
+
+        // Search recently active
+        //  - No search, case-insensitive order
+        $users = $manager->getLastLoggedInUsers(4);
+        $this->assertEquals(['test_active_3', 'test_active_1', 'TEST_ACTIVE_2_FRED', 'test_active_4'], $users);
+        //  - Search, case-insensitive order
+        $users = $manager->getLastLoggedInUsers(search: 'act');
+        $this->assertEquals(['test_active_3', 'test_active_1', 'TEST_ACTIVE_2_FRED', 'test_active_4'], $users);
+        //  - No search with offset
+        $users = $manager->getLastLoggedInUsers(2, 2);
+        $this->assertEquals(['TEST_ACTIVE_2_FRED', 'test_active_4'], $users);
+        //  - Case insensitive search (email)
+        $users = $manager->getLastLoggedInUsers(search: 'active.com');
+        $this->assertEquals(['test_active_1', 'TEST_ACTIVE_2_FRED'], $users);
+        //  - Case insensitive search (display name)
+        $users = $manager->getLastLoggedInUsers(search: 'upper');
+        $this->assertEquals(['TEST_ACTIVE_2_FRED'], $users);
+        //  - Case insensitive search (uid)
+        $users = $manager->getLastLoggedInUsers(search: 'fred');
+        $this->assertEquals(['TEST_ACTIVE_2_FRED'], $users);
+
+        // Delete users and config keys
+        $user1->delete();
+        $user2->delete();
+        $user3->delete();
+        $user4->delete();
+        $user5->delete();
+    }
+
+    public function testDeleteUser(): void {
+        /** @var AllConfig&MockObject */
+        $config = $this->getMockBuilder(AllConfig::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $config
+            ->expects($this->any())
+            ->method('getUserValue')
+            ->willReturnArgument(3);
+        $config
+            ->expects($this->any())
+            ->method('getAppValue')
+            ->willReturnArgument(2);
+
+        $manager = new \OC\User\Manager($config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
+        $backend = new \Test\Util\User\Dummy();
+
+        $manager->registerBackend($backend);
+        $backend->createUser('foo', 'bar');
+        $this->assertTrue($manager->userExists('foo'));
+        $manager->get('foo')->delete();
+        $this->assertFalse($manager->userExists('foo'));
+    }
+
+    public function testGetByEmail(): void {
+        /** @var AllConfig&MockObject */
+        $config = $this->getMockBuilder(AllConfig::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $config
+            ->expects($this->once())
+            ->method('getUsersForUserValueCaseInsensitive')
+            ->with('settings', 'email', 'test@example.com')
+            ->willReturn(['uid1', 'uid99', 'uid2']);
+
+        $backend = $this->createMock(\Test\Util\User\Dummy::class);
+        $backend->expects($this->exactly(3))
+            ->method('userExists')
+            ->willReturnMap([
+                ['uid1', true],
+                ['uid99', false],
+                ['uid2', true]
+            ]);
+
+        $manager = new \OC\User\Manager($config, $this->cacheFactory, $this->eventDispatcher, $this->logger);
+        $manager->registerBackend($backend);
+
+        $users = $manager->getByEmail('test@example.com');
+        $this->assertCount(2, $users);
+        $this->assertEquals('uid1', $users[0]->getUID());
+        $this->assertEquals('uid2', $users[1]->getUID());
+    }
 }

tests/lib/Files/SimpleFS/InMemoryFileTest.php

Indentation +105 added lines, -105 removed lines

@@ -19,109 +19,109 @@
  * @package Test\File\SimpleFS
  */
 class InMemoryFileTest extends TestCase {
-	/**
-	 * Holds a pdf file with know attributes for tests.
-	 */
-	private InMemoryFile $testPdf;
-
-	/**
-	 * Sets the test file from "./resources/test.pdf".
-	 */
-	#[\PHPUnit\Framework\Attributes\Before()]
-	public function setupTestPdf(): void {
-		$fileContents = file_get_contents(
-			__DIR__ . '/../../../data/test.pdf'
-		);
-		$this->testPdf = new InMemoryFile('test.pdf', $fileContents);
-	}
-
-	/**
-	 * Asserts that putContent replaces the file contents.
-	 *
-	 * @return void
-	 */
-	public function testPutContent(): void {
-		$this->testPdf->putContent('test');
-		self::assertEquals('test', $this->testPdf->getContent());
-	}
-
-	/**
-	 * Asserts that delete() doesn't rise an exception.
-	 *
-	 * @return void
-	 */
-	public function testDelete(): void {
-		$this->testPdf->delete();
-		// assert true, otherwise phpunit complains about not doing any assert
-		self::assertTrue(true);
-	}
-
-	/**
-	 * Asserts that getName returns the name passed on file creation.
-	 *
-	 * @return void
-	 */
-	public function testGetName(): void {
-		self::assertEquals('test.pdf', $this->testPdf->getName());
-	}
-
-	/**
-	 * Asserts that the file size is the size of the test file.
-	 *
-	 * @return void
-	 */
-	public function testGetSize(): void {
-		self::assertEquals(7083, $this->testPdf->getSize());
-	}
-
-	/**
-	 * Asserts the file contents are the same than the original file contents.
-	 *
-	 * @return void
-	 */
-	public function testGetContent(): void {
-		self::assertEquals(
-			file_get_contents(__DIR__ . '/../../../data/test.pdf'),
-			$this->testPdf->getContent()
-		);
-	}
-
-	/**
-	 * Asserts the test file modification time is an integer.
-	 *
-	 * @return void
-	 */
-	public function testGetMTime(): void {
-		self::assertTrue(is_int($this->testPdf->getMTime()));
-	}
-
-	/**
-	 * Asserts the test file mime type is "application/json".
-	 *
-	 * @return void
-	 */
-	public function testGetMimeType(): void {
-		self::assertEquals('application/pdf', $this->testPdf->getMimeType());
-	}
-
-
-	/**
-	 * Asserts that read() raises an NotPermittedException.
-	 *
-	 * @return void
-	 */
-	public function testRead(): void {
-		self::expectException(NotPermittedException::class);
-		$this->testPdf->read();
-	}
-
-	/**
-	 * Asserts that write() raises an NotPermittedException.
-	 *
-	 * @return void
-	 */
-	public function testWrite(): void {
-		self::expectException(NotPermittedException::class);
-		$this->testPdf->write();
-	}
+    /**
+     * Holds a pdf file with know attributes for tests.
+     */
+    private InMemoryFile $testPdf;
+
+    /**
+     * Sets the test file from "./resources/test.pdf".
+     */
+    #[\PHPUnit\Framework\Attributes\Before()]
+    public function setupTestPdf(): void {
+        $fileContents = file_get_contents(
+            __DIR__ . '/../../../data/test.pdf'
+        );
+        $this->testPdf = new InMemoryFile('test.pdf', $fileContents);
+    }
+
+    /**
+     * Asserts that putContent replaces the file contents.
+     *
+     * @return void
+     */
+    public function testPutContent(): void {
+        $this->testPdf->putContent('test');
+        self::assertEquals('test', $this->testPdf->getContent());
+    }
+
+    /**
+     * Asserts that delete() doesn't rise an exception.
+     *
+     * @return void
+     */
+    public function testDelete(): void {
+        $this->testPdf->delete();
+        // assert true, otherwise phpunit complains about not doing any assert
+        self::assertTrue(true);
+    }
+
+    /**
+     * Asserts that getName returns the name passed on file creation.
+     *
+     * @return void
+     */
+    public function testGetName(): void {
+        self::assertEquals('test.pdf', $this->testPdf->getName());
+    }
+
+    /**
+     * Asserts that the file size is the size of the test file.
+     *
+     * @return void
+     */
+    public function testGetSize(): void {
+        self::assertEquals(7083, $this->testPdf->getSize());
+    }
+
+    /**
+     * Asserts the file contents are the same than the original file contents.
+     *
+     * @return void
+     */
+    public function testGetContent(): void {
+        self::assertEquals(
+            file_get_contents(__DIR__ . '/../../../data/test.pdf'),
+            $this->testPdf->getContent()
+        );
+    }
+
+    /**
+     * Asserts the test file modification time is an integer.
+     *
+     * @return void
+     */
+    public function testGetMTime(): void {
+        self::assertTrue(is_int($this->testPdf->getMTime()));
+    }
+
+    /**
+     * Asserts the test file mime type is "application/json".
+     *
+     * @return void
+     */
+    public function testGetMimeType(): void {
+        self::assertEquals('application/pdf', $this->testPdf->getMimeType());
+    }
+
+
+    /**
+     * Asserts that read() raises an NotPermittedException.
+     *
+     * @return void
+     */
+    public function testRead(): void {
+        self::expectException(NotPermittedException::class);
+        $this->testPdf->read();
+    }
+
+    /**
+     * Asserts that write() raises an NotPermittedException.
+     *
+     * @return void
+     */
+    public function testWrite(): void {
+        self::expectException(NotPermittedException::class);
+        $this->testPdf->write();
+    }
 }

Spacing +2 added lines, -2 removed lines

@@ -30,7 +30,7 @@ 
 	#[\PHPUnit\Framework\Attributes\Before()]
 	public function setupTestPdf(): void {
 		$fileContents = file_get_contents(
-			__DIR__ . '/../../../data/test.pdf'
+			__DIR__.'/../../../data/test.pdf'
 		);
 		$this->testPdf = new InMemoryFile('test.pdf', $fileContents);
 	}
@@ -81,7 +81,7 @@ 
 	 */
 	public function testGetContent(): void {
 		self::assertEquals(
-			file_get_contents(__DIR__ . '/../../../data/test.pdf'),
+			file_get_contents(__DIR__.'/../../../data/test.pdf'),
 			$this->testPdf->getContent()
 		);
 	}

tests/lib/Files/FilenameValidatorTest.php

Indentation +461 added lines, -461 removed lines

@@ -26,465 +26,465 @@
 
 class FilenameValidatorTest extends TestCase {
 
-	protected IFactory&MockObject $l10n;
-	protected IConfig&MockObject $config;
-	protected IDBConnection&MockObject $database;
-	protected LoggerInterface&MockObject $logger;
-
-	protected function setUp(): void {
-		parent::setUp();
-		$l10n = $this->createMock(IL10N::class);
-		$l10n->method('t')
-			->willReturnCallback(fn ($string, $params) => sprintf($string, ...$params));
-		$this->l10n = $this->createMock(IFactory::class);
-		$this->l10n
-			->method('get')
-			->willReturn($l10n);
-
-		$this->config = $this->createMock(IConfig::class);
-		$this->logger = $this->createMock(LoggerInterface::class);
-		$this->database = $this->createMock(IDBConnection::class);
-		$this->database->method('supports4ByteText')->willReturn(true);
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataValidateFilename')]
-	public function testValidateFilename(
-		string $filename,
-		array $forbiddenNames,
-		array $forbiddenBasenames,
-		array $forbiddenExtensions,
-		array $forbiddenCharacters,
-		?string $exception,
-	): void {
-		/** @var FilenameValidator&MockObject */
-		$validator = $this->getMockBuilder(FilenameValidator::class)
-			->onlyMethods([
-				'getForbiddenBasenames',
-				'getForbiddenCharacters',
-				'getForbiddenExtensions',
-				'getForbiddenFilenames',
-			])
-			->setConstructorArgs([$this->l10n, $this->database, $this->config, $this->logger])
-			->getMock();
-
-		$validator->method('getForbiddenBasenames')
-			->willReturn($forbiddenBasenames);
-		$validator->method('getForbiddenCharacters')
-			->willReturn($forbiddenCharacters);
-		$validator->method('getForbiddenExtensions')
-			->willReturn($forbiddenExtensions);
-		$validator->method('getForbiddenFilenames')
-			->willReturn($forbiddenNames);
-
-		if ($exception !== null) {
-			$this->expectException($exception);
-		} else {
-			$this->expectNotToPerformAssertions();
-		}
-		$validator->validateFilename($filename);
-	}
-
-	#[\PHPUnit\Framework\Attributes\DataProvider('dataValidateFilename')]
-	public function testIsFilenameValid(
-		string $filename,
-		array $forbiddenNames,
-		array $forbiddenBasenames,
-		array $forbiddenExtensions,
-		array $forbiddenCharacters,
-		?string $exception,
-	): void {
-		/** @var FilenameValidator&MockObject */
-		$validator = $this->getMockBuilder(FilenameValidator::class)
-			->onlyMethods([
-				'getForbiddenBasenames',
-				'getForbiddenExtensions',
-				'getForbiddenFilenames',
-				'getForbiddenCharacters',
-			])
-			->setConstructorArgs([$this->l10n, $this->database, $this->config, $this->logger])
-			->getMock();
-
-		$validator->method('getForbiddenBasenames')
-			->willReturn($forbiddenBasenames);
-		$validator->method('getForbiddenCharacters')
-			->willReturn($forbiddenCharacters);
-		$validator->method('getForbiddenExtensions')
-			->willReturn($forbiddenExtensions);
-		$validator->method('getForbiddenFilenames')
-			->willReturn($forbiddenNames);
-
-
-		$this->assertEquals($exception === null, $validator->isFilenameValid($filename));
-	}
-
-	public static function dataValidateFilename(): array {
-		return [
-			'valid name' => [
-				'a: b.txt', ['.htaccess'], [], [], [], null
-			],
-			'forbidden name in the middle is ok' => [
-				'a.htaccess.txt', ['.htaccess'], [], [], [], null
-			],
-			'valid name with some more parameters' => [
-				'a: b.txt', ['.htaccess'], [], ['exe'], ['~'], null
-			],
-			'valid name checks only the full name' => [
-				'.htaccess.sample', ['.htaccess'], [], [], [], null
-			],
-			'forbidden name' => [
-				'.htaccess', ['.htaccess'], [], [], [], ReservedWordException::class
-			],
-			'forbidden name - name is case insensitive' => [
-				'COM1', ['.htaccess', 'com1'], [], [], [], ReservedWordException::class
-			],
-			'forbidden basename' => [
-				// needed for Windows namespaces
-				'com1.suffix', ['.htaccess'], ['com1'], [], [], ReservedWordException::class
-			],
-			'forbidden basename case insensitive' => [
-				// needed for Windows namespaces
-				'COM1.suffix', ['.htaccess'], ['com1'], [], [], ReservedWordException::class
-			],
-			'forbidden basename for hidden files' => [
-				// needed for Windows namespaces
-				'.thumbs.db', ['.htaccess'], ['.thumbs'], [], [], ReservedWordException::class
-			],
-			'invalid character' => [
-				'a: b.txt', ['.htaccess'], [], [], [':'], InvalidCharacterInPathException::class
-			],
-			'invalid path' => [
-				'../../foo.bar', ['.htaccess'], [], [], ['/', '\\'], InvalidCharacterInPathException::class,
-			],
-			'invalid extension' => [
-				'a: b.txt', ['.htaccess'], [], ['.txt'], [], InvalidPathException::class
-			],
-			'invalid extension case insensitive' => [
-				'a: b.TXT', ['.htaccess'], [], ['.txt'], [], InvalidPathException::class
-			],
-			'empty filename' => [
-				'', [], [], [], [], EmptyFileNameException::class
-			],
-			'reserved unix name "."' => [
-				'.', [], [], [], [], InvalidDirectoryException::class
-			],
-			'reserved unix name ".."' => [
-				'..', [], [], [], [], InvalidDirectoryException::class
-			],
-			'weird but valid tripple dot name' => [
-				'...', [], [], [], [], null // is valid
-			],
-			'too long filename "."' => [
-				str_repeat('a', 251), [], [], [], [], FileNameTooLongException::class
-			],
-			// make sure to not split the list entries as they migh contain Unicode sequences
-			// in this example the "face in clouds" emoji contains the clouds emoji so only having clouds is ok
-			['

tests/lib/Repair/RepairCollationTest.php

Indentation +54 added lines, -54 removed lines

@@ -19,13 +19,13 @@ 
 use Test\TestCase;
 
 class TestCollationRepair extends Collation {
-	/**
-	 * @param IDBConnection $connection
-	 * @return string[]
-	 */
-	public function getAllNonUTF8BinTables(IDBConnection $connection) {
-		return parent::getAllNonUTF8BinTables($connection);
-	}
+    /**
+     * @param IDBConnection $connection
+     * @return string[]
+     */
+    public function getAllNonUTF8BinTables(IDBConnection $connection) {
+        return parent::getAllNonUTF8BinTables($connection);
+    }
 }
 
 /**
@@ -36,51 +36,51 @@ 
 #[\PHPUnit\Framework\Attributes\Group('DB')]
 class RepairCollationTest extends TestCase {
 
-	private TestCollationRepair $repair;
-	private ConnectionAdapter $connection;
-	private string $tableName;
-	private IConfig $config;
-
-	private LoggerInterface&MockObject $logger;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->connection = Server::get(ConnectionAdapter::class);
-		if ($this->connection->getDatabaseProvider() !== IDBConnection::PLATFORM_MYSQL) {
-			$this->markTestSkipped('Test only relevant on MySql');
-			return;
-		}
-
-		$this->logger = $this->createMock(LoggerInterface::class);
-		$this->config = Server::get(IConfig::class);
-		$dbPrefix = $this->config->getSystemValueString('dbtableprefix');
-		$this->tableName = $this->getUniqueID($dbPrefix . '_collation_test');
-		$this->connection->prepare("CREATE TABLE $this->tableName(text VARCHAR(16)) COLLATE utf8_unicode_ci")->execute();
-
-		$this->repair = new TestCollationRepair($this->config, $this->logger, $this->connection, false);
-	}
-
-	protected function tearDown(): void {
-		$this->connection = Server::get(ConnectionAdapter::class);
-		if ($this->connection->getDatabaseProvider() === IDBConnection::PLATFORM_MYSQL) {
-			// tear down only needed on MySQL
-			$this->connection->getInner()->createSchemaManager()->dropTable($this->tableName);
-		}
-		parent::tearDown();
-	}
-
-	public function testCollationConvert(): void {
-		$tables = $this->repair->getAllNonUTF8BinTables($this->connection);
-		$this->assertGreaterThanOrEqual(1, count($tables));
-
-		$outputMock = $this->getMockBuilder(IOutput::class)
-			->disableOriginalConstructor()
-			->getMock();
-
-		$this->repair->run($outputMock);
-
-		$tables = $this->repair->getAllNonUTF8BinTables($this->connection);
-		$this->assertCount(0, $tables);
-	}
+    private TestCollationRepair $repair;
+    private ConnectionAdapter $connection;
+    private string $tableName;
+    private IConfig $config;
+
+    private LoggerInterface&MockObject $logger;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->connection = Server::get(ConnectionAdapter::class);
+        if ($this->connection->getDatabaseProvider() !== IDBConnection::PLATFORM_MYSQL) {
+            $this->markTestSkipped('Test only relevant on MySql');
+            return;
+        }
+
+        $this->logger = $this->createMock(LoggerInterface::class);
+        $this->config = Server::get(IConfig::class);
+        $dbPrefix = $this->config->getSystemValueString('dbtableprefix');
+        $this->tableName = $this->getUniqueID($dbPrefix . '_collation_test');
+        $this->connection->prepare("CREATE TABLE $this->tableName(text VARCHAR(16)) COLLATE utf8_unicode_ci")->execute();
+
+        $this->repair = new TestCollationRepair($this->config, $this->logger, $this->connection, false);
+    }
+
+    protected function tearDown(): void {
+        $this->connection = Server::get(ConnectionAdapter::class);
+        if ($this->connection->getDatabaseProvider() === IDBConnection::PLATFORM_MYSQL) {
+            // tear down only needed on MySQL
+            $this->connection->getInner()->createSchemaManager()->dropTable($this->tableName);
+        }
+        parent::tearDown();
+    }
+
+    public function testCollationConvert(): void {
+        $tables = $this->repair->getAllNonUTF8BinTables($this->connection);
+        $this->assertGreaterThanOrEqual(1, count($tables));
+
+        $outputMock = $this->getMockBuilder(IOutput::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $this->repair->run($outputMock);
+
+        $tables = $this->repair->getAllNonUTF8BinTables($this->connection);
+        $this->assertCount(0, $tables);
+    }
 }

Spacing +1 added lines, -1 removed lines

@@ -55,7 +55,7 @@
 		$this->logger = $this->createMock(LoggerInterface::class);
 		$this->config = Server::get(IConfig::class);
 		$dbPrefix = $this->config->getSystemValueString('dbtableprefix');
-		$this->tableName = $this->getUniqueID($dbPrefix . '_collation_test');
+		$this->tableName = $this->getUniqueID($dbPrefix.'_collation_test');
 		$this->connection->prepare("CREATE TABLE $this->tableName(text VARCHAR(16)) COLLATE utf8_unicode_ci")->execute();
 
 		$this->repair = new TestCollationRepair($this->config, $this->logger, $this->connection, false);

tests/lib/AppFramework/Middleware/MiddlewareDispatcherTest.php

Indentation +203 added lines, -203 removed lines

@@ -18,265 +18,265 @@
 
 // needed to test ordering
 class TestMiddleware extends Middleware {
-	public static $beforeControllerCalled = 0;
-	public static $afterControllerCalled = 0;
-	public static $afterExceptionCalled = 0;
-	public static $beforeOutputCalled = 0;
-
-	public $beforeControllerOrder = 0;
-	public $afterControllerOrder = 0;
-	public $afterExceptionOrder = 0;
-	public $beforeOutputOrder = 0;
-
-	public $controller;
-	public $methodName;
-	public $exception;
-	public $response;
-	public $output;
-
-	/**
-	 * @param boolean $beforeControllerThrowsEx
-	 */
-	public function __construct(
-		private $beforeControllerThrowsEx,
-	) {
-		self::$beforeControllerCalled = 0;
-		self::$afterControllerCalled = 0;
-		self::$afterExceptionCalled = 0;
-		self::$beforeOutputCalled = 0;
-	}
-
-	public function beforeController($controller, $methodName) {
-		self::$beforeControllerCalled++;
-		$this->beforeControllerOrder = self::$beforeControllerCalled;
-		$this->controller = $controller;
-		$this->methodName = $methodName;
-		if ($this->beforeControllerThrowsEx) {
-			throw new \Exception();
-		}
-	}
-
-	public function afterException($controller, $methodName, \Exception $exception) {
-		self::$afterExceptionCalled++;
-		$this->afterExceptionOrder = self::$afterExceptionCalled;
-		$this->controller = $controller;
-		$this->methodName = $methodName;
-		$this->exception = $exception;
-		parent::afterException($controller, $methodName, $exception);
-	}
-
-	public function afterController($controller, $methodName, Response $response) {
-		self::$afterControllerCalled++;
-		$this->afterControllerOrder = self::$afterControllerCalled;
-		$this->controller = $controller;
-		$this->methodName = $methodName;
-		$this->response = $response;
-		return parent::afterController($controller, $methodName, $response);
-	}
-
-	public function beforeOutput($controller, $methodName, $output) {
-		self::$beforeOutputCalled++;
-		$this->beforeOutputOrder = self::$beforeOutputCalled;
-		$this->controller = $controller;
-		$this->methodName = $methodName;
-		$this->output = $output;
-		return parent::beforeOutput($controller, $methodName, $output);
-	}
+    public static $beforeControllerCalled = 0;
+    public static $afterControllerCalled = 0;
+    public static $afterExceptionCalled = 0;
+    public static $beforeOutputCalled = 0;
+
+    public $beforeControllerOrder = 0;
+    public $afterControllerOrder = 0;
+    public $afterExceptionOrder = 0;
+    public $beforeOutputOrder = 0;
+
+    public $controller;
+    public $methodName;
+    public $exception;
+    public $response;
+    public $output;
+
+    /**
+     * @param boolean $beforeControllerThrowsEx
+     */
+    public function __construct(
+        private $beforeControllerThrowsEx,
+    ) {
+        self::$beforeControllerCalled = 0;
+        self::$afterControllerCalled = 0;
+        self::$afterExceptionCalled = 0;
+        self::$beforeOutputCalled = 0;
+    }
+
+    public function beforeController($controller, $methodName) {
+        self::$beforeControllerCalled++;
+        $this->beforeControllerOrder = self::$beforeControllerCalled;
+        $this->controller = $controller;
+        $this->methodName = $methodName;
+        if ($this->beforeControllerThrowsEx) {
+            throw new \Exception();
+        }
+    }
+
+    public function afterException($controller, $methodName, \Exception $exception) {
+        self::$afterExceptionCalled++;
+        $this->afterExceptionOrder = self::$afterExceptionCalled;
+        $this->controller = $controller;
+        $this->methodName = $methodName;
+        $this->exception = $exception;
+        parent::afterException($controller, $methodName, $exception);
+    }
+
+    public function afterController($controller, $methodName, Response $response) {
+        self::$afterControllerCalled++;
+        $this->afterControllerOrder = self::$afterControllerCalled;
+        $this->controller = $controller;
+        $this->methodName = $methodName;
+        $this->response = $response;
+        return parent::afterController($controller, $methodName, $response);
+    }
+
+    public function beforeOutput($controller, $methodName, $output) {
+        self::$beforeOutputCalled++;
+        $this->beforeOutputOrder = self::$beforeOutputCalled;
+        $this->controller = $controller;
+        $this->methodName = $methodName;
+        $this->output = $output;
+        return parent::beforeOutput($controller, $methodName, $output);
+    }
 }
 
 class TestController extends Controller {
-	public function controllerMethod(): void {
-	}
+    public function controllerMethod(): void {
+    }
 }
 
 class MiddlewareDispatcherTest extends \Test\TestCase {
-	public $exception;
-	public $response;
-	private $out;
-	private $method;
-	private $controller;
+    public $exception;
+    public $response;
+    private $out;
+    private $method;
+    private $controller;
 
-	/**
-	 * @var MiddlewareDispatcher
-	 */
-	private $dispatcher;
+    /**
+     * @var MiddlewareDispatcher
+     */
+    private $dispatcher;
 
-	protected function setUp(): void {
-		parent::setUp();
+    protected function setUp(): void {
+        parent::setUp();
 
-		$this->dispatcher = new MiddlewareDispatcher();
-		$this->controller = $this->getControllerMock();
-		$this->method = 'method';
-		$this->response = new Response();
-		$this->out = 'hi';
-		$this->exception = new \Exception();
-	}
+        $this->dispatcher = new MiddlewareDispatcher();
+        $this->controller = $this->getControllerMock();
+        $this->method = 'method';
+        $this->response = new Response();
+        $this->out = 'hi';
+        $this->exception = new \Exception();
+    }
 
 
-	private function getControllerMock() {
-		return $this->getMockBuilder(TestController::class)
-			->onlyMethods(['controllerMethod'])
-			->setConstructorArgs(['app',
-				new Request(
-					['controllerMethod' => 'GET'],
-					$this->createMock(IRequestId::class),
-					$this->createMock(IConfig::class)
-				)
-			])->getMock();
-	}
+    private function getControllerMock() {
+        return $this->getMockBuilder(TestController::class)
+            ->onlyMethods(['controllerMethod'])
+            ->setConstructorArgs(['app',
+                new Request(
+                    ['controllerMethod' => 'GET'],
+                    $this->createMock(IRequestId::class),
+                    $this->createMock(IConfig::class)
+                )
+            ])->getMock();
+    }
 
 
-	private function getMiddleware($beforeControllerThrowsEx = false) {
-		$m1 = new TestMiddleware($beforeControllerThrowsEx);
-		$this->dispatcher->registerMiddleware($m1);
-		return $m1;
-	}
+    private function getMiddleware($beforeControllerThrowsEx = false) {
+        $m1 = new TestMiddleware($beforeControllerThrowsEx);
+        $this->dispatcher->registerMiddleware($m1);
+        return $m1;
+    }
 
 
-	public function testAfterExceptionShouldReturnResponseOfMiddleware(): void {
-		$response = new Response();
-		$m1 = $this->getMockBuilder(Middleware::class)
-			->onlyMethods(['afterException', 'beforeController'])
-			->getMock();
-		$m1->expects($this->never())
-			->method('afterException');
+    public function testAfterExceptionShouldReturnResponseOfMiddleware(): void {
+        $response = new Response();
+        $m1 = $this->getMockBuilder(Middleware::class)
+            ->onlyMethods(['afterException', 'beforeController'])
+            ->getMock();
+        $m1->expects($this->never())
+            ->method('afterException');
 
-		$m2 = $this->getMockBuilder(Middleware::class)
-			->onlyMethods(['afterException', 'beforeController'])
-			->getMock();
-		$m2->expects($this->once())
-			->method('afterException')
-			->willReturn($response);
+        $m2 = $this->getMockBuilder(Middleware::class)
+            ->onlyMethods(['afterException', 'beforeController'])
+            ->getMock();
+        $m2->expects($this->once())
+            ->method('afterException')
+            ->willReturn($response);
 
-		$this->dispatcher->registerMiddleware($m1);
-		$this->dispatcher->registerMiddleware($m2);
+        $this->dispatcher->registerMiddleware($m1);
+        $this->dispatcher->registerMiddleware($m2);
 
-		$this->dispatcher->beforeController($this->controller, $this->method);
-		$this->assertEquals($response, $this->dispatcher->afterException($this->controller, $this->method, $this->exception));
-	}
+        $this->dispatcher->beforeController($this->controller, $this->method);
+        $this->assertEquals($response, $this->dispatcher->afterException($this->controller, $this->method, $this->exception));
+    }
 
 
-	public function testAfterExceptionShouldThrowAgainWhenNotHandled(): void {
-		$m1 = new TestMiddleware(false);
-		$m2 = new TestMiddleware(true);
+    public function testAfterExceptionShouldThrowAgainWhenNotHandled(): void {
+        $m1 = new TestMiddleware(false);
+        $m2 = new TestMiddleware(true);
 
-		$this->dispatcher->registerMiddleware($m1);
-		$this->dispatcher->registerMiddleware($m2);
+        $this->dispatcher->registerMiddleware($m1);
+        $this->dispatcher->registerMiddleware($m2);
 
-		$this->expectException(\Exception::class);
-		$this->dispatcher->beforeController($this->controller, $this->method);
-		$this->dispatcher->afterException($this->controller, $this->method, $this->exception);
-	}
+        $this->expectException(\Exception::class);
+        $this->dispatcher->beforeController($this->controller, $this->method);
+        $this->dispatcher->afterException($this->controller, $this->method, $this->exception);
+    }
 
 
-	public function testBeforeControllerCorrectArguments(): void {
-		$m1 = $this->getMiddleware();
-		$this->dispatcher->beforeController($this->controller, $this->method);
+    public function testBeforeControllerCorrectArguments(): void {
+        $m1 = $this->getMiddleware();
+        $this->dispatcher->beforeController($this->controller, $this->method);
 
-		$this->assertEquals($this->controller, $m1->controller);
-		$this->assertEquals($this->method, $m1->methodName);
-	}
+        $this->assertEquals($this->controller, $m1->controller);
+        $this->assertEquals($this->method, $m1->methodName);
+    }
 
 
-	public function testAfterControllerCorrectArguments(): void {
-		$m1 = $this->getMiddleware();
+    public function testAfterControllerCorrectArguments(): void {
+        $m1 = $this->getMiddleware();
 
-		$this->dispatcher->afterController($this->controller, $this->method, $this->response);
+        $this->dispatcher->afterController($this->controller, $this->method, $this->response);
 
-		$this->assertEquals($this->controller, $m1->controller);
-		$this->assertEquals($this->method, $m1->methodName);
-		$this->assertEquals($this->response, $m1->response);
-	}
+        $this->assertEquals($this->controller, $m1->controller);
+        $this->assertEquals($this->method, $m1->methodName);
+        $this->assertEquals($this->response, $m1->response);
+    }
 
 
-	public function testAfterExceptionCorrectArguments(): void {
-		$m1 = $this->getMiddleware();
+    public function testAfterExceptionCorrectArguments(): void {
+        $m1 = $this->getMiddleware();
 
-		$this->expectException(\Exception::class);
+        $this->expectException(\Exception::class);
 
-		$this->dispatcher->beforeController($this->controller, $this->method);
-		$this->dispatcher->afterException($this->controller, $this->method, $this->exception);
+        $this->dispatcher->beforeController($this->controller, $this->method);
+        $this->dispatcher->afterException($this->controller, $this->method, $this->exception);
 
-		$this->assertEquals($this->controller, $m1->controller);
-		$this->assertEquals($this->method, $m1->methodName);
-		$this->assertEquals($this->exception, $m1->exception);
-	}
+        $this->assertEquals($this->controller, $m1->controller);
+        $this->assertEquals($this->method, $m1->methodName);
+        $this->assertEquals($this->exception, $m1->exception);
+    }
 
 
-	public function testBeforeOutputCorrectArguments(): void {
-		$m1 = $this->getMiddleware();
+    public function testBeforeOutputCorrectArguments(): void {
+        $m1 = $this->getMiddleware();
 
-		$this->dispatcher->beforeOutput($this->controller, $this->method, $this->out);
+        $this->dispatcher->beforeOutput($this->controller, $this->method, $this->out);
 
-		$this->assertEquals($this->controller, $m1->controller);
-		$this->assertEquals($this->method, $m1->methodName);
-		$this->assertEquals($this->out, $m1->output);
-	}
+        $this->assertEquals($this->controller, $m1->controller);
+        $this->assertEquals($this->method, $m1->methodName);
+        $this->assertEquals($this->out, $m1->output);
+    }
 
 
-	public function testBeforeControllerOrder(): void {
-		$m1 = $this->getMiddleware();
-		$m2 = $this->getMiddleware();
+    public function testBeforeControllerOrder(): void {
+        $m1 = $this->getMiddleware();
+        $m2 = $this->getMiddleware();
 
-		$this->dispatcher->beforeController($this->controller, $this->method);
+        $this->dispatcher->beforeController($this->controller, $this->method);
 
-		$this->assertEquals(1, $m1->beforeControllerOrder);
-		$this->assertEquals(2, $m2->beforeControllerOrder);
-	}
+        $this->assertEquals(1, $m1->beforeControllerOrder);
+        $this->assertEquals(2, $m2->beforeControllerOrder);
+    }
 
-	public function testAfterControllerOrder(): void {
-		$m1 = $this->getMiddleware();
-		$m2 = $this->getMiddleware();
+    public function testAfterControllerOrder(): void {
+        $m1 = $this->getMiddleware();
+        $m2 = $this->getMiddleware();
 
-		$this->dispatcher->afterController($this->controller, $this->method, $this->response);
+        $this->dispatcher->afterController($this->controller, $this->method, $this->response);
 
-		$this->assertEquals(2, $m1->afterControllerOrder);
-		$this->assertEquals(1, $m2->afterControllerOrder);
-	}
+        $this->assertEquals(2, $m1->afterControllerOrder);
+        $this->assertEquals(1, $m2->afterControllerOrder);
+    }
 
 
-	public function testAfterExceptionOrder(): void {
-		$m1 = $this->getMiddleware();
-		$m2 = $this->getMiddleware();
+    public function testAfterExceptionOrder(): void {
+        $m1 = $this->getMiddleware();
+        $m2 = $this->getMiddleware();
 
-		$this->expectException(\Exception::class);
-		$this->dispatcher->beforeController($this->controller, $this->method);
-		$this->dispatcher->afterException($this->controller, $this->method, $this->exception);
+        $this->expectException(\Exception::class);
+        $this->dispatcher->beforeController($this->controller, $this->method);
+        $this->dispatcher->afterException($this->controller, $this->method, $this->exception);
 
-		$this->assertEquals(1, $m1->afterExceptionOrder);
-		$this->assertEquals(1, $m2->afterExceptionOrder);
-	}
+        $this->assertEquals(1, $m1->afterExceptionOrder);
+        $this->assertEquals(1, $m2->afterExceptionOrder);
+    }
 
 
-	public function testBeforeOutputOrder(): void {
-		$m1 = $this->getMiddleware();
-		$m2 = $this->getMiddleware();
+    public function testBeforeOutputOrder(): void {
+        $m1 = $this->getMiddleware();
+        $m2 = $this->getMiddleware();
 
-		$this->dispatcher->beforeOutput($this->controller, $this->method, $this->out);
+        $this->dispatcher->beforeOutput($this->controller, $this->method, $this->out);
 
-		$this->assertEquals(2, $m1->beforeOutputOrder);
-		$this->assertEquals(1, $m2->beforeOutputOrder);
-	}
+        $this->assertEquals(2, $m1->beforeOutputOrder);
+        $this->assertEquals(1, $m2->beforeOutputOrder);
+    }
 
 
-	public function testExceptionShouldRunAfterExceptionOfOnlyPreviouslyExecutedMiddlewares(): void {
-		$m1 = $this->getMiddleware();
-		$m2 = $this->getMiddleware(true);
-		$m3 = $this->createMock(Middleware::class);
-		$m3->expects($this->never())
-			->method('afterException');
-		$m3->expects($this->never())
-			->method('beforeController');
-		$m3->expects($this->never())
-			->method('afterController');
-		$m3->method('beforeOutput')
-			->willReturnArgument(2);
+    public function testExceptionShouldRunAfterExceptionOfOnlyPreviouslyExecutedMiddlewares(): void {
+        $m1 = $this->getMiddleware();
+        $m2 = $this->getMiddleware(true);
+        $m3 = $this->createMock(Middleware::class);
+        $m3->expects($this->never())
+            ->method('afterException');
+        $m3->expects($this->never())
+            ->method('beforeController');
+        $m3->expects($this->never())
+            ->method('afterController');
+        $m3->method('beforeOutput')
+            ->willReturnArgument(2);
 
-		$this->dispatcher->registerMiddleware($m3);
+        $this->dispatcher->registerMiddleware($m3);
 
-		$this->dispatcher->beforeOutput($this->controller, $this->method, $this->out);
+        $this->dispatcher->beforeOutput($this->controller, $this->method, $this->out);
 
-		$this->assertEquals(2, $m1->beforeOutputOrder);
-		$this->assertEquals(1, $m2->beforeOutputOrder);
-	}
+        $this->assertEquals(2, $m1->beforeOutputOrder);
+        $this->assertEquals(1, $m2->beforeOutputOrder);
+    }
 }

apps/settings/tests/SetupChecks/AppDirsWithDifferentOwnerTest.php

Indentation +74 added lines, -74 removed lines

@@ -14,85 +14,85 @@
 use Test\TestCase;
 
 class AppDirsWithDifferentOwnerTest extends TestCase {
-	private AppDirsWithDifferentOwner $check;
+    private AppDirsWithDifferentOwner $check;
 
-	private IL10N&MockObject $l10n;
+    private IL10N&MockObject $l10n;
 
-	/**
-	 * Holds a list of directories created during tests.
-	 *
-	 * @var array
-	 */
-	private $dirsToRemove = [];
+    /**
+     * Holds a list of directories created during tests.
+     *
+     * @var array
+     */
+    private $dirsToRemove = [];
 
-	protected function setUp(): void {
-		parent::setUp();
+    protected function setUp(): void {
+        parent::setUp();
 
-		$this->l10n = $this->createMock(IL10N::class);
-		$this->l10n->expects($this->any())
-			->method('t')
-			->willReturnCallback(function ($message, array $replace) {
-				return vsprintf($message, $replace);
-			});
-		$this->check = new AppDirsWithDifferentOwner(
-			$this->l10n,
-		);
-	}
+        $this->l10n = $this->createMock(IL10N::class);
+        $this->l10n->expects($this->any())
+            ->method('t')
+            ->willReturnCallback(function ($message, array $replace) {
+                return vsprintf($message, $replace);
+            });
+        $this->check = new AppDirsWithDifferentOwner(
+            $this->l10n,
+        );
+    }
 
-	/**
-	 * Setups a temp directory and some subdirectories.
-	 * Then calls the 'getAppDirsWithDifferentOwner' method.
-	 * The result is expected to be empty since
-	 * there are no directories with different owners than the current user.
-	 */
-	public function testAppDirectoryOwnersOk(): void {
-		$tempDir = tempnam(sys_get_temp_dir(), 'apps') . 'dir';
-		mkdir($tempDir);
-		mkdir($tempDir . DIRECTORY_SEPARATOR . 'app1');
-		mkdir($tempDir . DIRECTORY_SEPARATOR . 'app2');
-		$this->dirsToRemove[] = $tempDir . DIRECTORY_SEPARATOR . 'app1';
-		$this->dirsToRemove[] = $tempDir . DIRECTORY_SEPARATOR . 'app2';
-		$this->dirsToRemove[] = $tempDir;
-		\OC::$APPSROOTS = [
-			[
-				'path' => $tempDir,
-				'url' => '/apps',
-				'writable' => true,
-			],
-		];
-		$this->assertSame(
-			[],
-			$this->invokePrivate($this->check, 'getAppDirsWithDifferentOwner', [posix_getuid()])
-		);
-	}
+    /**
+     * Setups a temp directory and some subdirectories.
+     * Then calls the 'getAppDirsWithDifferentOwner' method.
+     * The result is expected to be empty since
+     * there are no directories with different owners than the current user.
+     */
+    public function testAppDirectoryOwnersOk(): void {
+        $tempDir = tempnam(sys_get_temp_dir(), 'apps') . 'dir';
+        mkdir($tempDir);
+        mkdir($tempDir . DIRECTORY_SEPARATOR . 'app1');
+        mkdir($tempDir . DIRECTORY_SEPARATOR . 'app2');
+        $this->dirsToRemove[] = $tempDir . DIRECTORY_SEPARATOR . 'app1';
+        $this->dirsToRemove[] = $tempDir . DIRECTORY_SEPARATOR . 'app2';
+        $this->dirsToRemove[] = $tempDir;
+        \OC::$APPSROOTS = [
+            [
+                'path' => $tempDir,
+                'url' => '/apps',
+                'writable' => true,
+            ],
+        ];
+        $this->assertSame(
+            [],
+            $this->invokePrivate($this->check, 'getAppDirsWithDifferentOwner', [posix_getuid()])
+        );
+    }
 
-	/**
-	 * Calls the check for a none existing app root that is marked as not writable.
-	 * It's expected that no error happens since the check shouldn't apply.
-	 */
-	public function testAppDirectoryOwnersNotWritable(): void {
-		$tempDir = tempnam(sys_get_temp_dir(), 'apps') . 'dir';
-		\OC::$APPSROOTS = [
-			[
-				'path' => $tempDir,
-				'url' => '/apps',
-				'writable' => false,
-			],
-		];
-		$this->assertSame(
-			[],
-			$this->invokePrivate($this->check, 'getAppDirsWithDifferentOwner', [posix_getuid()])
-		);
-	}
+    /**
+     * Calls the check for a none existing app root that is marked as not writable.
+     * It's expected that no error happens since the check shouldn't apply.
+     */
+    public function testAppDirectoryOwnersNotWritable(): void {
+        $tempDir = tempnam(sys_get_temp_dir(), 'apps') . 'dir';
+        \OC::$APPSROOTS = [
+            [
+                'path' => $tempDir,
+                'url' => '/apps',
+                'writable' => false,
+            ],
+        ];
+        $this->assertSame(
+            [],
+            $this->invokePrivate($this->check, 'getAppDirsWithDifferentOwner', [posix_getuid()])
+        );
+    }
 
-	/**
-	 * Removes directories created during tests.
-	 */
-	#[\PHPUnit\Framework\Attributes\After()]
-	public function removeTestDirectories(): void {
-		foreach ($this->dirsToRemove as $dirToRemove) {
-			rmdir($dirToRemove);
-		}
-		$this->dirsToRemove = [];
-	}
+    /**
+     * Removes directories created during tests.
+     */
+    #[\PHPUnit\Framework\Attributes\After()]
+    public function removeTestDirectories(): void {
+        foreach ($this->dirsToRemove as $dirToRemove) {
+            rmdir($dirToRemove);
+        }
+        $this->dirsToRemove = [];
+    }
 }

Spacing +7 added lines, -7 removed lines

@@ -31,7 +31,7 @@ 
 		$this->l10n = $this->createMock(IL10N::class);
 		$this->l10n->expects($this->any())
 			->method('t')
-			->willReturnCallback(function ($message, array $replace) {
+			->willReturnCallback(function($message, array $replace) {
 				return vsprintf($message, $replace);
 			});
 		$this->check = new AppDirsWithDifferentOwner(
@@ -46,12 +46,12 @@ 
 	 * there are no directories with different owners than the current user.
 	 */
 	public function testAppDirectoryOwnersOk(): void {
-		$tempDir = tempnam(sys_get_temp_dir(), 'apps') . 'dir';
+		$tempDir = tempnam(sys_get_temp_dir(), 'apps').'dir';
 		mkdir($tempDir);
-		mkdir($tempDir . DIRECTORY_SEPARATOR . 'app1');
-		mkdir($tempDir . DIRECTORY_SEPARATOR . 'app2');
-		$this->dirsToRemove[] = $tempDir . DIRECTORY_SEPARATOR . 'app1';
-		$this->dirsToRemove[] = $tempDir . DIRECTORY_SEPARATOR . 'app2';
+		mkdir($tempDir.DIRECTORY_SEPARATOR.'app1');
+		mkdir($tempDir.DIRECTORY_SEPARATOR.'app2');
+		$this->dirsToRemove[] = $tempDir.DIRECTORY_SEPARATOR.'app1';
+		$this->dirsToRemove[] = $tempDir.DIRECTORY_SEPARATOR.'app2';
 		$this->dirsToRemove[] = $tempDir;
 		\OC::$APPSROOTS = [
 			[
@@ -71,7 +71,7 @@ 
 	 * It's expected that no error happens since the check shouldn't apply.
 	 */
 	public function testAppDirectoryOwnersNotWritable(): void {
-		$tempDir = tempnam(sys_get_temp_dir(), 'apps') . 'dir';
+		$tempDir = tempnam(sys_get_temp_dir(), 'apps').'dir';
 		\OC::$APPSROOTS = [
 			[
 				'path' => $tempDir,

apps/dav/tests/unit/Listener/OutOfOfficeListenerTest.php

Indentation +562 added lines, -562 removed lines

@@ -39,566 +39,566 @@
 #[\PHPUnit\Framework\Attributes\CoversClass(OutOfOfficeListener::class)]
 class OutOfOfficeListenerTest extends TestCase {
 
-	private ServerFactory&MockObject $serverFactory;
-	private IConfig&MockObject $appConfig;
-	private LoggerInterface&MockObject $loggerInterface;
-	private TimezoneService&MockObject $timezoneService;
-	private OutOfOfficeListener $listener;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->serverFactory = $this->createMock(ServerFactory::class);
-		$this->appConfig = $this->createMock(IConfig::class);
-		$this->timezoneService = $this->createMock(TimezoneService::class);
-		$this->loggerInterface = $this->createMock(LoggerInterface::class);
-
-		$this->listener = new OutOfOfficeListener(
-			$this->serverFactory,
-			$this->appConfig,
-			$this->timezoneService,
-			$this->loggerInterface,
-		);
-	}
-
-	public function testHandleUnrelated(): void {
-		$event = new Event();
-
-		$this->listener->handle($event);
-
-		$this->addToAssertionCount(1);
-	}
-
-	public function testHandleSchedulingNoCalendarHome(): void {
-		$user = $this->createMock(IUser::class);
-		$user->method('getUID')->willReturn('user123');
-		$data = $this->createMock(IOutOfOfficeData::class);
-		$data->method('getUser')->willReturn($user);
-		$davServer = $this->createMock(Server::class);
-		$invitationServer = $this->createMock(InvitationResponseServer::class);
-		$invitationServer->method('getServer')->willReturn($davServer);
-		$this->serverFactory->method('createInviationResponseServer')->willReturn($invitationServer);
-		$caldavPlugin = $this->createMock(Plugin::class);
-		$davServer->expects(self::once())
-			->method('getPlugin')
-			->with('caldav')
-			->willReturn($caldavPlugin);
-		$event = new OutOfOfficeScheduledEvent($data);
-
-		$this->listener->handle($event);
-	}
-
-	public function testHandleSchedulingNoCalendarHomeNode(): void {
-		$user = $this->createMock(IUser::class);
-		$user->method('getUID')->willReturn('user123');
-		$data = $this->createMock(IOutOfOfficeData::class);
-		$data->method('getUser')->willReturn($user);
-		$davServer = $this->createMock(Server::class);
-		$invitationServer = $this->createMock(InvitationResponseServer::class);
-		$invitationServer->method('getServer')->willReturn($davServer);
-		$this->serverFactory->method('createInviationResponseServer')->willReturn($invitationServer);
-		$caldavPlugin = $this->createMock(Plugin::class);
-		$davServer->expects(self::once())
-			->method('getPlugin')
-			->with('caldav')
-			->willReturn($caldavPlugin);
-		$caldavPlugin->expects(self::once())
-			->method('getCalendarHomeForPrincipal')
-			->willReturn('/home/calendar');
-		$tree = $this->createMock(Tree::class);
-		$davServer->tree = $tree;
-		$tree->expects(self::once())
-			->method('getNodeForPath')
-			->with('/home/calendar')
-			->willThrowException(new NotFound('nope'));
-		$event = new OutOfOfficeScheduledEvent($data);
-
-		$this->listener->handle($event);
-	}
-
-	public function testHandleSchedulingPersonalCalendarNotFound(): void {
-		$user = $this->createMock(IUser::class);
-		$user->method('getUID')->willReturn('user123');
-		$data = $this->createMock(IOutOfOfficeData::class);
-		$data->method('getUser')->willReturn($user);
-		$davServer = $this->createMock(Server::class);
-		$invitationServer = $this->createMock(InvitationResponseServer::class);
-		$invitationServer->method('getServer')->willReturn($davServer);
-		$this->serverFactory->method('createInviationResponseServer')->willReturn($invitationServer);
-		$caldavPlugin = $this->createMock(Plugin::class);
-		$davServer->expects(self::once())
-			->method('getPlugin')
-			->with('caldav')
-			->willReturn($caldavPlugin);
-		$caldavPlugin->expects(self::once())
-			->method('getCalendarHomeForPrincipal')
-			->willReturn('/home/calendar');
-		$tree = $this->createMock(Tree::class);
-		$davServer->tree = $tree;
-		$calendarHome = $this->createMock(CalendarHome::class);
-		$tree->expects(self::once())
-			->method('getNodeForPath')
-			->with('/home/calendar')
-			->willReturn($calendarHome);
-		$this->appConfig->expects(self::once())
-			->method('getUserValue')
-			->with('user123', 'dav', 'defaultCalendar', 'personal')
-			->willReturn('personal-1');
-		$calendarHome->expects(self::once())
-			->method('getChild')
-			->with('personal-1')
-			->willThrowException(new NotFound('nope'));
-		$event = new OutOfOfficeScheduledEvent($data);
-
-		$this->listener->handle($event);
-	}
-
-	public function testHandleSchedulingWithDefaultTimezone(): void {
-		$user = $this->createMock(IUser::class);
-		$user->method('getUID')->willReturn('user123');
-		$data = $this->createMock(IOutOfOfficeData::class);
-		$data->method('getUser')->willReturn($user);
-		$data->method('getStartDate')
-			->willReturn((new DateTimeImmutable('2023-12-12T00:00:00Z'))->getTimestamp());
-		$data->method('getEndDate')
-			->willReturn((new DateTimeImmutable('2023-12-13T00:00:00Z'))->getTimestamp());
-		$davServer = $this->createMock(Server::class);
-		$invitationServer = $this->createMock(InvitationResponseServer::class);
-		$invitationServer->method('getServer')->willReturn($davServer);
-		$this->serverFactory->method('createInviationResponseServer')->willReturn($invitationServer);
-		$caldavPlugin = $this->createMock(Plugin::class);
-		$davServer->expects(self::once())
-			->method('getPlugin')
-			->with('caldav')
-			->willReturn($caldavPlugin);
-		$caldavPlugin->expects(self::once())
-			->method('getCalendarHomeForPrincipal')
-			->willReturn('/home/calendar');
-		$tree = $this->createMock(Tree::class);
-		$davServer->tree = $tree;
-		$calendarHome = $this->createMock(CalendarHome::class);
-		$tree->expects(self::once())
-			->method('getNodeForPath')
-			->with('/home/calendar')
-			->willReturn($calendarHome);
-		$this->appConfig->expects(self::once())
-			->method('getUserValue')
-			->with('user123', 'dav', 'defaultCalendar', 'personal')
-			->willReturn('personal-1');
-		$calendar = $this->createMock(Calendar::class);
-		$this->timezoneService->expects(self::once())
-			->method('getUserTimezone')
-			->with('user123')
-			->willReturn('Europe/Prague');
-		$calendarHome->expects(self::once())
-			->method('getChild')
-			->with('personal-1')
-			->willReturn($calendar);
-		$calendar->expects(self::once())
-			->method('createFile')
-			->willReturnCallback(function ($name, $data): void {
-				$vcalendar = Reader::read($data);
-				if (!($vcalendar instanceof VCalendar)) {
-					throw new InvalidArgumentException('Calendar data should be a VCALENDAR');
-				}
-				$vevent = $vcalendar->VEVENT;
-				if ($vevent === null || !($vevent instanceof VEvent)) {
-					throw new InvalidArgumentException('Calendar data should contain a VEVENT');
-				}
-				self::assertSame('Europe/Prague', $vevent->DTSTART['TZID']?->getValue());
-				self::assertSame('Europe/Prague', $vevent->DTEND['TZID']?->getValue());
-			});
-		$event = new OutOfOfficeScheduledEvent($data);
-
-		$this->listener->handle($event);
-	}
-
-	public function testHandleChangeNoCalendarHome(): void {
-		$user = $this->createMock(IUser::class);
-		$user->method('getUID')->willReturn('user123');
-		$data = $this->createMock(IOutOfOfficeData::class);
-		$data->method('getUser')->willReturn($user);
-		$davServer = $this->createMock(Server::class);
-		$invitationServer = $this->createMock(InvitationResponseServer::class);
-		$invitationServer->method('getServer')->willReturn($davServer);
-		$this->serverFactory->method('createInviationResponseServer')->willReturn($invitationServer);
-		$caldavPlugin = $this->createMock(Plugin::class);
-		$davServer->expects(self::once())
-			->method('getPlugin')
-			->with('caldav')
-			->willReturn($caldavPlugin);
-		$event = new OutOfOfficeChangedEvent($data);
-
-		$this->listener->handle($event);
-	}
-
-	public function testHandleChangeNoCalendarHomeNode(): void {
-		$user = $this->createMock(IUser::class);
-		$user->method('getUID')->willReturn('user123');
-		$data = $this->createMock(IOutOfOfficeData::class);
-		$data->method('getUser')->willReturn($user);
-		$davServer = $this->createMock(Server::class);
-		$invitationServer = $this->createMock(InvitationResponseServer::class);
-		$invitationServer->method('getServer')->willReturn($davServer);
-		$this->serverFactory->method('createInviationResponseServer')->willReturn($invitationServer);
-		$caldavPlugin = $this->createMock(Plugin::class);
-		$davServer->expects(self::once())
-			->method('getPlugin')
-			->with('caldav')
-			->willReturn($caldavPlugin);
-		$caldavPlugin->expects(self::once())
-			->method('getCalendarHomeForPrincipal')
-			->willReturn('/home/calendar');
-		$tree = $this->createMock(Tree::class);
-		$davServer->tree = $tree;
-		$tree->expects(self::once())
-			->method('getNodeForPath')
-			->with('/home/calendar')
-			->willThrowException(new NotFound('nope'));
-		$event = new OutOfOfficeChangedEvent($data);
-
-		$this->listener->handle($event);
-	}
-
-	public function testHandleChangePersonalCalendarNotFound(): void {
-		$user = $this->createMock(IUser::class);
-		$user->method('getUID')->willReturn('user123');
-		$data = $this->createMock(IOutOfOfficeData::class);
-		$data->method('getUser')->willReturn($user);
-		$davServer = $this->createMock(Server::class);
-		$invitationServer = $this->createMock(InvitationResponseServer::class);
-		$invitationServer->method('getServer')->willReturn($davServer);
-		$this->serverFactory->method('createInviationResponseServer')->willReturn($invitationServer);
-		$caldavPlugin = $this->createMock(Plugin::class);
-		$davServer->expects(self::once())
-			->method('getPlugin')
-			->with('caldav')
-			->willReturn($caldavPlugin);
-		$caldavPlugin->expects(self::once())
-			->method('getCalendarHomeForPrincipal')
-			->willReturn('/home/calendar');
-		$tree = $this->createMock(Tree::class);
-		$davServer->tree = $tree;
-		$calendarHome = $this->createMock(CalendarHome::class);
-		$tree->expects(self::once())
-			->method('getNodeForPath')
-			->with('/home/calendar')
-			->willReturn($calendarHome);
-		$this->appConfig->expects(self::once())
-			->method('getUserValue')
-			->with('user123', 'dav', 'defaultCalendar', 'personal')
-			->willReturn('personal-1');
-		$calendarHome->expects(self::once())
-			->method('getChild')
-			->with('personal-1')
-			->willThrowException(new NotFound('nope'));
-		$event = new OutOfOfficeChangedEvent($data);
-
-		$this->listener->handle($event);
-	}
-
-	public function testHandleChangeRecreate(): void {
-		$user = $this->createMock(IUser::class);
-		$user->method('getUID')->willReturn('user123');
-		$data = $this->createMock(IOutOfOfficeData::class);
-		$data->method('getUser')->willReturn($user);
-		$data->method('getStartDate')
-			->willReturn((new DateTimeImmutable('2023-12-12T00:00:00Z'))->getTimestamp());
-		$data->method('getEndDate')
-			->willReturn((new DateTimeImmutable('2023-12-14T00:00:00Z'))->getTimestamp());
-		$davServer = $this->createMock(Server::class);
-		$invitationServer = $this->createMock(InvitationResponseServer::class);
-		$invitationServer->method('getServer')->willReturn($davServer);
-		$this->serverFactory->method('createInviationResponseServer')->willReturn($invitationServer);
-		$caldavPlugin = $this->createMock(Plugin::class);
-		$davServer->expects(self::once())
-			->method('getPlugin')
-			->with('caldav')
-			->willReturn($caldavPlugin);
-		$caldavPlugin->expects(self::once())
-			->method('getCalendarHomeForPrincipal')
-			->willReturn('/home/calendar');
-		$tree = $this->createMock(Tree::class);
-		$davServer->tree = $tree;
-		$calendarHome = $this->createMock(CalendarHome::class);
-		$tree->expects(self::once())
-			->method('getNodeForPath')
-			->with('/home/calendar')
-			->willReturn($calendarHome);
-		$this->appConfig->expects(self::once())
-			->method('getUserValue')
-			->with('user123', 'dav', 'defaultCalendar', 'personal')
-			->willReturn('personal-1');
-		$calendar = $this->createMock(Calendar::class);
-		$this->timezoneService->expects(self::once())
-			->method('getUserTimezone')
-			->with('user123')
-			->willReturn(null);
-		$this->timezoneService->expects(self::once())
-			->method('getDefaultTimezone')
-			->willReturn('Europe/Berlin');
-		$calendarHome->expects(self::once())
-			->method('getChild')
-			->with('personal-1')
-			->willReturn($calendar);
-		$calendar->expects(self::once())
-			->method('getChild')
-			->willThrowException(new NotFound());
-		$calendar->expects(self::once())
-			->method('createFile')
-			->willReturnCallback(function ($name, $data): void {
-				$vcalendar = Reader::read($data);
-				if (!($vcalendar instanceof VCalendar)) {
-					throw new InvalidArgumentException('Calendar data should be a VCALENDAR');
-				}
-				$vevent = $vcalendar->VEVENT;
-				if ($vevent === null || !($vevent instanceof VEvent)) {
-					throw new InvalidArgumentException('Calendar data should contain a VEVENT');
-				}
-				self::assertSame('Europe/Berlin', $vevent->DTSTART['TZID']?->getValue());
-				self::assertSame('Europe/Berlin', $vevent->DTEND['TZID']?->getValue());
-			});
-		$event = new OutOfOfficeChangedEvent($data);
-
-		$this->listener->handle($event);
-	}
-
-	public function testHandleChangeWithoutTimezone(): void {
-		$user = $this->createMock(IUser::class);
-		$user->method('getUID')->willReturn('user123');
-		$data = $this->createMock(IOutOfOfficeData::class);
-		$data->method('getUser')->willReturn($user);
-		$data->method('getStartDate')
-			->willReturn((new DateTimeImmutable('2023-01-12T00:00:00Z'))->getTimestamp());
-		$data->method('getEndDate')
-			->willReturn((new DateTimeImmutable('2023-12-14T00:00:00Z'))->getTimestamp());
-		$davServer = $this->createMock(Server::class);
-		$invitationServer = $this->createMock(InvitationResponseServer::class);
-		$invitationServer->method('getServer')->willReturn($davServer);
-		$this->serverFactory->method('createInviationResponseServer')->willReturn($invitationServer);
-		$caldavPlugin = $this->createMock(Plugin::class);
-		$davServer->expects(self::once())
-			->method('getPlugin')
-			->with('caldav')
-			->willReturn($caldavPlugin);
-		$caldavPlugin->expects(self::once())
-			->method('getCalendarHomeForPrincipal')
-			->willReturn('/home/calendar');
-		$tree = $this->createMock(Tree::class);
-		$davServer->tree = $tree;
-		$calendarHome = $this->createMock(CalendarHome::class);
-		$tree->expects(self::once())
-			->method('getNodeForPath')
-			->with('/home/calendar')
-			->willReturn($calendarHome);
-		$this->appConfig->expects(self::once())
-			->method('getUserValue')
-			->with('user123', 'dav', 'defaultCalendar', 'personal')
-			->willReturn('personal-1');
-		$calendar = $this->createMock(Calendar::class);
-		$calendarHome->expects(self::once())
-			->method('getChild')
-			->with('personal-1')
-			->willReturn($calendar);
-		$eventNode = $this->createMock(CalendarObject::class);
-		$this->timezoneService->expects(self::once())
-			->method('getUserTimezone')
-			->with('user123')
-			->willReturn(null);
-		$this->timezoneService->expects(self::once())
-			->method('getDefaultTimezone')
-			->willReturn('UTC');
-		$calendar->expects(self::once())
-			->method('getChild')
-			->willReturn($eventNode);
-		$eventNode->expects(self::once())
-			->method('put')
-			->willReturnCallback(function ($data): void {
-				$vcalendar = Reader::read($data);
-				if (!($vcalendar instanceof VCalendar)) {
-					throw new InvalidArgumentException('Calendar data should be a VCALENDAR');
-				}
-				$vevent = $vcalendar->VEVENT;
-				if ($vevent === null || !($vevent instanceof VEvent)) {
-					throw new InvalidArgumentException('Calendar data should contain a VEVENT');
-				}
-				// UTC datetimes are stored without a TZID
-				self::assertSame(null, $vevent->DTSTART['TZID']?->getValue());
-				self::assertSame(null, $vevent->DTEND['TZID']?->getValue());
-			});
-		$calendar->expects(self::never())
-			->method('createFile');
-		$event = new OutOfOfficeChangedEvent($data);
-
-		$this->listener->handle($event);
-	}
-
-	public function testHandleClearNoCalendarHome(): void {
-		$user = $this->createMock(IUser::class);
-		$user->method('getUID')->willReturn('user123');
-		$data = $this->createMock(IOutOfOfficeData::class);
-		$data->method('getUser')->willReturn($user);
-		$davServer = $this->createMock(Server::class);
-		$invitationServer = $this->createMock(InvitationResponseServer::class);
-		$invitationServer->method('getServer')->willReturn($davServer);
-		$this->serverFactory->method('createInviationResponseServer')->willReturn($invitationServer);
-		$caldavPlugin = $this->createMock(Plugin::class);
-		$davServer->expects(self::once())
-			->method('getPlugin')
-			->with('caldav')
-			->willReturn($caldavPlugin);
-		$event = new OutOfOfficeClearedEvent($data);
-
-		$this->listener->handle($event);
-	}
-
-	public function testHandleClearNoCalendarHomeNode(): void {
-		$user = $this->createMock(IUser::class);
-		$user->method('getUID')->willReturn('user123');
-		$data = $this->createMock(IOutOfOfficeData::class);
-		$data->method('getUser')->willReturn($user);
-		$davServer = $this->createMock(Server::class);
-		$invitationServer = $this->createMock(InvitationResponseServer::class);
-		$invitationServer->method('getServer')->willReturn($davServer);
-		$this->serverFactory->method('createInviationResponseServer')->willReturn($invitationServer);
-		$caldavPlugin = $this->createMock(Plugin::class);
-		$davServer->expects(self::once())
-			->method('getPlugin')
-			->with('caldav')
-			->willReturn($caldavPlugin);
-		$caldavPlugin->expects(self::once())
-			->method('getCalendarHomeForPrincipal')
-			->willReturn('/home/calendar');
-		$tree = $this->createMock(Tree::class);
-		$davServer->tree = $tree;
-		$tree->expects(self::once())
-			->method('getNodeForPath')
-			->with('/home/calendar')
-			->willThrowException(new NotFound('nope'));
-		$event = new OutOfOfficeClearedEvent($data);
-
-		$this->listener->handle($event);
-	}
-
-	public function testHandleClearPersonalCalendarNotFound(): void {
-		$user = $this->createMock(IUser::class);
-		$user->method('getUID')->willReturn('user123');
-		$data = $this->createMock(IOutOfOfficeData::class);
-		$data->method('getUser')->willReturn($user);
-		$davServer = $this->createMock(Server::class);
-		$invitationServer = $this->createMock(InvitationResponseServer::class);
-		$invitationServer->method('getServer')->willReturn($davServer);
-		$this->serverFactory->method('createInviationResponseServer')->willReturn($invitationServer);
-		$caldavPlugin = $this->createMock(Plugin::class);
-		$davServer->expects(self::once())
-			->method('getPlugin')
-			->with('caldav')
-			->willReturn($caldavPlugin);
-		$caldavPlugin->expects(self::once())
-			->method('getCalendarHomeForPrincipal')
-			->willReturn('/home/calendar');
-		$tree = $this->createMock(Tree::class);
-		$davServer->tree = $tree;
-		$calendarHome = $this->createMock(CalendarHome::class);
-		$tree->expects(self::once())
-			->method('getNodeForPath')
-			->with('/home/calendar')
-			->willReturn($calendarHome);
-		$this->appConfig->expects(self::once())
-			->method('getUserValue')
-			->with('user123', 'dav', 'defaultCalendar', 'personal')
-			->willReturn('personal-1');
-		$calendarHome->expects(self::once())
-			->method('getChild')
-			->with('personal-1')
-			->willThrowException(new NotFound('nope'));
-		$event = new OutOfOfficeClearedEvent($data);
-
-		$this->listener->handle($event);
-	}
-
-	public function testHandleClearRecreate(): void {
-		$user = $this->createMock(IUser::class);
-		$user->method('getUID')->willReturn('user123');
-		$data = $this->createMock(IOutOfOfficeData::class);
-		$data->method('getUser')->willReturn($user);
-		$davServer = $this->createMock(Server::class);
-		$invitationServer = $this->createMock(InvitationResponseServer::class);
-		$invitationServer->method('getServer')->willReturn($davServer);
-		$this->serverFactory->method('createInviationResponseServer')->willReturn($invitationServer);
-		$caldavPlugin = $this->createMock(Plugin::class);
-		$davServer->expects(self::once())
-			->method('getPlugin')
-			->with('caldav')
-			->willReturn($caldavPlugin);
-		$caldavPlugin->expects(self::once())
-			->method('getCalendarHomeForPrincipal')
-			->willReturn('/home/calendar');
-		$tree = $this->createMock(Tree::class);
-		$davServer->tree = $tree;
-		$calendarHome = $this->createMock(CalendarHome::class);
-		$tree->expects(self::once())
-			->method('getNodeForPath')
-			->with('/home/calendar')
-			->willReturn($calendarHome);
-		$this->appConfig->expects(self::once())
-			->method('getUserValue')
-			->with('user123', 'dav', 'defaultCalendar', 'personal')
-			->willReturn('personal-1');
-		$calendar = $this->createMock(Calendar::class);
-		$calendarHome->expects(self::once())
-			->method('getChild')
-			->with('personal-1')
-			->willReturn($calendar);
-		$calendar->expects(self::once())
-			->method('getChild')
-			->willThrowException(new NotFound());
-		$event = new OutOfOfficeClearedEvent($data);
-
-		$this->listener->handle($event);
-	}
-
-	public function testHandleClear(): void {
-		$user = $this->createMock(IUser::class);
-		$user->method('getUID')->willReturn('user123');
-		$data = $this->createMock(IOutOfOfficeData::class);
-		$data->method('getUser')->willReturn($user);
-		$davServer = $this->createMock(Server::class);
-		$invitationServer = $this->createMock(InvitationResponseServer::class);
-		$invitationServer->method('getServer')->willReturn($davServer);
-		$this->serverFactory->method('createInviationResponseServer')->willReturn($invitationServer);
-		$caldavPlugin = $this->createMock(Plugin::class);
-		$davServer->expects(self::once())
-			->method('getPlugin')
-			->with('caldav')
-			->willReturn($caldavPlugin);
-		$caldavPlugin->expects(self::once())
-			->method('getCalendarHomeForPrincipal')
-			->willReturn('/home/calendar');
-		$tree = $this->createMock(Tree::class);
-		$davServer->tree = $tree;
-		$calendarHome = $this->createMock(CalendarHome::class);
-		$tree->expects(self::once())
-			->method('getNodeForPath')
-			->with('/home/calendar')
-			->willReturn($calendarHome);
-		$this->appConfig->expects(self::once())
-			->method('getUserValue')
-			->with('user123', 'dav', 'defaultCalendar', 'personal')
-			->willReturn('personal-1');
-		$calendar = $this->createMock(Calendar::class);
-		$calendarHome->expects(self::once())
-			->method('getChild')
-			->with('personal-1')
-			->willReturn($calendar);
-		$eventNode = $this->createMock(CalendarObject::class);
-		$calendar->expects(self::once())
-			->method('getChild')
-			->willReturn($eventNode);
-		$eventNode->expects(self::once())
-			->method('delete');
-		$event = new OutOfOfficeClearedEvent($data);
-
-		$this->listener->handle($event);
-	}
+    private ServerFactory&MockObject $serverFactory;
+    private IConfig&MockObject $appConfig;
+    private LoggerInterface&MockObject $loggerInterface;
+    private TimezoneService&MockObject $timezoneService;
+    private OutOfOfficeListener $listener;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->serverFactory = $this->createMock(ServerFactory::class);
+        $this->appConfig = $this->createMock(IConfig::class);
+        $this->timezoneService = $this->createMock(TimezoneService::class);
+        $this->loggerInterface = $this->createMock(LoggerInterface::class);
+
+        $this->listener = new OutOfOfficeListener(
+            $this->serverFactory,
+            $this->appConfig,
+            $this->timezoneService,
+            $this->loggerInterface,
+        );
+    }
+
+    public function testHandleUnrelated(): void {
+        $event = new Event();
+
+        $this->listener->handle($event);
+
+        $this->addToAssertionCount(1);
+    }
+
+    public function testHandleSchedulingNoCalendarHome(): void {
+        $user = $this->createMock(IUser::class);
+        $user->method('getUID')->willReturn('user123');
+        $data = $this->createMock(IOutOfOfficeData::class);
+        $data->method('getUser')->willReturn($user);
+        $davServer = $this->createMock(Server::class);
+        $invitationServer = $this->createMock(InvitationResponseServer::class);
+        $invitationServer->method('getServer')->willReturn($davServer);
+        $this->serverFactory->method('createInviationResponseServer')->willReturn($invitationServer);
+        $caldavPlugin = $this->createMock(Plugin::class);
+        $davServer->expects(self::once())
+            ->method('getPlugin')
+            ->with('caldav')
+            ->willReturn($caldavPlugin);
+        $event = new OutOfOfficeScheduledEvent($data);
+
+        $this->listener->handle($event);
+    }
+
+    public function testHandleSchedulingNoCalendarHomeNode(): void {
+        $user = $this->createMock(IUser::class);
+        $user->method('getUID')->willReturn('user123');
+        $data = $this->createMock(IOutOfOfficeData::class);
+        $data->method('getUser')->willReturn($user);
+        $davServer = $this->createMock(Server::class);
+        $invitationServer = $this->createMock(InvitationResponseServer::class);
+        $invitationServer->method('getServer')->willReturn($davServer);
+        $this->serverFactory->method('createInviationResponseServer')->willReturn($invitationServer);
+        $caldavPlugin = $this->createMock(Plugin::class);
+        $davServer->expects(self::once())
+            ->method('getPlugin')
+            ->with('caldav')
+            ->willReturn($caldavPlugin);
+        $caldavPlugin->expects(self::once())
+            ->method('getCalendarHomeForPrincipal')
+            ->willReturn('/home/calendar');
+        $tree = $this->createMock(Tree::class);
+        $davServer->tree = $tree;
+        $tree->expects(self::once())
+            ->method('getNodeForPath')
+            ->with('/home/calendar')
+            ->willThrowException(new NotFound('nope'));
+        $event = new OutOfOfficeScheduledEvent($data);
+
+        $this->listener->handle($event);
+    }
+
+    public function testHandleSchedulingPersonalCalendarNotFound(): void {
+        $user = $this->createMock(IUser::class);
+        $user->method('getUID')->willReturn('user123');
+        $data = $this->createMock(IOutOfOfficeData::class);
+        $data->method('getUser')->willReturn($user);
+        $davServer = $this->createMock(Server::class);
+        $invitationServer = $this->createMock(InvitationResponseServer::class);
+        $invitationServer->method('getServer')->willReturn($davServer);
+        $this->serverFactory->method('createInviationResponseServer')->willReturn($invitationServer);
+        $caldavPlugin = $this->createMock(Plugin::class);
+        $davServer->expects(self::once())
+            ->method('getPlugin')
+            ->with('caldav')
+            ->willReturn($caldavPlugin);
+        $caldavPlugin->expects(self::once())
+            ->method('getCalendarHomeForPrincipal')
+            ->willReturn('/home/calendar');
+        $tree = $this->createMock(Tree::class);
+        $davServer->tree = $tree;
+        $calendarHome = $this->createMock(CalendarHome::class);
+        $tree->expects(self::once())
+            ->method('getNodeForPath')
+            ->with('/home/calendar')
+            ->willReturn($calendarHome);
+        $this->appConfig->expects(self::once())
+            ->method('getUserValue')
+            ->with('user123', 'dav', 'defaultCalendar', 'personal')
+            ->willReturn('personal-1');
+        $calendarHome->expects(self::once())
+            ->method('getChild')
+            ->with('personal-1')
+            ->willThrowException(new NotFound('nope'));
+        $event = new OutOfOfficeScheduledEvent($data);
+
+        $this->listener->handle($event);
+    }
+
+    public function testHandleSchedulingWithDefaultTimezone(): void {
+        $user = $this->createMock(IUser::class);
+        $user->method('getUID')->willReturn('user123');
+        $data = $this->createMock(IOutOfOfficeData::class);
+        $data->method('getUser')->willReturn($user);
+        $data->method('getStartDate')
+            ->willReturn((new DateTimeImmutable('2023-12-12T00:00:00Z'))->getTimestamp());
+        $data->method('getEndDate')
+            ->willReturn((new DateTimeImmutable('2023-12-13T00:00:00Z'))->getTimestamp());
+        $davServer = $this->createMock(Server::class);
+        $invitationServer = $this->createMock(InvitationResponseServer::class);
+        $invitationServer->method('getServer')->willReturn($davServer);
+        $this->serverFactory->method('createInviationResponseServer')->willReturn($invitationServer);
+        $caldavPlugin = $this->createMock(Plugin::class);
+        $davServer->expects(self::once())
+            ->method('getPlugin')
+            ->with('caldav')
+            ->willReturn($caldavPlugin);
+        $caldavPlugin->expects(self::once())
+            ->method('getCalendarHomeForPrincipal')
+            ->willReturn('/home/calendar');
+        $tree = $this->createMock(Tree::class);
+        $davServer->tree = $tree;
+        $calendarHome = $this->createMock(CalendarHome::class);
+        $tree->expects(self::once())
+            ->method('getNodeForPath')
+            ->with('/home/calendar')
+            ->willReturn($calendarHome);
+        $this->appConfig->expects(self::once())
+            ->method('getUserValue')
+            ->with('user123', 'dav', 'defaultCalendar', 'personal')
+            ->willReturn('personal-1');
+        $calendar = $this->createMock(Calendar::class);
+        $this->timezoneService->expects(self::once())
+            ->method('getUserTimezone')
+            ->with('user123')
+            ->willReturn('Europe/Prague');
+        $calendarHome->expects(self::once())
+            ->method('getChild')
+            ->with('personal-1')
+            ->willReturn($calendar);
+        $calendar->expects(self::once())
+            ->method('createFile')
+            ->willReturnCallback(function ($name, $data): void {
+                $vcalendar = Reader::read($data);
+                if (!($vcalendar instanceof VCalendar)) {
+                    throw new InvalidArgumentException('Calendar data should be a VCALENDAR');
+                }
+                $vevent = $vcalendar->VEVENT;
+                if ($vevent === null || !($vevent instanceof VEvent)) {
+                    throw new InvalidArgumentException('Calendar data should contain a VEVENT');
+                }
+                self::assertSame('Europe/Prague', $vevent->DTSTART['TZID']?->getValue());
+                self::assertSame('Europe/Prague', $vevent->DTEND['TZID']?->getValue());
+            });
+        $event = new OutOfOfficeScheduledEvent($data);
+
+        $this->listener->handle($event);
+    }
+
+    public function testHandleChangeNoCalendarHome(): void {
+        $user = $this->createMock(IUser::class);
+        $user->method('getUID')->willReturn('user123');
+        $data = $this->createMock(IOutOfOfficeData::class);
+        $data->method('getUser')->willReturn($user);
+        $davServer = $this->createMock(Server::class);
+        $invitationServer = $this->createMock(InvitationResponseServer::class);
+        $invitationServer->method('getServer')->willReturn($davServer);
+        $this->serverFactory->method('createInviationResponseServer')->willReturn($invitationServer);
+        $caldavPlugin = $this->createMock(Plugin::class);
+        $davServer->expects(self::once())
+            ->method('getPlugin')
+            ->with('caldav')
+            ->willReturn($caldavPlugin);
+        $event = new OutOfOfficeChangedEvent($data);
+
+        $this->listener->handle($event);
+    }
+
+    public function testHandleChangeNoCalendarHomeNode(): void {
+        $user = $this->createMock(IUser::class);
+        $user->method('getUID')->willReturn('user123');
+        $data = $this->createMock(IOutOfOfficeData::class);
+        $data->method('getUser')->willReturn($user);
+        $davServer = $this->createMock(Server::class);
+        $invitationServer = $this->createMock(InvitationResponseServer::class);
+        $invitationServer->method('getServer')->willReturn($davServer);
+        $this->serverFactory->method('createInviationResponseServer')->willReturn($invitationServer);
+        $caldavPlugin = $this->createMock(Plugin::class);
+        $davServer->expects(self::once())
+            ->method('getPlugin')
+            ->with('caldav')
+            ->willReturn($caldavPlugin);
+        $caldavPlugin->expects(self::once())
+            ->method('getCalendarHomeForPrincipal')
+            ->willReturn('/home/calendar');
+        $tree = $this->createMock(Tree::class);
+        $davServer->tree = $tree;
+        $tree->expects(self::once())
+            ->method('getNodeForPath')
+            ->with('/home/calendar')
+            ->willThrowException(new NotFound('nope'));
+        $event = new OutOfOfficeChangedEvent($data);
+
+        $this->listener->handle($event);
+    }
+
+    public function testHandleChangePersonalCalendarNotFound(): void {
+        $user = $this->createMock(IUser::class);
+        $user->method('getUID')->willReturn('user123');
+        $data = $this->createMock(IOutOfOfficeData::class);
+        $data->method('getUser')->willReturn($user);
+        $davServer = $this->createMock(Server::class);
+        $invitationServer = $this->createMock(InvitationResponseServer::class);
+        $invitationServer->method('getServer')->willReturn($davServer);
+        $this->serverFactory->method('createInviationResponseServer')->willReturn($invitationServer);
+        $caldavPlugin = $this->createMock(Plugin::class);
+        $davServer->expects(self::once())
+            ->method('getPlugin')
+            ->with('caldav')
+            ->willReturn($caldavPlugin);
+        $caldavPlugin->expects(self::once())
+            ->method('getCalendarHomeForPrincipal')
+            ->willReturn('/home/calendar');
+        $tree = $this->createMock(Tree::class);
+        $davServer->tree = $tree;
+        $calendarHome = $this->createMock(CalendarHome::class);
+        $tree->expects(self::once())
+            ->method('getNodeForPath')
+            ->with('/home/calendar')
+            ->willReturn($calendarHome);
+        $this->appConfig->expects(self::once())
+            ->method('getUserValue')
+            ->with('user123', 'dav', 'defaultCalendar', 'personal')
+            ->willReturn('personal-1');
+        $calendarHome->expects(self::once())
+            ->method('getChild')
+            ->with('personal-1')
+            ->willThrowException(new NotFound('nope'));
+        $event = new OutOfOfficeChangedEvent($data);
+
+        $this->listener->handle($event);
+    }
+
+    public function testHandleChangeRecreate(): void {
+        $user = $this->createMock(IUser::class);
+        $user->method('getUID')->willReturn('user123');
+        $data = $this->createMock(IOutOfOfficeData::class);
+        $data->method('getUser')->willReturn($user);
+        $data->method('getStartDate')
+            ->willReturn((new DateTimeImmutable('2023-12-12T00:00:00Z'))->getTimestamp());
+        $data->method('getEndDate')
+            ->willReturn((new DateTimeImmutable('2023-12-14T00:00:00Z'))->getTimestamp());
+        $davServer = $this->createMock(Server::class);
+        $invitationServer = $this->createMock(InvitationResponseServer::class);
+        $invitationServer->method('getServer')->willReturn($davServer);
+        $this->serverFactory->method('createInviationResponseServer')->willReturn($invitationServer);
+        $caldavPlugin = $this->createMock(Plugin::class);
+        $davServer->expects(self::once())
+            ->method('getPlugin')
+            ->with('caldav')
+            ->willReturn($caldavPlugin);
+        $caldavPlugin->expects(self::once())
+            ->method('getCalendarHomeForPrincipal')
+            ->willReturn('/home/calendar');
+        $tree = $this->createMock(Tree::class);
+        $davServer->tree = $tree;
+        $calendarHome = $this->createMock(CalendarHome::class);
+        $tree->expects(self::once())
+            ->method('getNodeForPath')
+            ->with('/home/calendar')
+            ->willReturn($calendarHome);
+        $this->appConfig->expects(self::once())
+            ->method('getUserValue')
+            ->with('user123', 'dav', 'defaultCalendar', 'personal')
+            ->willReturn('personal-1');
+        $calendar = $this->createMock(Calendar::class);
+        $this->timezoneService->expects(self::once())
+            ->method('getUserTimezone')
+            ->with('user123')
+            ->willReturn(null);
+        $this->timezoneService->expects(self::once())
+            ->method('getDefaultTimezone')
+            ->willReturn('Europe/Berlin');
+        $calendarHome->expects(self::once())
+            ->method('getChild')
+            ->with('personal-1')
+            ->willReturn($calendar);
+        $calendar->expects(self::once())
+            ->method('getChild')
+            ->willThrowException(new NotFound());
+        $calendar->expects(self::once())
+            ->method('createFile')
+            ->willReturnCallback(function ($name, $data): void {
+                $vcalendar = Reader::read($data);
+                if (!($vcalendar instanceof VCalendar)) {
+                    throw new InvalidArgumentException('Calendar data should be a VCALENDAR');
+                }
+                $vevent = $vcalendar->VEVENT;
+                if ($vevent === null || !($vevent instanceof VEvent)) {
+                    throw new InvalidArgumentException('Calendar data should contain a VEVENT');
+                }
+                self::assertSame('Europe/Berlin', $vevent->DTSTART['TZID']?->getValue());
+                self::assertSame('Europe/Berlin', $vevent->DTEND['TZID']?->getValue());
+            });
+        $event = new OutOfOfficeChangedEvent($data);
+
+        $this->listener->handle($event);
+    }
+
+    public function testHandleChangeWithoutTimezone(): void {
+        $user = $this->createMock(IUser::class);
+        $user->method('getUID')->willReturn('user123');
+        $data = $this->createMock(IOutOfOfficeData::class);
+        $data->method('getUser')->willReturn($user);
+        $data->method('getStartDate')
+            ->willReturn((new DateTimeImmutable('2023-01-12T00:00:00Z'))->getTimestamp());
+        $data->method('getEndDate')
+            ->willReturn((new DateTimeImmutable('2023-12-14T00:00:00Z'))->getTimestamp());
+        $davServer = $this->createMock(Server::class);
+        $invitationServer = $this->createMock(InvitationResponseServer::class);
+        $invitationServer->method('getServer')->willReturn($davServer);
+        $this->serverFactory->method('createInviationResponseServer')->willReturn($invitationServer);
+        $caldavPlugin = $this->createMock(Plugin::class);
+        $davServer->expects(self::once())
+            ->method('getPlugin')
+            ->with('caldav')
+            ->willReturn($caldavPlugin);
+        $caldavPlugin->expects(self::once())
+            ->method('getCalendarHomeForPrincipal')
+            ->willReturn('/home/calendar');
+        $tree = $this->createMock(Tree::class);
+        $davServer->tree = $tree;
+        $calendarHome = $this->createMock(CalendarHome::class);
+        $tree->expects(self::once())
+            ->method('getNodeForPath')
+            ->with('/home/calendar')
+            ->willReturn($calendarHome);
+        $this->appConfig->expects(self::once())
+            ->method('getUserValue')
+            ->with('user123', 'dav', 'defaultCalendar', 'personal')
+            ->willReturn('personal-1');
+        $calendar = $this->createMock(Calendar::class);
+        $calendarHome->expects(self::once())
+            ->method('getChild')
+            ->with('personal-1')
+            ->willReturn($calendar);
+        $eventNode = $this->createMock(CalendarObject::class);
+        $this->timezoneService->expects(self::once())
+            ->method('getUserTimezone')
+            ->with('user123')
+            ->willReturn(null);
+        $this->timezoneService->expects(self::once())
+            ->method('getDefaultTimezone')
+            ->willReturn('UTC');
+        $calendar->expects(self::once())
+            ->method('getChild')
+            ->willReturn($eventNode);
+        $eventNode->expects(self::once())
+            ->method('put')
+            ->willReturnCallback(function ($data): void {
+                $vcalendar = Reader::read($data);
+                if (!($vcalendar instanceof VCalendar)) {
+                    throw new InvalidArgumentException('Calendar data should be a VCALENDAR');
+                }
+                $vevent = $vcalendar->VEVENT;
+                if ($vevent === null || !($vevent instanceof VEvent)) {
+                    throw new InvalidArgumentException('Calendar data should contain a VEVENT');
+                }
+                // UTC datetimes are stored without a TZID
+                self::assertSame(null, $vevent->DTSTART['TZID']?->getValue());
+                self::assertSame(null, $vevent->DTEND['TZID']?->getValue());
+            });
+        $calendar->expects(self::never())
+            ->method('createFile');
+        $event = new OutOfOfficeChangedEvent($data);
+
+        $this->listener->handle($event);
+    }
+
+    public function testHandleClearNoCalendarHome(): void {
+        $user = $this->createMock(IUser::class);
+        $user->method('getUID')->willReturn('user123');
+        $data = $this->createMock(IOutOfOfficeData::class);
+        $data->method('getUser')->willReturn($user);
+        $davServer = $this->createMock(Server::class);
+        $invitationServer = $this->createMock(InvitationResponseServer::class);
+        $invitationServer->method('getServer')->willReturn($davServer);
+        $this->serverFactory->method('createInviationResponseServer')->willReturn($invitationServer);
+        $caldavPlugin = $this->createMock(Plugin::class);
+        $davServer->expects(self::once())
+            ->method('getPlugin')
+            ->with('caldav')
+            ->willReturn($caldavPlugin);
+        $event = new OutOfOfficeClearedEvent($data);
+
+        $this->listener->handle($event);
+    }
+
+    public function testHandleClearNoCalendarHomeNode(): void {
+        $user = $this->createMock(IUser::class);
+        $user->method('getUID')->willReturn('user123');
+        $data = $this->createMock(IOutOfOfficeData::class);
+        $data->method('getUser')->willReturn($user);
+        $davServer = $this->createMock(Server::class);
+        $invitationServer = $this->createMock(InvitationResponseServer::class);
+        $invitationServer->method('getServer')->willReturn($davServer);
+        $this->serverFactory->method('createInviationResponseServer')->willReturn($invitationServer);
+        $caldavPlugin = $this->createMock(Plugin::class);
+        $davServer->expects(self::once())
+            ->method('getPlugin')
+            ->with('caldav')
+            ->willReturn($caldavPlugin);
+        $caldavPlugin->expects(self::once())
+            ->method('getCalendarHomeForPrincipal')
+            ->willReturn('/home/calendar');
+        $tree = $this->createMock(Tree::class);
+        $davServer->tree = $tree;
+        $tree->expects(self::once())
+            ->method('getNodeForPath')
+            ->with('/home/calendar')
+            ->willThrowException(new NotFound('nope'));
+        $event = new OutOfOfficeClearedEvent($data);
+
+        $this->listener->handle($event);
+    }
+
+    public function testHandleClearPersonalCalendarNotFound(): void {
+        $user = $this->createMock(IUser::class);
+        $user->method('getUID')->willReturn('user123');
+        $data = $this->createMock(IOutOfOfficeData::class);
+        $data->method('getUser')->willReturn($user);
+        $davServer = $this->createMock(Server::class);
+        $invitationServer = $this->createMock(InvitationResponseServer::class);
+        $invitationServer->method('getServer')->willReturn($davServer);
+        $this->serverFactory->method('createInviationResponseServer')->willReturn($invitationServer);
+        $caldavPlugin = $this->createMock(Plugin::class);
+        $davServer->expects(self::once())
+            ->method('getPlugin')
+            ->with('caldav')
+            ->willReturn($caldavPlugin);
+        $caldavPlugin->expects(self::once())
+            ->method('getCalendarHomeForPrincipal')
+            ->willReturn('/home/calendar');
+        $tree = $this->createMock(Tree::class);
+        $davServer->tree = $tree;
+        $calendarHome = $this->createMock(CalendarHome::class);
+        $tree->expects(self::once())
+            ->method('getNodeForPath')
+            ->with('/home/calendar')
+            ->willReturn($calendarHome);
+        $this->appConfig->expects(self::once())
+            ->method('getUserValue')
+            ->with('user123', 'dav', 'defaultCalendar', 'personal')
+            ->willReturn('personal-1');
+        $calendarHome->expects(self::once())
+            ->method('getChild')
+            ->with('personal-1')
+            ->willThrowException(new NotFound('nope'));
+        $event = new OutOfOfficeClearedEvent($data);
+
+        $this->listener->handle($event);
+    }
+
+    public function testHandleClearRecreate(): void {
+        $user = $this->createMock(IUser::class);
+        $user->method('getUID')->willReturn('user123');
+        $data = $this->createMock(IOutOfOfficeData::class);
+        $data->method('getUser')->willReturn($user);
+        $davServer = $this->createMock(Server::class);
+        $invitationServer = $this->createMock(InvitationResponseServer::class);
+        $invitationServer->method('getServer')->willReturn($davServer);
+        $this->serverFactory->method('createInviationResponseServer')->willReturn($invitationServer);
+        $caldavPlugin = $this->createMock(Plugin::class);
+        $davServer->expects(self::once())
+            ->method('getPlugin')
+            ->with('caldav')
+            ->willReturn($caldavPlugin);
+        $caldavPlugin->expects(self::once())
+            ->method('getCalendarHomeForPrincipal')
+            ->willReturn('/home/calendar');
+        $tree = $this->createMock(Tree::class);
+        $davServer->tree = $tree;
+        $calendarHome = $this->createMock(CalendarHome::class);
+        $tree->expects(self::once())
+            ->method('getNodeForPath')
+            ->with('/home/calendar')
+            ->willReturn($calendarHome);
+        $this->appConfig->expects(self::once())
+            ->method('getUserValue')
+            ->with('user123', 'dav', 'defaultCalendar', 'personal')
+            ->willReturn('personal-1');
+        $calendar = $this->createMock(Calendar::class);
+        $calendarHome->expects(self::once())
+            ->method('getChild')
+            ->with('personal-1')
+            ->willReturn($calendar);
+        $calendar->expects(self::once())
+            ->method('getChild')
+            ->willThrowException(new NotFound());
+        $event = new OutOfOfficeClearedEvent($data);
+
+        $this->listener->handle($event);
+    }
+
+    public function testHandleClear(): void {
+        $user = $this->createMock(IUser::class);
+        $user->method('getUID')->willReturn('user123');
+        $data = $this->createMock(IOutOfOfficeData::class);
+        $data->method('getUser')->willReturn($user);
+        $davServer = $this->createMock(Server::class);
+        $invitationServer = $this->createMock(InvitationResponseServer::class);
+        $invitationServer->method('getServer')->willReturn($davServer);
+        $this->serverFactory->method('createInviationResponseServer')->willReturn($invitationServer);
+        $caldavPlugin = $this->createMock(Plugin::class);
+        $davServer->expects(self::once())
+            ->method('getPlugin')
+            ->with('caldav')
+            ->willReturn($caldavPlugin);
+        $caldavPlugin->expects(self::once())
+            ->method('getCalendarHomeForPrincipal')
+            ->willReturn('/home/calendar');
+        $tree = $this->createMock(Tree::class);
+        $davServer->tree = $tree;
+        $calendarHome = $this->createMock(CalendarHome::class);
+        $tree->expects(self::once())
+            ->method('getNodeForPath')
+            ->with('/home/calendar')
+            ->willReturn($calendarHome);
+        $this->appConfig->expects(self::once())
+            ->method('getUserValue')
+            ->with('user123', 'dav', 'defaultCalendar', 'personal')
+            ->willReturn('personal-1');
+        $calendar = $this->createMock(Calendar::class);
+        $calendarHome->expects(self::once())
+            ->method('getChild')
+            ->with('personal-1')
+            ->willReturn($calendar);
+        $eventNode = $this->createMock(CalendarObject::class);
+        $calendar->expects(self::once())
+            ->method('getChild')
+            ->willReturn($eventNode);
+        $eventNode->expects(self::once())
+            ->method('delete');
+        $event = new OutOfOfficeClearedEvent($data);
+
+        $this->listener->handle($event);
+    }
 }

apps/dav/tests/unit/CalDAV/Schedule/IMipPluginCharsetTest.php

Indentation +150 added lines, -150 removed lines

@@ -41,154 +41,154 @@
 use Test\Traits\EmailValidatorTrait;
 
 class IMipPluginCharsetTest extends TestCase {
-	use EmailValidatorTrait;
-	// Dependencies
-	private Defaults&MockObject $defaults;
-	private IAppConfig&MockObject $appConfig;
-	private IConfig&MockObject $config;
-	private IDBConnection&MockObject $db;
-	private IFactory $l10nFactory;
-	private IManager&MockObject $mailManager;
-	private IMailer&MockObject $mailer;
-	private ISecureRandom&MockObject $random;
-	private ITimeFactory&MockObject $timeFactory;
-	private IUrlGenerator&MockObject $urlGenerator;
-	private IUserSession&MockObject $userSession;
-	private LoggerInterface $logger;
-
-	// Services
-	private EventComparisonService $eventComparisonService;
-	private IMipPlugin $imipPlugin;
-	private IMipService $imipService;
-
-	// ITip Message
-	private Message $itipMessage;
-
-	protected function setUp(): void {
-		// Used by IMipService and IMipPlugin
-		$today = new \DateTime('2025-06-15 14:30');
-		$this->timeFactory = $this->createMock(ITimeFactory::class);
-		$this->timeFactory->method('getTime')
-			->willReturn($today->getTimestamp());
-		$this->timeFactory->method('getDateTime')
-			->willReturn($today);
-
-		// IMipService
-		$this->urlGenerator = $this->createMock(URLGenerator::class);
-		$this->config = $this->createMock(IConfig::class);
-		$this->db = $this->createMock(IDBConnection::class);
-		$this->random = $this->createMock(ISecureRandom::class);
-		$l10n = $this->createMock(L10N::class);
-		$this->l10nFactory = $this->createMock(IFactory::class);
-		$this->l10nFactory->method('findGenericLanguage')
-			->willReturn('en');
-		$this->l10nFactory->method('findLocale')
-			->willReturn('en_US');
-		$this->l10nFactory->method('get')
-			->willReturn($l10n);
-		$this->imipService = new IMipService(
-			$this->urlGenerator,
-			$this->config,
-			$this->db,
-			$this->random,
-			$this->l10nFactory,
-			$this->timeFactory,
-		);
-
-		// EventComparisonService
-		$this->eventComparisonService = new EventComparisonService();
-
-		// IMipPlugin
-		$this->appConfig = $this->createMock(IAppConfig::class);
-		$message = new \OC\Mail\Message(new Email(), false);
-		$this->mailer = $this->createMock(IMailer::class);
-		$this->mailer->method('createMessage')
-			->willReturn($message);
-		$this->logger = new NullLogger();
-		$this->defaults = $this->createMock(Defaults::class);
-		$this->defaults->method('getName')
-			->willReturn('Instance Name 123');
-		$user = $this->createMock(IUser::class);
-		$user->method('getUID')
-			->willReturn('luigi');
-		$this->userSession = $this->createMock(IUserSession::class);
-		$this->userSession->method('getUser')
-			->willReturn($user);
-		$this->mailManager = $this->createMock(IManager::class);
-		$this->imipPlugin = new IMipPlugin(
-			$this->appConfig,
-			$this->mailer,
-			$this->logger,
-			$this->timeFactory,
-			$this->defaults,
-			$this->userSession,
-			$this->imipService,
-			$this->eventComparisonService,
-			$this->mailManager,
-			$this->getEmailValidatorWithStrictEmailCheck(),
-		);
-
-		// ITipMessage
-		$calendar = new VCalendar();
-		$event = new VEvent($calendar, 'VEVENT');
-		$event->UID = 'uid-1234';
-		$event->SEQUENCE = 1;
-		$event->SUMMARY = 'Lunch';
-		$event->DTSTART = new \DateTime('2025-06-20 12:30:00');
-		$organizer = new CalAddress($calendar, 'ORGANIZER', 'mailto:luigi@example.org');
-		$event->add($organizer);
-		$attendee = new CalAddress($calendar, 'ATTENDEE', 'mailto:jose@example.org', ['RSVP' => 'TRUE', 'CN' => 'José']);
-		$event->add($attendee);
-		$calendar->add($event);
-		$this->itipMessage = new Message();
-		$this->itipMessage->method = 'REQUEST';
-		$this->itipMessage->message = $calendar;
-		$this->itipMessage->sender = 'mailto:luigi@example.org';
-		$this->itipMessage->senderName = 'Luigi';
-		$this->itipMessage->recipient = 'mailto:' . 'jose@example.org';
-	}
-
-	public function testCharsetMailer(): void {
-		// Arrange
-		$symfonyEmail = null;
-		$this->mailer->expects(self::once())
-			->method('send')
-			->willReturnCallback(function (IMessage $message) use (&$symfonyEmail): array {
-				if ($message instanceof \OC\Mail\Message) {
-					$symfonyEmail = $message->getSymfonyEmail();
-				}
-				return [];
-			});
-
-		// Act
-		$this->imipPlugin->schedule($this->itipMessage);
-
-		// Assert
-		$this->assertNotNull($symfonyEmail);
-		$body = $symfonyEmail->getBody()->toString();
-		$this->assertStringContainsString('Content-Type: text/calendar; method=REQUEST; charset="utf-8"; name=event.ics', $body);
-	}
-
-	public function testCharsetMailProvider(): void {
-		// Arrange
-		$this->appConfig->method('getValueBool')
-			->with('core', 'mail_providers_enabled', true)
-			->willReturn(true);
-		$mailMessage = new MailProviderMessage();
-		$mailService = $this->createMockForIntersectionOfInterfaces([IService::class, IMessageSend::class]);
-		$mailService->method('initiateMessage')
-			->willReturn($mailMessage);
-		$mailService->expects(self::once())
-			->method('sendMessage');
-		$this->mailManager->method('findServiceByAddress')
-			->willReturn($mailService);
-
-		// Act
-		$this->imipPlugin->schedule($this->itipMessage);
-
-		// Assert
-		$attachments = $mailMessage->getAttachments();
-		$this->assertCount(1, $attachments);
-		$this->assertStringContainsString('text/calendar; method=REQUEST; charset="utf-8"; name=event.ics', $attachments[0]->getType());
-	}
+    use EmailValidatorTrait;
+    // Dependencies
+    private Defaults&MockObject $defaults;
+    private IAppConfig&MockObject $appConfig;
+    private IConfig&MockObject $config;
+    private IDBConnection&MockObject $db;
+    private IFactory $l10nFactory;
+    private IManager&MockObject $mailManager;
+    private IMailer&MockObject $mailer;
+    private ISecureRandom&MockObject $random;
+    private ITimeFactory&MockObject $timeFactory;
+    private IUrlGenerator&MockObject $urlGenerator;
+    private IUserSession&MockObject $userSession;
+    private LoggerInterface $logger;
+
+    // Services
+    private EventComparisonService $eventComparisonService;
+    private IMipPlugin $imipPlugin;
+    private IMipService $imipService;
+
+    // ITip Message
+    private Message $itipMessage;
+
+    protected function setUp(): void {
+        // Used by IMipService and IMipPlugin
+        $today = new \DateTime('2025-06-15 14:30');
+        $this->timeFactory = $this->createMock(ITimeFactory::class);
+        $this->timeFactory->method('getTime')
+            ->willReturn($today->getTimestamp());
+        $this->timeFactory->method('getDateTime')
+            ->willReturn($today);
+
+        // IMipService
+        $this->urlGenerator = $this->createMock(URLGenerator::class);
+        $this->config = $this->createMock(IConfig::class);
+        $this->db = $this->createMock(IDBConnection::class);
+        $this->random = $this->createMock(ISecureRandom::class);
+        $l10n = $this->createMock(L10N::class);
+        $this->l10nFactory = $this->createMock(IFactory::class);
+        $this->l10nFactory->method('findGenericLanguage')
+            ->willReturn('en');
+        $this->l10nFactory->method('findLocale')
+            ->willReturn('en_US');
+        $this->l10nFactory->method('get')
+            ->willReturn($l10n);
+        $this->imipService = new IMipService(
+            $this->urlGenerator,
+            $this->config,
+            $this->db,
+            $this->random,
+            $this->l10nFactory,
+            $this->timeFactory,
+        );
+
+        // EventComparisonService
+        $this->eventComparisonService = new EventComparisonService();
+
+        // IMipPlugin
+        $this->appConfig = $this->createMock(IAppConfig::class);
+        $message = new \OC\Mail\Message(new Email(), false);
+        $this->mailer = $this->createMock(IMailer::class);
+        $this->mailer->method('createMessage')
+            ->willReturn($message);
+        $this->logger = new NullLogger();
+        $this->defaults = $this->createMock(Defaults::class);
+        $this->defaults->method('getName')
+            ->willReturn('Instance Name 123');
+        $user = $this->createMock(IUser::class);
+        $user->method('getUID')
+            ->willReturn('luigi');
+        $this->userSession = $this->createMock(IUserSession::class);
+        $this->userSession->method('getUser')
+            ->willReturn($user);
+        $this->mailManager = $this->createMock(IManager::class);
+        $this->imipPlugin = new IMipPlugin(
+            $this->appConfig,
+            $this->mailer,
+            $this->logger,
+            $this->timeFactory,
+            $this->defaults,
+            $this->userSession,
+            $this->imipService,
+            $this->eventComparisonService,
+            $this->mailManager,
+            $this->getEmailValidatorWithStrictEmailCheck(),
+        );
+
+        // ITipMessage
+        $calendar = new VCalendar();
+        $event = new VEvent($calendar, 'VEVENT');
+        $event->UID = 'uid-1234';
+        $event->SEQUENCE = 1;
+        $event->SUMMARY = 'Lunch';
+        $event->DTSTART = new \DateTime('2025-06-20 12:30:00');
+        $organizer = new CalAddress($calendar, 'ORGANIZER', 'mailto:luigi@example.org');
+        $event->add($organizer);
+        $attendee = new CalAddress($calendar, 'ATTENDEE', 'mailto:jose@example.org', ['RSVP' => 'TRUE', 'CN' => 'José']);
+        $event->add($attendee);
+        $calendar->add($event);
+        $this->itipMessage = new Message();
+        $this->itipMessage->method = 'REQUEST';
+        $this->itipMessage->message = $calendar;
+        $this->itipMessage->sender = 'mailto:luigi@example.org';
+        $this->itipMessage->senderName = 'Luigi';
+        $this->itipMessage->recipient = 'mailto:' . 'jose@example.org';
+    }
+
+    public function testCharsetMailer(): void {
+        // Arrange
+        $symfonyEmail = null;
+        $this->mailer->expects(self::once())
+            ->method('send')
+            ->willReturnCallback(function (IMessage $message) use (&$symfonyEmail): array {
+                if ($message instanceof \OC\Mail\Message) {
+                    $symfonyEmail = $message->getSymfonyEmail();
+                }
+                return [];
+            });
+
+        // Act
+        $this->imipPlugin->schedule($this->itipMessage);
+
+        // Assert
+        $this->assertNotNull($symfonyEmail);
+        $body = $symfonyEmail->getBody()->toString();
+        $this->assertStringContainsString('Content-Type: text/calendar; method=REQUEST; charset="utf-8"; name=event.ics', $body);
+    }
+
+    public function testCharsetMailProvider(): void {
+        // Arrange
+        $this->appConfig->method('getValueBool')
+            ->with('core', 'mail_providers_enabled', true)
+            ->willReturn(true);
+        $mailMessage = new MailProviderMessage();
+        $mailService = $this->createMockForIntersectionOfInterfaces([IService::class, IMessageSend::class]);
+        $mailService->method('initiateMessage')
+            ->willReturn($mailMessage);
+        $mailService->expects(self::once())
+            ->method('sendMessage');
+        $this->mailManager->method('findServiceByAddress')
+            ->willReturn($mailService);
+
+        // Act
+        $this->imipPlugin->schedule($this->itipMessage);
+
+        // Assert
+        $attachments = $mailMessage->getAttachments();
+        $this->assertCount(1, $attachments);
+        $this->assertStringContainsString('text/calendar; method=REQUEST; charset="utf-8"; name=event.ics', $attachments[0]->getType());
+    }
 }