nextcloud / server

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());
+    }
 }

tests/lib/Http/Client/ResponseTest.php

Indentation +40 added lines, -40 removed lines

@@ -15,44 +15,44 @@
  * Class ResponseTest
  */
 class ResponseTest extends \Test\TestCase {
-	/** @var GuzzleResponse */
-	private $guzzleResponse;
-
-	protected function setUp(): void {
-		parent::setUp();
-		$this->guzzleResponse = new GuzzleResponse(418);
-	}
-
-	public function testGetBody(): void {
-		$response = new Response($this->guzzleResponse->withBody(Utils::streamFor('MyResponse')));
-		$this->assertSame('MyResponse', $response->getBody());
-	}
-
-	public function testGetStatusCode(): void {
-		$response = new Response($this->guzzleResponse);
-		$this->assertSame(418, $response->getStatusCode());
-	}
-
-	public function testGetHeader(): void {
-		$response = new Response($this->guzzleResponse->withHeader('bar', 'foo'));
-		$this->assertSame('foo', $response->getHeader('bar'));
-	}
-
-	public function testGetHeaders(): void {
-		$response = new Response($this->guzzleResponse
-			->withHeader('bar', 'foo')
-			->withHeader('x-awesome', 'yes')
-		);
-
-		$expected = [
-			'bar' => [
-				0 => 'foo',
-			],
-			'x-awesome' => [
-				0 => 'yes',
-			],
-		];
-		$this->assertSame($expected, $response->getHeaders());
-		$this->assertSame('yes', $response->getHeader('x-awesome'));
-	}
+    /** @var GuzzleResponse */
+    private $guzzleResponse;
+
+    protected function setUp(): void {
+        parent::setUp();
+        $this->guzzleResponse = new GuzzleResponse(418);
+    }
+
+    public function testGetBody(): void {
+        $response = new Response($this->guzzleResponse->withBody(Utils::streamFor('MyResponse')));
+        $this->assertSame('MyResponse', $response->getBody());
+    }
+
+    public function testGetStatusCode(): void {
+        $response = new Response($this->guzzleResponse);
+        $this->assertSame(418, $response->getStatusCode());
+    }
+
+    public function testGetHeader(): void {
+        $response = new Response($this->guzzleResponse->withHeader('bar', 'foo'));
+        $this->assertSame('foo', $response->getHeader('bar'));
+    }
+
+    public function testGetHeaders(): void {
+        $response = new Response($this->guzzleResponse
+            ->withHeader('bar', 'foo')
+            ->withHeader('x-awesome', 'yes')
+        );
+
+        $expected = [
+            'bar' => [
+                0 => 'foo',
+            ],
+            'x-awesome' => [
+                0 => 'yes',
+            ],
+        ];
+        $this->assertSame($expected, $response->getHeaders());
+        $this->assertSame('yes', $response->getHeader('x-awesome'));
+    }
 }

tests/lib/Authentication/TwoFactorAuth/ProviderLoaderTest.php

Indentation +97 added lines, -97 removed lines

@@ -20,101 +20,101 @@
 use Test\TestCase;
 
 class ProviderLoaderTest extends TestCase {
-	/** @var IAppManager|MockObject */
-	private $appManager;
-
-	/** @var IUser|MockObject */
-	private $user;
-
-	/** @var RegistrationContext|MockObject */
-	private $registrationContext;
-
-	/** @var ProviderLoader */
-	private $loader;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->appManager = $this->createMock(IAppManager::class);
-		$this->user = $this->createMock(IUser::class);
-
-		$this->registrationContext = $this->createMock(RegistrationContext::class);
-		$coordinator = $this->createMock(Coordinator::class);
-		$coordinator->method('getRegistrationContext')
-			->willReturn($this->registrationContext);
-
-		$this->loader = new ProviderLoader($this->appManager, $coordinator);
-	}
-
-
-	public function testFailHardIfProviderCanNotBeLoaded(): void {
-		$this->expectException(\Exception::class);
-		$this->expectExceptionMessage('Could not load two-factor auth provider \\OCA\\MyFaulty2faApp\\DoesNotExist');
-
-		$this->appManager->expects($this->once())
-			->method('getEnabledAppsForUser')
-			->with($this->user)
-			->willReturn(['mail', 'twofactor_totp']);
-		$this->appManager
-			->method('getAppInfo')
-			->willReturnMap([
-				['mail', false, null, []],
-				['twofactor_totp', false, null, [
-					'two-factor-providers' => [
-						'\\OCA\\MyFaulty2faApp\\DoesNotExist',
-					],
-				]],
-			]);
-
-		$this->loader->getProviders($this->user);
-	}
-
-	public function testGetProviders(): void {
-		$provider = $this->createMock(IProvider::class);
-		$provider->method('getId')->willReturn('test');
-		\OC::$server->registerService('\\OCA\\TwoFactorTest\\Provider', function () use ($provider) {
-			return $provider;
-		});
-		$this->appManager->expects($this->once())
-			->method('getEnabledAppsForUser')
-			->with($this->user)
-			->willReturn(['twofactor_test']);
-		$this->appManager
-			->method('getAppInfo')
-			->with('twofactor_test')
-			->willReturn(['two-factor-providers' => [
-				'\\OCA\\TwoFactorTest\\Provider',
-			]]);
-
-		$providers = $this->loader->getProviders($this->user);
-
-		$this->assertCount(1, $providers);
-		$this->assertArrayHasKey('test', $providers);
-		$this->assertSame($provider, $providers['test']);
-	}
-
-	public function testGetProvidersBootstrap(): void {
-		$provider = $this->createMock(IProvider::class);
-		$provider->method('getId')->willReturn('test');
-
-		\OC::$server->registerService('\\OCA\\TwoFactorTest\\Provider', function () use ($provider) {
-			return $provider;
-		});
-
-		$this->appManager->expects($this->once())
-			->method('getEnabledAppsForUser')
-			->with($this->user)
-			->willReturn([]);
-
-		$this->registrationContext->method('getTwoFactorProviders')
-			->willReturn([
-				new ServiceRegistration('twofactor_test', '\\OCA\\TwoFactorTest\\Provider')
-			]);
-
-		$providers = $this->loader->getProviders($this->user);
-
-		$this->assertCount(1, $providers);
-		$this->assertArrayHasKey('test', $providers);
-		$this->assertSame($provider, $providers['test']);
-	}
+    /** @var IAppManager|MockObject */
+    private $appManager;
+
+    /** @var IUser|MockObject */
+    private $user;
+
+    /** @var RegistrationContext|MockObject */
+    private $registrationContext;
+
+    /** @var ProviderLoader */
+    private $loader;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->appManager = $this->createMock(IAppManager::class);
+        $this->user = $this->createMock(IUser::class);
+
+        $this->registrationContext = $this->createMock(RegistrationContext::class);
+        $coordinator = $this->createMock(Coordinator::class);
+        $coordinator->method('getRegistrationContext')
+            ->willReturn($this->registrationContext);
+
+        $this->loader = new ProviderLoader($this->appManager, $coordinator);
+    }
+
+
+    public function testFailHardIfProviderCanNotBeLoaded(): void {
+        $this->expectException(\Exception::class);
+        $this->expectExceptionMessage('Could not load two-factor auth provider \\OCA\\MyFaulty2faApp\\DoesNotExist');
+
+        $this->appManager->expects($this->once())
+            ->method('getEnabledAppsForUser')
+            ->with($this->user)
+            ->willReturn(['mail', 'twofactor_totp']);
+        $this->appManager
+            ->method('getAppInfo')
+            ->willReturnMap([
+                ['mail', false, null, []],
+                ['twofactor_totp', false, null, [
+                    'two-factor-providers' => [
+                        '\\OCA\\MyFaulty2faApp\\DoesNotExist',
+                    ],
+                ]],
+            ]);
+
+        $this->loader->getProviders($this->user);
+    }
+
+    public function testGetProviders(): void {
+        $provider = $this->createMock(IProvider::class);
+        $provider->method('getId')->willReturn('test');
+        \OC::$server->registerService('\\OCA\\TwoFactorTest\\Provider', function () use ($provider) {
+            return $provider;
+        });
+        $this->appManager->expects($this->once())
+            ->method('getEnabledAppsForUser')
+            ->with($this->user)
+            ->willReturn(['twofactor_test']);
+        $this->appManager
+            ->method('getAppInfo')
+            ->with('twofactor_test')
+            ->willReturn(['two-factor-providers' => [
+                '\\OCA\\TwoFactorTest\\Provider',
+            ]]);
+
+        $providers = $this->loader->getProviders($this->user);
+
+        $this->assertCount(1, $providers);
+        $this->assertArrayHasKey('test', $providers);
+        $this->assertSame($provider, $providers['test']);
+    }
+
+    public function testGetProvidersBootstrap(): void {
+        $provider = $this->createMock(IProvider::class);
+        $provider->method('getId')->willReturn('test');
+
+        \OC::$server->registerService('\\OCA\\TwoFactorTest\\Provider', function () use ($provider) {
+            return $provider;
+        });
+
+        $this->appManager->expects($this->once())
+            ->method('getEnabledAppsForUser')
+            ->with($this->user)
+            ->willReturn([]);
+
+        $this->registrationContext->method('getTwoFactorProviders')
+            ->willReturn([
+                new ServiceRegistration('twofactor_test', '\\OCA\\TwoFactorTest\\Provider')
+            ]);
+
+        $providers = $this->loader->getProviders($this->user);
+
+        $this->assertCount(1, $providers);
+        $this->assertArrayHasKey('test', $providers);
+        $this->assertSame($provider, $providers['test']);
+    }
 }

tests/lib/Authentication/TwoFactorAuth/MandatoryTwoFactorTest.php

Indentation +158 added lines, -158 removed lines

@@ -18,162 +18,162 @@
 use Test\TestCase;
 
 class MandatoryTwoFactorTest extends TestCase {
-	/** @var IConfig|MockObject */
-	private $config;
-
-	/** @var IGroupManager|MockObject */
-	private $groupManager;
-
-	/** @var MandatoryTwoFactor */
-	private $mandatoryTwoFactor;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->config = $this->createMock(IConfig::class);
-		$this->groupManager = $this->createMock(IGroupManager::class);
-
-		$this->mandatoryTwoFactor = new MandatoryTwoFactor($this->config, $this->groupManager);
-	}
-
-	public function testIsNotEnforced(): void {
-		$this->config
-			->method('getSystemValue')
-			->willReturnMap([
-				['twofactor_enforced', 'false', 'false'],
-				['twofactor_enforced_groups', [], []],
-				['twofactor_enforced_excluded_groups', [], []],
-			]);
-
-		$state = $this->mandatoryTwoFactor->getState();
-
-		$this->assertFalse($state->isEnforced());
-	}
-
-	public function testIsEnforced(): void {
-		$this->config
-			->method('getSystemValue')
-			->willReturnMap([
-				['twofactor_enforced', 'false', 'true'],
-				['twofactor_enforced_groups', [], []],
-				['twofactor_enforced_excluded_groups', [], []],
-			]);
-
-		$state = $this->mandatoryTwoFactor->getState();
-
-		$this->assertTrue($state->isEnforced());
-	}
-
-	public function testIsNotEnforcedForAnybody(): void {
-		$user = $this->createMock(IUser::class);
-		$user->method('getUID')->willReturn('user123');
-		$this->config
-			->method('getSystemValue')
-			->willReturnMap([
-				['twofactor_enforced', 'false', 'false'],
-				['twofactor_enforced_groups', [], []],
-				['twofactor_enforced_excluded_groups', [], []],
-			]);
-
-		$isEnforced = $this->mandatoryTwoFactor->isEnforcedFor($user);
-
-		$this->assertFalse($isEnforced);
-	}
-
-	public function testIsEnforcedForAGroupMember(): void {
-		$user = $this->createMock(IUser::class);
-		$user->method('getUID')->willReturn('user123');
-		$this->config
-			->method('getSystemValue')
-			->willReturnMap([
-				['twofactor_enforced', 'false', 'true'],
-				['twofactor_enforced_groups', [], ['twofactorers']],
-				['twofactor_enforced_excluded_groups', [], []],
-			]);
-		$this->groupManager->method('isInGroup')
-			->willReturnCallback(function ($user, $group) {
-				return $user === 'user123' && $group === 'twofactorers';
-			});
-
-		$isEnforced = $this->mandatoryTwoFactor->isEnforcedFor($user);
-
-		$this->assertTrue($isEnforced);
-	}
-
-	public function testIsEnforcedForOtherGroups(): void {
-		$user = $this->createMock(IUser::class);
-		$user->method('getUID')->willReturn('user123');
-		$this->config
-			->method('getSystemValue')
-			->willReturnMap([
-				['twofactor_enforced', 'false', 'true'],
-				['twofactor_enforced_groups', [], ['twofactorers']],
-				['twofactor_enforced_excluded_groups', [], []],
-			]);
-		$this->groupManager->method('isInGroup')
-			->willReturn(false);
-
-		$isEnforced = $this->mandatoryTwoFactor->isEnforcedFor($user);
-
-		$this->assertFalse($isEnforced);
-	}
-
-	public function testIsEnforcedButMemberOfExcludedGroup(): void {
-		$user = $this->createMock(IUser::class);
-		$user->method('getUID')->willReturn('user123');
-		$this->config
-			->method('getSystemValue')
-			->willReturnMap([
-				['twofactor_enforced', 'false', 'true'],
-				['twofactor_enforced_groups', [], []],
-				['twofactor_enforced_excluded_groups', [], ['yoloers']],
-			]);
-		$this->groupManager->method('isInGroup')
-			->willReturnCallback(function ($user, $group) {
-				return $user === 'user123' && $group === 'yoloers';
-			});
-
-		$isEnforced = $this->mandatoryTwoFactor->isEnforcedFor($user);
-
-		$this->assertFalse($isEnforced);
-	}
-
-	public function testSetEnforced(): void {
-		$this->config
-			->expects($this->exactly(3))
-			->method('setSystemValue')
-			->willReturnMap([
-				['twofactor_enforced', 'true'],
-				['twofactor_enforced_groups', []],
-				['twofactor_enforced_excluded_groups', []],
-			]);
-
-		$this->mandatoryTwoFactor->setState(new EnforcementState(true));
-	}
-
-	public function testSetEnforcedForGroups(): void {
-		$this->config
-			->expects($this->exactly(3))
-			->method('setSystemValue')
-			->willReturnMap([
-				['twofactor_enforced', 'true'],
-				['twofactor_enforced_groups', ['twofactorers']],
-				['twofactor_enforced_excluded_groups', ['yoloers']],
-			]);
-
-		$this->mandatoryTwoFactor->setState(new EnforcementState(true, ['twofactorers'], ['yoloers']));
-	}
-
-	public function testSetNotEnforced(): void {
-		$this->config
-			->expects($this->exactly(3))
-			->method('setSystemValue')
-			->willReturnMap([
-				['twofactor_enforced', 'false'],
-				['twofactor_enforced_groups', []],
-				['twofactor_enforced_excluded_groups', []],
-			]);
-
-		$this->mandatoryTwoFactor->setState(new EnforcementState(false));
-	}
+    /** @var IConfig|MockObject */
+    private $config;
+
+    /** @var IGroupManager|MockObject */
+    private $groupManager;
+
+    /** @var MandatoryTwoFactor */
+    private $mandatoryTwoFactor;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->config = $this->createMock(IConfig::class);
+        $this->groupManager = $this->createMock(IGroupManager::class);
+
+        $this->mandatoryTwoFactor = new MandatoryTwoFactor($this->config, $this->groupManager);
+    }
+
+    public function testIsNotEnforced(): void {
+        $this->config
+            ->method('getSystemValue')
+            ->willReturnMap([
+                ['twofactor_enforced', 'false', 'false'],
+                ['twofactor_enforced_groups', [], []],
+                ['twofactor_enforced_excluded_groups', [], []],
+            ]);
+
+        $state = $this->mandatoryTwoFactor->getState();
+
+        $this->assertFalse($state->isEnforced());
+    }
+
+    public function testIsEnforced(): void {
+        $this->config
+            ->method('getSystemValue')
+            ->willReturnMap([
+                ['twofactor_enforced', 'false', 'true'],
+                ['twofactor_enforced_groups', [], []],
+                ['twofactor_enforced_excluded_groups', [], []],
+            ]);
+
+        $state = $this->mandatoryTwoFactor->getState();
+
+        $this->assertTrue($state->isEnforced());
+    }
+
+    public function testIsNotEnforcedForAnybody(): void {
+        $user = $this->createMock(IUser::class);
+        $user->method('getUID')->willReturn('user123');
+        $this->config
+            ->method('getSystemValue')
+            ->willReturnMap([
+                ['twofactor_enforced', 'false', 'false'],
+                ['twofactor_enforced_groups', [], []],
+                ['twofactor_enforced_excluded_groups', [], []],
+            ]);
+
+        $isEnforced = $this->mandatoryTwoFactor->isEnforcedFor($user);
+
+        $this->assertFalse($isEnforced);
+    }
+
+    public function testIsEnforcedForAGroupMember(): void {
+        $user = $this->createMock(IUser::class);
+        $user->method('getUID')->willReturn('user123');
+        $this->config
+            ->method('getSystemValue')
+            ->willReturnMap([
+                ['twofactor_enforced', 'false', 'true'],
+                ['twofactor_enforced_groups', [], ['twofactorers']],
+                ['twofactor_enforced_excluded_groups', [], []],
+            ]);
+        $this->groupManager->method('isInGroup')
+            ->willReturnCallback(function ($user, $group) {
+                return $user === 'user123' && $group === 'twofactorers';
+            });
+
+        $isEnforced = $this->mandatoryTwoFactor->isEnforcedFor($user);
+
+        $this->assertTrue($isEnforced);
+    }
+
+    public function testIsEnforcedForOtherGroups(): void {
+        $user = $this->createMock(IUser::class);
+        $user->method('getUID')->willReturn('user123');
+        $this->config
+            ->method('getSystemValue')
+            ->willReturnMap([
+                ['twofactor_enforced', 'false', 'true'],
+                ['twofactor_enforced_groups', [], ['twofactorers']],
+                ['twofactor_enforced_excluded_groups', [], []],
+            ]);
+        $this->groupManager->method('isInGroup')
+            ->willReturn(false);
+
+        $isEnforced = $this->mandatoryTwoFactor->isEnforcedFor($user);
+
+        $this->assertFalse($isEnforced);
+    }
+
+    public function testIsEnforcedButMemberOfExcludedGroup(): void {
+        $user = $this->createMock(IUser::class);
+        $user->method('getUID')->willReturn('user123');
+        $this->config
+            ->method('getSystemValue')
+            ->willReturnMap([
+                ['twofactor_enforced', 'false', 'true'],
+                ['twofactor_enforced_groups', [], []],
+                ['twofactor_enforced_excluded_groups', [], ['yoloers']],
+            ]);
+        $this->groupManager->method('isInGroup')
+            ->willReturnCallback(function ($user, $group) {
+                return $user === 'user123' && $group === 'yoloers';
+            });
+
+        $isEnforced = $this->mandatoryTwoFactor->isEnforcedFor($user);
+
+        $this->assertFalse($isEnforced);
+    }
+
+    public function testSetEnforced(): void {
+        $this->config
+            ->expects($this->exactly(3))
+            ->method('setSystemValue')
+            ->willReturnMap([
+                ['twofactor_enforced', 'true'],
+                ['twofactor_enforced_groups', []],
+                ['twofactor_enforced_excluded_groups', []],
+            ]);
+
+        $this->mandatoryTwoFactor->setState(new EnforcementState(true));
+    }
+
+    public function testSetEnforcedForGroups(): void {
+        $this->config
+            ->expects($this->exactly(3))
+            ->method('setSystemValue')
+            ->willReturnMap([
+                ['twofactor_enforced', 'true'],
+                ['twofactor_enforced_groups', ['twofactorers']],
+                ['twofactor_enforced_excluded_groups', ['yoloers']],
+            ]);
+
+        $this->mandatoryTwoFactor->setState(new EnforcementState(true, ['twofactorers'], ['yoloers']));
+    }
+
+    public function testSetNotEnforced(): void {
+        $this->config
+            ->expects($this->exactly(3))
+            ->method('setSystemValue')
+            ->willReturnMap([
+                ['twofactor_enforced', 'false'],
+                ['twofactor_enforced_groups', []],
+                ['twofactor_enforced_excluded_groups', []],
+            ]);
+
+        $this->mandatoryTwoFactor->setState(new EnforcementState(false));
+    }
 }

tests/lib/Authentication/TwoFactorAuth/ProviderSetTest.php

Indentation +57 added lines, -57 removed lines

@@ -15,61 +15,61 @@
 use Test\TestCase;
 
 class ProviderSetTest extends TestCase {
-	/** @var ProviderSet */
-	private $providerSet;
-
-	public function testIndexesProviders(): void {
-		$p1 = $this->createMock(IProvider::class);
-		$p1->method('getId')->willReturn('p1');
-		$p2 = $this->createMock(IProvider::class);
-		$p2->method('getId')->willReturn('p2');
-		$expected = [
-			'p1' => $p1,
-			'p2' => $p2,
-		];
-
-		$set = new ProviderSet([$p2, $p1], false);
-
-		$this->assertEquals($expected, $set->getProviders());
-	}
-
-	public function testGet3rdPartyProviders(): void {
-		$p1 = $this->createMock(IProvider::class);
-		$p1->method('getId')->willReturn('p1');
-		$p2 = $this->createMock(IProvider::class);
-		$p2->method('getId')->willReturn('p2');
-		$p3 = $this->createMock(BackupCodesProvider::class);
-		$p3->method('getId')->willReturn('p3');
-		$expected = [
-			'p1' => $p1,
-			'p2' => $p2,
-		];
-
-		$set = new ProviderSet([$p2, $p1], false);
-
-		$this->assertEquals($expected, $set->getPrimaryProviders());
-	}
-
-	public function testGetProvider(): void {
-		$p1 = $this->createMock(IProvider::class);
-		$p1->method('getId')->willReturn('p1');
-
-		$set = new ProviderSet([$p1], false);
-		$provider = $set->getProvider('p1');
-
-		$this->assertEquals($p1, $provider);
-	}
-
-	public function testGetProviderNotFound(): void {
-		$set = new ProviderSet([], false);
-		$provider = $set->getProvider('p1');
-
-		$this->assertNull($provider);
-	}
-
-	public function testIsProviderMissing(): void {
-		$set = new ProviderSet([], true);
-
-		$this->assertTrue($set->isProviderMissing());
-	}
+    /** @var ProviderSet */
+    private $providerSet;
+
+    public function testIndexesProviders(): void {
+        $p1 = $this->createMock(IProvider::class);
+        $p1->method('getId')->willReturn('p1');
+        $p2 = $this->createMock(IProvider::class);
+        $p2->method('getId')->willReturn('p2');
+        $expected = [
+            'p1' => $p1,
+            'p2' => $p2,
+        ];
+
+        $set = new ProviderSet([$p2, $p1], false);
+
+        $this->assertEquals($expected, $set->getProviders());
+    }
+
+    public function testGet3rdPartyProviders(): void {
+        $p1 = $this->createMock(IProvider::class);
+        $p1->method('getId')->willReturn('p1');
+        $p2 = $this->createMock(IProvider::class);
+        $p2->method('getId')->willReturn('p2');
+        $p3 = $this->createMock(BackupCodesProvider::class);
+        $p3->method('getId')->willReturn('p3');
+        $expected = [
+            'p1' => $p1,
+            'p2' => $p2,
+        ];
+
+        $set = new ProviderSet([$p2, $p1], false);
+
+        $this->assertEquals($expected, $set->getPrimaryProviders());
+    }
+
+    public function testGetProvider(): void {
+        $p1 = $this->createMock(IProvider::class);
+        $p1->method('getId')->willReturn('p1');
+
+        $set = new ProviderSet([$p1], false);
+        $provider = $set->getProvider('p1');
+
+        $this->assertEquals($p1, $provider);
+    }
+
+    public function testGetProviderNotFound(): void {
+        $set = new ProviderSet([], false);
+        $provider = $set->getProvider('p1');
+
+        $this->assertNull($provider);
+    }
+
+    public function testIsProviderMissing(): void {
+        $set = new ProviderSet([], true);
+
+        $this->assertTrue($set->isProviderMissing());
+    }
 }

tests/lib/Authentication/TwoFactorAuth/EnforcementStateTest.php

Indentation +22 added lines, -22 removed lines

@@ -17,34 +17,34 @@
 use Test\TestCase;
 
 class EnforcementStateTest extends TestCase {
-	public function testIsEnforced(): void {
-		$state = new EnforcementState(true);
+    public function testIsEnforced(): void {
+        $state = new EnforcementState(true);
 
-		$this->assertTrue($state->isEnforced());
-	}
+        $this->assertTrue($state->isEnforced());
+    }
 
-	public function testGetEnforcedGroups(): void {
-		$state = new EnforcementState(true, ['twofactorers']);
+    public function testGetEnforcedGroups(): void {
+        $state = new EnforcementState(true, ['twofactorers']);
 
-		$this->assertEquals(['twofactorers'], $state->getEnforcedGroups());
-	}
+        $this->assertEquals(['twofactorers'], $state->getEnforcedGroups());
+    }
 
-	public function testGetExcludedGroups(): void {
-		$state = new EnforcementState(true, [], ['yoloers']);
+    public function testGetExcludedGroups(): void {
+        $state = new EnforcementState(true, [], ['yoloers']);
 
-		$this->assertEquals(['yoloers'], $state->getExcludedGroups());
-	}
+        $this->assertEquals(['yoloers'], $state->getExcludedGroups());
+    }
 
-	public function testJsonSerialize(): void {
-		$state = new EnforcementState(true, ['twofactorers'], ['yoloers']);
-		$expected = [
-			'enforced' => true,
-			'enforcedGroups' => ['twofactorers'],
-			'excludedGroups' => ['yoloers'],
-		];
+    public function testJsonSerialize(): void {
+        $state = new EnforcementState(true, ['twofactorers'], ['yoloers']);
+        $expected = [
+            'enforced' => true,
+            'enforcedGroups' => ['twofactorers'],
+            'excludedGroups' => ['yoloers'],
+        ];
 
-		$json = $state->jsonSerialize();
+        $json = $state->jsonSerialize();
 
-		$this->assertEquals($expected, $json);
-	}
+        $this->assertEquals($expected, $json);
+    }
 }