nextcloud / server

tests/lib/Lockdown/LockdownManagerTest.php

Indentation +30 added lines, -30 removed lines

@@ -13,34 +13,34 @@
 use Test\TestCase;
 
 class LockdownManagerTest extends TestCase {
-	private $sessionCallback;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->sessionCallback = function () {
-			return $this->createMock(ISession::class);
-		};
-	}
-
-	public function testCanAccessFilesystemDisabled(): void {
-		$manager = new LockdownManager($this->sessionCallback);
-		$this->assertTrue($manager->canAccessFilesystem());
-	}
-
-	public function testCanAccessFilesystemAllowed(): void {
-		$token = new PublicKeyToken();
-		$token->setScope([IToken::SCOPE_FILESYSTEM => true]);
-		$manager = new LockdownManager($this->sessionCallback);
-		$manager->setToken($token);
-		$this->assertTrue($manager->canAccessFilesystem());
-	}
-
-	public function testCanAccessFilesystemNotAllowed(): void {
-		$token = new PublicKeyToken();
-		$token->setScope([IToken::SCOPE_FILESYSTEM => false]);
-		$manager = new LockdownManager($this->sessionCallback);
-		$manager->setToken($token);
-		$this->assertFalse($manager->canAccessFilesystem());
-	}
+    private $sessionCallback;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->sessionCallback = function () {
+            return $this->createMock(ISession::class);
+        };
+    }
+
+    public function testCanAccessFilesystemDisabled(): void {
+        $manager = new LockdownManager($this->sessionCallback);
+        $this->assertTrue($manager->canAccessFilesystem());
+    }
+
+    public function testCanAccessFilesystemAllowed(): void {
+        $token = new PublicKeyToken();
+        $token->setScope([IToken::SCOPE_FILESYSTEM => true]);
+        $manager = new LockdownManager($this->sessionCallback);
+        $manager->setToken($token);
+        $this->assertTrue($manager->canAccessFilesystem());
+    }
+
+    public function testCanAccessFilesystemNotAllowed(): void {
+        $token = new PublicKeyToken();
+        $token->setScope([IToken::SCOPE_FILESYSTEM => false]);
+        $manager = new LockdownManager($this->sessionCallback);
+        $manager->setToken($token);
+        $this->assertFalse($manager->canAccessFilesystem());
+    }
 }

tests/lib/Lockdown/Filesystem/NullStorageTest.php

Indentation +154 added lines, -154 removed lines

@@ -15,214 +15,214 @@
 use Test\TestCase;
 
 class NullStorageTest extends TestCase {
-	/** @var NullStorage */
-	private $storage;
+    /** @var NullStorage */
+    private $storage;
 
-	protected function setUp(): void {
-		parent::setUp();
+    protected function setUp(): void {
+        parent::setUp();
 
-		$this->storage = new NullStorage([]);
-	}
+        $this->storage = new NullStorage([]);
+    }
 
-	public function testGetId(): void {
-		$this->assertSame('null', $this->storage->getId());
-	}
+    public function testGetId(): void {
+        $this->assertSame('null', $this->storage->getId());
+    }
 
-	public function testMkdir(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testMkdir(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->mkdir('foo');
-	}
+        $this->storage->mkdir('foo');
+    }
 
-	public function testRmdir(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testRmdir(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->rmdir('foo');
-	}
+        $this->storage->rmdir('foo');
+    }
 
-	public function testOpendir(): void {
-		$this->assertInstanceOf(IteratorDirectory::class, $this->storage->opendir('foo'));
-	}
+    public function testOpendir(): void {
+        $this->assertInstanceOf(IteratorDirectory::class, $this->storage->opendir('foo'));
+    }
 
-	public function testIs_dir(): void {
-		$this->assertTrue($this->storage->is_dir(''));
-		$this->assertFalse($this->storage->is_dir('foo'));
-	}
+    public function testIs_dir(): void {
+        $this->assertTrue($this->storage->is_dir(''));
+        $this->assertFalse($this->storage->is_dir('foo'));
+    }
 
-	public function testIs_file(): void {
-		$this->assertFalse($this->storage->is_file('foo'));
-	}
+    public function testIs_file(): void {
+        $this->assertFalse($this->storage->is_file('foo'));
+    }
 
-	public function testStat(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testStat(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->stat('foo');
-	}
+        $this->storage->stat('foo');
+    }
 
-	public function testFiletype(): void {
-		$this->assertSame('dir', $this->storage->filetype(''));
-		$this->assertFalse($this->storage->filetype('foo'));
-	}
+    public function testFiletype(): void {
+        $this->assertSame('dir', $this->storage->filetype(''));
+        $this->assertFalse($this->storage->filetype('foo'));
+    }
 
-	public function testFilesize(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testFilesize(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->filesize('foo');
-	}
+        $this->storage->filesize('foo');
+    }
 
-	public function testIsCreatable(): void {
-		$this->assertFalse($this->storage->isCreatable('foo'));
-	}
+    public function testIsCreatable(): void {
+        $this->assertFalse($this->storage->isCreatable('foo'));
+    }
 
-	public function testIsReadable(): void {
-		$this->assertTrue($this->storage->isReadable(''));
-		$this->assertFalse($this->storage->isReadable('foo'));
-	}
+    public function testIsReadable(): void {
+        $this->assertTrue($this->storage->isReadable(''));
+        $this->assertFalse($this->storage->isReadable('foo'));
+    }
 
-	public function testIsUpdatable(): void {
-		$this->assertFalse($this->storage->isUpdatable('foo'));
-	}
+    public function testIsUpdatable(): void {
+        $this->assertFalse($this->storage->isUpdatable('foo'));
+    }
 
-	public function testIsDeletable(): void {
-		$this->assertFalse($this->storage->isDeletable('foo'));
-	}
+    public function testIsDeletable(): void {
+        $this->assertFalse($this->storage->isDeletable('foo'));
+    }
 
-	public function testIsSharable(): void {
-		$this->assertFalse($this->storage->isSharable('foo'));
-	}
+    public function testIsSharable(): void {
+        $this->assertFalse($this->storage->isSharable('foo'));
+    }
 
-	public function testGetPermissions(): void {
-		$this->assertEquals(0, $this->storage->getPermissions('foo'));
-	}
+    public function testGetPermissions(): void {
+        $this->assertEquals(0, $this->storage->getPermissions('foo'));
+    }
 
-	public function testFile_exists(): void {
-		$this->assertTrue($this->storage->file_exists(''));
-		$this->assertFalse($this->storage->file_exists('foo'));
-	}
+    public function testFile_exists(): void {
+        $this->assertTrue($this->storage->file_exists(''));
+        $this->assertFalse($this->storage->file_exists('foo'));
+    }
 
-	public function testFilemtime(): void {
-		$this->assertFalse($this->storage->filemtime('foo'));
-	}
+    public function testFilemtime(): void {
+        $this->assertFalse($this->storage->filemtime('foo'));
+    }
 
-	public function testFile_get_contents(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testFile_get_contents(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->file_get_contents('foo');
-	}
+        $this->storage->file_get_contents('foo');
+    }
 
-	public function testFile_put_contents(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testFile_put_contents(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->file_put_contents('foo', 'bar');
-	}
+        $this->storage->file_put_contents('foo', 'bar');
+    }
 
-	public function testUnlink(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testUnlink(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->unlink('foo');
-	}
+        $this->storage->unlink('foo');
+    }
 
-	public function testRename(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testRename(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->rename('foo', 'bar');
-	}
+        $this->storage->rename('foo', 'bar');
+    }
 
-	public function testCopy(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testCopy(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->copy('foo', 'bar');
-	}
+        $this->storage->copy('foo', 'bar');
+    }
 
-	public function testFopen(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testFopen(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->fopen('foo', 'R');
-	}
+        $this->storage->fopen('foo', 'R');
+    }
 
-	public function testGetMimeType(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testGetMimeType(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->getMimeType('foo');
-	}
+        $this->storage->getMimeType('foo');
+    }
 
-	public function testHash(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testHash(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->hash('md5', 'foo', true);
-	}
+        $this->storage->hash('md5', 'foo', true);
+    }
 
-	public function testFree_space(): void {
-		$this->assertSame(FileInfo::SPACE_UNKNOWN, $this->storage->free_space('foo'));
-	}
+    public function testFree_space(): void {
+        $this->assertSame(FileInfo::SPACE_UNKNOWN, $this->storage->free_space('foo'));
+    }
 
-	public function testTouch(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testTouch(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->touch('foo');
-	}
+        $this->storage->touch('foo');
+    }
 
-	public function testGetLocalFile(): void {
-		$this->assertFalse($this->storage->getLocalFile('foo'));
-	}
+    public function testGetLocalFile(): void {
+        $this->assertFalse($this->storage->getLocalFile('foo'));
+    }
 
-	public function testHasUpdated(): void {
-		$this->assertFalse($this->storage->hasUpdated('foo', 42));
-	}
+    public function testHasUpdated(): void {
+        $this->assertFalse($this->storage->hasUpdated('foo', 42));
+    }
 
-	public function testGetETag(): void {
-		$this->assertSame('', $this->storage->getETag('foo'));
-	}
+    public function testGetETag(): void {
+        $this->assertSame('', $this->storage->getETag('foo'));
+    }
 
-	public function testIsLocal(): void {
-		$this->assertFalse($this->storage->isLocal());
-	}
+    public function testIsLocal(): void {
+        $this->assertFalse($this->storage->isLocal());
+    }
 
-	public function testGetDirectDownload(): void {
-		$this->assertFalse($this->storage->getDirectDownload('foo'));
-	}
+    public function testGetDirectDownload(): void {
+        $this->assertFalse($this->storage->getDirectDownload('foo'));
+    }
 
-	public function testCopyFromStorage(): void {
-		$sourceStorage = $this->createMock(IStorage::class);
+    public function testCopyFromStorage(): void {
+        $sourceStorage = $this->createMock(IStorage::class);
 
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->copyFromStorage($sourceStorage, 'foo', 'bar');
-	}
+        $this->storage->copyFromStorage($sourceStorage, 'foo', 'bar');
+    }
 
-	public function testMoveFromStorage(): void {
-		$sourceStorage = $this->createMock(IStorage::class);
+    public function testMoveFromStorage(): void {
+        $sourceStorage = $this->createMock(IStorage::class);
 
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->moveFromStorage($sourceStorage, 'foo', 'bar');
-	}
+        $this->storage->moveFromStorage($sourceStorage, 'foo', 'bar');
+    }
 
-	public function testTest() {
-		$this->assertTrue($this->storage->test());
-		return true;
-	}
+    public function testTest() {
+        $this->assertTrue($this->storage->test());
+        return true;
+    }
 
-	public function testGetOwner(): void {
-		$this->assertFalse($this->storage->getOwner('foo'));
-	}
+    public function testGetOwner(): void {
+        $this->assertFalse($this->storage->getOwner('foo'));
+    }
 
-	public function testGetCache(): void {
-		$this->assertInstanceOf(NullCache::class, $this->storage->getCache('foo'));
-	}
+    public function testGetCache(): void {
+        $this->assertInstanceOf(NullCache::class, $this->storage->getCache('foo'));
+    }
 }

tests/lib/AppScriptSortTest.php

Indentation +102 added lines, -102 removed lines

@@ -18,106 +18,106 @@
  * @group DB
  */
 class AppScriptSortTest extends \Test\TestCase {
-	private $logger;
-
-	protected function setUp(): void {
-		$this->logger = $this->getMockBuilder(LoggerInterface::class)
-			->disableOriginalConstructor()
-			->getMock();
-
-		parent::setUp();
-	}
-
-	public function testSort(): void {
-		$scripts = [
-			'first' => ['myFirstJSFile'],
-			'core' => [
-				'core/js/myFancyJSFile1',
-				'core/js/myFancyJSFile4',
-				'core/js/myFancyJSFile5',
-				'core/js/myFancyJSFile1',
-			],
-			'files' => ['files/js/myFancyJSFile2'],
-			'myApp5' => ['myApp5/js/myApp5JSFile'],
-			'myApp' => ['myApp/js/myFancyJSFile3'],
-			'myApp4' => ['myApp4/js/myApp4JSFile'],
-			'myApp3' => ['myApp3/js/myApp3JSFile'],
-			'myApp2' => ['myApp2/js/myApp2JSFile'],
-		];
-		$scriptDeps = [
-			'first' => new AppScriptDependency('first', ['core']),
-			'core' => new AppScriptDependency('core', ['core']),
-			'files' => new AppScriptDependency('files', ['core']),
-			'myApp5' => new AppScriptDependency('myApp5', ['myApp2']),
-			'myApp' => new AppScriptDependency('myApp', ['core']),
-			'myApp4' => new AppScriptDependency('myApp4', ['myApp3']),
-			'myApp3' => new AppScriptDependency('myApp3', ['myApp2']),
-			'myApp2' => new AppScriptDependency('myApp2', ['myApp']),
-		];
-
-		// No circular dependency is detected and logged as an error
-		$this->logger->expects(self::never())->method('error');
-
-		$scriptSort = new AppScriptSort($this->logger);
-		$sortedScripts = $scriptSort->sort($scripts, $scriptDeps);
-
-		$sortedScriptKeys = array_keys($sortedScripts);
-
-		// Core should appear first
-		$this->assertEquals(
-			0,
-			array_search('core', $sortedScriptKeys, true)
-		);
-
-		// Dependencies should appear before their children
-		$this->assertLessThan(
-			array_search('files', $sortedScriptKeys, true),
-			array_search('core', $sortedScriptKeys, true)
-		);
-		$this->assertLessThan(
-			array_search('myApp2', $sortedScriptKeys, true),
-			array_search('myApp', $sortedScriptKeys, true)
-		);
-		$this->assertLessThan(
-			array_search('myApp3', $sortedScriptKeys, true),
-			array_search('myApp2', $sortedScriptKeys, true)
-		);
-		$this->assertLessThan(
-			array_search('myApp4', $sortedScriptKeys, true),
-			array_search('myApp3', $sortedScriptKeys, true)
-		);
-		$this->assertLessThan(
-			array_search('myApp5', $sortedScriptKeys, true),
-			array_search('myApp2', $sortedScriptKeys, true)
-		);
-
-		// All apps still there
-		foreach ($scripts as $app => $_) {
-			$this->assertContains($app, $sortedScriptKeys);
-		}
-	}
-
-	public function testSortCircularDependency(): void {
-		$scripts = [
-			'circular' => ['circular/js/file1'],
-			'dependency' => ['dependency/js/file2'],
-		];
-		$scriptDeps = [
-			'circular' => new AppScriptDependency('circular', ['dependency']),
-			'dependency' => new AppScriptDependency('dependency', ['circular']),
-		];
-
-		// A circular dependency is detected and logged as an error
-		$this->logger->expects(self::once())->method('error');
-
-		$scriptSort = new AppScriptSort($this->logger);
-		$sortedScripts = $scriptSort->sort($scripts, $scriptDeps);
-
-		$sortedScriptKeys = array_keys($sortedScripts);
-
-		// All apps still there
-		foreach ($scripts as $app => $_) {
-			$this->assertContains($app, $sortedScriptKeys);
-		}
-	}
+    private $logger;
+
+    protected function setUp(): void {
+        $this->logger = $this->getMockBuilder(LoggerInterface::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        parent::setUp();
+    }
+
+    public function testSort(): void {
+        $scripts = [
+            'first' => ['myFirstJSFile'],
+            'core' => [
+                'core/js/myFancyJSFile1',
+                'core/js/myFancyJSFile4',
+                'core/js/myFancyJSFile5',
+                'core/js/myFancyJSFile1',
+            ],
+            'files' => ['files/js/myFancyJSFile2'],
+            'myApp5' => ['myApp5/js/myApp5JSFile'],
+            'myApp' => ['myApp/js/myFancyJSFile3'],
+            'myApp4' => ['myApp4/js/myApp4JSFile'],
+            'myApp3' => ['myApp3/js/myApp3JSFile'],
+            'myApp2' => ['myApp2/js/myApp2JSFile'],
+        ];
+        $scriptDeps = [
+            'first' => new AppScriptDependency('first', ['core']),
+            'core' => new AppScriptDependency('core', ['core']),
+            'files' => new AppScriptDependency('files', ['core']),
+            'myApp5' => new AppScriptDependency('myApp5', ['myApp2']),
+            'myApp' => new AppScriptDependency('myApp', ['core']),
+            'myApp4' => new AppScriptDependency('myApp4', ['myApp3']),
+            'myApp3' => new AppScriptDependency('myApp3', ['myApp2']),
+            'myApp2' => new AppScriptDependency('myApp2', ['myApp']),
+        ];
+
+        // No circular dependency is detected and logged as an error
+        $this->logger->expects(self::never())->method('error');
+
+        $scriptSort = new AppScriptSort($this->logger);
+        $sortedScripts = $scriptSort->sort($scripts, $scriptDeps);
+
+        $sortedScriptKeys = array_keys($sortedScripts);
+
+        // Core should appear first
+        $this->assertEquals(
+            0,
+            array_search('core', $sortedScriptKeys, true)
+        );
+
+        // Dependencies should appear before their children
+        $this->assertLessThan(
+            array_search('files', $sortedScriptKeys, true),
+            array_search('core', $sortedScriptKeys, true)
+        );
+        $this->assertLessThan(
+            array_search('myApp2', $sortedScriptKeys, true),
+            array_search('myApp', $sortedScriptKeys, true)
+        );
+        $this->assertLessThan(
+            array_search('myApp3', $sortedScriptKeys, true),
+            array_search('myApp2', $sortedScriptKeys, true)
+        );
+        $this->assertLessThan(
+            array_search('myApp4', $sortedScriptKeys, true),
+            array_search('myApp3', $sortedScriptKeys, true)
+        );
+        $this->assertLessThan(
+            array_search('myApp5', $sortedScriptKeys, true),
+            array_search('myApp2', $sortedScriptKeys, true)
+        );
+
+        // All apps still there
+        foreach ($scripts as $app => $_) {
+            $this->assertContains($app, $sortedScriptKeys);
+        }
+    }
+
+    public function testSortCircularDependency(): void {
+        $scripts = [
+            'circular' => ['circular/js/file1'],
+            'dependency' => ['dependency/js/file2'],
+        ];
+        $scriptDeps = [
+            'circular' => new AppScriptDependency('circular', ['dependency']),
+            'dependency' => new AppScriptDependency('dependency', ['circular']),
+        ];
+
+        // A circular dependency is detected and logged as an error
+        $this->logger->expects(self::once())->method('error');
+
+        $scriptSort = new AppScriptSort($this->logger);
+        $sortedScripts = $scriptSort->sort($scripts, $scriptDeps);
+
+        $sortedScriptKeys = array_keys($sortedScripts);
+
+        // All apps still there
+        foreach ($scripts as $app => $_) {
+            $this->assertContains($app, $sortedScriptKeys);
+        }
+    }
 }

tests/lib/Diagnostics/EventLoggerTest.php

Indentation +40 added lines, -40 removed lines

@@ -14,44 +14,44 @@
 use Test\TestCase;
 
 class EventLoggerTest extends TestCase {
-	/** @var \OC\Diagnostics\EventLogger */
-	private $logger;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->logger = new EventLogger(
-			$this->createMock(SystemConfig::class),
-			$this->createMock(LoggerInterface::class),
-			$this->createMock(Log::class)
-		);
-	}
-
-	public function testQueryLogger(): void {
-		// Module is not activated and this should not be logged
-		$this->logger->start('test1', 'testevent1');
-		$this->logger->end('test1');
-		$this->logger->log('test2', 'testevent2', microtime(true), microtime(true));
-		$events = $this->logger->getEvents();
-		$this->assertSame(0, sizeof($events));
-
-		// Activate module and log some query
-		$this->logger->activate();
-
-		// start one event
-		$this->logger->start('test3', 'testevent3');
-
-		// force log of another event
-		$this->logger->log('test4', 'testevent4', microtime(true), microtime(true));
-
-		// log started event
-		$this->logger->end('test3');
-
-		$events = $this->logger->getEvents();
-		$this->assertSame('test4', $events['test4']->getId());
-		$this->assertSame('testevent4', $events['test4']->getDescription());
-		$this->assertSame('test3', $events['test3']->getId());
-		$this->assertSame('testevent3', $events['test3']->getDescription());
-		$this->assertSame(2, sizeof($events));
-	}
+    /** @var \OC\Diagnostics\EventLogger */
+    private $logger;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->logger = new EventLogger(
+            $this->createMock(SystemConfig::class),
+            $this->createMock(LoggerInterface::class),
+            $this->createMock(Log::class)
+        );
+    }
+
+    public function testQueryLogger(): void {
+        // Module is not activated and this should not be logged
+        $this->logger->start('test1', 'testevent1');
+        $this->logger->end('test1');
+        $this->logger->log('test2', 'testevent2', microtime(true), microtime(true));
+        $events = $this->logger->getEvents();
+        $this->assertSame(0, sizeof($events));
+
+        // Activate module and log some query
+        $this->logger->activate();
+
+        // start one event
+        $this->logger->start('test3', 'testevent3');
+
+        // force log of another event
+        $this->logger->log('test4', 'testevent4', microtime(true), microtime(true));
+
+        // log started event
+        $this->logger->end('test3');
+
+        $events = $this->logger->getEvents();
+        $this->assertSame('test4', $events['test4']->getId());
+        $this->assertSame('testevent4', $events['test4']->getDescription());
+        $this->assertSame('test3', $events['test3']->getId());
+        $this->assertSame('testevent3', $events['test3']->getDescription());
+        $this->assertSame(2, sizeof($events));
+    }
 }

tests/lib/SetupCheck/CheckServerResponseTraitImplementation.php

Indentation +14 added lines, -14 removed lines

@@ -20,20 +20,20 @@
  */
 class CheckServerResponseTraitImplementation {
 
-	use CheckServerResponseTrait {
-		CheckServerResponseTrait::getRequestOptions as public;
-		CheckServerResponseTrait::runRequest as public;
-		CheckServerResponseTrait::normalizeUrl as public;
-		CheckServerResponseTrait::getTestUrls as public;
-	}
+    use CheckServerResponseTrait {
+        CheckServerResponseTrait::getRequestOptions as public;
+        CheckServerResponseTrait::runRequest as public;
+        CheckServerResponseTrait::normalizeUrl as public;
+        CheckServerResponseTrait::getTestUrls as public;
+    }
 
-	public function __construct(
-		protected IL10N $l10n,
-		protected IConfig $config,
-		protected IURLGenerator $urlGenerator,
-		protected IClientService $clientService,
-		protected LoggerInterface $logger,
-	) {
-	}
+    public function __construct(
+        protected IL10N $l10n,
+        protected IConfig $config,
+        protected IURLGenerator $urlGenerator,
+        protected IClientService $clientService,
+        protected LoggerInterface $logger,
+    ) {
+    }
 
 }

tests/lib/TemplateFunctionsTest.php

Indentation +221 added lines, -221 removed lines

@@ -8,269 +8,269 @@
 namespace Test;
 
 class TemplateFunctionsTest extends \Test\TestCase {
-	protected function setUp(): void {
-		parent::setUp();
-
-		require_once \OC::$SERVERROOT . '/lib/private/Template/functions.php';
-	}
-
-	public function testPJavaScript(): void {
-		$this->expectOutputString('<img onload="alert(1)" />');
-		p('<img onload="alert(1)" />');
-	}
-
-	public function testPJavaScriptWithScriptTags(): void {
-		$this->expectOutputString('&lt;script&gt;alert(&#039;Hacked!&#039;);&lt;/script&gt;');
-		p("<script>alert('Hacked!');</script>");
-	}
-
-	public function testPNormalString(): void {
-		$string = 'This is a good string without HTML.';
-		$this->expectOutputString($string);
-		p($string);
-	}
-
-	public function testPrintUnescaped(): void {
-		$htmlString = "<script>alert('xss');</script>";
-		$this->expectOutputString($htmlString);
-		print_unescaped($htmlString);
-	}
-
-	public function testPrintUnescapedNormalString(): void {
-		$string = 'This is a good string!';
-		$this->expectOutputString($string);
-		print_unescaped($string);
-	}
-
-	public function testEmitScriptTagWithContent(): void {
-		$this->expectOutputRegex('/<script nonce="[^"]+">\nalert\(\)\n<\/script>\n?/');
-		emit_script_tag('', 'alert()');
-	}
-
-	public function testEmitScriptTagWithSource(): void {
-		$this->expectOutputRegex('/<script nonce=".*" defer src="some.js"><\/script>/');
-		emit_script_tag('some.js');
-	}
-
-	public function testEmitScriptTagWithModuleSource(): void {
-		$this->expectOutputRegex('/<script nonce=".*" defer src="some.mjs" type="module"><\/script>/');
-		emit_script_tag('some.mjs', '', 'module');
-	}
-
-	public function testEmitScriptLoadingTags(): void {
-		// Test mjs js and inline content
-		$pattern = '/src="some\.mjs"[^>]+type="module"[^>]*>.+\n'; // some.mjs with type = module
-		$pattern .= '<script[^>]+src="other\.js"[^>]*>.+\n'; // other.js as plain javascript
-		$pattern .= '<script[^>]*>\n?.*inline.*\n?<\/script>'; // inline content
-		$pattern .= '/'; // no flags
-
-		$this->expectOutputRegex($pattern);
-		emit_script_loading_tags([
-			'jsfiles' => ['some.mjs', 'other.js'],
-			'inline_ocjs' => '// inline'
-		]);
-	}
-
-	public function testEmitScriptLoadingTagsWithVersion(): void {
-		// Test mjs js and inline content
-		$pattern = '/src="some\.mjs\?v=ab123cd"[^>]+type="module"[^>]*>.+\n'; // some.mjs with type = module
-		$pattern .= '<script[^>]+src="other\.js\?v=12abc34"[^>]*>.+\n'; // other.js as plain javascript
-		$pattern .= '/'; // no flags
-
-		$this->expectOutputRegex($pattern);
-		emit_script_loading_tags([
-			'jsfiles' => ['some.mjs?v=ab123cd', 'other.js?v=12abc34'],
-		]);
-	}
-
-	// ---------------------------------------------------------------------------
-	// Test relative_modified_date with dates only
-	// ---------------------------------------------------------------------------
-	public function testRelativeDateToday(): void {
-		$currentTime = 1380703592;
-		$elementTime = $currentTime;
-		$result = (string)relative_modified_date($elementTime, $currentTime, true);
-
-		$this->assertEquals('today', $result);
-
-		// 2 hours ago is still today
-		$elementTime = $currentTime - 2 * 3600;
-		$result = (string)relative_modified_date($elementTime, $currentTime, true);
-
-		$this->assertEquals('today', $result);
-	}
-
-	public function testRelativeDateYesterday(): void {
-		$currentTime = 1380703592;
-		$elementTime = $currentTime - 24 * 3600;
-		$result = (string)relative_modified_date($elementTime, $currentTime, true);
-
-		$this->assertEquals('yesterday', $result);
-
-		// yesterday - 2 hours is still yesterday
-		$elementTime = $currentTime - 26 * 3600;
-		$result = (string)relative_modified_date($elementTime, $currentTime, true);
-
-		$this->assertEquals('yesterday', $result);
-	}
-
-	public function testRelativeDate2DaysAgo(): void {
-		$currentTime = 1380703592;
-		$elementTime = $currentTime - 48 * 3600;
-		$result = (string)relative_modified_date($elementTime, $currentTime, true);
+    protected function setUp(): void {
+        parent::setUp();
+
+        require_once \OC::$SERVERROOT . '/lib/private/Template/functions.php';
+    }
+
+    public function testPJavaScript(): void {
+        $this->expectOutputString('&lt;img onload=&quot;alert(1)&quot; /&gt;');
+        p('<img onload="alert(1)" />');
+    }
+
+    public function testPJavaScriptWithScriptTags(): void {
+        $this->expectOutputString('&lt;script&gt;alert(&#039;Hacked!&#039;);&lt;/script&gt;');
+        p("<script>alert('Hacked!');</script>");
+    }
+
+    public function testPNormalString(): void {
+        $string = 'This is a good string without HTML.';
+        $this->expectOutputString($string);
+        p($string);
+    }
+
+    public function testPrintUnescaped(): void {
+        $htmlString = "<script>alert('xss');</script>";
+        $this->expectOutputString($htmlString);
+        print_unescaped($htmlString);
+    }
+
+    public function testPrintUnescapedNormalString(): void {
+        $string = 'This is a good string!';
+        $this->expectOutputString($string);
+        print_unescaped($string);
+    }
+
+    public function testEmitScriptTagWithContent(): void {
+        $this->expectOutputRegex('/<script nonce="[^"]+">\nalert\(\)\n<\/script>\n?/');
+        emit_script_tag('', 'alert()');
+    }
+
+    public function testEmitScriptTagWithSource(): void {
+        $this->expectOutputRegex('/<script nonce=".*" defer src="some.js"><\/script>/');
+        emit_script_tag('some.js');
+    }
+
+    public function testEmitScriptTagWithModuleSource(): void {
+        $this->expectOutputRegex('/<script nonce=".*" defer src="some.mjs" type="module"><\/script>/');
+        emit_script_tag('some.mjs', '', 'module');
+    }
+
+    public function testEmitScriptLoadingTags(): void {
+        // Test mjs js and inline content
+        $pattern = '/src="some\.mjs"[^>]+type="module"[^>]*>.+\n'; // some.mjs with type = module
+        $pattern .= '<script[^>]+src="other\.js"[^>]*>.+\n'; // other.js as plain javascript
+        $pattern .= '<script[^>]*>\n?.*inline.*\n?<\/script>'; // inline content
+        $pattern .= '/'; // no flags
+
+        $this->expectOutputRegex($pattern);
+        emit_script_loading_tags([
+            'jsfiles' => ['some.mjs', 'other.js'],
+            'inline_ocjs' => '// inline'
+        ]);
+    }
+
+    public function testEmitScriptLoadingTagsWithVersion(): void {
+        // Test mjs js and inline content
+        $pattern = '/src="some\.mjs\?v=ab123cd"[^>]+type="module"[^>]*>.+\n'; // some.mjs with type = module
+        $pattern .= '<script[^>]+src="other\.js\?v=12abc34"[^>]*>.+\n'; // other.js as plain javascript
+        $pattern .= '/'; // no flags
+
+        $this->expectOutputRegex($pattern);
+        emit_script_loading_tags([
+            'jsfiles' => ['some.mjs?v=ab123cd', 'other.js?v=12abc34'],
+        ]);
+    }
+
+    // ---------------------------------------------------------------------------
+    // Test relative_modified_date with dates only
+    // ---------------------------------------------------------------------------
+    public function testRelativeDateToday(): void {
+        $currentTime = 1380703592;
+        $elementTime = $currentTime;
+        $result = (string)relative_modified_date($elementTime, $currentTime, true);
+
+        $this->assertEquals('today', $result);
+
+        // 2 hours ago is still today
+        $elementTime = $currentTime - 2 * 3600;
+        $result = (string)relative_modified_date($elementTime, $currentTime, true);
+
+        $this->assertEquals('today', $result);
+    }
+
+    public function testRelativeDateYesterday(): void {
+        $currentTime = 1380703592;
+        $elementTime = $currentTime - 24 * 3600;
+        $result = (string)relative_modified_date($elementTime, $currentTime, true);
+
+        $this->assertEquals('yesterday', $result);
+
+        // yesterday - 2 hours is still yesterday
+        $elementTime = $currentTime - 26 * 3600;
+        $result = (string)relative_modified_date($elementTime, $currentTime, true);
+
+        $this->assertEquals('yesterday', $result);
+    }
+
+    public function testRelativeDate2DaysAgo(): void {
+        $currentTime = 1380703592;
+        $elementTime = $currentTime - 48 * 3600;
+        $result = (string)relative_modified_date($elementTime, $currentTime, true);
 
-		$this->assertEquals('2 days ago', $result);
-
-		// 2 days ago minus 4 hours is still 2 days ago
-		$elementTime = $currentTime - 52 * 3600;
-		$result = (string)relative_modified_date($elementTime, $currentTime, true);
-
-		$this->assertEquals('2 days ago', $result);
-	}
+        $this->assertEquals('2 days ago', $result);
+
+        // 2 days ago minus 4 hours is still 2 days ago
+        $elementTime = $currentTime - 52 * 3600;
+        $result = (string)relative_modified_date($elementTime, $currentTime, true);
+
+        $this->assertEquals('2 days ago', $result);
+    }
 
-	public function testRelativeDateLastMonth(): void {
-		$currentTime = 1380703592;
-		$elementTime = $currentTime - 86400 * 31;
-		$result = (string)relative_modified_date($elementTime, $currentTime, true);
+    public function testRelativeDateLastMonth(): void {
+        $currentTime = 1380703592;
+        $elementTime = $currentTime - 86400 * 31;
+        $result = (string)relative_modified_date($elementTime, $currentTime, true);
 
-		$this->assertEquals('last month', $result);
+        $this->assertEquals('last month', $result);
 
-		$elementTime = $currentTime - 86400 * 35;
-		$result = (string)relative_modified_date($elementTime, $currentTime, true);
+        $elementTime = $currentTime - 86400 * 35;
+        $result = (string)relative_modified_date($elementTime, $currentTime, true);
 
-		$this->assertEquals('last month', $result);
-	}
+        $this->assertEquals('last month', $result);
+    }
 
-	public function testRelativeDateMonthsAgo(): void {
-		$currentTime = 1380703592;
-		$elementTime = $currentTime - 86400 * 65;
-		$result = (string)relative_modified_date($elementTime, $currentTime, true);
+    public function testRelativeDateMonthsAgo(): void {
+        $currentTime = 1380703592;
+        $elementTime = $currentTime - 86400 * 65;
+        $result = (string)relative_modified_date($elementTime, $currentTime, true);
 
-		$this->assertEquals('2 months ago', $result);
+        $this->assertEquals('2 months ago', $result);
 
-		$elementTime = $currentTime - 86400 * 130;
-		$result = (string)relative_modified_date($elementTime, $currentTime, true);
+        $elementTime = $currentTime - 86400 * 130;
+        $result = (string)relative_modified_date($elementTime, $currentTime, true);
 
-		$this->assertEquals('4 months ago', $result);
-	}
+        $this->assertEquals('4 months ago', $result);
+    }
 
-	public function testRelativeDateLastYear(): void {
-		$currentTime = 1380703592;
-		$elementTime = $currentTime - 86400 * 365;
-		$result = (string)relative_modified_date($elementTime, $currentTime, true);
+    public function testRelativeDateLastYear(): void {
+        $currentTime = 1380703592;
+        $elementTime = $currentTime - 86400 * 365;
+        $result = (string)relative_modified_date($elementTime, $currentTime, true);
 
-		$this->assertEquals('last year', $result);
+        $this->assertEquals('last year', $result);
 
-		$elementTime = $currentTime - 86400 * 450;
-		$result = (string)relative_modified_date($elementTime, $currentTime, true);
+        $elementTime = $currentTime - 86400 * 450;
+        $result = (string)relative_modified_date($elementTime, $currentTime, true);
 
-		$this->assertEquals('last year', $result);
-	}
+        $this->assertEquals('last year', $result);
+    }
 
-	public function testRelativeDateYearsAgo(): void {
-		$currentTime = 1380703592;
-		$elementTime = $currentTime - 86400 * 365.25 * 2;
-		$result = (string)relative_modified_date($elementTime, $currentTime, true);
+    public function testRelativeDateYearsAgo(): void {
+        $currentTime = 1380703592;
+        $elementTime = $currentTime - 86400 * 365.25 * 2;
+        $result = (string)relative_modified_date($elementTime, $currentTime, true);
 
-		$this->assertEquals('2 years ago', $result);
+        $this->assertEquals('2 years ago', $result);
 
-		$elementTime = $currentTime - 86400 * 365.25 * 3;
-		$result = (string)relative_modified_date($elementTime, $currentTime, true);
+        $elementTime = $currentTime - 86400 * 365.25 * 3;
+        $result = (string)relative_modified_date($elementTime, $currentTime, true);
 
-		$this->assertEquals('3 years ago', $result);
-	}
+        $this->assertEquals('3 years ago', $result);
+    }
 
-	// ---------------------------------------------------------------------------
-	// Test relative_modified_date with timestamps only (date + time value)
-	// ---------------------------------------------------------------------------
+    // ---------------------------------------------------------------------------
+    // Test relative_modified_date with timestamps only (date + time value)
+    // ---------------------------------------------------------------------------
 
-	public function testRelativeTimeSecondsAgo(): void {
-		$currentTime = 1380703592;
-		$elementTime = $currentTime - 5;
-		$result = (string)relative_modified_date($elementTime, $currentTime, false);
+    public function testRelativeTimeSecondsAgo(): void {
+        $currentTime = 1380703592;
+        $elementTime = $currentTime - 5;
+        $result = (string)relative_modified_date($elementTime, $currentTime, false);
 
-		$this->assertEquals('seconds ago', $result);
-	}
+        $this->assertEquals('seconds ago', $result);
+    }
 
-	public function testRelativeTimeMinutesAgo(): void {
-		$currentTime = 1380703592;
-		$elementTime = $currentTime - 190;
-		$result = (string)relative_modified_date($elementTime, $currentTime, false);
+    public function testRelativeTimeMinutesAgo(): void {
+        $currentTime = 1380703592;
+        $elementTime = $currentTime - 190;
+        $result = (string)relative_modified_date($elementTime, $currentTime, false);
 
-		$this->assertEquals('3 minutes ago', $result);
-	}
+        $this->assertEquals('3 minutes ago', $result);
+    }
 
-	public function testRelativeTimeHoursAgo(): void {
-		$currentTime = 1380703592;
-		$elementTime = $currentTime - 7500;
-		$result = (string)relative_modified_date($elementTime, $currentTime, false);
+    public function testRelativeTimeHoursAgo(): void {
+        $currentTime = 1380703592;
+        $elementTime = $currentTime - 7500;
+        $result = (string)relative_modified_date($elementTime, $currentTime, false);
 
-		$this->assertEquals('2 hours ago', $result);
-	}
+        $this->assertEquals('2 hours ago', $result);
+    }
 
-	public function testRelativeTime2DaysAgo(): void {
-		$currentTime = 1380703592;
-		$elementTime = $currentTime - 48 * 3600;
-		$result = (string)relative_modified_date($elementTime, $currentTime, false);
+    public function testRelativeTime2DaysAgo(): void {
+        $currentTime = 1380703592;
+        $elementTime = $currentTime - 48 * 3600;
+        $result = (string)relative_modified_date($elementTime, $currentTime, false);
 
-		$this->assertEquals('2 days ago', $result);
+        $this->assertEquals('2 days ago', $result);
 
-		// 2 days ago minus 4 hours is still 2 days ago
-		$elementTime = $currentTime - 52 * 3600;
-		$result = (string)relative_modified_date($elementTime, $currentTime, false);
+        // 2 days ago minus 4 hours is still 2 days ago
+        $elementTime = $currentTime - 52 * 3600;
+        $result = (string)relative_modified_date($elementTime, $currentTime, false);
 
-		$this->assertEquals('2 days ago', $result);
-	}
+        $this->assertEquals('2 days ago', $result);
+    }
 
-	public function testRelativeTimeLastMonth(): void {
-		$currentTime = 1380703592;
-		$elementTime = $currentTime - 86400 * 31;
-		$result = (string)relative_modified_date($elementTime, $currentTime, false);
+    public function testRelativeTimeLastMonth(): void {
+        $currentTime = 1380703592;
+        $elementTime = $currentTime - 86400 * 31;
+        $result = (string)relative_modified_date($elementTime, $currentTime, false);
 
-		$this->assertEquals('last month', $result);
+        $this->assertEquals('last month', $result);
 
-		$elementTime = $currentTime - 86400 * 35;
-		$result = (string)relative_modified_date($elementTime, $currentTime, false);
+        $elementTime = $currentTime - 86400 * 35;
+        $result = (string)relative_modified_date($elementTime, $currentTime, false);
 
-		$this->assertEquals('last month', $result);
-	}
+        $this->assertEquals('last month', $result);
+    }
 
-	public function testRelativeTimeMonthsAgo(): void {
-		$currentTime = 1380703592;
-		$elementTime = $currentTime - 86400 * 65;
-		$result = (string)relative_modified_date($elementTime, $currentTime, false);
+    public function testRelativeTimeMonthsAgo(): void {
+        $currentTime = 1380703592;
+        $elementTime = $currentTime - 86400 * 65;
+        $result = (string)relative_modified_date($elementTime, $currentTime, false);
 
-		$this->assertEquals('2 months ago', $result);
+        $this->assertEquals('2 months ago', $result);
 
-		$elementTime = $currentTime - 86400 * 130;
-		$result = (string)relative_modified_date($elementTime, $currentTime, false);
+        $elementTime = $currentTime - 86400 * 130;
+        $result = (string)relative_modified_date($elementTime, $currentTime, false);
 
-		$this->assertEquals('4 months ago', $result);
-	}
+        $this->assertEquals('4 months ago', $result);
+    }
 
-	public function testRelativeTimeLastYear(): void {
-		$currentTime = 1380703592;
-		$elementTime = $currentTime - 86400 * 365;
-		$result = (string)relative_modified_date($elementTime, $currentTime, false);
+    public function testRelativeTimeLastYear(): void {
+        $currentTime = 1380703592;
+        $elementTime = $currentTime - 86400 * 365;
+        $result = (string)relative_modified_date($elementTime, $currentTime, false);
 
-		$this->assertEquals('last year', $result);
+        $this->assertEquals('last year', $result);
 
-		$elementTime = $currentTime - 86400 * 450;
-		$result = (string)relative_modified_date($elementTime, $currentTime, false);
+        $elementTime = $currentTime - 86400 * 450;
+        $result = (string)relative_modified_date($elementTime, $currentTime, false);
 
-		$this->assertEquals('last year', $result);
-	}
+        $this->assertEquals('last year', $result);
+    }
 
-	public function testRelativeTimeYearsAgo(): void {
-		$currentTime = 1380703592;
-		$elementTime = $currentTime - 86400 * 365.25 * 2;
-		$result = (string)relative_modified_date($elementTime, $currentTime, false);
+    public function testRelativeTimeYearsAgo(): void {
+        $currentTime = 1380703592;
+        $elementTime = $currentTime - 86400 * 365.25 * 2;
+        $result = (string)relative_modified_date($elementTime, $currentTime, false);
 
-		$this->assertEquals('2 years ago', $result);
+        $this->assertEquals('2 years ago', $result);
 
-		$elementTime = $currentTime - 86400 * 365.25 * 3;
-		$result = (string)relative_modified_date($elementTime, $currentTime, false);
+        $elementTime = $currentTime - 86400 * 365.25 * 3;
+        $result = (string)relative_modified_date($elementTime, $currentTime, false);
 
-		$this->assertEquals('3 years ago', $result);
-	}
+        $this->assertEquals('3 years ago', $result);
+    }
 }

tests/lib/Http/WellKnown/RequestManagerTest.php

Indentation +124 added lines, -124 removed lines

@@ -27,128 +27,128 @@
 use function get_class;
 
 class RequestManagerTest extends TestCase {
-	/** @var Coordinator|MockObject */
-	private $coordinator;
-
-	/** @var IServerContainer|MockObject */
-	private $container;
-
-	/** @var MockObject|LoggerInterface */
-	private $logger;
-
-	/** @var RequestManager */
-	private $manager;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->coordinator = $this->createMock(Coordinator::class);
-		$this->container = $this->createMock(IServerContainer::class);
-		$this->logger = $this->createMock(LoggerInterface::class);
-
-		$this->manager = new RequestManager(
-			$this->coordinator,
-			$this->container,
-			$this->logger,
-		);
-	}
-
-	public function testProcessAppsNotRegistered(): void {
-		$request = $this->createMock(IRequest::class);
-		$this->expectException(RuntimeException::class);
-
-		$this->manager->process('webfinger', $request);
-	}
-
-	public function testProcessNoHandlersRegistered(): void {
-		$request = $this->createMock(IRequest::class);
-		$registrationContext = $this->createMock(RegistrationContext::class);
-		$this->coordinator->expects(self::once())
-			->method('getRegistrationContext')
-			->willReturn($registrationContext);
-		$registrationContext->expects(self::once())
-			->method('getWellKnownHandlers')
-			->willReturn([]);
-
-		$response = $this->manager->process('webfinger', $request);
-
-		self::assertNull($response);
-	}
-
-	public function testProcessHandlerNotLoadable(): void {
-		$request = $this->createMock(IRequest::class);
-		$registrationContext = $this->createMock(RegistrationContext::class);
-		$this->coordinator->expects(self::once())
-			->method('getRegistrationContext')
-			->willReturn($registrationContext);
-		$handler = new class {
-		};
-		$registrationContext->expects(self::once())
-			->method('getWellKnownHandlers')
-			->willReturn([
-				new ServiceRegistration('test', get_class($handler)),
-			]);
-		$this->container->expects(self::once())
-			->method('get')
-			->with(get_class($handler))
-			->willThrowException(new QueryException(''));
-		$this->logger->expects(self::once())
-			->method('error');
-
-		$response = $this->manager->process('webfinger', $request);
-
-		self::assertNull($response);
-	}
-
-	public function testProcessHandlerOfWrongType(): void {
-		$request = $this->createMock(IRequest::class);
-		$registrationContext = $this->createMock(RegistrationContext::class);
-		$this->coordinator->expects(self::once())
-			->method('getRegistrationContext')
-			->willReturn($registrationContext);
-		$handler = new class {
-		};
-		$registrationContext->expects(self::once())
-			->method('getWellKnownHandlers')
-			->willReturn([
-				new ServiceRegistration('test', get_class($handler)),
-			]);
-		$this->container->expects(self::once())
-			->method('get')
-			->with(get_class($handler))
-			->willReturn($handler);
-		$this->logger->expects(self::once())
-			->method('error');
-
-		$response = $this->manager->process('webfinger', $request);
-
-		self::assertNull($response);
-	}
-
-	public function testProcess(): void {
-		$request = $this->createMock(IRequest::class);
-		$registrationContext = $this->createMock(RegistrationContext::class);
-		$this->coordinator->expects(self::once())
-			->method('getRegistrationContext')
-			->willReturn($registrationContext);
-		$handler = new class implements IHandler {
-			public function handle(string $service, IRequestContext $context, ?IResponse $previousResponse): ?IResponse {
-				return (new JrdResponse($service))->addAlias('alias');
-			}
-		};
-		$registrationContext->expects(self::once())
-			->method('getWellKnownHandlers')
-			->willReturn([
-				new ServiceRegistration('test', get_class($handler)),
-			]);
-		$this->container->expects(self::once())
-			->method('get')
-			->with(get_class($handler))
-			->willReturn($handler);
-
-		$response = $this->manager->process('webfinger', $request);
-
-		self::assertNotNull($response);
-		self::assertInstanceOf(JrdResponse::class, $response);
-	}
+    /** @var Coordinator|MockObject */
+    private $coordinator;
+
+    /** @var IServerContainer|MockObject */
+    private $container;
+
+    /** @var MockObject|LoggerInterface */
+    private $logger;
+
+    /** @var RequestManager */
+    private $manager;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->coordinator = $this->createMock(Coordinator::class);
+        $this->container = $this->createMock(IServerContainer::class);
+        $this->logger = $this->createMock(LoggerInterface::class);
+
+        $this->manager = new RequestManager(
+            $this->coordinator,
+            $this->container,
+            $this->logger,
+        );
+    }
+
+    public function testProcessAppsNotRegistered(): void {
+        $request = $this->createMock(IRequest::class);
+        $this->expectException(RuntimeException::class);
+
+        $this->manager->process('webfinger', $request);
+    }
+
+    public function testProcessNoHandlersRegistered(): void {
+        $request = $this->createMock(IRequest::class);
+        $registrationContext = $this->createMock(RegistrationContext::class);
+        $this->coordinator->expects(self::once())
+            ->method('getRegistrationContext')
+            ->willReturn($registrationContext);
+        $registrationContext->expects(self::once())
+            ->method('getWellKnownHandlers')
+            ->willReturn([]);
+
+        $response = $this->manager->process('webfinger', $request);
+
+        self::assertNull($response);
+    }
+
+    public function testProcessHandlerNotLoadable(): void {
+        $request = $this->createMock(IRequest::class);
+        $registrationContext = $this->createMock(RegistrationContext::class);
+        $this->coordinator->expects(self::once())
+            ->method('getRegistrationContext')
+            ->willReturn($registrationContext);
+        $handler = new class {
+        };
+        $registrationContext->expects(self::once())
+            ->method('getWellKnownHandlers')
+            ->willReturn([
+                new ServiceRegistration('test', get_class($handler)),
+            ]);
+        $this->container->expects(self::once())
+            ->method('get')
+            ->with(get_class($handler))
+            ->willThrowException(new QueryException(''));
+        $this->logger->expects(self::once())
+            ->method('error');
+
+        $response = $this->manager->process('webfinger', $request);
+
+        self::assertNull($response);
+    }
+
+    public function testProcessHandlerOfWrongType(): void {
+        $request = $this->createMock(IRequest::class);
+        $registrationContext = $this->createMock(RegistrationContext::class);
+        $this->coordinator->expects(self::once())
+            ->method('getRegistrationContext')
+            ->willReturn($registrationContext);
+        $handler = new class {
+        };
+        $registrationContext->expects(self::once())
+            ->method('getWellKnownHandlers')
+            ->willReturn([
+                new ServiceRegistration('test', get_class($handler)),
+            ]);
+        $this->container->expects(self::once())
+            ->method('get')
+            ->with(get_class($handler))
+            ->willReturn($handler);
+        $this->logger->expects(self::once())
+            ->method('error');
+
+        $response = $this->manager->process('webfinger', $request);
+
+        self::assertNull($response);
+    }
+
+    public function testProcess(): void {
+        $request = $this->createMock(IRequest::class);
+        $registrationContext = $this->createMock(RegistrationContext::class);
+        $this->coordinator->expects(self::once())
+            ->method('getRegistrationContext')
+            ->willReturn($registrationContext);
+        $handler = new class implements IHandler {
+            public function handle(string $service, IRequestContext $context, ?IResponse $previousResponse): ?IResponse {
+                return (new JrdResponse($service))->addAlias('alias');
+            }
+        };
+        $registrationContext->expects(self::once())
+            ->method('getWellKnownHandlers')
+            ->willReturn([
+                new ServiceRegistration('test', get_class($handler)),
+            ]);
+        $this->container->expects(self::once())
+            ->method('get')
+            ->with(get_class($handler))
+            ->willReturn($handler);
+
+        $response = $this->manager->process('webfinger', $request);
+
+        self::assertNotNull($response);
+        self::assertInstanceOf(JrdResponse::class, $response);
+    }
 }

tests/lib/Http/WellKnown/JrdResponseTest.php

Indentation +72 added lines, -72 removed lines

@@ -14,79 +14,79 @@
 use Test\TestCase;
 
 class JrdResponseTest extends TestCase {
-	public function testEmptyToHttpResponse(): void {
-		$response = new JrdResponse('subject');
-		$httpResponse = $response->toHttpResponse();
+    public function testEmptyToHttpResponse(): void {
+        $response = new JrdResponse('subject');
+        $httpResponse = $response->toHttpResponse();
 
-		self::assertTrue($response->isEmpty());
-		self::assertInstanceOf(JSONResponse::class, $httpResponse);
-		/** @var JSONResponse $httpResponse */
-		self::assertEquals(
-			[
-				'subject' => 'subject',
-			],
-			$httpResponse->getData()
-		);
-	}
+        self::assertTrue($response->isEmpty());
+        self::assertInstanceOf(JSONResponse::class, $httpResponse);
+        /** @var JSONResponse $httpResponse */
+        self::assertEquals(
+            [
+                'subject' => 'subject',
+            ],
+            $httpResponse->getData()
+        );
+    }
 
-	public function testComplexToHttpResponse(): void {
-		$response = new JrdResponse('subject');
-		$response->addAlias('alias');
-		$response->addAlias('blias');
-		$response->addProperty('propa', 'a');
-		$response->addProperty('propb', null);
-		$response->setExpires('tomorrow');
-		$response->addLink('rel', null, null);
-		$response->addLink('rel', 'type', null);
-		$response->addLink('rel', 'type', 'href', ['title' => 'titlevalue']);
-		$response->addLink('rel', 'type', 'href', ['title' => 'titlevalue'], ['propx' => 'valx']);
-		$httpResponse = $response->toHttpResponse();
+    public function testComplexToHttpResponse(): void {
+        $response = new JrdResponse('subject');
+        $response->addAlias('alias');
+        $response->addAlias('blias');
+        $response->addProperty('propa', 'a');
+        $response->addProperty('propb', null);
+        $response->setExpires('tomorrow');
+        $response->addLink('rel', null, null);
+        $response->addLink('rel', 'type', null);
+        $response->addLink('rel', 'type', 'href', ['title' => 'titlevalue']);
+        $response->addLink('rel', 'type', 'href', ['title' => 'titlevalue'], ['propx' => 'valx']);
+        $httpResponse = $response->toHttpResponse();
 
-		self::assertFalse($response->isEmpty());
-		self::assertInstanceOf(JSONResponse::class, $httpResponse);
-		/** @var JSONResponse $httpResponse */
-		self::assertEquals(
-			[
-				'subject' => 'subject',
-				'aliases' => [
-					'alias',
-					'blias',
-				],
-				'properties' => [
-					'propa' => 'a',
-					'propb' => null,
-				],
-				'expires' => 'tomorrow',
-				'links' => [
-					[
-						'rel' => 'rel',
-					],
-					[
-						'rel' => 'rel',
-						'type' => 'type',
-					],
-					[
-						'rel' => 'rel',
-						'type' => 'type',
-						'href' => 'href',
-						'titles' => [
-							'title' => 'titlevalue',
-						],
-					],
-					[
-						'rel' => 'rel',
-						'type' => 'type',
-						'href' => 'href',
-						'titles' => [
-							'title' => 'titlevalue',
-						],
-						'properties' => [
-							'propx' => 'valx',
-						],
-					],
-				]
-			],
-			$httpResponse->getData()
-		);
-	}
+        self::assertFalse($response->isEmpty());
+        self::assertInstanceOf(JSONResponse::class, $httpResponse);
+        /** @var JSONResponse $httpResponse */
+        self::assertEquals(
+            [
+                'subject' => 'subject',
+                'aliases' => [
+                    'alias',
+                    'blias',
+                ],
+                'properties' => [
+                    'propa' => 'a',
+                    'propb' => null,
+                ],
+                'expires' => 'tomorrow',
+                'links' => [
+                    [
+                        'rel' => 'rel',
+                    ],
+                    [
+                        'rel' => 'rel',
+                        'type' => 'type',
+                    ],
+                    [
+                        'rel' => 'rel',
+                        'type' => 'type',
+                        'href' => 'href',
+                        'titles' => [
+                            'title' => 'titlevalue',
+                        ],
+                    ],
+                    [
+                        'rel' => 'rel',
+                        'type' => 'type',
+                        'href' => 'href',
+                        'titles' => [
+                            'title' => 'titlevalue',
+                        ],
+                        'properties' => [
+                            'propx' => 'valx',
+                        ],
+                    ],
+                ]
+            ],
+            $httpResponse->getData()
+        );
+    }
 }

tests/lib/Http/WellKnown/GenericResponseTest.php

Indentation +5 added lines, -5 removed lines

@@ -14,11 +14,11 @@
 use Test\TestCase;
 
 class GenericResponseTest extends TestCase {
-	public function testToHttpResponse(): void {
-		$httpResponse = $this->createMock(JSONResponse::class);
+    public function testToHttpResponse(): void {
+        $httpResponse = $this->createMock(JSONResponse::class);
 
-		$response = new GenericResponse($httpResponse);
+        $response = new GenericResponse($httpResponse);
 
-		self::assertSame($httpResponse, $response->toHttpResponse());
-	}
+        self::assertSame($httpResponse, $response->toHttpResponse());
+    }
 }