nextcloud / server

apps/twofactor_backupcodes/tests/Unit/BackgroundJob/RememberBackupCodesJobTest.php

Indentation +189 added lines, -189 removed lines

@@ -21,193 +21,193 @@
 use Test\TestCase;
 
 class RememberBackupCodesJobTest extends TestCase {
-	private IRegistry&MockObject $registry;
-	private IUserManager&MockObject $userManager;
-	private ITimeFactory&MockObject $time;
-	private IManager&MockObject $notificationManager;
-	private IJobList&MockObject $jobList;
-	private RememberBackupCodesJob $job;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->registry = $this->createMock(IRegistry::class);
-		$this->userManager = $this->createMock(IUserManager::class);
-		$this->time = $this->createMock(ITimeFactory::class);
-		$this->time->method('getTime')
-			->willReturn(10000000);
-		$this->notificationManager = $this->createMock(IManager::class);
-		$this->jobList = $this->createMock(IJobList::class);
-
-		$this->job = new RememberBackupCodesJob(
-			$this->registry,
-			$this->userManager,
-			$this->time,
-			$this->notificationManager,
-			$this->jobList
-		);
-	}
-
-	public function testInvalidUID(): void {
-		$this->userManager->method('get')
-			->with('invalidUID')
-			->willReturn(null);
-
-		$this->notificationManager->expects($this->never())
-			->method($this->anything());
-		$this->jobList->expects($this->once())
-			->method('remove')
-			->with(
-				RememberBackupCodesJob::class,
-				['uid' => 'invalidUID']
-			);
-		$this->jobList->expects($this->never())
-			->method('add');
-
-		self::invokePrivate($this->job, 'run', [['uid' => 'invalidUID']]);
-	}
-
-	public function testBackupCodesGenerated(): void {
-		$user = $this->createMock(IUser::class);
-		$user->method('getUID')
-			->willReturn('validUID');
-		$user->method('isEnabled')
-			->willReturn(true);
-
-		$this->userManager->method('get')
-			->with('validUID')
-			->willReturn($user);
-
-		$this->registry->method('getProviderStates')
-			->with($user)
-			->willReturn([
-				'backup_codes' => true
-			]);
-
-		$this->jobList->expects($this->once())
-			->method('remove')
-			->with(
-				RememberBackupCodesJob::class,
-				['uid' => 'validUID']
-			);
-
-		$this->notificationManager->expects($this->never())
-			->method($this->anything());
-
-		self::invokePrivate($this->job, 'run', [['uid' => 'validUID']]);
-	}
-
-	public function testNoActiveProvider(): void {
-		$user = $this->createMock(IUser::class);
-		$user->method('getUID')
-			->willReturn('validUID');
-		$this->userManager->method('get')
-			->with('validUID')
-			->willReturn($user);
-
-		$this->registry->method('getProviderStates')
-			->with($user)
-			->willReturn([
-				'backup_codes' => false,
-				'foo' => false,
-			]);
-
-		$this->jobList->expects($this->once())
-			->method('remove')
-			->with(
-				RememberBackupCodesJob::class,
-				['uid' => 'validUID']
-			);
-
-		$this->notificationManager->expects($this->never())
-			->method($this->anything());
-
-		self::invokePrivate($this->job, 'run', [['uid' => 'validUID']]);
-	}
-
-	public function testNotificationSend(): void {
-		$user = $this->createMock(IUser::class);
-		$user->method('getUID')
-			->willReturn('validUID');
-		$user->method('isEnabled')
-			->willReturn(true);
-		$this->userManager->method('get')
-			->with('validUID')
-			->willReturn($user);
-
-		$this->registry->method('getProviderStates')
-			->with($user)
-			->willReturn([
-				'backup_codes' => false,
-				'foo' => true,
-			]);
-
-		$this->jobList->expects($this->never())
-			->method($this->anything());
-
-		$date = new \DateTime();
-		$date->setTimestamp($this->time->getTime());
-
-		$this->notificationManager->method('createNotification')
-			->willReturn(Server::get(IManager::class)->createNotification());
-
-		$this->notificationManager->expects($this->once())
-			->method('notify')
-			->with($this->callback(function (INotification $n) {
-				return $n->getApp() === 'twofactor_backupcodes' &&
-					$n->getUser() === 'validUID' &&
-					$n->getDateTime()->getTimestamp() === 10000000 &&
-					$n->getObjectType() === 'create' &&
-					$n->getObjectId() === 'codes' &&
-					$n->getSubject() === 'create_backupcodes';
-			}));
-
-		self::invokePrivate($this->job, 'run', [['uid' => 'validUID']]);
-	}
-
-	public function testNotificationNotSendForDisabledUser(): void {
-		$user = $this->createMock(IUser::class);
-		$user->method('getUID')
-			->willReturn('validUID');
-		$user->method('isEnabled')
-			->willReturn(false);
-		$this->userManager->method('get')
-			->with('validUID')
-			->willReturn($user);
-
-		$this->registry->method('getProviderStates')
-			->with($user)
-			->willReturn([
-				'backup_codes' => false,
-				'foo' => true,
-			]);
-
-		$this->jobList->expects($this->once())
-			->method('remove')
-			->with(
-				RememberBackupCodesJob::class,
-				['uid' => 'validUID']
-			);
-
-		$date = new \DateTime();
-		$date->setTimestamp($this->time->getTime());
-
-		$this->notificationManager->method('createNotification')
-			->willReturn(Server::get(IManager::class)->createNotification());
-
-		$this->notificationManager->expects($this->once())
-			->method('markProcessed')
-			->with($this->callback(function (INotification $n) {
-				return $n->getApp() === 'twofactor_backupcodes' &&
-					$n->getUser() === 'validUID' &&
-					$n->getObjectType() === 'create' &&
-					$n->getObjectId() === 'codes' &&
-					$n->getSubject() === 'create_backupcodes';
-			}));
-
-		$this->notificationManager->expects($this->never())
-			->method('notify');
-
-		self::invokePrivate($this->job, 'run', [['uid' => 'validUID']]);
-	}
+    private IRegistry&MockObject $registry;
+    private IUserManager&MockObject $userManager;
+    private ITimeFactory&MockObject $time;
+    private IManager&MockObject $notificationManager;
+    private IJobList&MockObject $jobList;
+    private RememberBackupCodesJob $job;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->registry = $this->createMock(IRegistry::class);
+        $this->userManager = $this->createMock(IUserManager::class);
+        $this->time = $this->createMock(ITimeFactory::class);
+        $this->time->method('getTime')
+            ->willReturn(10000000);
+        $this->notificationManager = $this->createMock(IManager::class);
+        $this->jobList = $this->createMock(IJobList::class);
+
+        $this->job = new RememberBackupCodesJob(
+            $this->registry,
+            $this->userManager,
+            $this->time,
+            $this->notificationManager,
+            $this->jobList
+        );
+    }
+
+    public function testInvalidUID(): void {
+        $this->userManager->method('get')
+            ->with('invalidUID')
+            ->willReturn(null);
+
+        $this->notificationManager->expects($this->never())
+            ->method($this->anything());
+        $this->jobList->expects($this->once())
+            ->method('remove')
+            ->with(
+                RememberBackupCodesJob::class,
+                ['uid' => 'invalidUID']
+            );
+        $this->jobList->expects($this->never())
+            ->method('add');
+
+        self::invokePrivate($this->job, 'run', [['uid' => 'invalidUID']]);
+    }
+
+    public function testBackupCodesGenerated(): void {
+        $user = $this->createMock(IUser::class);
+        $user->method('getUID')
+            ->willReturn('validUID');
+        $user->method('isEnabled')
+            ->willReturn(true);
+
+        $this->userManager->method('get')
+            ->with('validUID')
+            ->willReturn($user);
+
+        $this->registry->method('getProviderStates')
+            ->with($user)
+            ->willReturn([
+                'backup_codes' => true
+            ]);
+
+        $this->jobList->expects($this->once())
+            ->method('remove')
+            ->with(
+                RememberBackupCodesJob::class,
+                ['uid' => 'validUID']
+            );
+
+        $this->notificationManager->expects($this->never())
+            ->method($this->anything());
+
+        self::invokePrivate($this->job, 'run', [['uid' => 'validUID']]);
+    }
+
+    public function testNoActiveProvider(): void {
+        $user = $this->createMock(IUser::class);
+        $user->method('getUID')
+            ->willReturn('validUID');
+        $this->userManager->method('get')
+            ->with('validUID')
+            ->willReturn($user);
+
+        $this->registry->method('getProviderStates')
+            ->with($user)
+            ->willReturn([
+                'backup_codes' => false,
+                'foo' => false,
+            ]);
+
+        $this->jobList->expects($this->once())
+            ->method('remove')
+            ->with(
+                RememberBackupCodesJob::class,
+                ['uid' => 'validUID']
+            );
+
+        $this->notificationManager->expects($this->never())
+            ->method($this->anything());
+
+        self::invokePrivate($this->job, 'run', [['uid' => 'validUID']]);
+    }
+
+    public function testNotificationSend(): void {
+        $user = $this->createMock(IUser::class);
+        $user->method('getUID')
+            ->willReturn('validUID');
+        $user->method('isEnabled')
+            ->willReturn(true);
+        $this->userManager->method('get')
+            ->with('validUID')
+            ->willReturn($user);
+
+        $this->registry->method('getProviderStates')
+            ->with($user)
+            ->willReturn([
+                'backup_codes' => false,
+                'foo' => true,
+            ]);
+
+        $this->jobList->expects($this->never())
+            ->method($this->anything());
+
+        $date = new \DateTime();
+        $date->setTimestamp($this->time->getTime());
+
+        $this->notificationManager->method('createNotification')
+            ->willReturn(Server::get(IManager::class)->createNotification());
+
+        $this->notificationManager->expects($this->once())
+            ->method('notify')
+            ->with($this->callback(function (INotification $n) {
+                return $n->getApp() === 'twofactor_backupcodes' &&
+                    $n->getUser() === 'validUID' &&
+                    $n->getDateTime()->getTimestamp() === 10000000 &&
+                    $n->getObjectType() === 'create' &&
+                    $n->getObjectId() === 'codes' &&
+                    $n->getSubject() === 'create_backupcodes';
+            }));
+
+        self::invokePrivate($this->job, 'run', [['uid' => 'validUID']]);
+    }
+
+    public function testNotificationNotSendForDisabledUser(): void {
+        $user = $this->createMock(IUser::class);
+        $user->method('getUID')
+            ->willReturn('validUID');
+        $user->method('isEnabled')
+            ->willReturn(false);
+        $this->userManager->method('get')
+            ->with('validUID')
+            ->willReturn($user);
+
+        $this->registry->method('getProviderStates')
+            ->with($user)
+            ->willReturn([
+                'backup_codes' => false,
+                'foo' => true,
+            ]);
+
+        $this->jobList->expects($this->once())
+            ->method('remove')
+            ->with(
+                RememberBackupCodesJob::class,
+                ['uid' => 'validUID']
+            );
+
+        $date = new \DateTime();
+        $date->setTimestamp($this->time->getTime());
+
+        $this->notificationManager->method('createNotification')
+            ->willReturn(Server::get(IManager::class)->createNotification());
+
+        $this->notificationManager->expects($this->once())
+            ->method('markProcessed')
+            ->with($this->callback(function (INotification $n) {
+                return $n->getApp() === 'twofactor_backupcodes' &&
+                    $n->getUser() === 'validUID' &&
+                    $n->getObjectType() === 'create' &&
+                    $n->getObjectId() === 'codes' &&
+                    $n->getSubject() === 'create_backupcodes';
+            }));
+
+        $this->notificationManager->expects($this->never())
+            ->method('notify');
+
+        self::invokePrivate($this->job, 'run', [['uid' => 'validUID']]);
+    }
 }

apps/workflowengine/tests/Check/RequestRemoteAddressTest.php

Indentation +92 added lines, -92 removed lines

@@ -15,96 +15,96 @@
 
 class RequestRemoteAddressTest extends \Test\TestCase {
 
-	protected IRequest&MockObject $request;
-
-	protected function getL10NMock(): IL10N&MockObject {
-		$l = $this->createMock(IL10N::class);
-		$l->expects($this->any())
-			->method('t')
-			->willReturnCallback(function ($string, $args) {
-				return sprintf($string, $args);
-			});
-		return $l;
-	}
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->request = $this->createMock(IRequest::class);
-	}
-
-	public static function dataExecuteCheckIPv4(): array {
-		return [
-			['127.0.0.1/32', '127.0.0.1', true],
-			['127.0.0.1/32', '127.0.0.0', false],
-			['127.0.0.1/31', '127.0.0.0', true],
-			['127.0.0.1/32', '127.0.0.2', false],
-			['127.0.0.1/31', '127.0.0.2', false],
-			['127.0.0.1/30', '127.0.0.2', true],
-		];
-	}
-
-	/**
-	 * @dataProvider dataExecuteCheckIPv4
-	 */
-	public function testExecuteCheckMatchesIPv4(string $value, string $ip, bool $expected): void {
-		$check = new RequestRemoteAddress($this->getL10NMock(), $this->request);
-
-		$this->request->expects($this->once())
-			->method('getRemoteAddress')
-			->willReturn($ip);
-
-		$this->assertEquals($expected, $check->executeCheck('matchesIPv4', $value));
-	}
-
-	/**
-	 * @dataProvider dataExecuteCheckIPv4
-	 */
-	public function testExecuteCheckNotMatchesIPv4(string $value, string $ip, bool $expected): void {
-		$check = new RequestRemoteAddress($this->getL10NMock(), $this->request);
-
-		$this->request->expects($this->once())
-			->method('getRemoteAddress')
-			->willReturn($ip);
-
-		$this->assertEquals(!$expected, $check->executeCheck('!matchesIPv4', $value));
-	}
-
-	public static function dataExecuteCheckIPv6(): array {
-		return [
-			['::1/128', '::1', true],
-			['::2/128', '::3', false],
-			['::2/127', '::3', true],
-			['::1/128', '::2', false],
-			['::1/127', '::2', false],
-			['::1/126', '::2', true],
-			['1234::1/127', '1234::', true],
-		];
-	}
-
-	/**
-	 * @dataProvider dataExecuteCheckIPv6
-	 */
-	public function testExecuteCheckMatchesIPv6(string $value, string $ip, bool $expected): void {
-		$check = new RequestRemoteAddress($this->getL10NMock(), $this->request);
-
-		$this->request->expects($this->once())
-			->method('getRemoteAddress')
-			->willReturn($ip);
-
-		$this->assertEquals($expected, $check->executeCheck('matchesIPv6', $value));
-	}
-
-	/**
-	 * @dataProvider dataExecuteCheckIPv6
-	 */
-	public function testExecuteCheckNotMatchesIPv6(string $value, string $ip, bool $expected): void {
-		$check = new RequestRemoteAddress($this->getL10NMock(), $this->request);
-
-		$this->request->expects($this->once())
-			->method('getRemoteAddress')
-			->willReturn($ip);
-
-		$this->assertEquals(!$expected, $check->executeCheck('!matchesIPv6', $value));
-	}
+    protected IRequest&MockObject $request;
+
+    protected function getL10NMock(): IL10N&MockObject {
+        $l = $this->createMock(IL10N::class);
+        $l->expects($this->any())
+            ->method('t')
+            ->willReturnCallback(function ($string, $args) {
+                return sprintf($string, $args);
+            });
+        return $l;
+    }
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->request = $this->createMock(IRequest::class);
+    }
+
+    public static function dataExecuteCheckIPv4(): array {
+        return [
+            ['127.0.0.1/32', '127.0.0.1', true],
+            ['127.0.0.1/32', '127.0.0.0', false],
+            ['127.0.0.1/31', '127.0.0.0', true],
+            ['127.0.0.1/32', '127.0.0.2', false],
+            ['127.0.0.1/31', '127.0.0.2', false],
+            ['127.0.0.1/30', '127.0.0.2', true],
+        ];
+    }
+
+    /**
+     * @dataProvider dataExecuteCheckIPv4
+     */
+    public function testExecuteCheckMatchesIPv4(string $value, string $ip, bool $expected): void {
+        $check = new RequestRemoteAddress($this->getL10NMock(), $this->request);
+
+        $this->request->expects($this->once())
+            ->method('getRemoteAddress')
+            ->willReturn($ip);
+
+        $this->assertEquals($expected, $check->executeCheck('matchesIPv4', $value));
+    }
+
+    /**
+     * @dataProvider dataExecuteCheckIPv4
+     */
+    public function testExecuteCheckNotMatchesIPv4(string $value, string $ip, bool $expected): void {
+        $check = new RequestRemoteAddress($this->getL10NMock(), $this->request);
+
+        $this->request->expects($this->once())
+            ->method('getRemoteAddress')
+            ->willReturn($ip);
+
+        $this->assertEquals(!$expected, $check->executeCheck('!matchesIPv4', $value));
+    }
+
+    public static function dataExecuteCheckIPv6(): array {
+        return [
+            ['::1/128', '::1', true],
+            ['::2/128', '::3', false],
+            ['::2/127', '::3', true],
+            ['::1/128', '::2', false],
+            ['::1/127', '::2', false],
+            ['::1/126', '::2', true],
+            ['1234::1/127', '1234::', true],
+        ];
+    }
+
+    /**
+     * @dataProvider dataExecuteCheckIPv6
+     */
+    public function testExecuteCheckMatchesIPv6(string $value, string $ip, bool $expected): void {
+        $check = new RequestRemoteAddress($this->getL10NMock(), $this->request);
+
+        $this->request->expects($this->once())
+            ->method('getRemoteAddress')
+            ->willReturn($ip);
+
+        $this->assertEquals($expected, $check->executeCheck('matchesIPv6', $value));
+    }
+
+    /**
+     * @dataProvider dataExecuteCheckIPv6
+     */
+    public function testExecuteCheckNotMatchesIPv6(string $value, string $ip, bool $expected): void {
+        $check = new RequestRemoteAddress($this->getL10NMock(), $this->request);
+
+        $this->request->expects($this->once())
+            ->method('getRemoteAddress')
+            ->willReturn($ip);
+
+        $this->assertEquals(!$expected, $check->executeCheck('!matchesIPv6', $value));
+    }
 }

Spacing +1 added lines, -1 removed lines

@@ -21,7 +21,7 @@
 		$l = $this->createMock(IL10N::class);
 		$l->expects($this->any())
 			->method('t')
-			->willReturnCallback(function ($string, $args) {
+			->willReturnCallback(function($string, $args) {
 				return sprintf($string, $args);
 			});
 		return $l;

apps/workflowengine/tests/Check/RequestUserAgentTest.php

Indentation +68 added lines, -68 removed lines

@@ -16,81 +16,81 @@
 use Test\TestCase;
 
 class RequestUserAgentTest extends TestCase {
-	protected IRequest&MockObject $request;
-	protected RequestUserAgent $check;
+    protected IRequest&MockObject $request;
+    protected RequestUserAgent $check;
 
-	protected function setUp(): void {
-		parent::setUp();
+    protected function setUp(): void {
+        parent::setUp();
 
-		$this->request = $this->createMock(IRequest::class);
-		/** @var IL10N&MockObject $l */
-		$l = $this->createMock(IL10N::class);
-		$l->expects($this->any())
-			->method('t')
-			->willReturnCallback(function ($string, $args) {
-				return sprintf($string, $args);
-			});
+        $this->request = $this->createMock(IRequest::class);
+        /** @var IL10N&MockObject $l */
+        $l = $this->createMock(IL10N::class);
+        $l->expects($this->any())
+            ->method('t')
+            ->willReturnCallback(function ($string, $args) {
+                return sprintf($string, $args);
+            });
 
-		$this->check = new RequestUserAgent($l, $this->request);
-	}
+        $this->check = new RequestUserAgent($l, $this->request);
+    }
 
-	public static function dataExecuteCheck(): array {
-		return [
-			['is', 'android', 'Mozilla/5.0 (Android) Nextcloud-android/2.2.0', true],
-			['is', 'android', 'Mozilla/5.0 (iOS) Nextcloud-iOS/2.2.0', false],
-			['is', 'android', 'Mozilla/5.0 (Linux) mirall/2.2.0', false],
-			['is', 'android', 'Mozilla/5.0 (Windows) Nextcloud-Outlook v2.2.0', false],
-			['is', 'android', 'Filelink for *cloud/2.2.0', false],
-			['!is', 'android', 'Mozilla/5.0 (Android) Nextcloud-android/2.2.0', false],
-			['!is', 'android', 'Mozilla/5.0 (iOS) Nextcloud-iOS/2.2.0', true],
-			['!is', 'android', 'Mozilla/5.0 (Linux) mirall/2.2.0', true],
-			['!is', 'android', 'Mozilla/5.0 (Windows) Nextcloud-Outlook v2.2.0', true],
-			['!is', 'android', 'Filelink for *cloud/2.2.0', true],
+    public static function dataExecuteCheck(): array {
+        return [
+            ['is', 'android', 'Mozilla/5.0 (Android) Nextcloud-android/2.2.0', true],
+            ['is', 'android', 'Mozilla/5.0 (iOS) Nextcloud-iOS/2.2.0', false],
+            ['is', 'android', 'Mozilla/5.0 (Linux) mirall/2.2.0', false],
+            ['is', 'android', 'Mozilla/5.0 (Windows) Nextcloud-Outlook v2.2.0', false],
+            ['is', 'android', 'Filelink for *cloud/2.2.0', false],
+            ['!is', 'android', 'Mozilla/5.0 (Android) Nextcloud-android/2.2.0', false],
+            ['!is', 'android', 'Mozilla/5.0 (iOS) Nextcloud-iOS/2.2.0', true],
+            ['!is', 'android', 'Mozilla/5.0 (Linux) mirall/2.2.0', true],
+            ['!is', 'android', 'Mozilla/5.0 (Windows) Nextcloud-Outlook v2.2.0', true],
+            ['!is', 'android', 'Filelink for *cloud/2.2.0', true],
 
-			['is', 'ios', 'Mozilla/5.0 (Android) Nextcloud-android/2.2.0', false],
-			['is', 'ios', 'Mozilla/5.0 (iOS) Nextcloud-iOS/2.2.0', true],
-			['is', 'ios', 'Mozilla/5.0 (Linux) mirall/2.2.0', false],
-			['is', 'ios', 'Mozilla/5.0 (Windows) Nextcloud-Outlook v2.2.0', false],
-			['is', 'ios', 'Filelink for *cloud/2.2.0', false],
-			['!is', 'ios', 'Mozilla/5.0 (Android) Nextcloud-android/2.2.0', true],
-			['!is', 'ios', 'Mozilla/5.0 (iOS) Nextcloud-iOS/2.2.0', false],
-			['!is', 'ios', 'Mozilla/5.0 (Linux) mirall/2.2.0', true],
-			['!is', 'ios', 'Mozilla/5.0 (Windows) Nextcloud-Outlook v2.2.0', true],
-			['!is', 'ios', 'Filelink for *cloud/2.2.0', true],
+            ['is', 'ios', 'Mozilla/5.0 (Android) Nextcloud-android/2.2.0', false],
+            ['is', 'ios', 'Mozilla/5.0 (iOS) Nextcloud-iOS/2.2.0', true],
+            ['is', 'ios', 'Mozilla/5.0 (Linux) mirall/2.2.0', false],
+            ['is', 'ios', 'Mozilla/5.0 (Windows) Nextcloud-Outlook v2.2.0', false],
+            ['is', 'ios', 'Filelink for *cloud/2.2.0', false],
+            ['!is', 'ios', 'Mozilla/5.0 (Android) Nextcloud-android/2.2.0', true],
+            ['!is', 'ios', 'Mozilla/5.0 (iOS) Nextcloud-iOS/2.2.0', false],
+            ['!is', 'ios', 'Mozilla/5.0 (Linux) mirall/2.2.0', true],
+            ['!is', 'ios', 'Mozilla/5.0 (Windows) Nextcloud-Outlook v2.2.0', true],
+            ['!is', 'ios', 'Filelink for *cloud/2.2.0', true],
 
-			['is', 'desktop', 'Mozilla/5.0 (Android) Nextcloud-android/2.2.0', false],
-			['is', 'desktop', 'Mozilla/5.0 (iOS) Nextcloud-iOS/2.2.0', false],
-			['is', 'desktop', 'Mozilla/5.0 (Linux) mirall/2.2.0', true],
-			['is', 'desktop', 'Mozilla/5.0 (Windows) Nextcloud-Outlook v2.2.0', false],
-			['is', 'desktop', 'Filelink for *cloud/2.2.0', false],
-			['!is', 'desktop', 'Mozilla/5.0 (Android) Nextcloud-android/2.2.0', true],
-			['!is', 'desktop', 'Mozilla/5.0 (iOS) Nextcloud-iOS/2.2.0', true],
-			['!is', 'desktop', 'Mozilla/5.0 (Linux) mirall/2.2.0', false],
-			['!is', 'desktop', 'Mozilla/5.0 (Windows) Nextcloud-Outlook v2.2.0', true],
-			['!is', 'desktop', 'Filelink for *cloud/2.2.0', true],
+            ['is', 'desktop', 'Mozilla/5.0 (Android) Nextcloud-android/2.2.0', false],
+            ['is', 'desktop', 'Mozilla/5.0 (iOS) Nextcloud-iOS/2.2.0', false],
+            ['is', 'desktop', 'Mozilla/5.0 (Linux) mirall/2.2.0', true],
+            ['is', 'desktop', 'Mozilla/5.0 (Windows) Nextcloud-Outlook v2.2.0', false],
+            ['is', 'desktop', 'Filelink for *cloud/2.2.0', false],
+            ['!is', 'desktop', 'Mozilla/5.0 (Android) Nextcloud-android/2.2.0', true],
+            ['!is', 'desktop', 'Mozilla/5.0 (iOS) Nextcloud-iOS/2.2.0', true],
+            ['!is', 'desktop', 'Mozilla/5.0 (Linux) mirall/2.2.0', false],
+            ['!is', 'desktop', 'Mozilla/5.0 (Windows) Nextcloud-Outlook v2.2.0', true],
+            ['!is', 'desktop', 'Filelink for *cloud/2.2.0', true],
 
-			['is', 'mail', 'Mozilla/5.0 (Android) Nextcloud-android/2.2.0', false],
-			['is', 'mail', 'Mozilla/5.0 (iOS) Nextcloud-iOS/2.2.0', false],
-			['is', 'mail', 'Mozilla/5.0 (Linux) mirall/2.2.0', false],
-			['is', 'mail', 'Mozilla/5.0 (Windows) Nextcloud-Outlook v2.2.0', true],
-			['is', 'mail', 'Filelink for *cloud/2.2.0', true],
-			['!is', 'mail', 'Mozilla/5.0 (Android) Nextcloud-android/2.2.0', true],
-			['!is', 'mail', 'Mozilla/5.0 (iOS) Nextcloud-iOS/2.2.0', true],
-			['!is', 'mail', 'Mozilla/5.0 (Linux) mirall/2.2.0', true],
-			['!is', 'mail', 'Mozilla/5.0 (Windows) Nextcloud-Outlook v2.2.0', false],
-			['!is', 'mail', 'Filelink for *cloud/2.2.0', false],
-		];
-	}
+            ['is', 'mail', 'Mozilla/5.0 (Android) Nextcloud-android/2.2.0', false],
+            ['is', 'mail', 'Mozilla/5.0 (iOS) Nextcloud-iOS/2.2.0', false],
+            ['is', 'mail', 'Mozilla/5.0 (Linux) mirall/2.2.0', false],
+            ['is', 'mail', 'Mozilla/5.0 (Windows) Nextcloud-Outlook v2.2.0', true],
+            ['is', 'mail', 'Filelink for *cloud/2.2.0', true],
+            ['!is', 'mail', 'Mozilla/5.0 (Android) Nextcloud-android/2.2.0', true],
+            ['!is', 'mail', 'Mozilla/5.0 (iOS) Nextcloud-iOS/2.2.0', true],
+            ['!is', 'mail', 'Mozilla/5.0 (Linux) mirall/2.2.0', true],
+            ['!is', 'mail', 'Mozilla/5.0 (Windows) Nextcloud-Outlook v2.2.0', false],
+            ['!is', 'mail', 'Filelink for *cloud/2.2.0', false],
+        ];
+    }
 
-	/**
-	 * @dataProvider dataExecuteCheck
-	 */
-	public function testExecuteCheck(string $operation, string $checkValue, string $actualValue, bool $expected): void {
-		$this->request->expects($this->once())
-			->method('getHeader')
-			->willReturn($actualValue);
+    /**
+     * @dataProvider dataExecuteCheck
+     */
+    public function testExecuteCheck(string $operation, string $checkValue, string $actualValue, bool $expected): void {
+        $this->request->expects($this->once())
+            ->method('getHeader')
+            ->willReturn($actualValue);
 
-		/** @var AbstractStringCheck $check */
-		$this->assertEquals($expected, $this->check->executeCheck($operation, $checkValue));
-	}
+        /** @var AbstractStringCheck $check */
+        $this->assertEquals($expected, $this->check->executeCheck($operation, $checkValue));
+    }
 }

Spacing +1 added lines, -1 removed lines

@@ -27,7 +27,7 @@
 		$l = $this->createMock(IL10N::class);
 		$l->expects($this->any())
 			->method('t')
-			->willReturnCallback(function ($string, $args) {
+			->willReturnCallback(function($string, $args) {
 				return sprintf($string, $args);
 			});
 

apps/workflowengine/tests/Check/AbstractStringCheckTest.php

Indentation +109 added lines, -109 removed lines

@@ -13,113 +13,113 @@
 use PHPUnit\Framework\MockObject\MockObject;
 
 class AbstractStringCheckTest extends \Test\TestCase {
-	protected function getCheckMock(): AbstractStringCheck|MockObject {
-		$l = $this->getMockBuilder(IL10N::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$l->expects($this->any())
-			->method('t')
-			->willReturnCallback(function ($string, $args) {
-				return sprintf($string, $args);
-			});
-
-		$check = $this->getMockBuilder(AbstractStringCheck::class)
-			->setConstructorArgs([
-				$l,
-			])
-			->onlyMethods([
-				'executeCheck',
-				'getActualValue',
-			])
-			->getMock();
-
-		return $check;
-	}
-
-	public static function dataExecuteStringCheck(): array {
-		return [
-			['is', 'same', 'same', true],
-			['is', 'different', 'not the same', false],
-			['!is', 'same', 'same', false],
-			['!is', 'different', 'not the same', true],
-
-			['matches', '/match/', 'match', true],
-			['matches', '/different/', 'not the same', false],
-			['!matches', '/match/', 'match', false],
-			['!matches', '/different/', 'not the same', true],
-		];
-	}
-
-	/**
-	 * @dataProvider dataExecuteStringCheck
-	 */
-	public function testExecuteStringCheck(string $operation, string $checkValue, string $actualValue, bool $expected): void {
-		$check = $this->getCheckMock();
-
-		/** @var AbstractStringCheck $check */
-		$this->assertEquals($expected, $this->invokePrivate($check, 'executeStringCheck', [$operation, $checkValue, $actualValue]));
-	}
-
-	public static function dataValidateCheck(): array {
-		return [
-			['is', '/Invalid(Regex/'],
-			['!is', '/Invalid(Regex/'],
-			['matches', '/Valid(Regex)/'],
-			['!matches', '/Valid(Regex)/'],
-		];
-	}
-
-	/**
-	 * @dataProvider dataValidateCheck
-	 */
-	public function testValidateCheck(string $operator, string $value): void {
-		$check = $this->getCheckMock();
-
-		/** @var AbstractStringCheck $check */
-		$check->validateCheck($operator, $value);
-
-		$this->addToAssertionCount(1);
-	}
-
-	public static function dataValidateCheckInvalid(): array {
-		return [
-			['!!is', '', 1, 'The given operator is invalid'],
-			['less', '', 1, 'The given operator is invalid'],
-			['matches', '/Invalid(Regex/', 2, 'The given regular expression is invalid'],
-			['!matches', '/Invalid(Regex/', 2, 'The given regular expression is invalid'],
-		];
-	}
-
-	/**
-	 * @dataProvider dataValidateCheckInvalid
-	 */
-	public function testValidateCheckInvalid(string $operator, string $value, int $exceptionCode, string $exceptionMessage): void {
-		$check = $this->getCheckMock();
-
-		try {
-			/** @var AbstractStringCheck $check */
-			$check->validateCheck($operator, $value);
-		} catch (\UnexpectedValueException $e) {
-			$this->assertEquals($exceptionCode, $e->getCode());
-			$this->assertEquals($exceptionMessage, $e->getMessage());
-		}
-	}
-
-	public static function dataMatch(): array {
-		return [
-			['/valid/', 'valid', [], true],
-			['/valid/', 'valid', [md5('/valid/') => [md5('valid') => false]], false], // Cache hit
-		];
-	}
-
-	/**
-	 * @dataProvider dataMatch
-	 */
-	public function testMatch(string $pattern, string $subject, array $matches, bool $expected): void {
-		$check = $this->getCheckMock();
-
-		$this->invokePrivate($check, 'matches', [$matches]);
-
-		$this->assertEquals($expected, $this->invokePrivate($check, 'match', [$pattern, $subject]));
-	}
+    protected function getCheckMock(): AbstractStringCheck|MockObject {
+        $l = $this->getMockBuilder(IL10N::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $l->expects($this->any())
+            ->method('t')
+            ->willReturnCallback(function ($string, $args) {
+                return sprintf($string, $args);
+            });
+
+        $check = $this->getMockBuilder(AbstractStringCheck::class)
+            ->setConstructorArgs([
+                $l,
+            ])
+            ->onlyMethods([
+                'executeCheck',
+                'getActualValue',
+            ])
+            ->getMock();
+
+        return $check;
+    }
+
+    public static function dataExecuteStringCheck(): array {
+        return [
+            ['is', 'same', 'same', true],
+            ['is', 'different', 'not the same', false],
+            ['!is', 'same', 'same', false],
+            ['!is', 'different', 'not the same', true],
+
+            ['matches', '/match/', 'match', true],
+            ['matches', '/different/', 'not the same', false],
+            ['!matches', '/match/', 'match', false],
+            ['!matches', '/different/', 'not the same', true],
+        ];
+    }
+
+    /**
+     * @dataProvider dataExecuteStringCheck
+     */
+    public function testExecuteStringCheck(string $operation, string $checkValue, string $actualValue, bool $expected): void {
+        $check = $this->getCheckMock();
+
+        /** @var AbstractStringCheck $check */
+        $this->assertEquals($expected, $this->invokePrivate($check, 'executeStringCheck', [$operation, $checkValue, $actualValue]));
+    }
+
+    public static function dataValidateCheck(): array {
+        return [
+            ['is', '/Invalid(Regex/'],
+            ['!is', '/Invalid(Regex/'],
+            ['matches', '/Valid(Regex)/'],
+            ['!matches', '/Valid(Regex)/'],
+        ];
+    }
+
+    /**
+     * @dataProvider dataValidateCheck
+     */
+    public function testValidateCheck(string $operator, string $value): void {
+        $check = $this->getCheckMock();
+
+        /** @var AbstractStringCheck $check */
+        $check->validateCheck($operator, $value);
+
+        $this->addToAssertionCount(1);
+    }
+
+    public static function dataValidateCheckInvalid(): array {
+        return [
+            ['!!is', '', 1, 'The given operator is invalid'],
+            ['less', '', 1, 'The given operator is invalid'],
+            ['matches', '/Invalid(Regex/', 2, 'The given regular expression is invalid'],
+            ['!matches', '/Invalid(Regex/', 2, 'The given regular expression is invalid'],
+        ];
+    }
+
+    /**
+     * @dataProvider dataValidateCheckInvalid
+     */
+    public function testValidateCheckInvalid(string $operator, string $value, int $exceptionCode, string $exceptionMessage): void {
+        $check = $this->getCheckMock();
+
+        try {
+            /** @var AbstractStringCheck $check */
+            $check->validateCheck($operator, $value);
+        } catch (\UnexpectedValueException $e) {
+            $this->assertEquals($exceptionCode, $e->getCode());
+            $this->assertEquals($exceptionMessage, $e->getMessage());
+        }
+    }
+
+    public static function dataMatch(): array {
+        return [
+            ['/valid/', 'valid', [], true],
+            ['/valid/', 'valid', [md5('/valid/') => [md5('valid') => false]], false], // Cache hit
+        ];
+    }
+
+    /**
+     * @dataProvider dataMatch
+     */
+    public function testMatch(string $pattern, string $subject, array $matches, bool $expected): void {
+        $check = $this->getCheckMock();
+
+        $this->invokePrivate($check, 'matches', [$matches]);
+
+        $this->assertEquals($expected, $this->invokePrivate($check, 'match', [$pattern, $subject]));
+    }
 }

Spacing +2 added lines, -2 removed lines

@@ -13,13 +13,13 @@
 use PHPUnit\Framework\MockObject\MockObject;
 
 class AbstractStringCheckTest extends \Test\TestCase {
-	protected function getCheckMock(): AbstractStringCheck|MockObject {
+	protected function getCheckMock(): AbstractStringCheck | MockObject {
 		$l = $this->getMockBuilder(IL10N::class)
 			->disableOriginalConstructor()
 			->getMock();
 		$l->expects($this->any())
 			->method('t')
-			->willReturnCallback(function ($string, $args) {
+			->willReturnCallback(function($string, $args) {
 				return sprintf($string, $args);
 			});
 

apps/workflowengine/tests/Check/RequestTimeTest.php

Indentation +117 added lines, -117 removed lines

@@ -14,121 +14,121 @@
 use PHPUnit\Framework\MockObject\MockObject;
 
 class RequestTimeTest extends \Test\TestCase {
-	protected ITimeFactory&MockObject $timeFactory;
-
-	protected function getL10NMock(): IL10N&MockObject {
-		$l = $this->createMock(IL10N::class);
-		$l->expects($this->any())
-			->method('t')
-			->willReturnCallback(function ($string, $args) {
-				return sprintf($string, $args);
-			});
-		return $l;
-	}
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->timeFactory = $this->createMock(ITimeFactory::class);
-	}
-
-	public static function dataExecuteCheck(): array {
-		return [
-			[json_encode(['08:00 Europe/Berlin', '17:00 Europe/Berlin']), 1467870105, false], // 2016-07-07T07:41:45+02:00
-			[json_encode(['08:00 Europe/Berlin', '17:00 Europe/Berlin']), 1467873705, true], // 2016-07-07T08:41:45+02:00
-			[json_encode(['08:00 Europe/Berlin', '17:00 Europe/Berlin']), 1467902505, true], // 2016-07-07T16:41:45+02:00
-			[json_encode(['08:00 Europe/Berlin', '17:00 Europe/Berlin']), 1467906105, false], // 2016-07-07T17:41:45+02:00
-			[json_encode(['17:00 Europe/Berlin', '08:00 Europe/Berlin']), 1467870105, true], // 2016-07-07T07:41:45+02:00
-			[json_encode(['17:00 Europe/Berlin', '08:00 Europe/Berlin']), 1467873705, false], // 2016-07-07T08:41:45+02:00
-			[json_encode(['17:00 Europe/Berlin', '08:00 Europe/Berlin']), 1467902505, false], // 2016-07-07T16:41:45+02:00
-			[json_encode(['17:00 Europe/Berlin', '08:00 Europe/Berlin']), 1467906105, true], // 2016-07-07T17:41:45+02:00
-
-			[json_encode(['08:00 Australia/Adelaide', '17:00 Australia/Adelaide']), 1467843105, false], // 2016-07-07T07:41:45+09:30
-			[json_encode(['08:00 Australia/Adelaide', '17:00 Australia/Adelaide']), 1467846705, true], // 2016-07-07T08:41:45+09:30
-			[json_encode(['08:00 Australia/Adelaide', '17:00 Australia/Adelaide']), 1467875505, true], // 2016-07-07T16:41:45+09:30
-			[json_encode(['08:00 Australia/Adelaide', '17:00 Australia/Adelaide']), 1467879105, false], // 2016-07-07T17:41:45+09:30
-			[json_encode(['17:00 Australia/Adelaide', '08:00 Australia/Adelaide']), 1467843105, true], // 2016-07-07T07:41:45+09:30
-			[json_encode(['17:00 Australia/Adelaide', '08:00 Australia/Adelaide']), 1467846705, false], // 2016-07-07T08:41:45+09:30
-			[json_encode(['17:00 Australia/Adelaide', '08:00 Australia/Adelaide']), 1467875505, false], // 2016-07-07T16:41:45+09:30
-			[json_encode(['17:00 Australia/Adelaide', '08:00 Australia/Adelaide']), 1467879105, true], // 2016-07-07T17:41:45+09:30
-
-			[json_encode(['08:00 Pacific/Niue', '17:00 Pacific/Niue']), 1467916905, false], // 2016-07-07T07:41:45-11:00
-			[json_encode(['08:00 Pacific/Niue', '17:00 Pacific/Niue']), 1467920505, true], // 2016-07-07T08:41:45-11:00
-			[json_encode(['08:00 Pacific/Niue', '17:00 Pacific/Niue']), 1467949305, true], // 2016-07-07T16:41:45-11:00
-			[json_encode(['08:00 Pacific/Niue', '17:00 Pacific/Niue']), 1467952905, false], // 2016-07-07T17:41:45-11:00
-			[json_encode(['17:00 Pacific/Niue', '08:00 Pacific/Niue']), 1467916905, true], // 2016-07-07T07:41:45-11:00
-			[json_encode(['17:00 Pacific/Niue', '08:00 Pacific/Niue']), 1467920505, false], // 2016-07-07T08:41:45-11:00
-			[json_encode(['17:00 Pacific/Niue', '08:00 Pacific/Niue']), 1467949305, false], // 2016-07-07T16:41:45-11:00
-			[json_encode(['17:00 Pacific/Niue', '08:00 Pacific/Niue']), 1467952905, true], // 2016-07-07T17:41:45-11:00
-		];
-	}
-
-	/**
-	 * @dataProvider dataExecuteCheck
-	 */
-	public function testExecuteCheckIn(string $value, int $timestamp, bool $expected): void {
-		$check = new RequestTime($this->getL10NMock(), $this->timeFactory);
-
-		$this->timeFactory->expects($this->once())
-			->method('getTime')
-			->willReturn($timestamp);
-
-		$this->assertEquals($expected, $check->executeCheck('in', $value));
-	}
-
-	/**
-	 * @dataProvider dataExecuteCheck
-	 */
-	public function testExecuteCheckNotIn(string $value, int $timestamp, bool $expected): void {
-		$check = new RequestTime($this->getL10NMock(), $this->timeFactory);
-
-		$this->timeFactory->expects($this->once())
-			->method('getTime')
-			->willReturn($timestamp);
-
-		$this->assertEquals(!$expected, $check->executeCheck('!in', $value));
-	}
-
-	public static function dataValidateCheck(): array {
-		return [
-			['in', '["08:00 Europe/Berlin","17:00 Europe/Berlin"]'],
-			['!in', '["08:00 Europe/Berlin","17:00 America/North_Dakota/Beulah"]'],
-			['in', '["08:00 America/Port-au-Prince","17:00 America/Argentina/San_Luis"]'],
-		];
-	}
-
-	/**
-	 * @dataProvider dataValidateCheck
-	 */
-	public function testValidateCheck(string $operator, string $value): void {
-		$check = new RequestTime($this->getL10NMock(), $this->timeFactory);
-		$check->validateCheck($operator, $value);
-		$this->addToAssertionCount(1);
-	}
-
-	public static function dataValidateCheckInvalid(): array {
-		return [
-			['!!in', '["08:00 Europe/Berlin","17:00 Europe/Berlin"]', 1, 'The given operator is invalid'],
-			['in', '["28:00 Europe/Berlin","17:00 Europe/Berlin"]', 2, 'The given time span is invalid'],
-			['in', '["08:00 Europe/Berlin","27:00 Europe/Berlin"]', 2, 'The given time span is invalid'],
-			['in', '["08:00 Europa/Berlin","17:00 Europe/Berlin"]', 3, 'The given start time is invalid'],
-			['in', '["08:00 Europe/Berlin","17:00 Europa/Berlin"]', 4, 'The given end time is invalid'],
-			['in', '["08:00 Europe/Bearlin","17:00 Europe/Berlin"]', 3, 'The given start time is invalid'],
-			['in', '["08:00 Europe/Berlin","17:00 Europe/Bearlin"]', 4, 'The given end time is invalid'],
-		];
-	}
-
-	/**
-	 * @dataProvider dataValidateCheckInvalid
-	 */
-	public function testValidateCheckInvalid(string $operator, string $value, int $exceptionCode, string $exceptionMessage): void {
-		$check = new RequestTime($this->getL10NMock(), $this->timeFactory);
-
-		try {
-			$check->validateCheck($operator, $value);
-		} catch (\UnexpectedValueException $e) {
-			$this->assertEquals($exceptionCode, $e->getCode());
-			$this->assertEquals($exceptionMessage, $e->getMessage());
-		}
-	}
+    protected ITimeFactory&MockObject $timeFactory;
+
+    protected function getL10NMock(): IL10N&MockObject {
+        $l = $this->createMock(IL10N::class);
+        $l->expects($this->any())
+            ->method('t')
+            ->willReturnCallback(function ($string, $args) {
+                return sprintf($string, $args);
+            });
+        return $l;
+    }
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->timeFactory = $this->createMock(ITimeFactory::class);
+    }
+
+    public static function dataExecuteCheck(): array {
+        return [
+            [json_encode(['08:00 Europe/Berlin', '17:00 Europe/Berlin']), 1467870105, false], // 2016-07-07T07:41:45+02:00
+            [json_encode(['08:00 Europe/Berlin', '17:00 Europe/Berlin']), 1467873705, true], // 2016-07-07T08:41:45+02:00
+            [json_encode(['08:00 Europe/Berlin', '17:00 Europe/Berlin']), 1467902505, true], // 2016-07-07T16:41:45+02:00
+            [json_encode(['08:00 Europe/Berlin', '17:00 Europe/Berlin']), 1467906105, false], // 2016-07-07T17:41:45+02:00
+            [json_encode(['17:00 Europe/Berlin', '08:00 Europe/Berlin']), 1467870105, true], // 2016-07-07T07:41:45+02:00
+            [json_encode(['17:00 Europe/Berlin', '08:00 Europe/Berlin']), 1467873705, false], // 2016-07-07T08:41:45+02:00
+            [json_encode(['17:00 Europe/Berlin', '08:00 Europe/Berlin']), 1467902505, false], // 2016-07-07T16:41:45+02:00
+            [json_encode(['17:00 Europe/Berlin', '08:00 Europe/Berlin']), 1467906105, true], // 2016-07-07T17:41:45+02:00
+
+            [json_encode(['08:00 Australia/Adelaide', '17:00 Australia/Adelaide']), 1467843105, false], // 2016-07-07T07:41:45+09:30
+            [json_encode(['08:00 Australia/Adelaide', '17:00 Australia/Adelaide']), 1467846705, true], // 2016-07-07T08:41:45+09:30
+            [json_encode(['08:00 Australia/Adelaide', '17:00 Australia/Adelaide']), 1467875505, true], // 2016-07-07T16:41:45+09:30
+            [json_encode(['08:00 Australia/Adelaide', '17:00 Australia/Adelaide']), 1467879105, false], // 2016-07-07T17:41:45+09:30
+            [json_encode(['17:00 Australia/Adelaide', '08:00 Australia/Adelaide']), 1467843105, true], // 2016-07-07T07:41:45+09:30
+            [json_encode(['17:00 Australia/Adelaide', '08:00 Australia/Adelaide']), 1467846705, false], // 2016-07-07T08:41:45+09:30
+            [json_encode(['17:00 Australia/Adelaide', '08:00 Australia/Adelaide']), 1467875505, false], // 2016-07-07T16:41:45+09:30
+            [json_encode(['17:00 Australia/Adelaide', '08:00 Australia/Adelaide']), 1467879105, true], // 2016-07-07T17:41:45+09:30
+
+            [json_encode(['08:00 Pacific/Niue', '17:00 Pacific/Niue']), 1467916905, false], // 2016-07-07T07:41:45-11:00
+            [json_encode(['08:00 Pacific/Niue', '17:00 Pacific/Niue']), 1467920505, true], // 2016-07-07T08:41:45-11:00
+            [json_encode(['08:00 Pacific/Niue', '17:00 Pacific/Niue']), 1467949305, true], // 2016-07-07T16:41:45-11:00
+            [json_encode(['08:00 Pacific/Niue', '17:00 Pacific/Niue']), 1467952905, false], // 2016-07-07T17:41:45-11:00
+            [json_encode(['17:00 Pacific/Niue', '08:00 Pacific/Niue']), 1467916905, true], // 2016-07-07T07:41:45-11:00
+            [json_encode(['17:00 Pacific/Niue', '08:00 Pacific/Niue']), 1467920505, false], // 2016-07-07T08:41:45-11:00
+            [json_encode(['17:00 Pacific/Niue', '08:00 Pacific/Niue']), 1467949305, false], // 2016-07-07T16:41:45-11:00
+            [json_encode(['17:00 Pacific/Niue', '08:00 Pacific/Niue']), 1467952905, true], // 2016-07-07T17:41:45-11:00
+        ];
+    }
+
+    /**
+     * @dataProvider dataExecuteCheck
+     */
+    public function testExecuteCheckIn(string $value, int $timestamp, bool $expected): void {
+        $check = new RequestTime($this->getL10NMock(), $this->timeFactory);
+
+        $this->timeFactory->expects($this->once())
+            ->method('getTime')
+            ->willReturn($timestamp);
+
+        $this->assertEquals($expected, $check->executeCheck('in', $value));
+    }
+
+    /**
+     * @dataProvider dataExecuteCheck
+     */
+    public function testExecuteCheckNotIn(string $value, int $timestamp, bool $expected): void {
+        $check = new RequestTime($this->getL10NMock(), $this->timeFactory);
+
+        $this->timeFactory->expects($this->once())
+            ->method('getTime')
+            ->willReturn($timestamp);
+
+        $this->assertEquals(!$expected, $check->executeCheck('!in', $value));
+    }
+
+    public static function dataValidateCheck(): array {
+        return [
+            ['in', '["08:00 Europe/Berlin","17:00 Europe/Berlin"]'],
+            ['!in', '["08:00 Europe/Berlin","17:00 America/North_Dakota/Beulah"]'],
+            ['in', '["08:00 America/Port-au-Prince","17:00 America/Argentina/San_Luis"]'],
+        ];
+    }
+
+    /**
+     * @dataProvider dataValidateCheck
+     */
+    public function testValidateCheck(string $operator, string $value): void {
+        $check = new RequestTime($this->getL10NMock(), $this->timeFactory);
+        $check->validateCheck($operator, $value);
+        $this->addToAssertionCount(1);
+    }
+
+    public static function dataValidateCheckInvalid(): array {
+        return [
+            ['!!in', '["08:00 Europe/Berlin","17:00 Europe/Berlin"]', 1, 'The given operator is invalid'],
+            ['in', '["28:00 Europe/Berlin","17:00 Europe/Berlin"]', 2, 'The given time span is invalid'],
+            ['in', '["08:00 Europe/Berlin","27:00 Europe/Berlin"]', 2, 'The given time span is invalid'],
+            ['in', '["08:00 Europa/Berlin","17:00 Europe/Berlin"]', 3, 'The given start time is invalid'],
+            ['in', '["08:00 Europe/Berlin","17:00 Europa/Berlin"]', 4, 'The given end time is invalid'],
+            ['in', '["08:00 Europe/Bearlin","17:00 Europe/Berlin"]', 3, 'The given start time is invalid'],
+            ['in', '["08:00 Europe/Berlin","17:00 Europe/Bearlin"]', 4, 'The given end time is invalid'],
+        ];
+    }
+
+    /**
+     * @dataProvider dataValidateCheckInvalid
+     */
+    public function testValidateCheckInvalid(string $operator, string $value, int $exceptionCode, string $exceptionMessage): void {
+        $check = new RequestTime($this->getL10NMock(), $this->timeFactory);
+
+        try {
+            $check->validateCheck($operator, $value);
+        } catch (\UnexpectedValueException $e) {
+            $this->assertEquals($exceptionCode, $e->getCode());
+            $this->assertEquals($exceptionMessage, $e->getMessage());
+        }
+    }
 }

Spacing +1 added lines, -1 removed lines

@@ -20,7 +20,7 @@
 		$l = $this->createMock(IL10N::class);
 		$l->expects($this->any())
 			->method('t')
-			->willReturnCallback(function ($string, $args) {
+			->willReturnCallback(function($string, $args) {
 				return sprintf($string, $args);
 			});
 		return $l;

apps/dashboard/tests/DashboardServiceTest.php

Indentation +76 added lines, -76 removed lines

@@ -20,81 +20,81 @@
 
 class DashboardServiceTest extends TestCase {
 
-	private IConfig&MockObject $config;
-	private IUserManager&MockObject $userManager;
-	private IAccountManager&MockObject $accountManager;
-	private DashboardService $service;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->config = $this->createMock(IConfig::class);
-		$this->userManager = $this->createMock(IUserManager::class);
-		$this->accountManager = $this->createMock(IAccountManager::class);
-
-		$this->service = new DashboardService(
-			$this->config,
-			'alice',
-			$this->userManager,
-			$this->accountManager,
-		);
-	}
-
-	public function testGetBirthdate(): void {
-		$user = $this->createMock(IUser::class);
-		$this->userManager->method('get')
-			->willReturn($user);
-
-		$account = new Account($user);
-		$account->setProperty(
-			IAccountManager::PROPERTY_BIRTHDATE,
-			'2024-12-10T00:00:00.000Z',
-			IAccountManager::SCOPE_LOCAL,
-			IAccountManager::VERIFIED,
-		);
-
-		$this->accountManager->method('getAccount')
-			->willReturn($account);
-
-		$birthdate = $this->service->getBirthdate();
-
-		$this->assertEquals('2024-12-10T00:00:00.000Z', $birthdate);
-	}
-
-	public function testGetBirthdatePropertyDoesNotExist(): void {
-		$user = $this->createMock(IUser::class);
-		$this->userManager->method('get')
-			->willReturn($user);
-
-		$account = new Account($user);
-		$this->accountManager->method('getAccount')
-			->willReturn($account);
-
-		$birthdate = $this->service->getBirthdate();
-
-		$this->assertEquals('', $birthdate);
-	}
-
-	public function testGetBirthdateUserNotFound(): void {
-		$this->userManager->method('get')
-			->willReturn(null);
-
-		$birthdate = $this->service->getBirthdate();
-
-		$this->assertEquals('', $birthdate);
-	}
-
-	public function testGetBirthdateNoUserId(): void {
-		$service = new DashboardService(
-			$this->config,
-			null,
-			$this->userManager,
-			$this->accountManager,
-		);
-
-		$birthdate = $service->getBirthdate();
-
-		$this->assertEquals('', $birthdate);
-	}
+    private IConfig&MockObject $config;
+    private IUserManager&MockObject $userManager;
+    private IAccountManager&MockObject $accountManager;
+    private DashboardService $service;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->config = $this->createMock(IConfig::class);
+        $this->userManager = $this->createMock(IUserManager::class);
+        $this->accountManager = $this->createMock(IAccountManager::class);
+
+        $this->service = new DashboardService(
+            $this->config,
+            'alice',
+            $this->userManager,
+            $this->accountManager,
+        );
+    }
+
+    public function testGetBirthdate(): void {
+        $user = $this->createMock(IUser::class);
+        $this->userManager->method('get')
+            ->willReturn($user);
+
+        $account = new Account($user);
+        $account->setProperty(
+            IAccountManager::PROPERTY_BIRTHDATE,
+            '2024-12-10T00:00:00.000Z',
+            IAccountManager::SCOPE_LOCAL,
+            IAccountManager::VERIFIED,
+        );
+
+        $this->accountManager->method('getAccount')
+            ->willReturn($account);
+
+        $birthdate = $this->service->getBirthdate();
+
+        $this->assertEquals('2024-12-10T00:00:00.000Z', $birthdate);
+    }
+
+    public function testGetBirthdatePropertyDoesNotExist(): void {
+        $user = $this->createMock(IUser::class);
+        $this->userManager->method('get')
+            ->willReturn($user);
+
+        $account = new Account($user);
+        $this->accountManager->method('getAccount')
+            ->willReturn($account);
+
+        $birthdate = $this->service->getBirthdate();
+
+        $this->assertEquals('', $birthdate);
+    }
+
+    public function testGetBirthdateUserNotFound(): void {
+        $this->userManager->method('get')
+            ->willReturn(null);
+
+        $birthdate = $this->service->getBirthdate();
+
+        $this->assertEquals('', $birthdate);
+    }
+
+    public function testGetBirthdateNoUserId(): void {
+        $service = new DashboardService(
+            $this->config,
+            null,
+            $this->userManager,
+            $this->accountManager,
+        );
+
+        $birthdate = $service->getBirthdate();
+
+        $this->assertEquals('', $birthdate);
+    }
 
 }

apps/comments/tests/Unit/AppInfo/ApplicationTest.php

Indentation +30 added lines, -30 removed lines

@@ -29,34 +29,34 @@
  * @package OCA\Comments\Tests\Unit\AppInfo
  */
 class ApplicationTest extends TestCase {
-	protected function setUp(): void {
-		parent::setUp();
-		Server::get(IUserManager::class)->createUser('dummy', '456');
-		Server::get(IUserSession::class)->setUser(Server::get(IUserManager::class)->get('dummy'));
-	}
-
-	protected function tearDown(): void {
-		Server::get(IUserManager::class)->get('dummy')->delete();
-		parent::tearDown();
-	}
-
-	public function test(): void {
-		$app = new Application();
-		$c = $app->getContainer();
-
-		$services = [
-			NotificationsController::class,
-			Filter::class,
-			Listener::class,
-			Provider::class,
-			Setting::class,
-			\OCA\Comments\Notification\Listener::class,
-			Notifier::class,
-		];
-
-		foreach ($services as $service) {
-			$s = $c->get($service);
-			$this->assertInstanceOf($service, $s);
-		}
-	}
+    protected function setUp(): void {
+        parent::setUp();
+        Server::get(IUserManager::class)->createUser('dummy', '456');
+        Server::get(IUserSession::class)->setUser(Server::get(IUserManager::class)->get('dummy'));
+    }
+
+    protected function tearDown(): void {
+        Server::get(IUserManager::class)->get('dummy')->delete();
+        parent::tearDown();
+    }
+
+    public function test(): void {
+        $app = new Application();
+        $c = $app->getContainer();
+
+        $services = [
+            NotificationsController::class,
+            Filter::class,
+            Listener::class,
+            Provider::class,
+            Setting::class,
+            \OCA\Comments\Notification\Listener::class,
+            Notifier::class,
+        ];
+
+        foreach ($services as $service) {
+            $s = $c->get($service);
+            $this->assertInstanceOf($service, $s);
+        }
+    }
 }

apps/comments/tests/Unit/Collaboration/CommentersSorterTest.php

Indentation +116 added lines, -116 removed lines

@@ -12,128 +12,128 @@
 use Test\TestCase;
 
 class CommentersSorterTest extends TestCase {
-	protected ICommentsManager&MockObject $commentsManager;
-	protected CommentersSorter $sorter;
+    protected ICommentsManager&MockObject $commentsManager;
+    protected CommentersSorter $sorter;
 
-	protected function setUp(): void {
-		parent::setUp();
+    protected function setUp(): void {
+        parent::setUp();
 
-		$this->commentsManager = $this->createMock(ICommentsManager::class);
+        $this->commentsManager = $this->createMock(ICommentsManager::class);
 
-		$this->sorter = new CommentersSorter($this->commentsManager);
-	}
+        $this->sorter = new CommentersSorter($this->commentsManager);
+    }
 
-	/**
-	 * @dataProvider sortDataProvider
-	 * @param $data
-	 */
-	public function testSort($data): void {
-		$commentMocks = [];
-		foreach ($data['actors'] as $actorType => $actors) {
-			foreach ($actors as $actorId => $noOfComments) {
-				for ($i = 0;$i < $noOfComments;$i++) {
-					$mock = $this->createMock(IComment::class);
-					$mock->expects($this->atLeastOnce())
-						->method('getActorType')
-						->willReturn($actorType);
-					$mock->expects($this->atLeastOnce())
-						->method('getActorId')
-						->willReturn($actorId);
-					$commentMocks[] = $mock;
-				}
-			}
-		}
+    /**
+     * @dataProvider sortDataProvider
+     * @param $data
+     */
+    public function testSort($data): void {
+        $commentMocks = [];
+        foreach ($data['actors'] as $actorType => $actors) {
+            foreach ($actors as $actorId => $noOfComments) {
+                for ($i = 0;$i < $noOfComments;$i++) {
+                    $mock = $this->createMock(IComment::class);
+                    $mock->expects($this->atLeastOnce())
+                        ->method('getActorType')
+                        ->willReturn($actorType);
+                    $mock->expects($this->atLeastOnce())
+                        ->method('getActorId')
+                        ->willReturn($actorId);
+                    $commentMocks[] = $mock;
+                }
+            }
+        }
 
-		$this->commentsManager->expects($this->once())
-			->method('getForObject')
-			->willReturn($commentMocks);
+        $this->commentsManager->expects($this->once())
+            ->method('getForObject')
+            ->willReturn($commentMocks);
 
-		$workArray = $data['input'];
-		$this->sorter->sort($workArray, ['itemType' => 'files', 'itemId' => '24']);
+        $workArray = $data['input'];
+        $this->sorter->sort($workArray, ['itemType' => 'files', 'itemId' => '24']);
 
-		$this->assertEquals($data['expected'], $workArray);
-	}
+        $this->assertEquals($data['expected'], $workArray);
+    }
 
-	public static function sortDataProvider(): array {
-		return [[
-			[
-				#1 – sort properly and otherwise keep existing order
-				'actors' => ['users' => ['celia' => 3, 'darius' => 7, 'faruk' => 5, 'gail' => 5], 'bots' => ['r2-d2' => 8]],
-				'input' => [
-					'users' =>
-						[
-							['value' => ['shareWith' => 'alice']],
-							['value' => ['shareWith' => 'bob']],
-							['value' => ['shareWith' => 'celia']],
-							['value' => ['shareWith' => 'darius']],
-							['value' => ['shareWith' => 'elena']],
-							['value' => ['shareWith' => 'faruk']],
-							['value' => ['shareWith' => 'gail']],
-						],
-					'bots' => [
-						['value' => ['shareWith' => 'c-3po']],
-						['value' => ['shareWith' => 'r2-d2']],
-					]
-				],
-				'expected' => [
-					'users' =>
-						[
-							['value' => ['shareWith' => 'darius']],
-							['value' => ['shareWith' => 'faruk']],
-							['value' => ['shareWith' => 'gail']],
-							['value' => ['shareWith' => 'celia']],
-							['value' => ['shareWith' => 'alice']],
-							['value' => ['shareWith' => 'bob']],
-							['value' => ['shareWith' => 'elena']],
-						],
-					'bots' => [
-						['value' => ['shareWith' => 'r2-d2']],
-						['value' => ['shareWith' => 'c-3po']],
-					]
-				],
-			],
-			[
-				#2 – no commentors, input equals output
-				'actors' => [],
-				'input' => [
-					'users' =>
-						[
-							['value' => ['shareWith' => 'alice']],
-							['value' => ['shareWith' => 'bob']],
-							['value' => ['shareWith' => 'celia']],
-							['value' => ['shareWith' => 'darius']],
-							['value' => ['shareWith' => 'elena']],
-							['value' => ['shareWith' => 'faruk']],
-							['value' => ['shareWith' => 'gail']],
-						],
-					'bots' => [
-						['value' => ['shareWith' => 'c-3po']],
-						['value' => ['shareWith' => 'r2-d2']],
-					]
-				],
-				'expected' => [
-					'users' =>
-						[
-							['value' => ['shareWith' => 'alice']],
-							['value' => ['shareWith' => 'bob']],
-							['value' => ['shareWith' => 'celia']],
-							['value' => ['shareWith' => 'darius']],
-							['value' => ['shareWith' => 'elena']],
-							['value' => ['shareWith' => 'faruk']],
-							['value' => ['shareWith' => 'gail']],
-						],
-					'bots' => [
-						['value' => ['shareWith' => 'c-3po']],
-						['value' => ['shareWith' => 'r2-d2']],
-					]
-				],
-			],
-			[
-				#3 – no nothing
-				'actors' => [],
-				'input' => [],
-				'expected' => [],
-			],
-		]];
-	}
+    public static function sortDataProvider(): array {
+        return [[
+            [
+                #1 – sort properly and otherwise keep existing order
+                'actors' => ['users' => ['celia' => 3, 'darius' => 7, 'faruk' => 5, 'gail' => 5], 'bots' => ['r2-d2' => 8]],
+                'input' => [
+                    'users' =>
+                        [
+                            ['value' => ['shareWith' => 'alice']],
+                            ['value' => ['shareWith' => 'bob']],
+                            ['value' => ['shareWith' => 'celia']],
+                            ['value' => ['shareWith' => 'darius']],
+                            ['value' => ['shareWith' => 'elena']],
+                            ['value' => ['shareWith' => 'faruk']],
+                            ['value' => ['shareWith' => 'gail']],
+                        ],
+                    'bots' => [
+                        ['value' => ['shareWith' => 'c-3po']],
+                        ['value' => ['shareWith' => 'r2-d2']],
+                    ]
+                ],
+                'expected' => [
+                    'users' =>
+                        [
+                            ['value' => ['shareWith' => 'darius']],
+                            ['value' => ['shareWith' => 'faruk']],
+                            ['value' => ['shareWith' => 'gail']],
+                            ['value' => ['shareWith' => 'celia']],
+                            ['value' => ['shareWith' => 'alice']],
+                            ['value' => ['shareWith' => 'bob']],
+                            ['value' => ['shareWith' => 'elena']],
+                        ],
+                    'bots' => [
+                        ['value' => ['shareWith' => 'r2-d2']],
+                        ['value' => ['shareWith' => 'c-3po']],
+                    ]
+                ],
+            ],
+            [
+                #2 – no commentors, input equals output
+                'actors' => [],
+                'input' => [
+                    'users' =>
+                        [
+                            ['value' => ['shareWith' => 'alice']],
+                            ['value' => ['shareWith' => 'bob']],
+                            ['value' => ['shareWith' => 'celia']],
+                            ['value' => ['shareWith' => 'darius']],
+                            ['value' => ['shareWith' => 'elena']],
+                            ['value' => ['shareWith' => 'faruk']],
+                            ['value' => ['shareWith' => 'gail']],
+                        ],
+                    'bots' => [
+                        ['value' => ['shareWith' => 'c-3po']],
+                        ['value' => ['shareWith' => 'r2-d2']],
+                    ]
+                ],
+                'expected' => [
+                    'users' =>
+                        [
+                            ['value' => ['shareWith' => 'alice']],
+                            ['value' => ['shareWith' => 'bob']],
+                            ['value' => ['shareWith' => 'celia']],
+                            ['value' => ['shareWith' => 'darius']],
+                            ['value' => ['shareWith' => 'elena']],
+                            ['value' => ['shareWith' => 'faruk']],
+                            ['value' => ['shareWith' => 'gail']],
+                        ],
+                    'bots' => [
+                        ['value' => ['shareWith' => 'c-3po']],
+                        ['value' => ['shareWith' => 'r2-d2']],
+                    ]
+                ],
+            ],
+            [
+                #3 – no nothing
+                'actors' => [],
+                'input' => [],
+                'expected' => [],
+            ],
+        ]];
+    }
 }

apps/comments/tests/Unit/Controller/NotificationsTest.php

Indentation +183 added lines, -183 removed lines

@@ -28,187 +28,187 @@
 use Test\TestCase;
 
 class NotificationsTest extends TestCase {
-	protected ICommentsManager&MockObject $commentsManager;
-	protected IRootFolder&MockObject $rootFolder;
-	protected IUserSession&MockObject $session;
-	protected IManager&MockObject $notificationManager;
-	protected IURLGenerator&MockObject $urlGenerator;
-	protected NotificationsController $notificationsController;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->commentsManager = $this->createMock(ICommentsManager::class);
-		$this->rootFolder = $this->createMock(IRootFolder::class);
-		$this->session = $this->createMock(IUserSession::class);
-		$this->notificationManager = $this->createMock(IManager::class);
-		$this->urlGenerator = $this->createMock(IURLGenerator::class);
-
-		$this->notificationsController = new NotificationsController(
-			'comments',
-			$this->createMock(IRequest::class),
-			$this->commentsManager,
-			$this->rootFolder,
-			$this->urlGenerator,
-			$this->notificationManager,
-			$this->session
-		);
-	}
-
-	public function testViewGuestRedirect(): void {
-		$this->commentsManager->expects($this->never())
-			->method('get');
-
-		$this->rootFolder->expects($this->never())
-			->method('getUserFolder');
-
-		$this->session->expects($this->once())
-			->method('getUser')
-			->willReturn(null);
-
-		$this->notificationManager->expects($this->never())
-			->method('createNotification');
-		$this->notificationManager->expects($this->never())
-			->method('markProcessed');
-
-		$this->urlGenerator->expects($this->exactly(2))
-			->method('linkToRoute')
-			->willReturnMap([
-				['comments.Notifications.view', ['id' => '42'], 'link-to-comment'],
-				['core.login.showLoginForm', ['redirect_url' => 'link-to-comment'], 'link-to-login'],
-			]);
-
-		/** @var RedirectResponse $response */
-		$response = $this->notificationsController->view('42');
-		$this->assertInstanceOf(RedirectResponse::class, $response);
-		$this->assertSame('link-to-login', $response->getRedirectURL());
-	}
-
-	public function testViewSuccess(): void {
-		$comment = $this->createMock(IComment::class);
-		$comment->expects($this->any())
-			->method('getObjectType')
-			->willReturn('files');
-		$comment->expects($this->any())
-			->method('getId')
-			->willReturn('1234');
-
-		$this->commentsManager->expects($this->any())
-			->method('get')
-			->with('42')
-			->willReturn($comment);
-
-		$file = $this->createMock(Node::class);
-		$folder = $this->createMock(Folder::class);
-		$user = $this->createMock(IUser::class);
-
-		$this->rootFolder->expects($this->once())
-			->method('getUserFolder')
-			->willReturn($folder);
-
-		$folder->expects($this->once())
-			->method('getById')
-			->willReturn([$file]);
-
-		$this->session->expects($this->once())
-			->method('getUser')
-			->willReturn($user);
-
-		$user->expects($this->any())
-			->method('getUID')
-			->willReturn('user');
-
-		$notification = $this->createMock(INotification::class);
-		$notification->expects($this->any())
-			->method($this->anything())
-			->willReturn($notification);
-
-		$this->notificationManager->expects($this->once())
-			->method('createNotification')
-			->willReturn($notification);
-		$this->notificationManager->expects($this->once())
-			->method('markProcessed')
-			->with($notification);
-
-		$response = $this->notificationsController->view('42');
-		$this->assertInstanceOf(RedirectResponse::class, $response);
-	}
-
-	public function testViewInvalidComment(): void {
-		$this->commentsManager->expects($this->any())
-			->method('get')
-			->with('42')
-			->will($this->throwException(new NotFoundException()));
-
-		$this->rootFolder->expects($this->never())
-			->method('getUserFolder');
-
-		$user = $this->createMock(IUser::class);
-
-		$this->session->expects($this->once())
-			->method('getUser')
-			->willReturn($user);
-
-		$user->expects($this->any())
-			->method('getUID')
-			->willReturn('user');
-
-		$this->notificationManager->expects($this->never())
-			->method('createNotification');
-		$this->notificationManager->expects($this->never())
-			->method('markProcessed');
-
-		$response = $this->notificationsController->view('42');
-		$this->assertInstanceOf(NotFoundResponse::class, $response);
-	}
-
-	public function testViewNoFile(): void {
-		$comment = $this->createMock(IComment::class);
-		$comment->expects($this->any())
-			->method('getObjectType')
-			->willReturn('files');
-		$comment->expects($this->any())
-			->method('getId')
-			->willReturn('1234');
-
-		$this->commentsManager->expects($this->any())
-			->method('get')
-			->with('42')
-			->willReturn($comment);
-
-		$folder = $this->createMock(Folder::class);
-
-		$this->rootFolder->expects($this->once())
-			->method('getUserFolder')
-			->willReturn($folder);
-
-		$folder->expects($this->once())
-			->method('getById')
-			->willReturn([]);
-
-		$user = $this->createMock(IUser::class);
-
-		$this->session->expects($this->once())
-			->method('getUser')
-			->willReturn($user);
-
-		$user->expects($this->any())
-			->method('getUID')
-			->willReturn('user');
-
-		$notification = $this->createMock(INotification::class);
-		$notification->expects($this->any())
-			->method($this->anything())
-			->willReturn($notification);
-
-		$this->notificationManager->expects($this->once())
-			->method('createNotification')
-			->willReturn($notification);
-		$this->notificationManager->expects($this->once())
-			->method('markProcessed')
-			->with($notification);
-
-		$response = $this->notificationsController->view('42');
-		$this->assertInstanceOf(NotFoundResponse::class, $response);
-	}
+    protected ICommentsManager&MockObject $commentsManager;
+    protected IRootFolder&MockObject $rootFolder;
+    protected IUserSession&MockObject $session;
+    protected IManager&MockObject $notificationManager;
+    protected IURLGenerator&MockObject $urlGenerator;
+    protected NotificationsController $notificationsController;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->commentsManager = $this->createMock(ICommentsManager::class);
+        $this->rootFolder = $this->createMock(IRootFolder::class);
+        $this->session = $this->createMock(IUserSession::class);
+        $this->notificationManager = $this->createMock(IManager::class);
+        $this->urlGenerator = $this->createMock(IURLGenerator::class);
+
+        $this->notificationsController = new NotificationsController(
+            'comments',
+            $this->createMock(IRequest::class),
+            $this->commentsManager,
+            $this->rootFolder,
+            $this->urlGenerator,
+            $this->notificationManager,
+            $this->session
+        );
+    }
+
+    public function testViewGuestRedirect(): void {
+        $this->commentsManager->expects($this->never())
+            ->method('get');
+
+        $this->rootFolder->expects($this->never())
+            ->method('getUserFolder');
+
+        $this->session->expects($this->once())
+            ->method('getUser')
+            ->willReturn(null);
+
+        $this->notificationManager->expects($this->never())
+            ->method('createNotification');
+        $this->notificationManager->expects($this->never())
+            ->method('markProcessed');
+
+        $this->urlGenerator->expects($this->exactly(2))
+            ->method('linkToRoute')
+            ->willReturnMap([
+                ['comments.Notifications.view', ['id' => '42'], 'link-to-comment'],
+                ['core.login.showLoginForm', ['redirect_url' => 'link-to-comment'], 'link-to-login'],
+            ]);
+
+        /** @var RedirectResponse $response */
+        $response = $this->notificationsController->view('42');
+        $this->assertInstanceOf(RedirectResponse::class, $response);
+        $this->assertSame('link-to-login', $response->getRedirectURL());
+    }
+
+    public function testViewSuccess(): void {
+        $comment = $this->createMock(IComment::class);
+        $comment->expects($this->any())
+            ->method('getObjectType')
+            ->willReturn('files');
+        $comment->expects($this->any())
+            ->method('getId')
+            ->willReturn('1234');
+
+        $this->commentsManager->expects($this->any())
+            ->method('get')
+            ->with('42')
+            ->willReturn($comment);
+
+        $file = $this->createMock(Node::class);
+        $folder = $this->createMock(Folder::class);
+        $user = $this->createMock(IUser::class);
+
+        $this->rootFolder->expects($this->once())
+            ->method('getUserFolder')
+            ->willReturn($folder);
+
+        $folder->expects($this->once())
+            ->method('getById')
+            ->willReturn([$file]);
+
+        $this->session->expects($this->once())
+            ->method('getUser')
+            ->willReturn($user);
+
+        $user->expects($this->any())
+            ->method('getUID')
+            ->willReturn('user');
+
+        $notification = $this->createMock(INotification::class);
+        $notification->expects($this->any())
+            ->method($this->anything())
+            ->willReturn($notification);
+
+        $this->notificationManager->expects($this->once())
+            ->method('createNotification')
+            ->willReturn($notification);
+        $this->notificationManager->expects($this->once())
+            ->method('markProcessed')
+            ->with($notification);
+
+        $response = $this->notificationsController->view('42');
+        $this->assertInstanceOf(RedirectResponse::class, $response);
+    }
+
+    public function testViewInvalidComment(): void {
+        $this->commentsManager->expects($this->any())
+            ->method('get')
+            ->with('42')
+            ->will($this->throwException(new NotFoundException()));
+
+        $this->rootFolder->expects($this->never())
+            ->method('getUserFolder');
+
+        $user = $this->createMock(IUser::class);
+
+        $this->session->expects($this->once())
+            ->method('getUser')
+            ->willReturn($user);
+
+        $user->expects($this->any())
+            ->method('getUID')
+            ->willReturn('user');
+
+        $this->notificationManager->expects($this->never())
+            ->method('createNotification');
+        $this->notificationManager->expects($this->never())
+            ->method('markProcessed');
+
+        $response = $this->notificationsController->view('42');
+        $this->assertInstanceOf(NotFoundResponse::class, $response);
+    }
+
+    public function testViewNoFile(): void {
+        $comment = $this->createMock(IComment::class);
+        $comment->expects($this->any())
+            ->method('getObjectType')
+            ->willReturn('files');
+        $comment->expects($this->any())
+            ->method('getId')
+            ->willReturn('1234');
+
+        $this->commentsManager->expects($this->any())
+            ->method('get')
+            ->with('42')
+            ->willReturn($comment);
+
+        $folder = $this->createMock(Folder::class);
+
+        $this->rootFolder->expects($this->once())
+            ->method('getUserFolder')
+            ->willReturn($folder);
+
+        $folder->expects($this->once())
+            ->method('getById')
+            ->willReturn([]);
+
+        $user = $this->createMock(IUser::class);
+
+        $this->session->expects($this->once())
+            ->method('getUser')
+            ->willReturn($user);
+
+        $user->expects($this->any())
+            ->method('getUID')
+            ->willReturn('user');
+
+        $notification = $this->createMock(INotification::class);
+        $notification->expects($this->any())
+            ->method($this->anything())
+            ->willReturn($notification);
+
+        $this->notificationManager->expects($this->once())
+            ->method('createNotification')
+            ->willReturn($notification);
+        $this->notificationManager->expects($this->once())
+            ->method('markProcessed')
+            ->with($notification);
+
+        $response = $this->notificationsController->view('42');
+        $this->assertInstanceOf(NotFoundResponse::class, $response);
+    }
 }