nextcloud / server

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

tests/lib/Authentication/Events/RemoteWipeStartedTest.php

Indentation +5 added lines, -5 removed lines

@@ -14,10 +14,10 @@
 use Test\TestCase;
 
 class RemoteWipeStartedTest extends TestCase {
-	public function testGetToken(): void {
-		$token = $this->createMock(IToken::class);
-		$event = new RemoteWipeStarted($token);
+    public function testGetToken(): void {
+        $token = $this->createMock(IToken::class);
+        $event = new RemoteWipeStarted($token);
 
-		$this->assertSame($token, $event->getToken());
-	}
+        $this->assertSame($token, $event->getToken());
+    }
 }

tests/lib/Authentication/Events/RemoteWipeFinishedTest.php

Indentation +5 added lines, -5 removed lines

@@ -14,10 +14,10 @@
 use Test\TestCase;
 
 class RemoteWipeFinishedTest extends TestCase {
-	public function testGetToken(): void {
-		$token = $this->createMock(IToken::class);
-		$event = new RemoteWipeFinished($token);
+    public function testGetToken(): void {
+        $token = $this->createMock(IToken::class);
+        $event = new RemoteWipeFinished($token);
 
-		$this->assertSame($token, $event->getToken());
-	}
+        $this->assertSame($token, $event->getToken());
+    }
 }

tests/lib/Authentication/LoginCredentials/CredentialsTest.php

Indentation +24 added lines, -24 removed lines

@@ -11,37 +11,37 @@
 use Test\TestCase;
 
 class CredentialsTest extends TestCase {
-	/** @var string */
-	private $uid;
+    /** @var string */
+    private $uid;
 
-	/** @var string */
-	private $user;
+    /** @var string */
+    private $user;
 
-	/** @var string */
-	private $password;
+    /** @var string */
+    private $password;
 
-	/** @var Credentials */
-	private $credentials;
+    /** @var Credentials */
+    private $credentials;
 
-	protected function setUp(): void {
-		parent::setUp();
+    protected function setUp(): void {
+        parent::setUp();
 
-		$this->uid = 'user123';
-		$this->user = 'User123';
-		$this->password = '123456';
+        $this->uid = 'user123';
+        $this->user = 'User123';
+        $this->password = '123456';
 
-		$this->credentials = new Credentials($this->uid, $this->user, $this->password);
-	}
+        $this->credentials = new Credentials($this->uid, $this->user, $this->password);
+    }
 
-	public function testGetUID(): void {
-		$this->assertEquals($this->uid, $this->credentials->getUID());
-	}
+    public function testGetUID(): void {
+        $this->assertEquals($this->uid, $this->credentials->getUID());
+    }
 
-	public function testGetUserName(): void {
-		$this->assertEquals($this->user, $this->credentials->getLoginName());
-	}
+    public function testGetUserName(): void {
+        $this->assertEquals($this->user, $this->credentials->getLoginName());
+    }
 
-	public function testGetPassword(): void {
-		$this->assertEquals($this->password, $this->credentials->getPassword());
-	}
+    public function testGetPassword(): void {
+        $this->assertEquals($this->password, $this->credentials->getPassword());
+    }
 }

tests/lib/Authentication/Listeners/RemoteWipeActivityListenerTest.php

Indentation +112 added lines, -112 removed lines

@@ -22,116 +22,116 @@
 use Test\TestCase;
 
 class RemoteWipeActivityListenerTest extends TestCase {
-	/** @var IActivityManager|MockObject */
-	private $activityManager;
-
-	/** @var LoggerInterface|MockObject */
-	private $logger;
-
-	/** @var IEventListener */
-	private $listener;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->activityManager = $this->createMock(IActivityManager::class);
-		$this->logger = $this->createMock(LoggerInterface::class);
-
-		$this->listener = new RemoteWipeActivityListener(
-			$this->activityManager,
-			$this->logger
-		);
-	}
-
-	public function testHandleUnrelated(): void {
-		$event = new Event();
-
-		$this->listener->handle($event);
-
-		$this->addToAssertionCount(1);
-	}
-
-	public function testHandleRemoteWipeStarted(): void {
-		/** @var IToken|MockObject $token */
-		$token = $this->createMock(IToken::class);
-		$event = new RemoteWipeStarted($token);
-		$activityEvent = $this->createMock(IActivityEvent::class);
-		$this->activityManager->expects($this->once())
-			->method('generateEvent')
-			->willReturn($activityEvent);
-		$activityEvent->expects($this->once())
-			->method('setApp')
-			->with('core')
-			->willReturnSelf();
-		$activityEvent->expects($this->once())
-			->method('setType')
-			->with('security')
-			->willReturnSelf();
-		$token->method('getUID')->willReturn('user123');
-		$activityEvent->expects($this->once())
-			->method('setAuthor')
-			->with('user123')
-			->willReturnSelf();
-		$activityEvent->expects($this->once())
-			->method('setAffectedUser')
-			->with('user123')
-			->willReturnSelf();
-		$token->method('getName')->willReturn('Token 1');
-		$activityEvent->expects($this->once())
-			->method('setSubject')
-			->with('remote_wipe_start', ['name' => 'Token 1'])
-			->willReturnSelf();
-		$this->activityManager->expects($this->once())
-			->method('publish');
-
-		$this->listener->handle($event);
-	}
-
-	public function testHandleRemoteWipeStartedCanNotPublish(): void {
-		$token = $this->createMock(IToken::class);
-		$event = new RemoteWipeStarted($token);
-		$this->activityManager->expects($this->once())
-			->method('generateEvent');
-		$this->activityManager->expects($this->once())
-			->method('publish')
-			->willThrowException(new \BadMethodCallException());
-
-		$this->listener->handle($event);
-	}
-
-	public function testHandleRemoteWipeFinished(): void {
-		/** @var IToken|MockObject $token */
-		$token = $this->createMock(IToken::class);
-		$event = new RemoteWipeFinished($token);
-		$activityEvent = $this->createMock(IActivityEvent::class);
-		$this->activityManager->expects($this->once())
-			->method('generateEvent')
-			->willReturn($activityEvent);
-		$activityEvent->expects($this->once())
-			->method('setApp')
-			->with('core')
-			->willReturnSelf();
-		$activityEvent->expects($this->once())
-			->method('setType')
-			->with('security')
-			->willReturnSelf();
-		$token->method('getUID')->willReturn('user123');
-		$activityEvent->expects($this->once())
-			->method('setAuthor')
-			->with('user123')
-			->willReturnSelf();
-		$activityEvent->expects($this->once())
-			->method('setAffectedUser')
-			->with('user123')
-			->willReturnSelf();
-		$token->method('getName')->willReturn('Token 1');
-		$activityEvent->expects($this->once())
-			->method('setSubject')
-			->with('remote_wipe_finish', ['name' => 'Token 1'])
-			->willReturnSelf();
-		$this->activityManager->expects($this->once())
-			->method('publish');
-
-		$this->listener->handle($event);
-	}
+    /** @var IActivityManager|MockObject */
+    private $activityManager;
+
+    /** @var LoggerInterface|MockObject */
+    private $logger;
+
+    /** @var IEventListener */
+    private $listener;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->activityManager = $this->createMock(IActivityManager::class);
+        $this->logger = $this->createMock(LoggerInterface::class);
+
+        $this->listener = new RemoteWipeActivityListener(
+            $this->activityManager,
+            $this->logger
+        );
+    }
+
+    public function testHandleUnrelated(): void {
+        $event = new Event();
+
+        $this->listener->handle($event);
+
+        $this->addToAssertionCount(1);
+    }
+
+    public function testHandleRemoteWipeStarted(): void {
+        /** @var IToken|MockObject $token */
+        $token = $this->createMock(IToken::class);
+        $event = new RemoteWipeStarted($token);
+        $activityEvent = $this->createMock(IActivityEvent::class);
+        $this->activityManager->expects($this->once())
+            ->method('generateEvent')
+            ->willReturn($activityEvent);
+        $activityEvent->expects($this->once())
+            ->method('setApp')
+            ->with('core')
+            ->willReturnSelf();
+        $activityEvent->expects($this->once())
+            ->method('setType')
+            ->with('security')
+            ->willReturnSelf();
+        $token->method('getUID')->willReturn('user123');
+        $activityEvent->expects($this->once())
+            ->method('setAuthor')
+            ->with('user123')
+            ->willReturnSelf();
+        $activityEvent->expects($this->once())
+            ->method('setAffectedUser')
+            ->with('user123')
+            ->willReturnSelf();
+        $token->method('getName')->willReturn('Token 1');
+        $activityEvent->expects($this->once())
+            ->method('setSubject')
+            ->with('remote_wipe_start', ['name' => 'Token 1'])
+            ->willReturnSelf();
+        $this->activityManager->expects($this->once())
+            ->method('publish');
+
+        $this->listener->handle($event);
+    }
+
+    public function testHandleRemoteWipeStartedCanNotPublish(): void {
+        $token = $this->createMock(IToken::class);
+        $event = new RemoteWipeStarted($token);
+        $this->activityManager->expects($this->once())
+            ->method('generateEvent');
+        $this->activityManager->expects($this->once())
+            ->method('publish')
+            ->willThrowException(new \BadMethodCallException());
+
+        $this->listener->handle($event);
+    }
+
+    public function testHandleRemoteWipeFinished(): void {
+        /** @var IToken|MockObject $token */
+        $token = $this->createMock(IToken::class);
+        $event = new RemoteWipeFinished($token);
+        $activityEvent = $this->createMock(IActivityEvent::class);
+        $this->activityManager->expects($this->once())
+            ->method('generateEvent')
+            ->willReturn($activityEvent);
+        $activityEvent->expects($this->once())
+            ->method('setApp')
+            ->with('core')
+            ->willReturnSelf();
+        $activityEvent->expects($this->once())
+            ->method('setType')
+            ->with('security')
+            ->willReturnSelf();
+        $token->method('getUID')->willReturn('user123');
+        $activityEvent->expects($this->once())
+            ->method('setAuthor')
+            ->with('user123')
+            ->willReturnSelf();
+        $activityEvent->expects($this->once())
+            ->method('setAffectedUser')
+            ->with('user123')
+            ->willReturnSelf();
+        $token->method('getName')->willReturn('Token 1');
+        $activityEvent->expects($this->once())
+            ->method('setSubject')
+            ->with('remote_wipe_finish', ['name' => 'Token 1'])
+            ->willReturnSelf();
+        $this->activityManager->expects($this->once())
+            ->method('publish');
+
+        $this->listener->handle($event);
+    }
 }

tests/lib/Authentication/Listeners/RemoteWipeEmailListenerTest.php

Indentation +195 added lines, -195 removed lines

@@ -27,199 +27,199 @@
 use Test\TestCase;
 
 class RemoteWipeEmailListenerTest extends TestCase {
-	/** @var IMailer|MockObject */
-	private $mailer;
-
-	/** @var IUserManager|MockObject */
-	private $userManager;
-
-	/** @var IFactory|MockObject */
-	private $l10nFactory;
-
-	/** @var IL10N|MockObject */
-	private $l10n;
-
-	/** @var LoggerInterface|MockObject */
-	private $logger;
-
-	/** @var IEventListener */
-	private $listener;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->mailer = $this->createMock(IMailer::class);
-		$this->userManager = $this->createMock(IUserManager::class);
-		$this->l10nFactory = $this->createMock(IFactory::class);
-		$this->l10n = $this->createMock(IL10N::class);
-		$this->logger = $this->createMock(LoggerInterface::class);
-
-		$this->l10nFactory->method('get')->with('core')->willReturn($this->l10n);
-		$this->l10n->method('t')->willReturnArgument(0);
-
-		$this->listener = new RemoteWipeEmailListener(
-			$this->mailer,
-			$this->userManager,
-			$this->l10nFactory,
-			$this->logger
-		);
-	}
-
-
-	public function testHandleUnrelated(): void {
-		$event = new Event();
-		$this->mailer->expects($this->never())->method('send');
-
-		$this->listener->handle($event);
-	}
-
-	public function testHandleRemoteWipeStartedInvalidUser(): void {
-		/** @var IToken|MockObject $token */
-		$token = $this->createMock(IToken::class);
-		$event = new RemoteWipeStarted($token);
-		$token->method('getUID')->willReturn('nope');
-		$this->userManager->expects($this->once())
-			->method('get')
-			->with('nope')
-			->willReturn(null);
-		$this->mailer->expects($this->never())->method('send');
-
-		$this->listener->handle($event);
-	}
-
-	public function testHandleRemoteWipeStartedNoEmailSet(): void {
-		/** @var IToken|MockObject $token */
-		$token = $this->createMock(IToken::class);
-		$event = new RemoteWipeStarted($token);
-		$token->method('getUID')->willReturn('nope');
-		$user = $this->createMock(IUser::class);
-		$this->userManager->expects($this->once())
-			->method('get')
-			->with('nope')
-			->willReturn($user);
-		$user->method('getEMailAddress')->willReturn(null);
-		$this->mailer->expects($this->never())->method('send');
-
-		$this->listener->handle($event);
-	}
-
-	public function testHandleRemoteWipeStartedTransmissionError(): void {
-		/** @var IToken|MockObject $token */
-		$token = $this->createMock(IToken::class);
-		$event = new RemoteWipeStarted($token);
-		$token->method('getUID')->willReturn('nope');
-		$user = $this->createMock(IUser::class);
-		$this->userManager->expects($this->once())
-			->method('get')
-			->with('nope')
-			->willReturn($user);
-		$user->method('getEMailAddress')->willReturn('user@domain.org');
-		$this->mailer->expects($this->once())
-			->method('send')
-			->willThrowException(new Exception());
-		$this->logger->expects($this->once())
-			->method('error');
-
-		$this->listener->handle($event);
-	}
-
-	public function testHandleRemoteWipeStarted(): void {
-		/** @var IToken|MockObject $token */
-		$token = $this->createMock(IToken::class);
-		$event = new RemoteWipeStarted($token);
-		$token->method('getUID')->willReturn('nope');
-		$user = $this->createMock(IUser::class);
-		$this->userManager->expects($this->once())
-			->method('get')
-			->with('nope')
-			->willReturn($user);
-		$user->method('getEMailAddress')->willReturn('user@domain.org');
-		$message = $this->createMock(IMessage::class);
-		$this->mailer->expects($this->once())
-			->method('createMessage')
-			->willReturn($message);
-		$message->expects($this->once())
-			->method('setTo')
-			->with($this->equalTo(['user@domain.org']));
-		$this->mailer->expects($this->once())
-			->method('send')
-			->with($message);
-
-		$this->listener->handle($event);
-	}
-
-	public function testHandleRemoteWipeFinishedInvalidUser(): void {
-		/** @var IToken|MockObject $token */
-		$token = $this->createMock(IToken::class);
-		$event = new RemoteWipeFinished($token);
-		$token->method('getUID')->willReturn('nope');
-		$this->userManager->expects($this->once())
-			->method('get')
-			->with('nope')
-			->willReturn(null);
-		$this->mailer->expects($this->never())->method('send');
-
-		$this->listener->handle($event);
-	}
-
-	public function testHandleRemoteWipeFinishedNoEmailSet(): void {
-		/** @var IToken|MockObject $token */
-		$token = $this->createMock(IToken::class);
-		$event = new RemoteWipeFinished($token);
-		$token->method('getUID')->willReturn('nope');
-		$user = $this->createMock(IUser::class);
-		$this->userManager->expects($this->once())
-			->method('get')
-			->with('nope')
-			->willReturn($user);
-		$user->method('getEMailAddress')->willReturn(null);
-		$this->mailer->expects($this->never())->method('send');
-
-		$this->listener->handle($event);
-	}
-
-	public function testHandleRemoteWipeFinishedTransmissionError(): void {
-		/** @var IToken|MockObject $token */
-		$token = $this->createMock(IToken::class);
-		$event = new RemoteWipeFinished($token);
-		$token->method('getUID')->willReturn('nope');
-		$user = $this->createMock(IUser::class);
-		$this->userManager->expects($this->once())
-			->method('get')
-			->with('nope')
-			->willReturn($user);
-		$user->method('getEMailAddress')->willReturn('user@domain.org');
-		$this->mailer->expects($this->once())
-			->method('send')
-			->willThrowException(new Exception());
-		$this->logger->expects($this->once())
-			->method('error');
-
-		$this->listener->handle($event);
-	}
-
-	public function testHandleRemoteWipeFinished(): void {
-		/** @var IToken|MockObject $token */
-		$token = $this->createMock(IToken::class);
-		$event = new RemoteWipeFinished($token);
-		$token->method('getUID')->willReturn('nope');
-		$user = $this->createMock(IUser::class);
-		$this->userManager->expects($this->once())
-			->method('get')
-			->with('nope')
-			->willReturn($user);
-		$user->method('getEMailAddress')->willReturn('user@domain.org');
-		$message = $this->createMock(IMessage::class);
-		$this->mailer->expects($this->once())
-			->method('createMessage')
-			->willReturn($message);
-		$message->expects($this->once())
-			->method('setTo')
-			->with($this->equalTo(['user@domain.org']));
-		$this->mailer->expects($this->once())
-			->method('send')
-			->with($message);
-
-		$this->listener->handle($event);
-	}
+    /** @var IMailer|MockObject */
+    private $mailer;
+
+    /** @var IUserManager|MockObject */
+    private $userManager;
+
+    /** @var IFactory|MockObject */
+    private $l10nFactory;
+
+    /** @var IL10N|MockObject */
+    private $l10n;
+
+    /** @var LoggerInterface|MockObject */
+    private $logger;
+
+    /** @var IEventListener */
+    private $listener;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->mailer = $this->createMock(IMailer::class);
+        $this->userManager = $this->createMock(IUserManager::class);
+        $this->l10nFactory = $this->createMock(IFactory::class);
+        $this->l10n = $this->createMock(IL10N::class);
+        $this->logger = $this->createMock(LoggerInterface::class);
+
+        $this->l10nFactory->method('get')->with('core')->willReturn($this->l10n);
+        $this->l10n->method('t')->willReturnArgument(0);
+
+        $this->listener = new RemoteWipeEmailListener(
+            $this->mailer,
+            $this->userManager,
+            $this->l10nFactory,
+            $this->logger
+        );
+    }
+
+
+    public function testHandleUnrelated(): void {
+        $event = new Event();
+        $this->mailer->expects($this->never())->method('send');
+
+        $this->listener->handle($event);
+    }
+
+    public function testHandleRemoteWipeStartedInvalidUser(): void {
+        /** @var IToken|MockObject $token */
+        $token = $this->createMock(IToken::class);
+        $event = new RemoteWipeStarted($token);
+        $token->method('getUID')->willReturn('nope');
+        $this->userManager->expects($this->once())
+            ->method('get')
+            ->with('nope')
+            ->willReturn(null);
+        $this->mailer->expects($this->never())->method('send');
+
+        $this->listener->handle($event);
+    }
+
+    public function testHandleRemoteWipeStartedNoEmailSet(): void {
+        /** @var IToken|MockObject $token */
+        $token = $this->createMock(IToken::class);
+        $event = new RemoteWipeStarted($token);
+        $token->method('getUID')->willReturn('nope');
+        $user = $this->createMock(IUser::class);
+        $this->userManager->expects($this->once())
+            ->method('get')
+            ->with('nope')
+            ->willReturn($user);
+        $user->method('getEMailAddress')->willReturn(null);
+        $this->mailer->expects($this->never())->method('send');
+
+        $this->listener->handle($event);
+    }
+
+    public function testHandleRemoteWipeStartedTransmissionError(): void {
+        /** @var IToken|MockObject $token */
+        $token = $this->createMock(IToken::class);
+        $event = new RemoteWipeStarted($token);
+        $token->method('getUID')->willReturn('nope');
+        $user = $this->createMock(IUser::class);
+        $this->userManager->expects($this->once())
+            ->method('get')
+            ->with('nope')
+            ->willReturn($user);
+        $user->method('getEMailAddress')->willReturn('user@domain.org');
+        $this->mailer->expects($this->once())
+            ->method('send')
+            ->willThrowException(new Exception());
+        $this->logger->expects($this->once())
+            ->method('error');
+
+        $this->listener->handle($event);
+    }
+
+    public function testHandleRemoteWipeStarted(): void {
+        /** @var IToken|MockObject $token */
+        $token = $this->createMock(IToken::class);
+        $event = new RemoteWipeStarted($token);
+        $token->method('getUID')->willReturn('nope');
+        $user = $this->createMock(IUser::class);
+        $this->userManager->expects($this->once())
+            ->method('get')
+            ->with('nope')
+            ->willReturn($user);
+        $user->method('getEMailAddress')->willReturn('user@domain.org');
+        $message = $this->createMock(IMessage::class);
+        $this->mailer->expects($this->once())
+            ->method('createMessage')
+            ->willReturn($message);
+        $message->expects($this->once())
+            ->method('setTo')
+            ->with($this->equalTo(['user@domain.org']));
+        $this->mailer->expects($this->once())
+            ->method('send')
+            ->with($message);
+
+        $this->listener->handle($event);
+    }
+
+    public function testHandleRemoteWipeFinishedInvalidUser(): void {
+        /** @var IToken|MockObject $token */
+        $token = $this->createMock(IToken::class);
+        $event = new RemoteWipeFinished($token);
+        $token->method('getUID')->willReturn('nope');
+        $this->userManager->expects($this->once())
+            ->method('get')
+            ->with('nope')
+            ->willReturn(null);
+        $this->mailer->expects($this->never())->method('send');
+
+        $this->listener->handle($event);
+    }
+
+    public function testHandleRemoteWipeFinishedNoEmailSet(): void {
+        /** @var IToken|MockObject $token */
+        $token = $this->createMock(IToken::class);
+        $event = new RemoteWipeFinished($token);
+        $token->method('getUID')->willReturn('nope');
+        $user = $this->createMock(IUser::class);
+        $this->userManager->expects($this->once())
+            ->method('get')
+            ->with('nope')
+            ->willReturn($user);
+        $user->method('getEMailAddress')->willReturn(null);
+        $this->mailer->expects($this->never())->method('send');
+
+        $this->listener->handle($event);
+    }
+
+    public function testHandleRemoteWipeFinishedTransmissionError(): void {
+        /** @var IToken|MockObject $token */
+        $token = $this->createMock(IToken::class);
+        $event = new RemoteWipeFinished($token);
+        $token->method('getUID')->willReturn('nope');
+        $user = $this->createMock(IUser::class);
+        $this->userManager->expects($this->once())
+            ->method('get')
+            ->with('nope')
+            ->willReturn($user);
+        $user->method('getEMailAddress')->willReturn('user@domain.org');
+        $this->mailer->expects($this->once())
+            ->method('send')
+            ->willThrowException(new Exception());
+        $this->logger->expects($this->once())
+            ->method('error');
+
+        $this->listener->handle($event);
+    }
+
+    public function testHandleRemoteWipeFinished(): void {
+        /** @var IToken|MockObject $token */
+        $token = $this->createMock(IToken::class);
+        $event = new RemoteWipeFinished($token);
+        $token->method('getUID')->willReturn('nope');
+        $user = $this->createMock(IUser::class);
+        $this->userManager->expects($this->once())
+            ->method('get')
+            ->with('nope')
+            ->willReturn($user);
+        $user->method('getEMailAddress')->willReturn('user@domain.org');
+        $message = $this->createMock(IMessage::class);
+        $this->mailer->expects($this->once())
+            ->method('createMessage')
+            ->willReturn($message);
+        $message->expects($this->once())
+            ->method('setTo')
+            ->with($this->equalTo(['user@domain.org']));
+        $this->mailer->expects($this->once())
+            ->method('send')
+            ->with($message);
+
+        $this->listener->handle($event);
+    }
 }