nextcloud / server

apps/user_ldap/tests/Mapping/GroupMappingTest.php

Indentation +3 added lines, -3 removed lines

@@ -19,7 +19,7 @@
  * @package OCA\User_LDAP\Tests\Mapping
  */
 class GroupMappingTest extends AbstractMappingTestCase {
-	public function getMapper(IDBConnection $dbMock) {
-		return new GroupMapping($dbMock);
-	}
+    public function getMapper(IDBConnection $dbMock) {
+        return new GroupMapping($dbMock);
+    }
 }

apps/user_ldap/tests/Mapping/UserMappingTest.php

Indentation +3 added lines, -3 removed lines

@@ -20,7 +20,7 @@
  * @package OCA\User_LDAP\Tests\Mapping
  */
 class UserMappingTest extends AbstractMappingTestCase {
-	public function getMapper(IDBConnection $dbMock) {
-		return new UserMapping($dbMock, $this->createMock(IAssertion::class));
-	}
+    public function getMapper(IDBConnection $dbMock) {
+        return new UserMapping($dbMock, $this->createMock(IAssertion::class));
+    }
 }

apps/user_ldap/tests/LDAPProviderTest.php

Indentation +843 added lines, -843 removed lines

@@ -34,851 +34,851 @@
  * @package OCA\User_LDAP\Tests
  */
 class LDAPProviderTest extends \Test\TestCase {
-	private function getServerMock(IUserLDAP $userBackend, IGroupLDAP $groupBackend) {
-		$server = $this->getMockBuilder('OC\Server')
-			->onlyMethods(['getUserManager', 'getGroupManager'])
-			->setConstructorArgs(['', new Config(\OC::$configDir)])
-			->getMock();
-		$server->expects($this->any())
-			->method('getUserManager')
-			->willReturn($this->getUserManagerMock($userBackend));
-		$server->expects($this->any())
-			->method('getGroupManager')
-			->willReturn($this->getGroupManagerMock($groupBackend));
-
-		return $server;
-	}
-
-	private function getUserManagerMock(IUserLDAP $userBackend) {
-		$userManager = $this->getMockBuilder(Manager::class)
-			->onlyMethods(['getBackends'])
-			->setConstructorArgs([
-				$this->createMock(IConfig::class),
-				$this->createMock(ICacheFactory::class),
-				$this->createMock(IEventDispatcher::class),
-				$this->createMock(LoggerInterface::class),
-			])
-			->getMock();
-		$userManager->expects($this->any())
-			->method('getBackends')
-			->willReturn([$userBackend]);
-		return $userManager;
-	}
-
-	private function getGroupManagerMock(IGroupLDAP $groupBackend) {
-		$groupManager = $this->getMockBuilder('OC\Group\Manager')
-			->onlyMethods(['getBackends'])
-			->disableOriginalConstructor()
-			->getMock();
-		$groupManager->expects($this->any())
-			->method('getBackends')
-			->willReturn([$groupBackend]);
-		return $groupManager;
-	}
-
-	private function getDefaultGroupBackendMock() {
-		$groupBackend = $this->getMockBuilder('OCA\User_LDAP\Group_LDAP')
-			->disableOriginalConstructor()
-			->getMock();
-
-		return $groupBackend;
-	}
-
-	private function getLDAPProvider(IServerContainer $serverContainer) {
-		$factory = new LDAPProviderFactory($serverContainer);
-		return $factory->getLDAPProvider();
-	}
-
-
-	public function testGetUserDNUserIDNotFound(): void {
-		$this->expectException(\Exception::class);
-		$this->expectExceptionMessage('User id not found in LDAP');
-
-		$userBackend = $this->getMockBuilder(User_LDAP::class)
-			->onlyMethods(['userExists'])
-			->disableOriginalConstructor()
-			->getMock();
-		$userBackend->expects($this->any())->method('userExists')->willReturn(false);
-
-		$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$ldapProvider->getUserDN('nonexisting_user');
-	}
-
-
-	public function testGetUserDN(): void {
-		$userAccess = $this->getMockBuilder(Access::class)
-			->onlyMethods(['username2dn'])
-			->disableOriginalConstructor()
-			->getMock();
-		$userAccess->expects($this->once())
-			->method('username2dn')
-			->willReturn('cn=existing_user,ou=Are Sufficient To,ou=Test,dc=example,dc=org');
-		$userBackend = $this->getMockBuilder(User_LDAP::class)
-			->onlyMethods(['userExists', 'getLDAPAccess'])
-			->disableOriginalConstructor()
-			->getMock();
-		$userBackend->expects($this->once())
-			->method('userExists')
-			->willReturn(true);
-		$userBackend->expects($this->any())
-			->method('getLDAPAccess')
-			->willReturn($userAccess);
-
-		$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$this->assertEquals('cn=existing_user,ou=Are Sufficient To,ou=Test,dc=example,dc=org',
-			$ldapProvider->getUserDN('existing_user'));
-	}
-
-
-	public function testGetGroupDNGroupIDNotFound(): void {
-		$this->expectException(\Exception::class);
-		$this->expectExceptionMessage('Group id not found in LDAP');
-
-		$userBackend = $this->createMock(User_LDAP::class);
-		$groupBackend = $this->getMockBuilder(Group_LDAP::class)
-			->onlyMethods(['groupExists'])
-			->disableOriginalConstructor()
-			->getMock();
-
-		$groupBackend->expects($this->any())->method('groupExists')->willReturn(false);
-
-		$server = $this->getServerMock($userBackend, $groupBackend);
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$ldapProvider->getGroupDN('nonexisting_group');
-	}
-
-	public function testGetGroupDN(): void {
-		$userBackend = $this->createMock(User_LDAP::class);
-
-		$groupBackend = $this->getMockBuilder(Group_LDAP::class)
-			->onlyMethods(['groupExists', 'getLDAPAccess'])
-			->disableOriginalConstructor()
-			->getMock();
-
-		$groupAccess = $this->createMock(Access::class);
-		$groupAccess->expects($this->once())
-			->method('groupname2dn')
-			->willReturn('cn=existing_group,ou=Are Sufficient To,ou=Test,dc=example,dc=org');
-		$groupBackend->expects($this->once())
-			->method('groupExists')
-			->willReturn(true);
-		$groupBackend->expects($this->any())
-			->method('getLDAPAccess')
-			->willReturn($groupAccess);
-
-		$server = $this->getServerMock($userBackend, $groupBackend);
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$this->assertEquals('cn=existing_group,ou=Are Sufficient To,ou=Test,dc=example,dc=org',
-			$ldapProvider->getGroupDN('existing_group'));
-	}
-
-	public function testGetUserName(): void {
-		$userBackend = $this->getMockBuilder(User_LDAP::class)
-			->onlyMethods(['dn2UserName'])
-			->disableOriginalConstructor()
-			->getMock();
-		$userBackend->expects($this->any())
-			->method('dn2UserName')
-			->willReturn('existing_user');
-
-		$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$this->assertEquals('existing_user',
-			$ldapProvider->getUserName('cn=existing_user,ou=Are Sufficient To,ou=Test,dc=example,dc=org'));
-	}
-
-	public function testDNasBaseParameter(): void {
-		$userBackend = $this->createMock(User_LDAP::class);
-
-		$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
+    private function getServerMock(IUserLDAP $userBackend, IGroupLDAP $groupBackend) {
+        $server = $this->getMockBuilder('OC\Server')
+            ->onlyMethods(['getUserManager', 'getGroupManager'])
+            ->setConstructorArgs(['', new Config(\OC::$configDir)])
+            ->getMock();
+        $server->expects($this->any())
+            ->method('getUserManager')
+            ->willReturn($this->getUserManagerMock($userBackend));
+        $server->expects($this->any())
+            ->method('getGroupManager')
+            ->willReturn($this->getGroupManagerMock($groupBackend));
+
+        return $server;
+    }
+
+    private function getUserManagerMock(IUserLDAP $userBackend) {
+        $userManager = $this->getMockBuilder(Manager::class)
+            ->onlyMethods(['getBackends'])
+            ->setConstructorArgs([
+                $this->createMock(IConfig::class),
+                $this->createMock(ICacheFactory::class),
+                $this->createMock(IEventDispatcher::class),
+                $this->createMock(LoggerInterface::class),
+            ])
+            ->getMock();
+        $userManager->expects($this->any())
+            ->method('getBackends')
+            ->willReturn([$userBackend]);
+        return $userManager;
+    }
+
+    private function getGroupManagerMock(IGroupLDAP $groupBackend) {
+        $groupManager = $this->getMockBuilder('OC\Group\Manager')
+            ->onlyMethods(['getBackends'])
+            ->disableOriginalConstructor()
+            ->getMock();
+        $groupManager->expects($this->any())
+            ->method('getBackends')
+            ->willReturn([$groupBackend]);
+        return $groupManager;
+    }
+
+    private function getDefaultGroupBackendMock() {
+        $groupBackend = $this->getMockBuilder('OCA\User_LDAP\Group_LDAP')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        return $groupBackend;
+    }
+
+    private function getLDAPProvider(IServerContainer $serverContainer) {
+        $factory = new LDAPProviderFactory($serverContainer);
+        return $factory->getLDAPProvider();
+    }
+
+
+    public function testGetUserDNUserIDNotFound(): void {
+        $this->expectException(\Exception::class);
+        $this->expectExceptionMessage('User id not found in LDAP');
+
+        $userBackend = $this->getMockBuilder(User_LDAP::class)
+            ->onlyMethods(['userExists'])
+            ->disableOriginalConstructor()
+            ->getMock();
+        $userBackend->expects($this->any())->method('userExists')->willReturn(false);
+
+        $server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $ldapProvider->getUserDN('nonexisting_user');
+    }
+
+
+    public function testGetUserDN(): void {
+        $userAccess = $this->getMockBuilder(Access::class)
+            ->onlyMethods(['username2dn'])
+            ->disableOriginalConstructor()
+            ->getMock();
+        $userAccess->expects($this->once())
+            ->method('username2dn')
+            ->willReturn('cn=existing_user,ou=Are Sufficient To,ou=Test,dc=example,dc=org');
+        $userBackend = $this->getMockBuilder(User_LDAP::class)
+            ->onlyMethods(['userExists', 'getLDAPAccess'])
+            ->disableOriginalConstructor()
+            ->getMock();
+        $userBackend->expects($this->once())
+            ->method('userExists')
+            ->willReturn(true);
+        $userBackend->expects($this->any())
+            ->method('getLDAPAccess')
+            ->willReturn($userAccess);
+
+        $server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $this->assertEquals('cn=existing_user,ou=Are Sufficient To,ou=Test,dc=example,dc=org',
+            $ldapProvider->getUserDN('existing_user'));
+    }
+
+
+    public function testGetGroupDNGroupIDNotFound(): void {
+        $this->expectException(\Exception::class);
+        $this->expectExceptionMessage('Group id not found in LDAP');
+
+        $userBackend = $this->createMock(User_LDAP::class);
+        $groupBackend = $this->getMockBuilder(Group_LDAP::class)
+            ->onlyMethods(['groupExists'])
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $groupBackend->expects($this->any())->method('groupExists')->willReturn(false);
+
+        $server = $this->getServerMock($userBackend, $groupBackend);
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $ldapProvider->getGroupDN('nonexisting_group');
+    }
+
+    public function testGetGroupDN(): void {
+        $userBackend = $this->createMock(User_LDAP::class);
+
+        $groupBackend = $this->getMockBuilder(Group_LDAP::class)
+            ->onlyMethods(['groupExists', 'getLDAPAccess'])
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $groupAccess = $this->createMock(Access::class);
+        $groupAccess->expects($this->once())
+            ->method('groupname2dn')
+            ->willReturn('cn=existing_group,ou=Are Sufficient To,ou=Test,dc=example,dc=org');
+        $groupBackend->expects($this->once())
+            ->method('groupExists')
+            ->willReturn(true);
+        $groupBackend->expects($this->any())
+            ->method('getLDAPAccess')
+            ->willReturn($groupAccess);
+
+        $server = $this->getServerMock($userBackend, $groupBackend);
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $this->assertEquals('cn=existing_group,ou=Are Sufficient To,ou=Test,dc=example,dc=org',
+            $ldapProvider->getGroupDN('existing_group'));
+    }
+
+    public function testGetUserName(): void {
+        $userBackend = $this->getMockBuilder(User_LDAP::class)
+            ->onlyMethods(['dn2UserName'])
+            ->disableOriginalConstructor()
+            ->getMock();
+        $userBackend->expects($this->any())
+            ->method('dn2UserName')
+            ->willReturn('existing_user');
+
+        $server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $this->assertEquals('existing_user',
+            $ldapProvider->getUserName('cn=existing_user,ou=Are Sufficient To,ou=Test,dc=example,dc=org'));
+    }
+
+    public function testDNasBaseParameter(): void {
+        $userBackend = $this->createMock(User_LDAP::class);
+
+        $server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
 
-		$helper = new Helper(Server::get(IConfig::class), Server::get(IDBConnection::class));
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$this->assertEquals(
-			$helper->DNasBaseParameter('cn=existing_user,ou=Are Sufficient To,ou=Test,dc=example,dc=org'),
-			$ldapProvider->DNasBaseParameter('cn=existing_user,ou=Are Sufficient To,ou=Test,dc=example,dc=org'));
-	}
-
-	public function testSanitizeDN(): void {
-		$userBackend = $this->createMock(User_LDAP::class);
-
-		$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
-
-		$helper = new Helper(Server::get(IConfig::class), Server::get(IDBConnection::class));
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$this->assertEquals(
-			$helper->sanitizeDN('cn=existing_user,ou=Are Sufficient To,ou=Test,dc=example,dc=org'),
-			$ldapProvider->sanitizeDN('cn=existing_user,ou=Are Sufficient To,ou=Test,dc=example,dc=org'));
-	}
+        $helper = new Helper(Server::get(IConfig::class), Server::get(IDBConnection::class));
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $this->assertEquals(
+            $helper->DNasBaseParameter('cn=existing_user,ou=Are Sufficient To,ou=Test,dc=example,dc=org'),
+            $ldapProvider->DNasBaseParameter('cn=existing_user,ou=Are Sufficient To,ou=Test,dc=example,dc=org'));
+    }
+
+    public function testSanitizeDN(): void {
+        $userBackend = $this->createMock(User_LDAP::class);
+
+        $server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
+
+        $helper = new Helper(Server::get(IConfig::class), Server::get(IDBConnection::class));
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $this->assertEquals(
+            $helper->sanitizeDN('cn=existing_user,ou=Are Sufficient To,ou=Test,dc=example,dc=org'),
+            $ldapProvider->sanitizeDN('cn=existing_user,ou=Are Sufficient To,ou=Test,dc=example,dc=org'));
+    }
 
 
-	public function testGetLDAPConnectionUserIDNotFound(): void {
-		$this->expectException(\Exception::class);
-		$this->expectExceptionMessage('User id not found in LDAP');
+    public function testGetLDAPConnectionUserIDNotFound(): void {
+        $this->expectException(\Exception::class);
+        $this->expectExceptionMessage('User id not found in LDAP');
 
-		$userBackend = $this->createMock(User_LDAP::class);
-		$userBackend->expects($this->any())->method('userExists')->willReturn(false);
-
-		$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$ldapProvider->getLDAPConnection('nonexisting_user');
-	}
-
-	public function testGetLDAPConnection(): void {
-		$userBackend = $this->getMockBuilder(User_LDAP::class)
-			->onlyMethods(['userExists', 'getNewLDAPConnection'])
-			->disableOriginalConstructor()
-			->getMock();
-		$userBackend->expects($this->any())
-			->method('userExists')
-			->willReturn(true);
-		$ldapConnection = ldap_connect('ldap://example.com');
-		$userBackend->expects($this->any())
-			->method('getNewLDAPConnection')
-			->willReturn($ldapConnection);
-
-		$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$this->assertEquals($ldapConnection, $ldapProvider->getLDAPConnection('existing_user'));
-	}
-
-
-	public function testGetGroupLDAPConnectionGroupIDNotFound(): void {
-		$this->expectException(\Exception::class);
-		$this->expectExceptionMessage('Group id not found in LDAP');
-
-		$userBackend = $this->createMock(User_LDAP::class);
-		$groupBackend = $this->getMockBuilder(Group_LDAP::class)
-			->onlyMethods(['groupExists'])
-			->disableOriginalConstructor()
-			->getMock();
-
-		$groupBackend->expects($this->any())->method('groupExists')->willReturn(false);
-
-		$server = $this->getServerMock($userBackend, $groupBackend);
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$ldapProvider->getGroupLDAPConnection('nonexisting_group');
-	}
-
-	public function testGetGroupLDAPConnection(): void {
-		$userBackend = $this->createMock(User_LDAP::class);
-		$groupBackend = $this->getMockBuilder(Group_LDAP::class)
-			->onlyMethods(['groupExists','getNewLDAPConnection'])
-			->disableOriginalConstructor()
-			->getMock();
-
-		$groupBackend->expects($this->any())
-			->method('groupExists')
-			->willReturn(true);
-
-		$ldapConnection = ldap_connect('ldap://example.com');
-		$groupBackend->expects($this->any())
-			->method('getNewLDAPConnection')
-			->willReturn($ldapConnection);
-
-		$server = $this->getServerMock($userBackend, $groupBackend);
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$this->assertEquals($ldapConnection, $ldapProvider->getGroupLDAPConnection('existing_group'));
-	}
-
-
-	public function testGetLDAPBaseUsersUserIDNotFound(): void {
-		$this->expectException(\Exception::class);
-		$this->expectExceptionMessage('User id not found in LDAP');
-
-		$userBackend = $this->getMockBuilder(User_LDAP::class)
-			->onlyMethods(['userExists'])
-			->disableOriginalConstructor()
-			->getMock();
-		$userBackend->expects($this->any())->method('userExists')->willReturn(false);
-
-		$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$ldapProvider->getLDAPBaseUsers('nonexisting_user');
-	}
-
-	public function testGetLDAPBaseUsers(): void {
-		$bases = [
-			'ou=users,ou=foobar,dc=example,dc=org',
-			'ou=users,ou=barfoo,dc=example,dc=org',
-		];
-		$dn = 'uid=malik,' . $bases[1];
-
-		$connection = $this->getMockBuilder(Connection::class)
-			->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
-			->getMock();
-		$connection->expects($this->any())
-			->method('__get')
-			->willReturnCallback(function ($key) use ($bases) {
-				switch ($key) {
-					case 'ldapBaseUsers':
-						return $bases;
-				}
-				return null;
-			});
-
-		$access = $this->createMock(Access::class);
-		$access->expects($this->any())
-			->method('getConnection')
-			->willReturn($connection);
-		$access->expects($this->exactly(2))
-			->method('isDNPartOfBase')
-			->willReturnOnConsecutiveCalls(false, true);
-		$access->expects($this->atLeastOnce())
-			->method('username2dn')
-			->willReturn($dn);
-
-		$userBackend = $this->getMockBuilder(User_LDAP::class)
-			->onlyMethods(['userExists', 'getLDAPAccess'])
-			->disableOriginalConstructor()
-			->getMock();
-		$userBackend->expects($this->atLeastOnce())
-			->method('userExists')
-			->willReturn(true);
-		$userBackend->expects($this->any())
-			->method('getLDAPAccess')
-			->willReturn($access);
-
-		$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$this->assertEquals($bases[1], $ldapProvider->getLDAPBaseUsers('existing_user'));
-	}
-
-
-	public function testGetLDAPBaseGroupsUserIDNotFound(): void {
-		$this->expectException(\Exception::class);
-		$this->expectExceptionMessage('User id not found in LDAP');
-
-		$userBackend = $this->getMockBuilder(User_LDAP::class)
-			->onlyMethods(['userExists'])
-			->disableOriginalConstructor()
-			->getMock();
-		$userBackend->expects($this->any())->method('userExists')->willReturn(false);
-
-		$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$ldapProvider->getLDAPBaseGroups('nonexisting_user');
-	}
-
-	public function testGetLDAPBaseGroups(): void {
-		$bases = [
-			'ou=groupd,ou=foobar,dc=example,dc=org',
-			'ou=groups,ou=barfoo,dc=example,dc=org',
-		];
-
-		$connection = $this->getMockBuilder(Connection::class)
-			->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
-			->getMock();
-		$connection->expects($this->any())
-			->method('__get')
-			->willReturnCallback(function ($key) use ($bases) {
-				switch ($key) {
-					case 'ldapBaseGroups':
-						return $bases;
-				}
-				return null;
-			});
-
-		$access = $this->createMock(Access::class);
-		$access->expects($this->any())
-			->method('getConnection')
-			->willReturn($connection);
-
-		$userBackend = $this->getMockBuilder(User_LDAP::class)
-			->onlyMethods(['userExists', 'getLDAPAccess'])
-			->disableOriginalConstructor()
-			->getMock();
-		$userBackend->expects($this->any())
-			->method('userExists')
-			->willReturn(true);
-		$userBackend->expects($this->any())
-			->method('getLDAPAccess')
-			->willReturn($access);
-
-		$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$this->assertEquals($bases[0], $ldapProvider->getLDAPBaseGroups('existing_user'));
-	}
-
-
-	public function testClearCacheUserIDNotFound(): void {
-		$this->expectException(\Exception::class);
-		$this->expectExceptionMessage('User id not found in LDAP');
-
-		$userBackend = $this->getMockBuilder(User_LDAP::class)
-			->onlyMethods(['userExists'])
-			->disableOriginalConstructor()
-			->getMock();
-		$userBackend->expects($this->any())->method('userExists')->willReturn(false);
-
-		$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$ldapProvider->clearCache('nonexisting_user');
-	}
-
-	public function testClearCache(): void {
-		$connection = $this->getMockBuilder(Connection::class)
-			->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
-			->getMock();
-		$connection->expects($this->once())
-			->method('clearCache')
-			->willReturn(true);
-		$access = $this->createMock(Access::class);
-		$access->method('getConnection')
-			->willReturn($connection);
-		$userBackend = $this->getMockBuilder(User_LDAP::class)
-			->onlyMethods(['userExists', 'getLDAPAccess'])
-			->disableOriginalConstructor()
-			->getMock();
-		$userBackend->expects($this->once())
-			->method('userExists')
-			->willReturn(true);
-		$userBackend->expects($this->any())
-			->method('getLDAPAccess')
-			->willReturn($access);
-
-		$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$ldapProvider->clearCache('existing_user');
-		$this->addToAssertionCount(1);
-	}
-
-
-	public function testClearGroupCacheGroupIDNotFound(): void {
-		$this->expectException(\Exception::class);
-		$this->expectExceptionMessage('Group id not found in LDAP');
-
-		$userBackend = $this->getMockBuilder(User_LDAP::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$groupBackend = $this->getMockBuilder(Group_LDAP::class)
-			->onlyMethods(['groupExists'])
-			->disableOriginalConstructor()
-			->getMock();
-		$groupBackend->expects($this->any())->method('groupExists')->willReturn(false);
-
-		$server = $this->getServerMock($userBackend, $groupBackend);
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$ldapProvider->clearGroupCache('nonexisting_group');
-	}
-
-	public function testClearGroupCache(): void {
-		$userBackend = $this->createMock(User_LDAP::class);
-		$connection = $this->getMockBuilder(Connection::class)
-			->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
-			->getMock();
-		$connection->expects($this->once())
-			->method('clearCache')
-			->willReturn(true);
-		$access = $this->createMock(Access::class);
-		$access->method('getConnection')
-			->willReturn($connection);
-		$groupBackend = $this->getMockBuilder(Group_LDAP::class)
-			->onlyMethods(['groupExists', 'getLDAPAccess'])
-			->disableOriginalConstructor()
-			->getMock();
-		$groupBackend->expects($this->once())
-			->method('groupExists')
-			->willReturn(true);
-		$groupBackend->expects($this->any())
-			->method('getLDAPAccess')
-			->willReturn($access);
-
-		$server = $this->getServerMock($userBackend, $groupBackend);
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$ldapProvider->clearGroupCache('existing_group');
-		$this->addToAssertionCount(1);
-	}
-
-	public function testDnExists(): void {
-		$userBackend = $this->getMockBuilder(User_LDAP::class)
-			->onlyMethods(['dn2UserName'])
-			->disableOriginalConstructor()
-			->getMock();
-		$userBackend->expects($this->any())
-			->method('dn2UserName')
-			->willReturn('existing_user');
-
-		$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$this->assertTrue($ldapProvider->dnExists('cn=existing_user,ou=Are Sufficient To,ou=Test,dc=example,dc=org'));
-	}
-
-	public function testFlagRecord(): void {
-		$userBackend = $this->createMock(User_LDAP::class);
-		$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$ldapProvider->flagRecord('existing_user');
-		$this->addToAssertionCount(1);
-	}
-
-	public function testUnflagRecord(): void {
-		$userBackend = $this->createMock(User_LDAP::class);
-		$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$ldapProvider->unflagRecord('existing_user');
-		$this->addToAssertionCount(1);
-	}
-
-
-	public function testGetLDAPDisplayNameFieldUserIDNotFound(): void {
-		$this->expectException(\Exception::class);
-		$this->expectExceptionMessage('User id not found in LDAP');
-
-		$userBackend = $this->getMockBuilder(User_LDAP::class)
-			->onlyMethods(['userExists'])
-			->disableOriginalConstructor()
-			->getMock();
-		$userBackend->expects($this->any())->method('userExists')->willReturn(false);
-
-		$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$ldapProvider->getLDAPDisplayNameField('nonexisting_user');
-	}
-
-	public function testGetLDAPDisplayNameField(): void {
-		$connection = $this->getMockBuilder(Connection::class)
-			->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
-			->getMock();
-		$connection->expects($this->once())
-			->method('getConfiguration')
-			->willReturn(['ldap_display_name' => 'displayName']);
-		$access = $this->createMock(Access::class);
-		$access->method('getConnection')
-			->willReturn($connection);
-		$userBackend = $this->getMockBuilder(User_LDAP::class)
-			->onlyMethods(['userExists', 'getLDAPAccess'])
-			->disableOriginalConstructor()
-			->getMock();
-		$userBackend->expects($this->once())
-			->method('userExists')
-			->willReturn(true);
-		$userBackend->expects($this->any())
-			->method('getLDAPAccess')
-			->willReturn($access);
-
-		$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$this->assertEquals('displayName', $ldapProvider->getLDAPDisplayNameField('existing_user'));
-	}
-
-
-	public function testGetLDAPEmailFieldUserIDNotFound(): void {
-		$this->expectException(\Exception::class);
-		$this->expectExceptionMessage('User id not found in LDAP');
-
-		$userBackend = $this->getMockBuilder(User_LDAP::class)
-			->onlyMethods(['userExists'])
-			->disableOriginalConstructor()
-			->getMock();
-		$userBackend->expects($this->any())->method('userExists')->willReturn(false);
-
-		$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$ldapProvider->getLDAPEmailField('nonexisting_user');
-	}
-
-	public function testGetLDAPEmailField(): void {
-		$connection = $this->getMockBuilder(Connection::class)
-			->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
-			->getMock();
-		$connection->expects($this->once())
-			->method('getConfiguration')
-			->willReturn(['ldap_email_attr' => 'mail']);
-		$access = $this->createMock(Access::class);
-		$access->method('getConnection')
-			->willReturn($connection);
-		$userBackend = $this->getMockBuilder(User_LDAP::class)
-			->onlyMethods(['userExists', 'getLDAPAccess'])
-			->disableOriginalConstructor()
-			->getMock();
-		$userBackend->expects($this->once())
-			->method('userExists')
-			->willReturn(true);
-		$userBackend->expects($this->any())
-			->method('getLDAPAccess')
-			->willReturn($access);
-
-		$server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$this->assertEquals('mail', $ldapProvider->getLDAPEmailField('existing_user'));
-	}
-
-
-	public function testGetLDAPGroupMemberAssocUserIDNotFound(): void {
-		$this->expectException(\Exception::class);
-		$this->expectExceptionMessage('Group id not found in LDAP');
-
-		$userBackend = $this->createMock(User_LDAP::class);
-		$groupBackend = $this->getMockBuilder(Group_LDAP::class)
-			->onlyMethods(['groupExists'])
-			->disableOriginalConstructor()
-			->getMock();
-
-		$groupBackend->expects($this->any())
-			->method('groupExists')
-			->willReturn(false);
-
-		$server = $this->getServerMock($userBackend, $groupBackend);
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$ldapProvider->getLDAPGroupMemberAssoc('nonexisting_group');
-	}
-
-	public function testgetLDAPGroupMemberAssoc(): void {
-		$userBackend = $this->createMock(User_LDAP::class);
-
-		$connection = $this->getMockBuilder(Connection::class)
-			->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
-			->getMock();
-		$connection->expects($this->once())
-			->method('getConfiguration')
-			->willReturn(['ldap_group_member_assoc_attribute' => 'assoc_type']);
-		$access = $this->createMock(Access::class);
-		$access->method('getConnection')
-			->willReturn($connection);
-		$groupBackend = $this->getMockBuilder(Group_LDAP::class)
-			->onlyMethods(['groupExists', 'getLDAPAccess'])
-			->disableOriginalConstructor()
-			->getMock();
-
-		$groupBackend->expects($this->once())
-			->method('groupExists')
-			->willReturn(true);
-		$groupBackend->expects($this->any())
-			->method('getLDAPAccess')
-			->willReturn($access);
-
-		$server = $this->getServerMock($userBackend, $groupBackend);
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$this->assertEquals('assoc_type', $ldapProvider->getLDAPGroupMemberAssoc('existing_group'));
-	}
-
-	public function testGetMultiValueUserAttributeUserNotFound(): void {
-		$this->expectException(\Exception::class);
-		$this->expectExceptionMessage('User id not found in LDAP');
-
-		$userBackend = $this->createMock(User_LDAP::class);
-		$userBackend->expects(self::once())
-			->method('userExists')
-			->with('admin')
-			->willReturn(false);
-		$groupBackend = $this->createMock(Group_LDAP::class);
-		$server = $this->getServerMock($userBackend, $groupBackend);
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$ldapProvider->getMultiValueUserAttribute('admin', 'mailAlias');
-	}
-
-	public function testGetMultiValueUserAttributeCacheHit(): void {
-		$connection = $this->getMockBuilder(Connection::class)
-			->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
-			->getMock();
-		$connection->expects(self::once())
-			->method('getFromCache')
-			->with('admin-mailAlias')
-			->willReturn(['aliasA@test.local', 'aliasB@test.local']);
-		$access = $this->createMock(Access::class);
-		$access->expects(self::once())
-			->method('getConnection')
-			->willReturn($connection);
-		$userBackend = $this->createMock(User_LDAP::class);
-		$userBackend->expects(self::once())
-			->method('userExists')
-			->with('admin')
-			->willReturn(true);
-		$userBackend->expects(self::once())
-			->method('getLDAPAccess')
-			->willReturn($access);
-		$groupBackend = $this->createMock(Group_LDAP::class);
-		$server = $this->getServerMock($userBackend, $groupBackend);
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$ldapProvider->getMultiValueUserAttribute('admin', 'mailAlias');
-	}
-
-	public function testGetMultiValueUserAttributeLdapError(): void {
-		$connection = $this->getMockBuilder(Connection::class)
-			->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
-			->getMock();
-		$connection->expects(self::once())
-			->method('getFromCache')
-			->with('admin-mailAlias')
-			->willReturn(null);
-		$access = $this->createMock(Access::class);
-		$access->expects(self::once())
-			->method('getConnection')
-			->willReturn($connection);
-		$access->expects(self::once())
-			->method('username2dn')
-			->with('admin')
-			->willReturn('admin');
-		$access->expects(self::once())
-			->method('readAttribute')
-			->with('admin', 'mailAlias')
-			->willReturn(false);
-		$userBackend = $this->getMockBuilder(User_LDAP::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$userBackend->method('userExists')
-			->with('admin')
-			->willReturn(true);
-		$userBackend->method('getLDAPAccess')
-			->willReturn($access);
-		$groupBackend = $this->getMockBuilder(Group_LDAP::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$server = $this->getServerMock($userBackend, $groupBackend);
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$values = $ldapProvider->getMultiValueUserAttribute('admin', 'mailAlias');
-
-		self::assertCount(0, $values);
-	}
-
-	public function testGetMultiValueUserAttribute(): void {
-		$connection = $this->getMockBuilder(Connection::class)
-			->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
-			->getMock();
-		$connection->expects(self::once())
-			->method('getFromCache')
-			->with('admin-mailAlias')
-			->willReturn(null);
-		$access = $this->createMock(Access::class);
-		$access->expects(self::once())
-			->method('getConnection')
-			->willReturn($connection);
-		$access->expects(self::once())
-			->method('username2dn')
-			->with('admin')
-			->willReturn('admin');
-		$access->expects(self::once())
-			->method('readAttribute')
-			->with('admin', 'mailAlias')
-			->willReturn(['aliasA@test.local', 'aliasB@test.local']);
-		$userBackend = $this->getMockBuilder(User_LDAP::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$userBackend->method('userExists')
-			->with('admin')
-			->willReturn(true);
-		$userBackend->method('getLDAPAccess')
-			->willReturn($access);
-		$groupBackend = $this->getMockBuilder(Group_LDAP::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$server = $this->getServerMock($userBackend, $groupBackend);
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$values = $ldapProvider->getMultiValueUserAttribute('admin', 'mailAlias');
-
-		self::assertCount(2, $values);
-	}
-
-	public function testGetUserAttributeLdapError(): void {
-		$connection = $this->getMockBuilder(Connection::class)
-			->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
-			->getMock();
-		$connection->expects(self::once())
-			->method('getFromCache')
-			->with('admin-mailAlias')
-			->willReturn(null);
-		$access = $this->createMock(Access::class);
-		$access->expects(self::once())
-			->method('getConnection')
-			->willReturn($connection);
-		$access->expects(self::once())
-			->method('username2dn')
-			->with('admin')
-			->willReturn('admin');
-		$access->expects(self::once())
-			->method('readAttribute')
-			->with('admin', 'mailAlias')
-			->willReturn(false);
-		$userBackend = $this->getMockBuilder(User_LDAP::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$userBackend->method('userExists')
-			->with('admin')
-			->willReturn(true);
-		$userBackend->method('getLDAPAccess')
-			->willReturn($access);
-		$groupBackend = $this->getMockBuilder(Group_LDAP::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$server = $this->getServerMock($userBackend, $groupBackend);
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$value = $ldapProvider->getUserAttribute('admin', 'mailAlias');
-
-		self::assertNull($value);
-	}
-
-	public function testGetUserAttribute(): void {
-		$connection = $this->getMockBuilder(Connection::class)
-			->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
-			->getMock();
-		$connection->expects(self::once())
-			->method('getFromCache')
-			->with('admin-mailAlias')
-			->willReturn(null);
-		$access = $this->createMock(Access::class);
-		$access->expects(self::once())
-			->method('getConnection')
-			->willReturn($connection);
-		$access->expects(self::once())
-			->method('username2dn')
-			->with('admin')
-			->willReturn('admin');
-		$access->expects(self::once())
-			->method('readAttribute')
-			->with('admin', 'mailAlias')
-			->willReturn(['aliasA@test.local', 'aliasB@test.local']);
-		$userBackend = $this->getMockBuilder(User_LDAP::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$userBackend->method('userExists')
-			->with('admin')
-			->willReturn(true);
-		$userBackend->method('getLDAPAccess')
-			->willReturn($access);
-		$groupBackend = $this->getMockBuilder(Group_LDAP::class)
-			->disableOriginalConstructor()
-			->getMock();
-		$server = $this->getServerMock($userBackend, $groupBackend);
-
-		$ldapProvider = $this->getLDAPProvider($server);
-		$value = $ldapProvider->getUserAttribute('admin', 'mailAlias');
-
-		self::assertEquals('aliasA@test.local', $value);
-	}
+        $userBackend = $this->createMock(User_LDAP::class);
+        $userBackend->expects($this->any())->method('userExists')->willReturn(false);
+
+        $server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $ldapProvider->getLDAPConnection('nonexisting_user');
+    }
+
+    public function testGetLDAPConnection(): void {
+        $userBackend = $this->getMockBuilder(User_LDAP::class)
+            ->onlyMethods(['userExists', 'getNewLDAPConnection'])
+            ->disableOriginalConstructor()
+            ->getMock();
+        $userBackend->expects($this->any())
+            ->method('userExists')
+            ->willReturn(true);
+        $ldapConnection = ldap_connect('ldap://example.com');
+        $userBackend->expects($this->any())
+            ->method('getNewLDAPConnection')
+            ->willReturn($ldapConnection);
+
+        $server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $this->assertEquals($ldapConnection, $ldapProvider->getLDAPConnection('existing_user'));
+    }
+
+
+    public function testGetGroupLDAPConnectionGroupIDNotFound(): void {
+        $this->expectException(\Exception::class);
+        $this->expectExceptionMessage('Group id not found in LDAP');
+
+        $userBackend = $this->createMock(User_LDAP::class);
+        $groupBackend = $this->getMockBuilder(Group_LDAP::class)
+            ->onlyMethods(['groupExists'])
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $groupBackend->expects($this->any())->method('groupExists')->willReturn(false);
+
+        $server = $this->getServerMock($userBackend, $groupBackend);
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $ldapProvider->getGroupLDAPConnection('nonexisting_group');
+    }
+
+    public function testGetGroupLDAPConnection(): void {
+        $userBackend = $this->createMock(User_LDAP::class);
+        $groupBackend = $this->getMockBuilder(Group_LDAP::class)
+            ->onlyMethods(['groupExists','getNewLDAPConnection'])
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $groupBackend->expects($this->any())
+            ->method('groupExists')
+            ->willReturn(true);
+
+        $ldapConnection = ldap_connect('ldap://example.com');
+        $groupBackend->expects($this->any())
+            ->method('getNewLDAPConnection')
+            ->willReturn($ldapConnection);
+
+        $server = $this->getServerMock($userBackend, $groupBackend);
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $this->assertEquals($ldapConnection, $ldapProvider->getGroupLDAPConnection('existing_group'));
+    }
+
+
+    public function testGetLDAPBaseUsersUserIDNotFound(): void {
+        $this->expectException(\Exception::class);
+        $this->expectExceptionMessage('User id not found in LDAP');
+
+        $userBackend = $this->getMockBuilder(User_LDAP::class)
+            ->onlyMethods(['userExists'])
+            ->disableOriginalConstructor()
+            ->getMock();
+        $userBackend->expects($this->any())->method('userExists')->willReturn(false);
+
+        $server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $ldapProvider->getLDAPBaseUsers('nonexisting_user');
+    }
+
+    public function testGetLDAPBaseUsers(): void {
+        $bases = [
+            'ou=users,ou=foobar,dc=example,dc=org',
+            'ou=users,ou=barfoo,dc=example,dc=org',
+        ];
+        $dn = 'uid=malik,' . $bases[1];
+
+        $connection = $this->getMockBuilder(Connection::class)
+            ->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
+            ->getMock();
+        $connection->expects($this->any())
+            ->method('__get')
+            ->willReturnCallback(function ($key) use ($bases) {
+                switch ($key) {
+                    case 'ldapBaseUsers':
+                        return $bases;
+                }
+                return null;
+            });
+
+        $access = $this->createMock(Access::class);
+        $access->expects($this->any())
+            ->method('getConnection')
+            ->willReturn($connection);
+        $access->expects($this->exactly(2))
+            ->method('isDNPartOfBase')
+            ->willReturnOnConsecutiveCalls(false, true);
+        $access->expects($this->atLeastOnce())
+            ->method('username2dn')
+            ->willReturn($dn);
+
+        $userBackend = $this->getMockBuilder(User_LDAP::class)
+            ->onlyMethods(['userExists', 'getLDAPAccess'])
+            ->disableOriginalConstructor()
+            ->getMock();
+        $userBackend->expects($this->atLeastOnce())
+            ->method('userExists')
+            ->willReturn(true);
+        $userBackend->expects($this->any())
+            ->method('getLDAPAccess')
+            ->willReturn($access);
+
+        $server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $this->assertEquals($bases[1], $ldapProvider->getLDAPBaseUsers('existing_user'));
+    }
+
+
+    public function testGetLDAPBaseGroupsUserIDNotFound(): void {
+        $this->expectException(\Exception::class);
+        $this->expectExceptionMessage('User id not found in LDAP');
+
+        $userBackend = $this->getMockBuilder(User_LDAP::class)
+            ->onlyMethods(['userExists'])
+            ->disableOriginalConstructor()
+            ->getMock();
+        $userBackend->expects($this->any())->method('userExists')->willReturn(false);
+
+        $server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $ldapProvider->getLDAPBaseGroups('nonexisting_user');
+    }
+
+    public function testGetLDAPBaseGroups(): void {
+        $bases = [
+            'ou=groupd,ou=foobar,dc=example,dc=org',
+            'ou=groups,ou=barfoo,dc=example,dc=org',
+        ];
+
+        $connection = $this->getMockBuilder(Connection::class)
+            ->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
+            ->getMock();
+        $connection->expects($this->any())
+            ->method('__get')
+            ->willReturnCallback(function ($key) use ($bases) {
+                switch ($key) {
+                    case 'ldapBaseGroups':
+                        return $bases;
+                }
+                return null;
+            });
+
+        $access = $this->createMock(Access::class);
+        $access->expects($this->any())
+            ->method('getConnection')
+            ->willReturn($connection);
+
+        $userBackend = $this->getMockBuilder(User_LDAP::class)
+            ->onlyMethods(['userExists', 'getLDAPAccess'])
+            ->disableOriginalConstructor()
+            ->getMock();
+        $userBackend->expects($this->any())
+            ->method('userExists')
+            ->willReturn(true);
+        $userBackend->expects($this->any())
+            ->method('getLDAPAccess')
+            ->willReturn($access);
+
+        $server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $this->assertEquals($bases[0], $ldapProvider->getLDAPBaseGroups('existing_user'));
+    }
+
+
+    public function testClearCacheUserIDNotFound(): void {
+        $this->expectException(\Exception::class);
+        $this->expectExceptionMessage('User id not found in LDAP');
+
+        $userBackend = $this->getMockBuilder(User_LDAP::class)
+            ->onlyMethods(['userExists'])
+            ->disableOriginalConstructor()
+            ->getMock();
+        $userBackend->expects($this->any())->method('userExists')->willReturn(false);
+
+        $server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $ldapProvider->clearCache('nonexisting_user');
+    }
+
+    public function testClearCache(): void {
+        $connection = $this->getMockBuilder(Connection::class)
+            ->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
+            ->getMock();
+        $connection->expects($this->once())
+            ->method('clearCache')
+            ->willReturn(true);
+        $access = $this->createMock(Access::class);
+        $access->method('getConnection')
+            ->willReturn($connection);
+        $userBackend = $this->getMockBuilder(User_LDAP::class)
+            ->onlyMethods(['userExists', 'getLDAPAccess'])
+            ->disableOriginalConstructor()
+            ->getMock();
+        $userBackend->expects($this->once())
+            ->method('userExists')
+            ->willReturn(true);
+        $userBackend->expects($this->any())
+            ->method('getLDAPAccess')
+            ->willReturn($access);
+
+        $server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $ldapProvider->clearCache('existing_user');
+        $this->addToAssertionCount(1);
+    }
+
+
+    public function testClearGroupCacheGroupIDNotFound(): void {
+        $this->expectException(\Exception::class);
+        $this->expectExceptionMessage('Group id not found in LDAP');
+
+        $userBackend = $this->getMockBuilder(User_LDAP::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $groupBackend = $this->getMockBuilder(Group_LDAP::class)
+            ->onlyMethods(['groupExists'])
+            ->disableOriginalConstructor()
+            ->getMock();
+        $groupBackend->expects($this->any())->method('groupExists')->willReturn(false);
+
+        $server = $this->getServerMock($userBackend, $groupBackend);
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $ldapProvider->clearGroupCache('nonexisting_group');
+    }
+
+    public function testClearGroupCache(): void {
+        $userBackend = $this->createMock(User_LDAP::class);
+        $connection = $this->getMockBuilder(Connection::class)
+            ->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
+            ->getMock();
+        $connection->expects($this->once())
+            ->method('clearCache')
+            ->willReturn(true);
+        $access = $this->createMock(Access::class);
+        $access->method('getConnection')
+            ->willReturn($connection);
+        $groupBackend = $this->getMockBuilder(Group_LDAP::class)
+            ->onlyMethods(['groupExists', 'getLDAPAccess'])
+            ->disableOriginalConstructor()
+            ->getMock();
+        $groupBackend->expects($this->once())
+            ->method('groupExists')
+            ->willReturn(true);
+        $groupBackend->expects($this->any())
+            ->method('getLDAPAccess')
+            ->willReturn($access);
+
+        $server = $this->getServerMock($userBackend, $groupBackend);
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $ldapProvider->clearGroupCache('existing_group');
+        $this->addToAssertionCount(1);
+    }
+
+    public function testDnExists(): void {
+        $userBackend = $this->getMockBuilder(User_LDAP::class)
+            ->onlyMethods(['dn2UserName'])
+            ->disableOriginalConstructor()
+            ->getMock();
+        $userBackend->expects($this->any())
+            ->method('dn2UserName')
+            ->willReturn('existing_user');
+
+        $server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $this->assertTrue($ldapProvider->dnExists('cn=existing_user,ou=Are Sufficient To,ou=Test,dc=example,dc=org'));
+    }
+
+    public function testFlagRecord(): void {
+        $userBackend = $this->createMock(User_LDAP::class);
+        $server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $ldapProvider->flagRecord('existing_user');
+        $this->addToAssertionCount(1);
+    }
+
+    public function testUnflagRecord(): void {
+        $userBackend = $this->createMock(User_LDAP::class);
+        $server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $ldapProvider->unflagRecord('existing_user');
+        $this->addToAssertionCount(1);
+    }
+
+
+    public function testGetLDAPDisplayNameFieldUserIDNotFound(): void {
+        $this->expectException(\Exception::class);
+        $this->expectExceptionMessage('User id not found in LDAP');
+
+        $userBackend = $this->getMockBuilder(User_LDAP::class)
+            ->onlyMethods(['userExists'])
+            ->disableOriginalConstructor()
+            ->getMock();
+        $userBackend->expects($this->any())->method('userExists')->willReturn(false);
+
+        $server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $ldapProvider->getLDAPDisplayNameField('nonexisting_user');
+    }
+
+    public function testGetLDAPDisplayNameField(): void {
+        $connection = $this->getMockBuilder(Connection::class)
+            ->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
+            ->getMock();
+        $connection->expects($this->once())
+            ->method('getConfiguration')
+            ->willReturn(['ldap_display_name' => 'displayName']);
+        $access = $this->createMock(Access::class);
+        $access->method('getConnection')
+            ->willReturn($connection);
+        $userBackend = $this->getMockBuilder(User_LDAP::class)
+            ->onlyMethods(['userExists', 'getLDAPAccess'])
+            ->disableOriginalConstructor()
+            ->getMock();
+        $userBackend->expects($this->once())
+            ->method('userExists')
+            ->willReturn(true);
+        $userBackend->expects($this->any())
+            ->method('getLDAPAccess')
+            ->willReturn($access);
+
+        $server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $this->assertEquals('displayName', $ldapProvider->getLDAPDisplayNameField('existing_user'));
+    }
+
+
+    public function testGetLDAPEmailFieldUserIDNotFound(): void {
+        $this->expectException(\Exception::class);
+        $this->expectExceptionMessage('User id not found in LDAP');
+
+        $userBackend = $this->getMockBuilder(User_LDAP::class)
+            ->onlyMethods(['userExists'])
+            ->disableOriginalConstructor()
+            ->getMock();
+        $userBackend->expects($this->any())->method('userExists')->willReturn(false);
+
+        $server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $ldapProvider->getLDAPEmailField('nonexisting_user');
+    }
+
+    public function testGetLDAPEmailField(): void {
+        $connection = $this->getMockBuilder(Connection::class)
+            ->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
+            ->getMock();
+        $connection->expects($this->once())
+            ->method('getConfiguration')
+            ->willReturn(['ldap_email_attr' => 'mail']);
+        $access = $this->createMock(Access::class);
+        $access->method('getConnection')
+            ->willReturn($connection);
+        $userBackend = $this->getMockBuilder(User_LDAP::class)
+            ->onlyMethods(['userExists', 'getLDAPAccess'])
+            ->disableOriginalConstructor()
+            ->getMock();
+        $userBackend->expects($this->once())
+            ->method('userExists')
+            ->willReturn(true);
+        $userBackend->expects($this->any())
+            ->method('getLDAPAccess')
+            ->willReturn($access);
+
+        $server = $this->getServerMock($userBackend, $this->getDefaultGroupBackendMock());
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $this->assertEquals('mail', $ldapProvider->getLDAPEmailField('existing_user'));
+    }
+
+
+    public function testGetLDAPGroupMemberAssocUserIDNotFound(): void {
+        $this->expectException(\Exception::class);
+        $this->expectExceptionMessage('Group id not found in LDAP');
+
+        $userBackend = $this->createMock(User_LDAP::class);
+        $groupBackend = $this->getMockBuilder(Group_LDAP::class)
+            ->onlyMethods(['groupExists'])
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $groupBackend->expects($this->any())
+            ->method('groupExists')
+            ->willReturn(false);
+
+        $server = $this->getServerMock($userBackend, $groupBackend);
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $ldapProvider->getLDAPGroupMemberAssoc('nonexisting_group');
+    }
+
+    public function testgetLDAPGroupMemberAssoc(): void {
+        $userBackend = $this->createMock(User_LDAP::class);
+
+        $connection = $this->getMockBuilder(Connection::class)
+            ->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
+            ->getMock();
+        $connection->expects($this->once())
+            ->method('getConfiguration')
+            ->willReturn(['ldap_group_member_assoc_attribute' => 'assoc_type']);
+        $access = $this->createMock(Access::class);
+        $access->method('getConnection')
+            ->willReturn($connection);
+        $groupBackend = $this->getMockBuilder(Group_LDAP::class)
+            ->onlyMethods(['groupExists', 'getLDAPAccess'])
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $groupBackend->expects($this->once())
+            ->method('groupExists')
+            ->willReturn(true);
+        $groupBackend->expects($this->any())
+            ->method('getLDAPAccess')
+            ->willReturn($access);
+
+        $server = $this->getServerMock($userBackend, $groupBackend);
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $this->assertEquals('assoc_type', $ldapProvider->getLDAPGroupMemberAssoc('existing_group'));
+    }
+
+    public function testGetMultiValueUserAttributeUserNotFound(): void {
+        $this->expectException(\Exception::class);
+        $this->expectExceptionMessage('User id not found in LDAP');
+
+        $userBackend = $this->createMock(User_LDAP::class);
+        $userBackend->expects(self::once())
+            ->method('userExists')
+            ->with('admin')
+            ->willReturn(false);
+        $groupBackend = $this->createMock(Group_LDAP::class);
+        $server = $this->getServerMock($userBackend, $groupBackend);
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $ldapProvider->getMultiValueUserAttribute('admin', 'mailAlias');
+    }
+
+    public function testGetMultiValueUserAttributeCacheHit(): void {
+        $connection = $this->getMockBuilder(Connection::class)
+            ->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
+            ->getMock();
+        $connection->expects(self::once())
+            ->method('getFromCache')
+            ->with('admin-mailAlias')
+            ->willReturn(['aliasA@test.local', 'aliasB@test.local']);
+        $access = $this->createMock(Access::class);
+        $access->expects(self::once())
+            ->method('getConnection')
+            ->willReturn($connection);
+        $userBackend = $this->createMock(User_LDAP::class);
+        $userBackend->expects(self::once())
+            ->method('userExists')
+            ->with('admin')
+            ->willReturn(true);
+        $userBackend->expects(self::once())
+            ->method('getLDAPAccess')
+            ->willReturn($access);
+        $groupBackend = $this->createMock(Group_LDAP::class);
+        $server = $this->getServerMock($userBackend, $groupBackend);
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $ldapProvider->getMultiValueUserAttribute('admin', 'mailAlias');
+    }
+
+    public function testGetMultiValueUserAttributeLdapError(): void {
+        $connection = $this->getMockBuilder(Connection::class)
+            ->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
+            ->getMock();
+        $connection->expects(self::once())
+            ->method('getFromCache')
+            ->with('admin-mailAlias')
+            ->willReturn(null);
+        $access = $this->createMock(Access::class);
+        $access->expects(self::once())
+            ->method('getConnection')
+            ->willReturn($connection);
+        $access->expects(self::once())
+            ->method('username2dn')
+            ->with('admin')
+            ->willReturn('admin');
+        $access->expects(self::once())
+            ->method('readAttribute')
+            ->with('admin', 'mailAlias')
+            ->willReturn(false);
+        $userBackend = $this->getMockBuilder(User_LDAP::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $userBackend->method('userExists')
+            ->with('admin')
+            ->willReturn(true);
+        $userBackend->method('getLDAPAccess')
+            ->willReturn($access);
+        $groupBackend = $this->getMockBuilder(Group_LDAP::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $server = $this->getServerMock($userBackend, $groupBackend);
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $values = $ldapProvider->getMultiValueUserAttribute('admin', 'mailAlias');
+
+        self::assertCount(0, $values);
+    }
+
+    public function testGetMultiValueUserAttribute(): void {
+        $connection = $this->getMockBuilder(Connection::class)
+            ->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
+            ->getMock();
+        $connection->expects(self::once())
+            ->method('getFromCache')
+            ->with('admin-mailAlias')
+            ->willReturn(null);
+        $access = $this->createMock(Access::class);
+        $access->expects(self::once())
+            ->method('getConnection')
+            ->willReturn($connection);
+        $access->expects(self::once())
+            ->method('username2dn')
+            ->with('admin')
+            ->willReturn('admin');
+        $access->expects(self::once())
+            ->method('readAttribute')
+            ->with('admin', 'mailAlias')
+            ->willReturn(['aliasA@test.local', 'aliasB@test.local']);
+        $userBackend = $this->getMockBuilder(User_LDAP::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $userBackend->method('userExists')
+            ->with('admin')
+            ->willReturn(true);
+        $userBackend->method('getLDAPAccess')
+            ->willReturn($access);
+        $groupBackend = $this->getMockBuilder(Group_LDAP::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $server = $this->getServerMock($userBackend, $groupBackend);
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $values = $ldapProvider->getMultiValueUserAttribute('admin', 'mailAlias');
+
+        self::assertCount(2, $values);
+    }
+
+    public function testGetUserAttributeLdapError(): void {
+        $connection = $this->getMockBuilder(Connection::class)
+            ->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
+            ->getMock();
+        $connection->expects(self::once())
+            ->method('getFromCache')
+            ->with('admin-mailAlias')
+            ->willReturn(null);
+        $access = $this->createMock(Access::class);
+        $access->expects(self::once())
+            ->method('getConnection')
+            ->willReturn($connection);
+        $access->expects(self::once())
+            ->method('username2dn')
+            ->with('admin')
+            ->willReturn('admin');
+        $access->expects(self::once())
+            ->method('readAttribute')
+            ->with('admin', 'mailAlias')
+            ->willReturn(false);
+        $userBackend = $this->getMockBuilder(User_LDAP::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $userBackend->method('userExists')
+            ->with('admin')
+            ->willReturn(true);
+        $userBackend->method('getLDAPAccess')
+            ->willReturn($access);
+        $groupBackend = $this->getMockBuilder(Group_LDAP::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $server = $this->getServerMock($userBackend, $groupBackend);
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $value = $ldapProvider->getUserAttribute('admin', 'mailAlias');
+
+        self::assertNull($value);
+    }
+
+    public function testGetUserAttribute(): void {
+        $connection = $this->getMockBuilder(Connection::class)
+            ->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
+            ->getMock();
+        $connection->expects(self::once())
+            ->method('getFromCache')
+            ->with('admin-mailAlias')
+            ->willReturn(null);
+        $access = $this->createMock(Access::class);
+        $access->expects(self::once())
+            ->method('getConnection')
+            ->willReturn($connection);
+        $access->expects(self::once())
+            ->method('username2dn')
+            ->with('admin')
+            ->willReturn('admin');
+        $access->expects(self::once())
+            ->method('readAttribute')
+            ->with('admin', 'mailAlias')
+            ->willReturn(['aliasA@test.local', 'aliasB@test.local']);
+        $userBackend = $this->getMockBuilder(User_LDAP::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $userBackend->method('userExists')
+            ->with('admin')
+            ->willReturn(true);
+        $userBackend->method('getLDAPAccess')
+            ->willReturn($access);
+        $groupBackend = $this->getMockBuilder(Group_LDAP::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+        $server = $this->getServerMock($userBackend, $groupBackend);
+
+        $ldapProvider = $this->getLDAPProvider($server);
+        $value = $ldapProvider->getUserAttribute('admin', 'mailAlias');
+
+        self::assertEquals('aliasA@test.local', $value);
+    }
 }

Spacing +4 added lines, -4 removed lines

@@ -275,7 +275,7 @@ 
 	public function testGetGroupLDAPConnection(): void {
 		$userBackend = $this->createMock(User_LDAP::class);
 		$groupBackend = $this->getMockBuilder(Group_LDAP::class)
-			->onlyMethods(['groupExists','getNewLDAPConnection'])
+			->onlyMethods(['groupExists', 'getNewLDAPConnection'])
 			->disableOriginalConstructor()
 			->getMock();
 
@@ -316,14 +316,14 @@ 
 			'ou=users,ou=foobar,dc=example,dc=org',
 			'ou=users,ou=barfoo,dc=example,dc=org',
 		];
-		$dn = 'uid=malik,' . $bases[1];
+		$dn = 'uid=malik,'.$bases[1];
 
 		$connection = $this->getMockBuilder(Connection::class)
 			->setConstructorArgs([$this->createMock(ILDAPWrapper::class)])
 			->getMock();
 		$connection->expects($this->any())
 			->method('__get')
-			->willReturnCallback(function ($key) use ($bases) {
+			->willReturnCallback(function($key) use ($bases) {
 				switch ($key) {
 					case 'ldapBaseUsers':
 						return $bases;
@@ -387,7 +387,7 @@ 
 			->getMock();
 		$connection->expects($this->any())
 			->method('__get')
-			->willReturnCallback(function ($key) use ($bases) {
+			->willReturnCallback(function($key) use ($bases) {
 				switch ($key) {
 					case 'ldapBaseGroups':
 						return $bases;

apps/user_ldap/tests/GroupLDAPPluginTest.php

Indentation +158 added lines, -158 removed lines

@@ -11,217 +11,217 @@
 use OCP\GroupInterface;
 
 class GroupLDAPPluginTest extends \Test\TestCase {
-	private function getGroupPluginManager(): GroupPluginManager {
-		return new GroupPluginManager();
-	}
+    private function getGroupPluginManager(): GroupPluginManager {
+        return new GroupPluginManager();
+    }
 
-	public function testImplementsActions(): void {
-		$pluginManager = $this->getGroupPluginManager();
+    public function testImplementsActions(): void {
+        $pluginManager = $this->getGroupPluginManager();
 
-		$plugin = $this->getMockBuilder(LDAPGroupPluginDummy::class)
-			->onlyMethods(['respondToActions'])
-			->getMock();
+        $plugin = $this->getMockBuilder(LDAPGroupPluginDummy::class)
+            ->onlyMethods(['respondToActions'])
+            ->getMock();
 
-		$plugin->expects($this->any())
-			->method('respondToActions')
-			->willReturn(GroupInterface::CREATE_GROUP);
+        $plugin->expects($this->any())
+            ->method('respondToActions')
+            ->willReturn(GroupInterface::CREATE_GROUP);
 
-		$plugin2 = $this->getMockBuilder(LDAPGroupPluginDummy::class)
-			->onlyMethods(['respondToActions'])
-			->getMock();
+        $plugin2 = $this->getMockBuilder(LDAPGroupPluginDummy::class)
+            ->onlyMethods(['respondToActions'])
+            ->getMock();
 
-		$plugin2->expects($this->any())
-			->method('respondToActions')
-			->willReturn(GroupInterface::ADD_TO_GROUP);
+        $plugin2->expects($this->any())
+            ->method('respondToActions')
+            ->willReturn(GroupInterface::ADD_TO_GROUP);
 
-		$pluginManager->register($plugin);
-		$pluginManager->register($plugin2);
+        $pluginManager->register($plugin);
+        $pluginManager->register($plugin2);
 
-		$this->assertEquals($pluginManager->getImplementedActions(), GroupInterface::CREATE_GROUP | GroupInterface::ADD_TO_GROUP);
-		$this->assertTrue($pluginManager->implementsActions(GroupInterface::CREATE_GROUP));
-		$this->assertTrue($pluginManager->implementsActions(GroupInterface::ADD_TO_GROUP));
-	}
+        $this->assertEquals($pluginManager->getImplementedActions(), GroupInterface::CREATE_GROUP | GroupInterface::ADD_TO_GROUP);
+        $this->assertTrue($pluginManager->implementsActions(GroupInterface::CREATE_GROUP));
+        $this->assertTrue($pluginManager->implementsActions(GroupInterface::ADD_TO_GROUP));
+    }
 
-	public function testCreateGroup(): void {
-		$pluginManager = $this->getGroupPluginManager();
+    public function testCreateGroup(): void {
+        $pluginManager = $this->getGroupPluginManager();
 
-		$plugin = $this->getMockBuilder(LDAPGroupPluginDummy::class)
-			->onlyMethods(['respondToActions', 'createGroup'])
-			->getMock();
+        $plugin = $this->getMockBuilder(LDAPGroupPluginDummy::class)
+            ->onlyMethods(['respondToActions', 'createGroup'])
+            ->getMock();
 
-		$plugin->expects($this->any())
-			->method('respondToActions')
-			->willReturn(GroupInterface::CREATE_GROUP);
+        $plugin->expects($this->any())
+            ->method('respondToActions')
+            ->willReturn(GroupInterface::CREATE_GROUP);
 
-		$plugin->expects($this->once())
-			->method('createGroup')
-			->with(
-				$this->equalTo('group')
-			);
+        $plugin->expects($this->once())
+            ->method('createGroup')
+            ->with(
+                $this->equalTo('group')
+            );
 
-		$pluginManager->register($plugin);
-		$pluginManager->createGroup('group');
-	}
+        $pluginManager->register($plugin);
+        $pluginManager->createGroup('group');
+    }
 
 
-	public function testCreateGroupNotRegistered(): void {
-		$this->expectException(\Exception::class);
-		$this->expectExceptionMessage('No plugin implements createGroup in this LDAP Backend.');
+    public function testCreateGroupNotRegistered(): void {
+        $this->expectException(\Exception::class);
+        $this->expectExceptionMessage('No plugin implements createGroup in this LDAP Backend.');
 
-		$pluginManager = $this->getGroupPluginManager();
-		$pluginManager->createGroup('foo');
-	}
+        $pluginManager = $this->getGroupPluginManager();
+        $pluginManager->createGroup('foo');
+    }
 
-	public function testDeleteGroup(): void {
-		$pluginManager = $this->getGroupPluginManager();
+    public function testDeleteGroup(): void {
+        $pluginManager = $this->getGroupPluginManager();
 
-		$plugin = $this->getMockBuilder(LDAPGroupPluginDummy::class)
-			->onlyMethods(['respondToActions', 'deleteGroup'])
-			->getMock();
+        $plugin = $this->getMockBuilder(LDAPGroupPluginDummy::class)
+            ->onlyMethods(['respondToActions', 'deleteGroup'])
+            ->getMock();
 
-		$plugin->expects($this->any())
-			->method('respondToActions')
-			->willReturn(GroupInterface::DELETE_GROUP);
+        $plugin->expects($this->any())
+            ->method('respondToActions')
+            ->willReturn(GroupInterface::DELETE_GROUP);
 
-		$plugin->expects($this->once())
-			->method('deleteGroup')
-			->with(
-				$this->equalTo('group')
-			)->willReturn(true);
+        $plugin->expects($this->once())
+            ->method('deleteGroup')
+            ->with(
+                $this->equalTo('group')
+            )->willReturn(true);
 
-		$pluginManager->register($plugin);
-		$this->assertTrue($pluginManager->deleteGroup('group'));
-	}
+        $pluginManager->register($plugin);
+        $this->assertTrue($pluginManager->deleteGroup('group'));
+    }
 
 
-	public function testDeleteGroupNotRegistered(): void {
-		$this->expectException(\Exception::class);
-		$this->expectExceptionMessage('No plugin implements deleteGroup in this LDAP Backend.');
+    public function testDeleteGroupNotRegistered(): void {
+        $this->expectException(\Exception::class);
+        $this->expectExceptionMessage('No plugin implements deleteGroup in this LDAP Backend.');
 
-		$pluginManager = $this->getGroupPluginManager();
-		$pluginManager->deleteGroup('foo');
-	}
+        $pluginManager = $this->getGroupPluginManager();
+        $pluginManager->deleteGroup('foo');
+    }
 
-	public function testAddToGroup(): void {
-		$pluginManager = $this->getGroupPluginManager();
+    public function testAddToGroup(): void {
+        $pluginManager = $this->getGroupPluginManager();
 
-		$plugin = $this->getMockBuilder(LDAPGroupPluginDummy::class)
-			->onlyMethods(['respondToActions', 'addToGroup'])
-			->getMock();
+        $plugin = $this->getMockBuilder(LDAPGroupPluginDummy::class)
+            ->onlyMethods(['respondToActions', 'addToGroup'])
+            ->getMock();
 
-		$plugin->expects($this->any())
-			->method('respondToActions')
-			->willReturn(GroupInterface::ADD_TO_GROUP);
+        $plugin->expects($this->any())
+            ->method('respondToActions')
+            ->willReturn(GroupInterface::ADD_TO_GROUP);
 
-		$plugin->expects($this->once())
-			->method('addToGroup')
-			->with(
-				$this->equalTo('uid'),
-				$this->equalTo('gid')
-			);
+        $plugin->expects($this->once())
+            ->method('addToGroup')
+            ->with(
+                $this->equalTo('uid'),
+                $this->equalTo('gid')
+            );
 
-		$pluginManager->register($plugin);
-		$pluginManager->addToGroup('uid', 'gid');
-	}
+        $pluginManager->register($plugin);
+        $pluginManager->addToGroup('uid', 'gid');
+    }
 
 
-	public function testAddToGroupNotRegistered(): void {
-		$this->expectException(\Exception::class);
-		$this->expectExceptionMessage('No plugin implements addToGroup in this LDAP Backend.');
+    public function testAddToGroupNotRegistered(): void {
+        $this->expectException(\Exception::class);
+        $this->expectExceptionMessage('No plugin implements addToGroup in this LDAP Backend.');
 
-		$pluginManager = $this->getGroupPluginManager();
-		$pluginManager->addToGroup('foo', 'bar');
-	}
+        $pluginManager = $this->getGroupPluginManager();
+        $pluginManager->addToGroup('foo', 'bar');
+    }
 
-	public function testRemoveFromGroup(): void {
-		$pluginManager = $this->getGroupPluginManager();
+    public function testRemoveFromGroup(): void {
+        $pluginManager = $this->getGroupPluginManager();
 
-		$plugin = $this->getMockBuilder(LDAPGroupPluginDummy::class)
-			->onlyMethods(['respondToActions', 'removeFromGroup'])
-			->getMock();
+        $plugin = $this->getMockBuilder(LDAPGroupPluginDummy::class)
+            ->onlyMethods(['respondToActions', 'removeFromGroup'])
+            ->getMock();
 
-		$plugin->expects($this->any())
-			->method('respondToActions')
-			->willReturn(GroupInterface::REMOVE_FROM_GROUP);
+        $plugin->expects($this->any())
+            ->method('respondToActions')
+            ->willReturn(GroupInterface::REMOVE_FROM_GROUP);
 
-		$plugin->expects($this->once())
-			->method('removeFromGroup')
-			->with(
-				$this->equalTo('uid'),
-				$this->equalTo('gid')
-			);
+        $plugin->expects($this->once())
+            ->method('removeFromGroup')
+            ->with(
+                $this->equalTo('uid'),
+                $this->equalTo('gid')
+            );
 
-		$pluginManager->register($plugin);
-		$pluginManager->removeFromGroup('uid', 'gid');
-	}
+        $pluginManager->register($plugin);
+        $pluginManager->removeFromGroup('uid', 'gid');
+    }
 
 
-	public function testRemoveFromGroupNotRegistered(): void {
-		$this->expectException(\Exception::class);
-		$this->expectExceptionMessage('No plugin implements removeFromGroup in this LDAP Backend.');
+    public function testRemoveFromGroupNotRegistered(): void {
+        $this->expectException(\Exception::class);
+        $this->expectExceptionMessage('No plugin implements removeFromGroup in this LDAP Backend.');
 
-		$pluginManager = $this->getGroupPluginManager();
-		$pluginManager->removeFromGroup('foo', 'bar');
-	}
+        $pluginManager = $this->getGroupPluginManager();
+        $pluginManager->removeFromGroup('foo', 'bar');
+    }
 
-	public function testCountUsersInGroup(): void {
-		$pluginManager = $this->getGroupPluginManager();
+    public function testCountUsersInGroup(): void {
+        $pluginManager = $this->getGroupPluginManager();
 
-		$plugin = $this->getMockBuilder(LDAPGroupPluginDummy::class)
-			->onlyMethods(['respondToActions', 'countUsersInGroup'])
-			->getMock();
+        $plugin = $this->getMockBuilder(LDAPGroupPluginDummy::class)
+            ->onlyMethods(['respondToActions', 'countUsersInGroup'])
+            ->getMock();
 
-		$plugin->expects($this->any())
-			->method('respondToActions')
-			->willReturn(GroupInterface::COUNT_USERS);
+        $plugin->expects($this->any())
+            ->method('respondToActions')
+            ->willReturn(GroupInterface::COUNT_USERS);
 
-		$plugin->expects($this->once())
-			->method('countUsersInGroup')
-			->with(
-				$this->equalTo('gid'),
-				$this->equalTo('search')
-			);
+        $plugin->expects($this->once())
+            ->method('countUsersInGroup')
+            ->with(
+                $this->equalTo('gid'),
+                $this->equalTo('search')
+            );
 
-		$pluginManager->register($plugin);
-		$pluginManager->countUsersInGroup('gid', 'search');
-	}
+        $pluginManager->register($plugin);
+        $pluginManager->countUsersInGroup('gid', 'search');
+    }
 
 
-	public function testCountUsersInGroupNotRegistered(): void {
-		$this->expectException(\Exception::class);
-		$this->expectExceptionMessage('No plugin implements countUsersInGroup in this LDAP Backend.');
+    public function testCountUsersInGroupNotRegistered(): void {
+        $this->expectException(\Exception::class);
+        $this->expectExceptionMessage('No plugin implements countUsersInGroup in this LDAP Backend.');
 
-		$pluginManager = $this->getGroupPluginManager();
-		$pluginManager->countUsersInGroup('foo', 'bar');
-	}
+        $pluginManager = $this->getGroupPluginManager();
+        $pluginManager->countUsersInGroup('foo', 'bar');
+    }
 
-	public function testgetGroupDetails(): void {
-		$pluginManager = $this->getGroupPluginManager();
+    public function testgetGroupDetails(): void {
+        $pluginManager = $this->getGroupPluginManager();
 
-		$plugin = $this->getMockBuilder(LDAPGroupPluginDummy::class)
-			->onlyMethods(['respondToActions', 'getGroupDetails'])
-			->getMock();
+        $plugin = $this->getMockBuilder(LDAPGroupPluginDummy::class)
+            ->onlyMethods(['respondToActions', 'getGroupDetails'])
+            ->getMock();
 
-		$plugin->expects($this->any())
-			->method('respondToActions')
-			->willReturn(GroupInterface::GROUP_DETAILS);
+        $plugin->expects($this->any())
+            ->method('respondToActions')
+            ->willReturn(GroupInterface::GROUP_DETAILS);
 
-		$plugin->expects($this->once())
-			->method('getGroupDetails')
-			->with(
-				$this->equalTo('gid')
-			);
+        $plugin->expects($this->once())
+            ->method('getGroupDetails')
+            ->with(
+                $this->equalTo('gid')
+            );
 
-		$pluginManager->register($plugin);
-		$pluginManager->getGroupDetails('gid');
-	}
+        $pluginManager->register($plugin);
+        $pluginManager->getGroupDetails('gid');
+    }
 
 
-	public function testgetGroupDetailsNotRegistered(): void {
-		$this->expectException(\Exception::class);
-		$this->expectExceptionMessage('No plugin implements getGroupDetails in this LDAP Backend.');
+    public function testgetGroupDetailsNotRegistered(): void {
+        $this->expectException(\Exception::class);
+        $this->expectExceptionMessage('No plugin implements getGroupDetails in this LDAP Backend.');
 
-		$pluginManager = $this->getGroupPluginManager();
-		$pluginManager->getGroupDetails('foo');
-	}
+        $pluginManager = $this->getGroupPluginManager();
+        $pluginManager->getGroupDetails('foo');
+    }
 }

apps/user_ldap/tests/LDAPUserPluginDummy.php

Indentation +30 added lines, -30 removed lines

@@ -10,43 +10,43 @@
 use OCA\User_LDAP\ILDAPUserPlugin;
 
 class LDAPUserPluginDummy implements ILDAPUserPlugin {
-	public function respondToActions() {
-		return null;
-	}
+    public function respondToActions() {
+        return null;
+    }
 
-	public function createUser($username, $password) {
-		return null;
-	}
+    public function createUser($username, $password) {
+        return null;
+    }
 
-	public function setPassword($uid, $password) {
-		return null;
-	}
+    public function setPassword($uid, $password) {
+        return null;
+    }
 
-	public function getHome($uid) {
-		return null;
-	}
+    public function getHome($uid) {
+        return null;
+    }
 
-	public function getDisplayName($uid) {
-		return null;
-	}
+    public function getDisplayName($uid) {
+        return null;
+    }
 
-	public function setDisplayName($uid, $displayName) {
-		return null;
-	}
+    public function setDisplayName($uid, $displayName) {
+        return null;
+    }
 
-	public function canChangeAvatar($uid) {
-		return null;
-	}
+    public function canChangeAvatar($uid) {
+        return null;
+    }
 
-	public function countUsers() {
-		return null;
-	}
+    public function countUsers() {
+        return null;
+    }
 
-	public function canDeleteUser() {
-		return true;
-	}
+    public function canDeleteUser() {
+        return true;
+    }
 
-	public function deleteUser($uid) {
-		return null;
-	}
+    public function deleteUser($uid) {
+        return null;
+    }
 }

apps/user_ldap/tests/Jobs/SyncTest.php

Indentation +348 added lines, -348 removed lines

@@ -31,352 +31,352 @@
  * @group DB
  */
 class SyncTest extends TestCase {
-	protected Helper&MockObject $helper;
-	protected LDAP&MockObject $ldapWrapper;
-	protected Manager&MockObject $userManager;
-	protected UserMapping&MockObject $mapper;
-	protected IConfig&MockObject $config;
-	protected IAvatarManager&MockObject $avatarManager;
-	protected IDBConnection&MockObject $dbc;
-	protected IUserManager&MockObject $ncUserManager;
-	protected IManager&MockObject $notificationManager;
-	protected ConnectionFactory&MockObject $connectionFactory;
-	protected AccessFactory&MockObject $accessFactory;
-	protected array $arguments = [];
-	protected Sync $sync;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->helper = $this->createMock(Helper::class);
-		$this->ldapWrapper = $this->createMock(LDAP::class);
-		$this->userManager = $this->createMock(Manager::class);
-		$this->mapper = $this->createMock(UserMapping::class);
-		$this->config = $this->createMock(IConfig::class);
-		$this->avatarManager = $this->createMock(IAvatarManager::class);
-		$this->dbc = $this->createMock(IDBConnection::class);
-		$this->ncUserManager = $this->createMock(IUserManager::class);
-		$this->notificationManager = $this->createMock(IManager::class);
-		$this->connectionFactory = $this->getMockBuilder(ConnectionFactory::class)
-			->setConstructorArgs([
-				$this->ldapWrapper,
-			])
-			->getMock();
-		$this->accessFactory = $this->createMock(AccessFactory::class);
-
-		$this->sync = new Sync(
-			Server::get(ITimeFactory::class),
-			Server::get(IEventDispatcher::class),
-			$this->config,
-			$this->dbc,
-			$this->avatarManager,
-			$this->ncUserManager,
-			Server::get(LoggerInterface::class),
-			$this->notificationManager,
-			$this->mapper,
-			$this->helper,
-			$this->connectionFactory,
-			$this->accessFactory,
-		);
-
-		$this->sync->overwritePropertiesForTest($this->ldapWrapper);
-	}
-
-	public static function intervalDataProvider(): array {
-		return [
-			[
-				0, 1000, 750
-			],
-			[
-				22,	0, 50
-			],
-			[
-				500, 500, 500
-			],
-			[
-				1357, 0, 0
-			],
-			[
-				421337, 2000, 3000
-			]
-		];
-	}
-
-	/**
-	 * @dataProvider intervalDataProvider
-	 */
-	public function testUpdateInterval(int $userCount, int $pagingSize1, int $pagingSize2): void {
-		$this->config->expects($this->once())
-			->method('setAppValue')
-			->with('user_ldap', 'background_sync_interval', $this->anything())
-			->willReturnCallback(function ($a, $k, $interval) {
-				$this->assertTrue($interval >= SYNC::MIN_INTERVAL);
-				$this->assertTrue($interval <= SYNC::MAX_INTERVAL);
-				return true;
-			});
-		$this->config->expects($this->atLeastOnce())
-			->method('getAppKeys')
-			->willReturn([
-				'blabla',
-				'ldap_paging_size',
-				's07blabla',
-				'installed',
-				's07ldap_paging_size'
-			]);
-		$this->config->expects($this->exactly(2))
-			->method('getAppValue')
-			->willReturnOnConsecutiveCalls($pagingSize1, $pagingSize2);
-
-		$this->mapper->expects($this->atLeastOnce())
-			->method('count')
-			->willReturn($userCount);
-
-		$this->sync->setArgument($this->arguments);
-		$this->sync->updateInterval();
-	}
-
-	public static function moreResultsProvider(): array {
-		return [
-			[ 3, 3, true ],
-			[ 3, 5, true ],
-			[ 3, 2, false],
-			[ 0, 4, false],
-			[ null, 4, false]
-		];
-	}
-
-	/**
-	 * @dataProvider moreResultsProvider
-	 */
-	public function testMoreResults($pagingSize, $results, $expected): void {
-		$connection = $this->getMockBuilder(Connection::class)
-			->setConstructorArgs([
-				$this->ldapWrapper,
-			])
-			->getMock();
-		$this->connectionFactory->expects($this->any())
-			->method('get')
-			->willReturn($connection);
-		$connection->expects($this->any())
-			->method('__get')
-			->willReturnCallback(function ($key) use ($pagingSize) {
-				if ($key === 'ldapPagingSize') {
-					return $pagingSize;
-				}
-				return null;
-			});
-
-		/** @var Access&MockObject $access */
-		$access = $this->createMock(Access::class);
-		$this->accessFactory->expects($this->any())
-			->method('get')
-			->with($connection)
-			->willReturn($access);
-
-		$this->userManager->expects($this->any())
-			->method('getAttributes')
-			->willReturn(['dn', 'uid', 'mail', 'displayname']);
-
-		$access->expects($this->once())
-			->method('fetchListOfUsers')
-			->willReturn(array_pad([], $results, 'someUser'));
-		$access->expects($this->any())
-			->method('combineFilterWithAnd')
-			->willReturn('pseudo=filter');
-		$access->connection = $connection;
-		$access->userManager = $this->userManager;
-
-		$this->sync->setArgument($this->arguments);
-		$hasMoreResults = $this->sync->runCycle(['prefix' => 's01', 'offset' => 100]);
-		$this->assertSame($expected, $hasMoreResults);
-	}
-
-	public static function cycleDataProvider(): array {
-		$lastCycle = ['prefix' => 's01', 'offset' => 1000];
-		$lastCycle2 = ['prefix' => '', 'offset' => 1000];
-		return [
-			[ null, ['s01'], ['prefix' => 's01', 'offset' => 0] ],
-			[ null, [''], ['prefix' => '', 'offset' => 0] ],
-			[ $lastCycle, ['s01', 's02'], ['prefix' => 's02', 'offset' => 0] ],
-			[ $lastCycle, [''], ['prefix' => '', 'offset' => 0] ],
-			[ $lastCycle2, ['', 's01'], ['prefix' => 's01', 'offset' => 0] ],
-			[ $lastCycle, [], null ],
-		];
-	}
-
-	/**
-	 * @dataProvider cycleDataProvider
-	 */
-	public function testDetermineNextCycle(?array $cycleData, array $prefixes, ?array $expectedCycle): void {
-		$this->helper->expects($this->any())
-			->method('getServerConfigurationPrefixes')
-			->with(true)
-			->willReturn($prefixes);
-
-		if (is_array($expectedCycle)) {
-			$calls = [
-				['user_ldap', 'background_sync_prefix', $expectedCycle['prefix']],
-				['user_ldap', 'background_sync_offset', $expectedCycle['offset']],
-			];
-			$this->config->expects($this->exactly(2))
-				->method('setAppValue')
-				->willReturnCallback(function () use (&$calls) {
-					$expected = array_shift($calls);
-					$this->assertEquals($expected, func_get_args());
-				});
-		} else {
-			$this->config->expects($this->never())
-				->method('setAppValue');
-		}
-
-		$this->sync->setArgument($this->arguments);
-		$nextCycle = $this->sync->determineNextCycle($cycleData);
-
-		if ($expectedCycle === null) {
-			$this->assertNull($nextCycle);
-		} else {
-			$this->assertSame($expectedCycle['prefix'], $nextCycle['prefix']);
-			$this->assertSame($expectedCycle['offset'], $nextCycle['offset']);
-		}
-	}
-
-	public function testQualifiesToRun(): void {
-		$cycleData = ['prefix' => 's01'];
-
-		$this->config->expects($this->exactly(2))
-			->method('getAppValue')
-			->willReturnOnConsecutiveCalls(time() - 60 * 40, time() - 60 * 20);
-
-		$this->sync->setArgument($this->arguments);
-		$this->assertTrue($this->sync->qualifiesToRun($cycleData));
-		$this->assertFalse($this->sync->qualifiesToRun($cycleData));
-	}
-
-	public static function runDataProvider(): array {
-		return [
-			#0 - one LDAP server, reset
-			[[
-				'prefixes' => [''],
-				'scheduledCycle' => ['prefix' => '', 'offset' => '4500'],
-				'pagingSize' => 500,
-				'usersThisCycle' => 0,
-				'expectedNextCycle' => ['prefix' => '', 'offset' => '0'],
-				'mappedUsers' => 123,
-			]],
-			#1 - 2 LDAP servers, next prefix
-			[[
-				'prefixes' => ['', 's01'],
-				'scheduledCycle' => ['prefix' => '', 'offset' => '4500'],
-				'pagingSize' => 500,
-				'usersThisCycle' => 0,
-				'expectedNextCycle' => ['prefix' => 's01', 'offset' => '0'],
-				'mappedUsers' => 123,
-			]],
-			#2 - 2 LDAP servers, rotate prefix
-			[[
-				'prefixes' => ['', 's01'],
-				'scheduledCycle' => ['prefix' => 's01', 'offset' => '4500'],
-				'pagingSize' => 500,
-				'usersThisCycle' => 0,
-				'expectedNextCycle' => ['prefix' => '', 'offset' => '0'],
-				'mappedUsers' => 123,
-			]],
-		];
-	}
-
-	/**
-	 * @dataProvider runDataProvider
-	 */
-	public function testRun(array $runData): void {
-		$this->config->expects($this->any())
-			->method('getAppValue')
-			->willReturnCallback(function ($app, $key, $default) use ($runData) {
-				if ($app === 'core' && $key === 'backgroundjobs_mode') {
-					return 'cron';
-				}
-				if ($app = 'user_ldap') {
-					// for getCycle()
-					if ($key === 'background_sync_prefix') {
-						return $runData['scheduledCycle']['prefix'];
-					}
-					if ($key === 'background_sync_offset') {
-						return $runData['scheduledCycle']['offset'];
-					}
-					// for qualifiesToRun()
-					if ($key === $runData['scheduledCycle']['prefix'] . '_lastChange') {
-						return time() - 60 * 40;
-					}
-					// for getMinPagingSize
-					if ($key === $runData['scheduledCycle']['prefix'] . 'ldap_paging_size') {
-						return $runData['pagingSize'];
-					}
-				}
-
-				return $default;
-			});
-
-		$calls = [
-			['user_ldap', 'background_sync_prefix', $runData['expectedNextCycle']['prefix']],
-			['user_ldap', 'background_sync_offset', $runData['expectedNextCycle']['offset']],
-			['user_ldap', 'background_sync_interval', '43200'],
-		];
-		$this->config->expects($this->exactly(3))
-			->method('setAppValue')
-			->willReturnCallback(function () use (&$calls) {
-				$expected = array_shift($calls);
-				$this->assertEquals($expected, func_get_args());
-			});
-		$this->config->expects($this->any())
-			->method('getAppKeys')
-			->with('user_ldap')
-			->willReturn([$runData['scheduledCycle']['prefix'] . 'ldap_paging_size']);
-
-		$this->helper->expects($this->any())
-			->method('getServerConfigurationPrefixes')
-			->with(true)
-			->willReturn($runData['prefixes']);
-
-		$connection = $this->getMockBuilder(Connection::class)
-			->setConstructorArgs([
-				$this->ldapWrapper,
-			])
-			->getMock();
-		$this->connectionFactory->expects($this->any())
-			->method('get')
-			->willReturn($connection);
-		$connection->expects($this->any())
-			->method('__get')
-			->willReturnCallback(function ($key) use ($runData) {
-				if ($key === 'ldapPagingSize') {
-					return $runData['pagingSize'];
-				}
-				return null;
-			});
-
-		/** @var Access&MockObject $access */
-		$access = $this->createMock(Access::class);
-		$this->accessFactory->expects($this->any())
-			->method('get')
-			->with($connection)
-			->willReturn($access);
-
-		$this->userManager->expects($this->any())
-			->method('getAttributes')
-			->willReturn(['dn', 'uid', 'mail', 'displayname']);
-
-		$access->expects($this->once())
-			->method('fetchListOfUsers')
-			->willReturn(array_pad([], $runData['usersThisCycle'], 'someUser'));
-		$access->expects($this->any())
-			->method('combineFilterWithAnd')
-			->willReturn('pseudo=filter');
-		$access->connection = $connection;
-		$access->userManager = $this->userManager;
-
-		$this->mapper->expects($this->any())
-			->method('count')
-			->willReturn($runData['mappedUsers']);
-
-		$this->sync->run($this->arguments);
-	}
+    protected Helper&MockObject $helper;
+    protected LDAP&MockObject $ldapWrapper;
+    protected Manager&MockObject $userManager;
+    protected UserMapping&MockObject $mapper;
+    protected IConfig&MockObject $config;
+    protected IAvatarManager&MockObject $avatarManager;
+    protected IDBConnection&MockObject $dbc;
+    protected IUserManager&MockObject $ncUserManager;
+    protected IManager&MockObject $notificationManager;
+    protected ConnectionFactory&MockObject $connectionFactory;
+    protected AccessFactory&MockObject $accessFactory;
+    protected array $arguments = [];
+    protected Sync $sync;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->helper = $this->createMock(Helper::class);
+        $this->ldapWrapper = $this->createMock(LDAP::class);
+        $this->userManager = $this->createMock(Manager::class);
+        $this->mapper = $this->createMock(UserMapping::class);
+        $this->config = $this->createMock(IConfig::class);
+        $this->avatarManager = $this->createMock(IAvatarManager::class);
+        $this->dbc = $this->createMock(IDBConnection::class);
+        $this->ncUserManager = $this->createMock(IUserManager::class);
+        $this->notificationManager = $this->createMock(IManager::class);
+        $this->connectionFactory = $this->getMockBuilder(ConnectionFactory::class)
+            ->setConstructorArgs([
+                $this->ldapWrapper,
+            ])
+            ->getMock();
+        $this->accessFactory = $this->createMock(AccessFactory::class);
+
+        $this->sync = new Sync(
+            Server::get(ITimeFactory::class),
+            Server::get(IEventDispatcher::class),
+            $this->config,
+            $this->dbc,
+            $this->avatarManager,
+            $this->ncUserManager,
+            Server::get(LoggerInterface::class),
+            $this->notificationManager,
+            $this->mapper,
+            $this->helper,
+            $this->connectionFactory,
+            $this->accessFactory,
+        );
+
+        $this->sync->overwritePropertiesForTest($this->ldapWrapper);
+    }
+
+    public static function intervalDataProvider(): array {
+        return [
+            [
+                0, 1000, 750
+            ],
+            [
+                22,	0, 50
+            ],
+            [
+                500, 500, 500
+            ],
+            [
+                1357, 0, 0
+            ],
+            [
+                421337, 2000, 3000
+            ]
+        ];
+    }
+
+    /**
+     * @dataProvider intervalDataProvider
+     */
+    public function testUpdateInterval(int $userCount, int $pagingSize1, int $pagingSize2): void {
+        $this->config->expects($this->once())
+            ->method('setAppValue')
+            ->with('user_ldap', 'background_sync_interval', $this->anything())
+            ->willReturnCallback(function ($a, $k, $interval) {
+                $this->assertTrue($interval >= SYNC::MIN_INTERVAL);
+                $this->assertTrue($interval <= SYNC::MAX_INTERVAL);
+                return true;
+            });
+        $this->config->expects($this->atLeastOnce())
+            ->method('getAppKeys')
+            ->willReturn([
+                'blabla',
+                'ldap_paging_size',
+                's07blabla',
+                'installed',
+                's07ldap_paging_size'
+            ]);
+        $this->config->expects($this->exactly(2))
+            ->method('getAppValue')
+            ->willReturnOnConsecutiveCalls($pagingSize1, $pagingSize2);
+
+        $this->mapper->expects($this->atLeastOnce())
+            ->method('count')
+            ->willReturn($userCount);
+
+        $this->sync->setArgument($this->arguments);
+        $this->sync->updateInterval();
+    }
+
+    public static function moreResultsProvider(): array {
+        return [
+            [ 3, 3, true ],
+            [ 3, 5, true ],
+            [ 3, 2, false],
+            [ 0, 4, false],
+            [ null, 4, false]
+        ];
+    }
+
+    /**
+     * @dataProvider moreResultsProvider
+     */
+    public function testMoreResults($pagingSize, $results, $expected): void {
+        $connection = $this->getMockBuilder(Connection::class)
+            ->setConstructorArgs([
+                $this->ldapWrapper,
+            ])
+            ->getMock();
+        $this->connectionFactory->expects($this->any())
+            ->method('get')
+            ->willReturn($connection);
+        $connection->expects($this->any())
+            ->method('__get')
+            ->willReturnCallback(function ($key) use ($pagingSize) {
+                if ($key === 'ldapPagingSize') {
+                    return $pagingSize;
+                }
+                return null;
+            });
+
+        /** @var Access&MockObject $access */
+        $access = $this->createMock(Access::class);
+        $this->accessFactory->expects($this->any())
+            ->method('get')
+            ->with($connection)
+            ->willReturn($access);
+
+        $this->userManager->expects($this->any())
+            ->method('getAttributes')
+            ->willReturn(['dn', 'uid', 'mail', 'displayname']);
+
+        $access->expects($this->once())
+            ->method('fetchListOfUsers')
+            ->willReturn(array_pad([], $results, 'someUser'));
+        $access->expects($this->any())
+            ->method('combineFilterWithAnd')
+            ->willReturn('pseudo=filter');
+        $access->connection = $connection;
+        $access->userManager = $this->userManager;
+
+        $this->sync->setArgument($this->arguments);
+        $hasMoreResults = $this->sync->runCycle(['prefix' => 's01', 'offset' => 100]);
+        $this->assertSame($expected, $hasMoreResults);
+    }
+
+    public static function cycleDataProvider(): array {
+        $lastCycle = ['prefix' => 's01', 'offset' => 1000];
+        $lastCycle2 = ['prefix' => '', 'offset' => 1000];
+        return [
+            [ null, ['s01'], ['prefix' => 's01', 'offset' => 0] ],
+            [ null, [''], ['prefix' => '', 'offset' => 0] ],
+            [ $lastCycle, ['s01', 's02'], ['prefix' => 's02', 'offset' => 0] ],
+            [ $lastCycle, [''], ['prefix' => '', 'offset' => 0] ],
+            [ $lastCycle2, ['', 's01'], ['prefix' => 's01', 'offset' => 0] ],
+            [ $lastCycle, [], null ],
+        ];
+    }
+
+    /**
+     * @dataProvider cycleDataProvider
+     */
+    public function testDetermineNextCycle(?array $cycleData, array $prefixes, ?array $expectedCycle): void {
+        $this->helper->expects($this->any())
+            ->method('getServerConfigurationPrefixes')
+            ->with(true)
+            ->willReturn($prefixes);
+
+        if (is_array($expectedCycle)) {
+            $calls = [
+                ['user_ldap', 'background_sync_prefix', $expectedCycle['prefix']],
+                ['user_ldap', 'background_sync_offset', $expectedCycle['offset']],
+            ];
+            $this->config->expects($this->exactly(2))
+                ->method('setAppValue')
+                ->willReturnCallback(function () use (&$calls) {
+                    $expected = array_shift($calls);
+                    $this->assertEquals($expected, func_get_args());
+                });
+        } else {
+            $this->config->expects($this->never())
+                ->method('setAppValue');
+        }
+
+        $this->sync->setArgument($this->arguments);
+        $nextCycle = $this->sync->determineNextCycle($cycleData);
+
+        if ($expectedCycle === null) {
+            $this->assertNull($nextCycle);
+        } else {
+            $this->assertSame($expectedCycle['prefix'], $nextCycle['prefix']);
+            $this->assertSame($expectedCycle['offset'], $nextCycle['offset']);
+        }
+    }
+
+    public function testQualifiesToRun(): void {
+        $cycleData = ['prefix' => 's01'];
+
+        $this->config->expects($this->exactly(2))
+            ->method('getAppValue')
+            ->willReturnOnConsecutiveCalls(time() - 60 * 40, time() - 60 * 20);
+
+        $this->sync->setArgument($this->arguments);
+        $this->assertTrue($this->sync->qualifiesToRun($cycleData));
+        $this->assertFalse($this->sync->qualifiesToRun($cycleData));
+    }
+
+    public static function runDataProvider(): array {
+        return [
+            #0 - one LDAP server, reset
+            [[
+                'prefixes' => [''],
+                'scheduledCycle' => ['prefix' => '', 'offset' => '4500'],
+                'pagingSize' => 500,
+                'usersThisCycle' => 0,
+                'expectedNextCycle' => ['prefix' => '', 'offset' => '0'],
+                'mappedUsers' => 123,
+            ]],
+            #1 - 2 LDAP servers, next prefix
+            [[
+                'prefixes' => ['', 's01'],
+                'scheduledCycle' => ['prefix' => '', 'offset' => '4500'],
+                'pagingSize' => 500,
+                'usersThisCycle' => 0,
+                'expectedNextCycle' => ['prefix' => 's01', 'offset' => '0'],
+                'mappedUsers' => 123,
+            ]],
+            #2 - 2 LDAP servers, rotate prefix
+            [[
+                'prefixes' => ['', 's01'],
+                'scheduledCycle' => ['prefix' => 's01', 'offset' => '4500'],
+                'pagingSize' => 500,
+                'usersThisCycle' => 0,
+                'expectedNextCycle' => ['prefix' => '', 'offset' => '0'],
+                'mappedUsers' => 123,
+            ]],
+        ];
+    }
+
+    /**
+     * @dataProvider runDataProvider
+     */
+    public function testRun(array $runData): void {
+        $this->config->expects($this->any())
+            ->method('getAppValue')
+            ->willReturnCallback(function ($app, $key, $default) use ($runData) {
+                if ($app === 'core' && $key === 'backgroundjobs_mode') {
+                    return 'cron';
+                }
+                if ($app = 'user_ldap') {
+                    // for getCycle()
+                    if ($key === 'background_sync_prefix') {
+                        return $runData['scheduledCycle']['prefix'];
+                    }
+                    if ($key === 'background_sync_offset') {
+                        return $runData['scheduledCycle']['offset'];
+                    }
+                    // for qualifiesToRun()
+                    if ($key === $runData['scheduledCycle']['prefix'] . '_lastChange') {
+                        return time() - 60 * 40;
+                    }
+                    // for getMinPagingSize
+                    if ($key === $runData['scheduledCycle']['prefix'] . 'ldap_paging_size') {
+                        return $runData['pagingSize'];
+                    }
+                }
+
+                return $default;
+            });
+
+        $calls = [
+            ['user_ldap', 'background_sync_prefix', $runData['expectedNextCycle']['prefix']],
+            ['user_ldap', 'background_sync_offset', $runData['expectedNextCycle']['offset']],
+            ['user_ldap', 'background_sync_interval', '43200'],
+        ];
+        $this->config->expects($this->exactly(3))
+            ->method('setAppValue')
+            ->willReturnCallback(function () use (&$calls) {
+                $expected = array_shift($calls);
+                $this->assertEquals($expected, func_get_args());
+            });
+        $this->config->expects($this->any())
+            ->method('getAppKeys')
+            ->with('user_ldap')
+            ->willReturn([$runData['scheduledCycle']['prefix'] . 'ldap_paging_size']);
+
+        $this->helper->expects($this->any())
+            ->method('getServerConfigurationPrefixes')
+            ->with(true)
+            ->willReturn($runData['prefixes']);
+
+        $connection = $this->getMockBuilder(Connection::class)
+            ->setConstructorArgs([
+                $this->ldapWrapper,
+            ])
+            ->getMock();
+        $this->connectionFactory->expects($this->any())
+            ->method('get')
+            ->willReturn($connection);
+        $connection->expects($this->any())
+            ->method('__get')
+            ->willReturnCallback(function ($key) use ($runData) {
+                if ($key === 'ldapPagingSize') {
+                    return $runData['pagingSize'];
+                }
+                return null;
+            });
+
+        /** @var Access&MockObject $access */
+        $access = $this->createMock(Access::class);
+        $this->accessFactory->expects($this->any())
+            ->method('get')
+            ->with($connection)
+            ->willReturn($access);
+
+        $this->userManager->expects($this->any())
+            ->method('getAttributes')
+            ->willReturn(['dn', 'uid', 'mail', 'displayname']);
+
+        $access->expects($this->once())
+            ->method('fetchListOfUsers')
+            ->willReturn(array_pad([], $runData['usersThisCycle'], 'someUser'));
+        $access->expects($this->any())
+            ->method('combineFilterWithAnd')
+            ->willReturn('pseudo=filter');
+        $access->connection = $connection;
+        $access->userManager = $this->userManager;
+
+        $this->mapper->expects($this->any())
+            ->method('count')
+            ->willReturn($runData['mappedUsers']);
+
+        $this->sync->run($this->arguments);
+    }
 }

Spacing +21 added lines, -21 removed lines

@@ -88,7 +88,7 @@ 
 				0, 1000, 750
 			],
 			[
-				22,	0, 50
+				22, 0, 50
 			],
 			[
 				500, 500, 500
@@ -109,7 +109,7 @@ 
 		$this->config->expects($this->once())
 			->method('setAppValue')
 			->with('user_ldap', 'background_sync_interval', $this->anything())
-			->willReturnCallback(function ($a, $k, $interval) {
+			->willReturnCallback(function($a, $k, $interval) {
 				$this->assertTrue($interval >= SYNC::MIN_INTERVAL);
 				$this->assertTrue($interval <= SYNC::MAX_INTERVAL);
 				return true;
@@ -137,11 +137,11 @@ 
 
 	public static function moreResultsProvider(): array {
 		return [
-			[ 3, 3, true ],
-			[ 3, 5, true ],
-			[ 3, 2, false],
-			[ 0, 4, false],
-			[ null, 4, false]
+			[3, 3, true],
+			[3, 5, true],
+			[3, 2, false],
+			[0, 4, false],
+			[null, 4, false]
 		];
 	}
 
@@ -159,7 +159,7 @@ 
 			->willReturn($connection);
 		$connection->expects($this->any())
 			->method('__get')
-			->willReturnCallback(function ($key) use ($pagingSize) {
+			->willReturnCallback(function($key) use ($pagingSize) {
 				if ($key === 'ldapPagingSize') {
 					return $pagingSize;
 				}
@@ -195,12 +195,12 @@ 
 		$lastCycle = ['prefix' => 's01', 'offset' => 1000];
 		$lastCycle2 = ['prefix' => '', 'offset' => 1000];
 		return [
-			[ null, ['s01'], ['prefix' => 's01', 'offset' => 0] ],
-			[ null, [''], ['prefix' => '', 'offset' => 0] ],
-			[ $lastCycle, ['s01', 's02'], ['prefix' => 's02', 'offset' => 0] ],
-			[ $lastCycle, [''], ['prefix' => '', 'offset' => 0] ],
-			[ $lastCycle2, ['', 's01'], ['prefix' => 's01', 'offset' => 0] ],
-			[ $lastCycle, [], null ],
+			[null, ['s01'], ['prefix' => 's01', 'offset' => 0]],
+			[null, [''], ['prefix' => '', 'offset' => 0]],
+			[$lastCycle, ['s01', 's02'], ['prefix' => 's02', 'offset' => 0]],
+			[$lastCycle, [''], ['prefix' => '', 'offset' => 0]],
+			[$lastCycle2, ['', 's01'], ['prefix' => 's01', 'offset' => 0]],
+			[$lastCycle, [], null],
 		];
 	}
 
@@ -220,7 +220,7 @@ 
 			];
 			$this->config->expects($this->exactly(2))
 				->method('setAppValue')
-				->willReturnCallback(function () use (&$calls) {
+				->willReturnCallback(function() use (&$calls) {
 					$expected = array_shift($calls);
 					$this->assertEquals($expected, func_get_args());
 				});
@@ -290,7 +290,7 @@ 
 	public function testRun(array $runData): void {
 		$this->config->expects($this->any())
 			->method('getAppValue')
-			->willReturnCallback(function ($app, $key, $default) use ($runData) {
+			->willReturnCallback(function($app, $key, $default) use ($runData) {
 				if ($app === 'core' && $key === 'backgroundjobs_mode') {
 					return 'cron';
 				}
@@ -303,11 +303,11 @@ 
 						return $runData['scheduledCycle']['offset'];
 					}
 					// for qualifiesToRun()
-					if ($key === $runData['scheduledCycle']['prefix'] . '_lastChange') {
+					if ($key === $runData['scheduledCycle']['prefix'].'_lastChange') {
 						return time() - 60 * 40;
 					}
 					// for getMinPagingSize
-					if ($key === $runData['scheduledCycle']['prefix'] . 'ldap_paging_size') {
+					if ($key === $runData['scheduledCycle']['prefix'].'ldap_paging_size') {
 						return $runData['pagingSize'];
 					}
 				}
@@ -322,14 +322,14 @@ 
 		];
 		$this->config->expects($this->exactly(3))
 			->method('setAppValue')
-			->willReturnCallback(function () use (&$calls) {
+			->willReturnCallback(function() use (&$calls) {
 				$expected = array_shift($calls);
 				$this->assertEquals($expected, func_get_args());
 			});
 		$this->config->expects($this->any())
 			->method('getAppKeys')
 			->with('user_ldap')
-			->willReturn([$runData['scheduledCycle']['prefix'] . 'ldap_paging_size']);
+			->willReturn([$runData['scheduledCycle']['prefix'].'ldap_paging_size']);
 
 		$this->helper->expects($this->any())
 			->method('getServerConfigurationPrefixes')
@@ -346,7 +346,7 @@ 
 			->willReturn($connection);
 		$connection->expects($this->any())
 			->method('__get')
-			->willReturnCallback(function ($key) use ($runData) {
+			->willReturnCallback(function($key) use ($runData) {
 				if ($key === 'ldapPagingSize') {
 					return $runData['pagingSize'];
 				}

apps/user_ldap/tests/Jobs/CleanUpTest.php

Indentation +98 added lines, -98 removed lines

@@ -19,102 +19,102 @@
 use Test\TestCase;
 
 class CleanUpTest extends TestCase {
-	protected CleanUp $bgJob;
-	protected array $mocks;
-
-	public function setUp(): void {
-		parent::setUp();
-		$this->createMocks();
-		$this->bgJob = new CleanUp($this->mocks['timeFactory'], $this->mocks['userBackend'], $this->mocks['deletedUsersIndex']);
-		$this->bgJob->setArguments($this->mocks);
-	}
-
-	protected function createMocks(): void {
-		$this->mocks = [];
-		$this->mocks['userBackend'] = $this->createMock(User_Proxy::class);
-		$this->mocks['deletedUsersIndex'] = $this->createMock(DeletedUsersIndex::class);
-		$this->mocks['ocConfig'] = $this->createMock(IConfig::class);
-		$this->mocks['db'] = $this->createMock(IDBConnection::class);
-		$this->mocks['helper'] = $this->createMock(Helper::class);
-		$this->mocks['timeFactory'] = $this->createMock(ITimeFactory::class);
-	}
-
-	/**
-	 * clean up job must not run when there are disabled configurations
-	 */
-	public function test_runNotAllowedByDisabledConfigurations(): void {
-		$this->mocks['helper']->expects($this->once())
-			->method('haveDisabledConfigurations')
-			->willReturn(true);
-
-		$this->mocks['ocConfig']->expects($this->never())
-			->method('getSystemValue');
-
-		$result = $this->bgJob->isCleanUpAllowed();
-		$this->assertSame(false, $result);
-	}
-
-	/**
-	 * clean up job must not run when LDAP Helper is broken i.e.
-	 * returning unexpected results
-	 */
-	public function test_runNotAllowedByBrokenHelper(): void {
-		$this->mocks['helper']->expects($this->once())
-			->method('haveDisabledConfigurations')
-			->will($this->throwException(new Exception()));
-
-		$this->mocks['ocConfig']->expects($this->never())
-			->method('getSystemValue');
-
-		$result = $this->bgJob->isCleanUpAllowed();
-		$this->assertSame(false, $result);
-	}
-
-	/**
-	 * clean up job must not run when it is not enabled
-	 */
-	public function test_runNotAllowedBySysConfig(): void {
-		$this->mocks['helper']->expects($this->once())
-			->method('haveDisabledConfigurations')
-			->willReturn(false);
-
-		$this->mocks['ocConfig']->expects($this->once())
-			->method('getSystemValue')
-			->willReturn(false);
-
-		$result = $this->bgJob->isCleanUpAllowed();
-		$this->assertSame(false, $result);
-	}
-
-	/**
-	 * clean up job is allowed to run
-	 */
-	public function test_runIsAllowed(): void {
-		$this->mocks['helper']->expects($this->once())
-			->method('haveDisabledConfigurations')
-			->willReturn(false);
-
-		$this->mocks['ocConfig']->expects($this->once())
-			->method('getSystemValue')
-			->willReturn(true);
-
-		$result = $this->bgJob->isCleanUpAllowed();
-		$this->assertSame(true, $result);
-	}
-
-	/**
-	 * check whether offset will be reset when it needs to
-	 */
-	public function test_OffsetResetIsNecessary(): void {
-		$result = $this->bgJob->isOffsetResetNecessary($this->bgJob->getChunkSize() - 1);
-		$this->assertSame(true, $result);
-	}
-
-	/**
-	 * make sure offset is not reset when it is not due
-	 */
-	public function test_OffsetResetIsNotNecessary(): void {
-		$result = $this->bgJob->isOffsetResetNecessary($this->bgJob->getChunkSize());
-		$this->assertSame(false, $result);
-	}
+    protected CleanUp $bgJob;
+    protected array $mocks;
+
+    public function setUp(): void {
+        parent::setUp();
+        $this->createMocks();
+        $this->bgJob = new CleanUp($this->mocks['timeFactory'], $this->mocks['userBackend'], $this->mocks['deletedUsersIndex']);
+        $this->bgJob->setArguments($this->mocks);
+    }
+
+    protected function createMocks(): void {
+        $this->mocks = [];
+        $this->mocks['userBackend'] = $this->createMock(User_Proxy::class);
+        $this->mocks['deletedUsersIndex'] = $this->createMock(DeletedUsersIndex::class);
+        $this->mocks['ocConfig'] = $this->createMock(IConfig::class);
+        $this->mocks['db'] = $this->createMock(IDBConnection::class);
+        $this->mocks['helper'] = $this->createMock(Helper::class);
+        $this->mocks['timeFactory'] = $this->createMock(ITimeFactory::class);
+    }
+
+    /**
+     * clean up job must not run when there are disabled configurations
+     */
+    public function test_runNotAllowedByDisabledConfigurations(): void {
+        $this->mocks['helper']->expects($this->once())
+            ->method('haveDisabledConfigurations')
+            ->willReturn(true);
+
+        $this->mocks['ocConfig']->expects($this->never())
+            ->method('getSystemValue');
+
+        $result = $this->bgJob->isCleanUpAllowed();
+        $this->assertSame(false, $result);
+    }
+
+    /**
+     * clean up job must not run when LDAP Helper is broken i.e.
+     * returning unexpected results
+     */
+    public function test_runNotAllowedByBrokenHelper(): void {
+        $this->mocks['helper']->expects($this->once())
+            ->method('haveDisabledConfigurations')
+            ->will($this->throwException(new Exception()));
+
+        $this->mocks['ocConfig']->expects($this->never())
+            ->method('getSystemValue');
+
+        $result = $this->bgJob->isCleanUpAllowed();
+        $this->assertSame(false, $result);
+    }
+
+    /**
+     * clean up job must not run when it is not enabled
+     */
+    public function test_runNotAllowedBySysConfig(): void {
+        $this->mocks['helper']->expects($this->once())
+            ->method('haveDisabledConfigurations')
+            ->willReturn(false);
+
+        $this->mocks['ocConfig']->expects($this->once())
+            ->method('getSystemValue')
+            ->willReturn(false);
+
+        $result = $this->bgJob->isCleanUpAllowed();
+        $this->assertSame(false, $result);
+    }
+
+    /**
+     * clean up job is allowed to run
+     */
+    public function test_runIsAllowed(): void {
+        $this->mocks['helper']->expects($this->once())
+            ->method('haveDisabledConfigurations')
+            ->willReturn(false);
+
+        $this->mocks['ocConfig']->expects($this->once())
+            ->method('getSystemValue')
+            ->willReturn(true);
+
+        $result = $this->bgJob->isCleanUpAllowed();
+        $this->assertSame(true, $result);
+    }
+
+    /**
+     * check whether offset will be reset when it needs to
+     */
+    public function test_OffsetResetIsNecessary(): void {
+        $result = $this->bgJob->isOffsetResetNecessary($this->bgJob->getChunkSize() - 1);
+        $this->assertSame(true, $result);
+    }
+
+    /**
+     * make sure offset is not reset when it is not due
+     */
+    public function test_OffsetResetIsNotNecessary(): void {
+        $result = $this->bgJob->isOffsetResetNecessary($this->bgJob->getChunkSize());
+        $this->assertSame(false, $result);
+    }
 }

apps/user_ldap/tests/Service/UpdateGroupsServiceTest.php

Indentation +100 added lines, -100 removed lines

@@ -24,114 +24,114 @@
 use Test\TestCase;
 
 class UpdateGroupsServiceTest extends TestCase {
-	protected Group_Proxy&MockObject $groupBackend;
-	protected IEventDispatcher&MockObject $dispatcher;
-	protected IGroupManager&MockObject $groupManager;
-	protected IUserManager&MockObject $userManager;
-	protected LoggerInterface&MockObject $logger;
-	protected GroupMembershipMapper&MockObject $groupMembershipMapper;
-	protected UpdateGroupsService $updateGroupsService;
+    protected Group_Proxy&MockObject $groupBackend;
+    protected IEventDispatcher&MockObject $dispatcher;
+    protected IGroupManager&MockObject $groupManager;
+    protected IUserManager&MockObject $userManager;
+    protected LoggerInterface&MockObject $logger;
+    protected GroupMembershipMapper&MockObject $groupMembershipMapper;
+    protected UpdateGroupsService $updateGroupsService;
 
-	public function setUp(): void {
-		$this->groupBackend = $this->createMock(Group_Proxy::class);
-		$this->dispatcher = $this->createMock(IEventDispatcher::class);
-		$this->groupManager = $this->createMock(IGroupManager::class);
-		$this->userManager = $this->createMock(IUserManager::class);
-		$this->logger = $this->createMock(LoggerInterface::class);
-		$this->groupMembershipMapper = $this->createMock(GroupMembershipMapper::class);
+    public function setUp(): void {
+        $this->groupBackend = $this->createMock(Group_Proxy::class);
+        $this->dispatcher = $this->createMock(IEventDispatcher::class);
+        $this->groupManager = $this->createMock(IGroupManager::class);
+        $this->userManager = $this->createMock(IUserManager::class);
+        $this->logger = $this->createMock(LoggerInterface::class);
+        $this->groupMembershipMapper = $this->createMock(GroupMembershipMapper::class);
 
-		$this->updateGroupsService = new UpdateGroupsService(
-			$this->groupBackend,
-			$this->dispatcher,
-			$this->groupManager,
-			$this->userManager,
-			$this->logger,
-			$this->groupMembershipMapper,
-		);
-	}
+        $this->updateGroupsService = new UpdateGroupsService(
+            $this->groupBackend,
+            $this->dispatcher,
+            $this->groupManager,
+            $this->userManager,
+            $this->logger,
+            $this->groupMembershipMapper,
+        );
+    }
 
-	public function testHandleKnownGroups(): void {
-		$knownGroups = [
-			'emptyGroup' => [],
-			'stableGroup' => ['userA', 'userC', 'userE'],
-			'groupWithAdditions' => ['userA', 'userC', 'userE'],
-			'groupWithRemovals' => ['userA', 'userC', 'userDeleted', 'userE'],
-			'groupWithAdditionsAndRemovals' => ['userA', 'userC', 'userE'],
-			'vanishedGroup' => ['userB', 'userDeleted'],
-		];
-		$knownGroupsDB = [];
-		foreach ($knownGroups as $gid => $members) {
-			$knownGroupsDB[] = [
-				'owncloudname' => $gid,
-				'owncloudusers' => $members
-			];
-		}
-		$actualGroups = [
-			'emptyGroup' => [],
-			'stableGroup' => ['userA', 'userC', 'userE'],
-			'groupWithAdditions' => ['userA', 'userC', 'userE', 'userF'],
-			'groupWithRemovals' => ['userA', 'userE'],
-			'groupWithAdditionsAndRemovals' => ['userC', 'userE', 'userF'],
-			'newGroup' => ['userB', 'userF'],
-		];
-		$groups = array_intersect(array_keys($knownGroups), array_keys($actualGroups));
+    public function testHandleKnownGroups(): void {
+        $knownGroups = [
+            'emptyGroup' => [],
+            'stableGroup' => ['userA', 'userC', 'userE'],
+            'groupWithAdditions' => ['userA', 'userC', 'userE'],
+            'groupWithRemovals' => ['userA', 'userC', 'userDeleted', 'userE'],
+            'groupWithAdditionsAndRemovals' => ['userA', 'userC', 'userE'],
+            'vanishedGroup' => ['userB', 'userDeleted'],
+        ];
+        $knownGroupsDB = [];
+        foreach ($knownGroups as $gid => $members) {
+            $knownGroupsDB[] = [
+                'owncloudname' => $gid,
+                'owncloudusers' => $members
+            ];
+        }
+        $actualGroups = [
+            'emptyGroup' => [],
+            'stableGroup' => ['userA', 'userC', 'userE'],
+            'groupWithAdditions' => ['userA', 'userC', 'userE', 'userF'],
+            'groupWithRemovals' => ['userA', 'userE'],
+            'groupWithAdditionsAndRemovals' => ['userC', 'userE', 'userF'],
+            'newGroup' => ['userB', 'userF'],
+        ];
+        $groups = array_intersect(array_keys($knownGroups), array_keys($actualGroups));
 
-		$this->groupMembershipMapper->expects($this->never())
-			->method('getKnownGroups');
-		$this->groupMembershipMapper->expects($this->exactly(5))
-			->method('findGroupMemberships')
-			->willReturnCallback(
-				fn ($group) => array_map(
-					fn ($userid) => GroupMembership::fromParams(['groupid' => $group,'userid' => $userid]),
-					$knownGroups[$group]
-				)
-			);
-		$this->groupMembershipMapper->expects($this->exactly(3))
-			->method('delete');
-		$this->groupMembershipMapper->expects($this->exactly(2))
-			->method('insert');
+        $this->groupMembershipMapper->expects($this->never())
+            ->method('getKnownGroups');
+        $this->groupMembershipMapper->expects($this->exactly(5))
+            ->method('findGroupMemberships')
+            ->willReturnCallback(
+                fn ($group) => array_map(
+                    fn ($userid) => GroupMembership::fromParams(['groupid' => $group,'userid' => $userid]),
+                    $knownGroups[$group]
+                )
+            );
+        $this->groupMembershipMapper->expects($this->exactly(3))
+            ->method('delete');
+        $this->groupMembershipMapper->expects($this->exactly(2))
+            ->method('insert');
 
-		$this->groupBackend->expects($this->any())
-			->method('usersInGroup')
-			->willReturnCallback(function ($groupID) use ($actualGroups) {
-				return $actualGroups[$groupID] ?? [];
-			});
+        $this->groupBackend->expects($this->any())
+            ->method('usersInGroup')
+            ->willReturnCallback(function ($groupID) use ($actualGroups) {
+                return $actualGroups[$groupID] ?? [];
+            });
 
-		$this->groupManager->expects($this->any())
-			->method('get')
-			->willReturnCallback(function (string $groupId): ?IGroup {
-				if ($groupId === 'vanishedGroup') {
-					return null;
-				}
-				return $this->createMock(IGroup::class);
-			});
+        $this->groupManager->expects($this->any())
+            ->method('get')
+            ->willReturnCallback(function (string $groupId): ?IGroup {
+                if ($groupId === 'vanishedGroup') {
+                    return null;
+                }
+                return $this->createMock(IGroup::class);
+            });
 
-		$this->userManager->expects($this->exactly(5))
-			->method('get')
-			->willReturnCallback(function (string $userId) {
-				if ($userId === 'userDeleted') {
-					// user already deleted
-					return null;
-				}
-				return $this->createMock(IUser::class);
-			});
+        $this->userManager->expects($this->exactly(5))
+            ->method('get')
+            ->willReturnCallback(function (string $userId) {
+                if ($userId === 'userDeleted') {
+                    // user already deleted
+                    return null;
+                }
+                return $this->createMock(IUser::class);
+            });
 
-		$addedEvents = 0;
-		$removedEvents = 0;
-		$this->dispatcher->expects($this->exactly(4))
-			->method('dispatchTyped')
-			->willReturnCallback(function ($event) use (&$addedEvents, &$removedEvents): void {
-				if ($event instanceof UserRemovedEvent) {
-					$removedEvents++;
-				} elseif ($event instanceof UserAddedEvent) {
-					$addedEvents++;
-				}
-			});
+        $addedEvents = 0;
+        $removedEvents = 0;
+        $this->dispatcher->expects($this->exactly(4))
+            ->method('dispatchTyped')
+            ->willReturnCallback(function ($event) use (&$addedEvents, &$removedEvents): void {
+                if ($event instanceof UserRemovedEvent) {
+                    $removedEvents++;
+                } elseif ($event instanceof UserAddedEvent) {
+                    $addedEvents++;
+                }
+            });
 
-		$this->updateGroupsService->handleKnownGroups($groups);
+        $this->updateGroupsService->handleKnownGroups($groups);
 
-		$this->assertSame(2, $removedEvents);
-		$this->assertSame(2, $addedEvents);
-		// and no event for the user that is already deleted, the DB is nevertheless updated, hence 5
-	}
+        $this->assertSame(2, $removedEvents);
+        $this->assertSame(2, $addedEvents);
+        // and no event for the user that is already deleted, the DB is nevertheless updated, hence 5
+    }
 }

apps/user_ldap/tests/Service/BirthdateParserServiceTest.php

Indentation +37 added lines, -37 removed lines

@@ -13,41 +13,41 @@
 use PHPUnit\Framework\TestCase;
 
 class BirthdateParserServiceTest extends TestCase {
-	private BirthdateParserService $service;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->service = new BirthdateParserService();
-	}
-
-	public static function parseBirthdateDataProvider(): array {
-		return [
-			['2024-01-01', new DateTimeImmutable('2024-01-01'), false],
-			['20240101', new DateTimeImmutable('2024-01-01'), false],
-			['199412161032Z', new DateTimeImmutable('1994-12-16'), false], // LDAP generalized time
-			['199412160532-0500', new DateTimeImmutable('1994-12-16'), false], // LDAP generalized time
-			['2023-07-31T00:60:59.000Z', null, true],
-			['01.01.2024', null, true],
-			['01/01/2024', null, true],
-			['01 01 2024', null, true],
-			['foobar', null, true],
-		];
-	}
-
-	/**
-	 * @dataProvider parseBirthdateDataProvider
-	 */
-	public function testParseBirthdate(
-		string $value,
-		?DateTimeImmutable $expected,
-		bool $shouldThrow,
-	): void {
-		if ($shouldThrow) {
-			$this->expectException(\InvalidArgumentException::class);
-		}
-
-		$actual = $this->service->parseBirthdate($value);
-		$this->assertEquals($expected, $actual);
-	}
+    private BirthdateParserService $service;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->service = new BirthdateParserService();
+    }
+
+    public static function parseBirthdateDataProvider(): array {
+        return [
+            ['2024-01-01', new DateTimeImmutable('2024-01-01'), false],
+            ['20240101', new DateTimeImmutable('2024-01-01'), false],
+            ['199412161032Z', new DateTimeImmutable('1994-12-16'), false], // LDAP generalized time
+            ['199412160532-0500', new DateTimeImmutable('1994-12-16'), false], // LDAP generalized time
+            ['2023-07-31T00:60:59.000Z', null, true],
+            ['01.01.2024', null, true],
+            ['01/01/2024', null, true],
+            ['01 01 2024', null, true],
+            ['foobar', null, true],
+        ];
+    }
+
+    /**
+     * @dataProvider parseBirthdateDataProvider
+     */
+    public function testParseBirthdate(
+        string $value,
+        ?DateTimeImmutable $expected,
+        bool $shouldThrow,
+    ): void {
+        if ($shouldThrow) {
+            $this->expectException(\InvalidArgumentException::class);
+        }
+
+        $actual = $this->service->parseBirthdate($value);
+        $this->assertEquals($expected, $actual);
+    }
 }