[Ldap] Deprecate '{username}' parameter use in favour of '{user_identifier}' in LDAP configuration

EXT - THERAGE Kevin · nicolas-grekas · commit 9a84fad3a4ab · 2022-07-28T14:53:06.000+02:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,6 +1,11 @@
 CHANGELOG
 =========
 
+6.2
+---
+
+ * Deprecate `{username}` parameter use in favour of `{user_identifier}`
+
 6.1
 ---
 
diff --git a/Security/CheckLdapCredentialsListener.php b/Security/CheckLdapCredentialsListener.php
@@ -83,17 +83,17 @@ public function onCheckPassport(CheckPassportEvent $event)
                 } else {
                     throw new LogicException('Using the "query_string" config without using a "search_dn" and a "search_password" is not supported.');
                 }
-                $username = $ldap->escape($user->getUserIdentifier(), '', LdapInterface::ESCAPE_FILTER);
-                $query = str_replace('{username}', $username, $ldapBadge->getQueryString());
+                $identifier = $ldap->escape($user->getUserIdentifier(), '', LdapInterface::ESCAPE_FILTER);
+                $query = str_replace('{user_identifier}', $identifier, $ldapBadge->getQueryString());
                 $result = $ldap->query($ldapBadge->getDnString(), $query)->execute();
                 if (1 !== $result->count()) {
-                    throw new BadCredentialsException('The presented username is invalid.');
+                    throw new BadCredentialsException('The presented user identifier is invalid.');
                 }
 
                 $dn = $result[0]->getDn();
             } else {
-                $username = $ldap->escape($user->getUserIdentifier(), '', LdapInterface::ESCAPE_DN);
-                $dn = str_replace('{username}', $username, $ldapBadge->getDnString());
+                $identifier = $ldap->escape($user->getUserIdentifier(), '', LdapInterface::ESCAPE_DN);
+                $dn = str_replace('{user_identifier}', $identifier, $ldapBadge->getDnString());
             }
 
             $ldap->bind($dn, $presentedPassword);
diff --git a/Security/LdapAuthenticator.php b/Security/LdapAuthenticator.php
@@ -42,7 +42,7 @@ class LdapAuthenticator implements AuthenticationEntryPointInterface, Interactiv
     private string $searchPassword;
     private string $queryString;
 
-    public function __construct(AuthenticatorInterface $authenticator, string $ldapServiceId, string $dnString = '{username}', string $searchDn = '', string $searchPassword = '', string $queryString = '')
+    public function __construct(AuthenticatorInterface $authenticator, string $ldapServiceId, string $dnString = '{user_identifier}', string $searchDn = '', string $searchPassword = '', string $queryString = '')
     {
         $this->authenticator = $authenticator;
         $this->ldapServiceId = $ldapServiceId;
diff --git a/Security/LdapBadge.php b/Security/LdapBadge.php
@@ -31,12 +31,20 @@ class LdapBadge implements BadgeInterface
     private string $searchPassword;
     private ?string $queryString;
 
-    public function __construct(string $ldapServiceId, string $dnString = '{username}', string $searchDn = '', string $searchPassword = '', string $queryString = null)
+    public function __construct(string $ldapServiceId, string $dnString = '{user_identifier}', string $searchDn = '', string $searchPassword = '', string $queryString = null)
     {
         $this->ldapServiceId = $ldapServiceId;
+        $dnString = str_replace('{username}', '{user_identifier}', $dnString, $replaceCount);
+        if ($replaceCount > 0) {
+            trigger_deprecation('symfony/ldap', '6.2', 'Using "{username}" parameter in LDAP configuration is deprecated, consider using "{user_identifier}" instead.');
+        }
         $this->dnString = $dnString;
         $this->searchDn = $searchDn;
         $this->searchPassword = $searchPassword;
+        $queryString = str_replace('{username}', '{user_identifier}', $queryString ?? '', $replaceCount);
+        if ($replaceCount > 0) {
+            trigger_deprecation('symfony/ldap', '6.2', 'Using "{username}" parameter in LDAP configuration is deprecated, consider using "{user_identifier}" instead.');
+        }
         $this->queryString = $queryString;
     }
 
diff --git a/Security/LdapUser.php b/Security/LdapUser.php
@@ -24,19 +24,19 @@
 class LdapUser implements UserInterface, PasswordAuthenticatedUserInterface, EquatableInterface
 {
     private Entry $entry;
-    private string $username;
+    private string $identifier;
     private ?string $password;
     private array $roles;
     private array $extraFields;
 
-    public function __construct(Entry $entry, string $username, #[\SensitiveParameter] ?string $password, array $roles = [], array $extraFields = [])
+    public function __construct(Entry $entry, string $identifier, #[\SensitiveParameter] ?string $password, array $roles = [], array $extraFields = [])
     {
-        if (!$username) {
+        if (!$identifier) {
             throw new \InvalidArgumentException('The username cannot be empty.');
         }
 
         $this->entry = $entry;
-        $this->username = $username;
+        $this->identifier = $identifier;
         $this->password = $password;
         $this->roles = $roles;
         $this->extraFields = $extraFields;
@@ -81,7 +81,7 @@ public function getUsername(): string
 
     public function getUserIdentifier(): string
     {
-        return $this->username;
+        return $this->identifier;
     }
 
     /**
diff --git a/Security/LdapUserProvider.php b/Security/LdapUserProvider.php
@@ -81,7 +81,11 @@ public function loadUserByIdentifier(string $identifier): UserInterface
         }
 
         $identifier = $this->ldap->escape($identifier, '', LdapInterface::ESCAPE_FILTER);
-        $query = str_replace(['{username}', '{user_identifier}'], $identifier, $this->defaultSearch);
+        $query = str_replace('{username}', '{user_identifier}', $this->defaultSearch, $replaceCount);
+        if ($replaceCount > 0) {
+            trigger_deprecation('symfony/ldap', '6.2', 'Using "{username}" parameter in LDAP configuration is deprecated, consider using "{user_identifier}" instead.');
+        }
+        $query = str_replace('{user_identifier}', $identifier, $query);
         $search = $this->ldap->query($this->baseDn, $query, ['filter' => 0 == \count($this->extraFields) ? '*' : $this->extraFields]);
 
         $entries = $search->execute();
diff --git a/Tests/Security/CheckLdapCredentialsListenerTest.php b/Tests/Security/CheckLdapCredentialsListenerTest.php
@@ -127,6 +127,43 @@ public function testBindFailureShouldThrowAnException()
         $listener->onCheckPassport($this->createEvent());
     }
 
+    /**
+     * @group legacy
+     *
+     * @dataProvider queryForDnProvider
+     */
+    public function testLegacyQueryForDn(string $dnString, string $queryString)
+    {
+        $collection = new class([new Entry('')]) extends \ArrayObject implements CollectionInterface {
+            public function toArray(): array
+            {
+                return $this->getArrayCopy();
+            }
+        };
+
+        $query = $this->createMock(QueryInterface::class);
+        $query->expects($this->once())->method('execute')->willReturn($collection);
+
+        $this->ldap
+            ->method('bind')
+            ->withConsecutive(
+                ['elsa', 'test1234A$']
+            );
+        $this->ldap->expects($this->any())->method('escape')->with('Wouter', '', LdapInterface::ESCAPE_FILTER)->willReturn('wouter');
+        $this->ldap->expects($this->once())->method('query')->with('{user_identifier}', 'wouter_test')->willReturn($query);
+
+        $listener = $this->createListener();
+        $listener->onCheckPassport($this->createEvent('s3cr3t', new LdapBadge('app.ldap', $dnString, 'elsa', 'test1234A$', $queryString)));
+    }
+
+    public function queryForDnProvider(): iterable
+    {
+        yield ['{username}', '{username}_test'];
+        yield ['{user_identifier}', '{username}_test'];
+        yield ['{username}', '{user_identifier}_test'];
+        yield ['{user_identifier}', '{user_identifier}_test'];
+    }
+
     public function testQueryForDn()
     {
         $collection = new class([new Entry('')]) extends \ArrayObject implements CollectionInterface {
@@ -145,16 +182,16 @@ public function toArray(): array
                 ['elsa', 'test1234A$']
             );
         $this->ldap->expects($this->any())->method('escape')->with('Wouter', '', LdapInterface::ESCAPE_FILTER)->willReturn('wouter');
-        $this->ldap->expects($this->once())->method('query')->with('{username}', 'wouter_test')->willReturn($query);
+        $this->ldap->expects($this->once())->method('query')->with('{user_identifier}', 'wouter_test')->willReturn($query);
 
         $listener = $this->createListener();
-        $listener->onCheckPassport($this->createEvent('s3cr3t', new LdapBadge('app.ldap', '{username}', 'elsa', 'test1234A$', '{username}_test')));
+        $listener->onCheckPassport($this->createEvent('s3cr3t', new LdapBadge('app.ldap', '{user_identifier}', 'elsa', 'test1234A$', '{user_identifier}_test')));
     }
 
     public function testEmptyQueryResultShouldThrowAnException()
     {
         $this->expectException(BadCredentialsException::class);
-        $this->expectExceptionMessage('The presented username is invalid.');
+        $this->expectExceptionMessage('The presented user identifier is invalid.');
 
         $collection = $this->createMock(CollectionInterface::class);
 
@@ -170,7 +207,7 @@ public function testEmptyQueryResultShouldThrowAnException()
         $this->ldap->expects($this->once())->method('query')->willReturn($query);
 
         $listener = $this->createListener();
-        $listener->onCheckPassport($this->createEvent('s3cr3t', new LdapBadge('app.ldap', '{username}', 'elsa', 'test1234A$', '{username}_test')));
+        $listener->onCheckPassport($this->createEvent('s3cr3t', new LdapBadge('app.ldap', '{user_identifier}', 'elsa', 'test1234A$', '{user_identifier}_test')));
     }
 
     private function createEvent($password = 's3cr3t', $ldapBadge = null)
diff --git a/Tests/Security/LdapUserProviderTest.php b/Tests/Security/LdapUserProviderTest.php
@@ -27,7 +27,7 @@
  */
 class LdapUserProviderTest extends TestCase
 {
-    public function testLoadUserByUsernameFailsIfCantConnectToLdap()
+    public function testLoadUserByIdentifierFailsIfCantConnectToLdap()
     {
         $this->expectException(ConnectionException::class);
 
@@ -42,7 +42,7 @@ public function testLoadUserByUsernameFailsIfCantConnectToLdap()
         $provider->loadUserByIdentifier('foo');
     }
 
-    public function testLoadUserByUsernameFailsIfNoLdapEntries()
+    public function testLoadUserByIdentifierFailsIfNoLdapEntries()
     {
         $this->expectException(UserNotFoundException::class);
 
@@ -74,7 +74,7 @@ public function testLoadUserByUsernameFailsIfNoLdapEntries()
         $provider->loadUserByIdentifier('foo');
     }
 
-    public function testLoadUserByUsernameFailsIfMoreThanOneLdapEntry()
+    public function testLoadUserByIdentifierFailsIfMoreThanOneLdapEntry()
     {
         $this->expectException(UserNotFoundException::class);
 
@@ -106,7 +106,7 @@ public function testLoadUserByUsernameFailsIfMoreThanOneLdapEntry()
         $provider->loadUserByIdentifier('foo');
     }
 
-    public function testLoadUserByUsernameFailsIfMoreThanOneLdapPasswordsInEntry()
+    public function testLoadUserByIdentifierFailsIfMoreThanOneLdapPasswordsInEntry()
     {
         $this->expectException(InvalidArgumentException::class);
 
@@ -143,11 +143,11 @@ public function testLoadUserByUsernameFailsIfMoreThanOneLdapPasswordsInEntry()
             ->willReturn($query)
         ;
 
-        $provider = new LdapUserProvider($ldap, 'ou=MyBusiness,dc=symfony,dc=com', null, null, [], 'sAMAccountName', '({uid_key}={username})', 'userpassword');
+        $provider = new LdapUserProvider($ldap, 'ou=MyBusiness,dc=symfony,dc=com', null, null, [], 'sAMAccountName', '({uid_key}={user_identifier})', 'userpassword');
         $this->assertInstanceOf(LdapUser::class, $provider->loadUserByIdentifier('foo'));
     }
 
-    public function testLoadUserByUsernameShouldNotFailIfEntryHasNoUidKeyAttribute()
+    public function testLoadUserByIdentifierShouldNotFailIfEntryHasNoUidKeyAttribute()
     {
         $result = $this->createMock(CollectionInterface::class);
         $query = $this->createMock(QueryInterface::class);
@@ -179,11 +179,11 @@ public function testLoadUserByUsernameShouldNotFailIfEntryHasNoUidKeyAttribute()
             ->willReturn($query)
         ;
 
-        $provider = new LdapUserProvider($ldap, 'ou=MyBusiness,dc=symfony,dc=com', null, null, [], 'sAMAccountName', '({uid_key}={username})');
+        $provider = new LdapUserProvider($ldap, 'ou=MyBusiness,dc=symfony,dc=com', null, null, [], 'sAMAccountName', '({uid_key}={user_identifier})');
         $this->assertInstanceOf(LdapUser::class, $provider->loadUserByIdentifier('foo'));
     }
 
-    public function testLoadUserByUsernameFailsIfEntryHasNoPasswordAttribute()
+    public function testLoadUserByIdentifierFailsIfEntryHasNoPasswordAttribute()
     {
         $this->expectException(InvalidArgumentException::class);
 
@@ -217,11 +217,11 @@ public function testLoadUserByUsernameFailsIfEntryHasNoPasswordAttribute()
             ->willReturn($query)
         ;
 
-        $provider = new LdapUserProvider($ldap, 'ou=MyBusiness,dc=symfony,dc=com', null, null, [], 'sAMAccountName', '({uid_key}={username})', 'userpassword');
+        $provider = new LdapUserProvider($ldap, 'ou=MyBusiness,dc=symfony,dc=com', null, null, [], 'sAMAccountName', '({uid_key}={user_identifier})', 'userpassword');
         $this->assertInstanceOf(LdapUser::class, $provider->loadUserByIdentifier('foo'));
     }
 
-    public function testLoadUserByUsernameIsSuccessfulWithoutPasswordAttribute()
+    public function testLoadUserByIdentifierIsSuccessfulWithoutPasswordAttribute()
     {
         $result = $this->createMock(CollectionInterface::class);
         $query = $this->createMock(QueryInterface::class);
@@ -257,7 +257,7 @@ public function testLoadUserByUsernameIsSuccessfulWithoutPasswordAttribute()
         $this->assertInstanceOf(LdapUser::class, $provider->loadUserByIdentifier('foo'));
     }
 
-    public function testLoadUserByUsernameIsSuccessfulWithoutPasswordAttributeAndWrongCase()
+    public function testLoadUserByIdentifierIsSuccessfulWithoutPasswordAttributeAndWrongCase()
     {
         $result = $this->createMock(CollectionInterface::class);
         $query = $this->createMock(QueryInterface::class);
@@ -293,7 +293,7 @@ public function testLoadUserByUsernameIsSuccessfulWithoutPasswordAttributeAndWro
         $this->assertSame('foo', $provider->loadUserByIdentifier('Foo')->getUserIdentifier());
     }
 
-    public function testLoadUserByUsernameIsSuccessfulWithPasswordAttribute()
+    public function testLoadUserByIdentifierIsSuccessfulWithPasswordAttribute()
     {
         $result = $this->createMock(CollectionInterface::class);
         $query = $this->createMock(QueryInterface::class);
@@ -329,14 +329,14 @@ public function testLoadUserByUsernameIsSuccessfulWithPasswordAttribute()
             ->willReturn($query)
         ;
 
-        $provider = new LdapUserProvider($ldap, 'ou=MyBusiness,dc=symfony,dc=com', null, null, [], 'sAMAccountName', '({uid_key}={username})', 'userpassword', ['email']);
+        $provider = new LdapUserProvider($ldap, 'ou=MyBusiness,dc=symfony,dc=com', null, null, [], 'sAMAccountName', '({uid_key}={user_identifier})', 'userpassword', ['email']);
         $this->assertInstanceOf(LdapUser::class, $provider->loadUserByIdentifier('foo'));
     }
 
     public function testRefreshUserShouldReturnUserWithSameProperties()
     {
         $ldap = $this->createMock(LdapInterface::class);
-        $provider = new LdapUserProvider($ldap, 'ou=MyBusiness,dc=symfony,dc=com', null, null, [], 'sAMAccountName', '({uid_key}={username})', 'userpassword', ['email']);
+        $provider = new LdapUserProvider($ldap, 'ou=MyBusiness,dc=symfony,dc=com', null, null, [], 'sAMAccountName', '({uid_key}={user_identifier})', 'userpassword', ['email']);
 
         $user = new LdapUser(new Entry('foo'), 'foo', 'bar', ['ROLE_DUMMY'], ['email' => 'foo@symfony.com']);
 
diff --git a/composer.json b/composer.json
@@ -18,6 +18,7 @@
     "require": {
         "php": ">=8.1",
         "ext-ldap": "*",
+        "symfony/deprecation-contracts": "^2.1|^3",
         "symfony/options-resolver": "^5.4|^6.0"
     },
     "require-dev": {

Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ class LdapAuthenticator implements AuthenticationEntryPointInterface, Interactiv`
`42`	`42`	`private string $searchPassword;`
`43`	`43`	`private string $queryString;`
`44`	`44`
`45`		`- public function __construct(AuthenticatorInterface $authenticator, string $ldapServiceId, string $dnString = '{username}', string $searchDn = '', string $searchPassword = '', string $queryString = '')`
	`45`	`+ public function __construct(AuthenticatorInterface $authenticator, string $ldapServiceId, string $dnString = '{user_identifier}', string $searchDn = '', string $searchPassword = '', string $queryString = '')`
`46`	`46`	`{`
`47`	`47`	`$this->authenticator = $authenticator;`
`48`	`48`	`$this->ldapServiceId = $ldapServiceId;`
Original file line number	Diff line number	Diff line change
`@@ -24,19 +24,19 @@`
`24`	`24`	`class LdapUser implements UserInterface, PasswordAuthenticatedUserInterface, EquatableInterface`
`25`	`25`	`{`
`26`	`26`	`private Entry $entry;`
`27`		`- private string $username;`
	`27`	`+ private string $identifier;`
`28`	`28`	`private ?string $password;`
`29`	`29`	`private array $roles;`
`30`	`30`	`private array $extraFields;`
`31`	`31`
`32`		`- public function __construct(Entry $entry, string $username, #[\SensitiveParameter] ?string $password, array $roles = [], array $extraFields = [])`
	`32`	`+ public function __construct(Entry $entry, string $identifier, #[\SensitiveParameter] ?string $password, array $roles = [], array $extraFields = [])`
`33`	`33`	`{`
`34`		`- if (!$username) {`
	`34`	`+ if (!$identifier) {`
`35`	`35`	`throw new \InvalidArgumentException('The username cannot be empty.');`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`$this->entry = $entry;`
`39`		`- $this->username = $username;`
	`39`	`+ $this->identifier = $identifier;`
`40`	`40`	`$this->password = $password;`
`41`	`41`	`$this->roles = $roles;`
`42`	`42`	`$this->extraFields = $extraFields;`
`@@ -81,7 +81,7 @@ public function getUsername(): string`
`81`	`81`
`82`	`82`	`public function getUserIdentifier(): string`
`83`	`83`	`{`
`84`		`- return $this->username;`
	`84`	`+ return $this->identifier;`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@`
`27`	`27`	`*/`
`28`	`28`	`class LdapUserProviderTest extends TestCase`
`29`	`29`	`{`
`30`		`- public function testLoadUserByUsernameFailsIfCantConnectToLdap()`
	`30`	`+ public function testLoadUserByIdentifierFailsIfCantConnectToLdap()`
`31`	`31`	`{`
`32`	`32`	`$this->expectException(ConnectionException::class);`
`33`	`33`
`@@ -42,7 +42,7 @@ public function testLoadUserByUsernameFailsIfCantConnectToLdap()`
`42`	`42`	`$provider->loadUserByIdentifier('foo');`
`43`	`43`	`}`
`44`	`44`
`45`		`- public function testLoadUserByUsernameFailsIfNoLdapEntries()`
	`45`	`+ public function testLoadUserByIdentifierFailsIfNoLdapEntries()`
`46`	`46`	`{`
`47`	`47`	`$this->expectException(UserNotFoundException::class);`
`48`	`48`
`@@ -74,7 +74,7 @@ public function testLoadUserByUsernameFailsIfNoLdapEntries()`
`74`	`74`	`$provider->loadUserByIdentifier('foo');`
`75`	`75`	`}`
`76`	`76`
`77`		`- public function testLoadUserByUsernameFailsIfMoreThanOneLdapEntry()`
	`77`	`+ public function testLoadUserByIdentifierFailsIfMoreThanOneLdapEntry()`
`78`	`78`	`{`
`79`	`79`	`$this->expectException(UserNotFoundException::class);`
`80`	`80`
`@@ -106,7 +106,7 @@ public function testLoadUserByUsernameFailsIfMoreThanOneLdapEntry()`
`106`	`106`	`$provider->loadUserByIdentifier('foo');`
`107`	`107`	`}`
`108`	`108`
`109`		`- public function testLoadUserByUsernameFailsIfMoreThanOneLdapPasswordsInEntry()`
	`109`	`+ public function testLoadUserByIdentifierFailsIfMoreThanOneLdapPasswordsInEntry()`
`110`	`110`	`{`
`111`	`111`	`$this->expectException(InvalidArgumentException::class);`
`112`	`112`
`@@ -143,11 +143,11 @@ public function testLoadUserByUsernameFailsIfMoreThanOneLdapPasswordsInEntry()`
`143`	`143`	`->willReturn($query)`
`144`	`144`	`;`
`145`	`145`
`146`		`- $provider = new LdapUserProvider($ldap, 'ou=MyBusiness,dc=symfony,dc=com', null, null, [], 'sAMAccountName', '({uid_key}={username})', 'userpassword');`
	`146`	`+ $provider = new LdapUserProvider($ldap, 'ou=MyBusiness,dc=symfony,dc=com', null, null, [], 'sAMAccountName', '({uid_key}={user_identifier})', 'userpassword');`
`147`	`147`	`$this->assertInstanceOf(LdapUser::class, $provider->loadUserByIdentifier('foo'));`
`148`	`148`	`}`
`149`	`149`
`150`		`- public function testLoadUserByUsernameShouldNotFailIfEntryHasNoUidKeyAttribute()`
	`150`	`+ public function testLoadUserByIdentifierShouldNotFailIfEntryHasNoUidKeyAttribute()`
`151`	`151`	`{`
`152`	`152`	`$result = $this->createMock(CollectionInterface::class);`
`153`	`153`	`$query = $this->createMock(QueryInterface::class);`
`@@ -179,11 +179,11 @@ public function testLoadUserByUsernameShouldNotFailIfEntryHasNoUidKeyAttribute()`
`179`	`179`	`->willReturn($query)`
`180`	`180`	`;`
`181`	`181`
`182`		`- $provider = new LdapUserProvider($ldap, 'ou=MyBusiness,dc=symfony,dc=com', null, null, [], 'sAMAccountName', '({uid_key}={username})');`
	`182`	`+ $provider = new LdapUserProvider($ldap, 'ou=MyBusiness,dc=symfony,dc=com', null, null, [], 'sAMAccountName', '({uid_key}={user_identifier})');`
`183`	`183`	`$this->assertInstanceOf(LdapUser::class, $provider->loadUserByIdentifier('foo'));`
`184`	`184`	`}`
`185`	`185`
`186`		`- public function testLoadUserByUsernameFailsIfEntryHasNoPasswordAttribute()`
	`186`	`+ public function testLoadUserByIdentifierFailsIfEntryHasNoPasswordAttribute()`
`187`	`187`	`{`
`188`	`188`	`$this->expectException(InvalidArgumentException::class);`
`189`	`189`
`@@ -217,11 +217,11 @@ public function testLoadUserByUsernameFailsIfEntryHasNoPasswordAttribute()`
`217`	`217`	`->willReturn($query)`
`218`	`218`	`;`
`219`	`219`
`220`		`- $provider = new LdapUserProvider($ldap, 'ou=MyBusiness,dc=symfony,dc=com', null, null, [], 'sAMAccountName', '({uid_key}={username})', 'userpassword');`
	`220`	`+ $provider = new LdapUserProvider($ldap, 'ou=MyBusiness,dc=symfony,dc=com', null, null, [], 'sAMAccountName', '({uid_key}={user_identifier})', 'userpassword');`
`221`	`221`	`$this->assertInstanceOf(LdapUser::class, $provider->loadUserByIdentifier('foo'));`
`222`	`222`	`}`
`223`	`223`
`224`		`- public function testLoadUserByUsernameIsSuccessfulWithoutPasswordAttribute()`
	`224`	`+ public function testLoadUserByIdentifierIsSuccessfulWithoutPasswordAttribute()`
`225`	`225`	`{`
`226`	`226`	`$result = $this->createMock(CollectionInterface::class);`
`227`	`227`	`$query = $this->createMock(QueryInterface::class);`
`@@ -257,7 +257,7 @@ public function testLoadUserByUsernameIsSuccessfulWithoutPasswordAttribute()`
`257`	`257`	`$this->assertInstanceOf(LdapUser::class, $provider->loadUserByIdentifier('foo'));`
`258`	`258`	`}`
`259`	`259`
`260`		`- public function testLoadUserByUsernameIsSuccessfulWithoutPasswordAttributeAndWrongCase()`
	`260`	`+ public function testLoadUserByIdentifierIsSuccessfulWithoutPasswordAttributeAndWrongCase()`
`261`	`261`	`{`
`262`	`262`	`$result = $this->createMock(CollectionInterface::class);`
`263`	`263`	`$query = $this->createMock(QueryInterface::class);`
`@@ -293,7 +293,7 @@ public function testLoadUserByUsernameIsSuccessfulWithoutPasswordAttributeAndWro`
`293`	`293`	`$this->assertSame('foo', $provider->loadUserByIdentifier('Foo')->getUserIdentifier());`
`294`	`294`	`}`
`295`	`295`
`296`		`- public function testLoadUserByUsernameIsSuccessfulWithPasswordAttribute()`
	`296`	`+ public function testLoadUserByIdentifierIsSuccessfulWithPasswordAttribute()`
`297`	`297`	`{`
`298`	`298`	`$result = $this->createMock(CollectionInterface::class);`
`299`	`299`	`$query = $this->createMock(QueryInterface::class);`
`@@ -329,14 +329,14 @@ public function testLoadUserByUsernameIsSuccessfulWithPasswordAttribute()`
`329`	`329`	`->willReturn($query)`
`330`	`330`	`;`
`331`	`331`
`332`		`- $provider = new LdapUserProvider($ldap, 'ou=MyBusiness,dc=symfony,dc=com', null, null, [], 'sAMAccountName', '({uid_key}={username})', 'userpassword', ['email']);`
	`332`	`+ $provider = new LdapUserProvider($ldap, 'ou=MyBusiness,dc=symfony,dc=com', null, null, [], 'sAMAccountName', '({uid_key}={user_identifier})', 'userpassword', ['email']);`
`333`	`333`	`$this->assertInstanceOf(LdapUser::class, $provider->loadUserByIdentifier('foo'));`
`334`	`334`	`}`
`335`	`335`
`336`	`336`	`public function testRefreshUserShouldReturnUserWithSameProperties()`
`337`	`337`	`{`
`338`	`338`	`$ldap = $this->createMock(LdapInterface::class);`
`339`		`- $provider = new LdapUserProvider($ldap, 'ou=MyBusiness,dc=symfony,dc=com', null, null, [], 'sAMAccountName', '({uid_key}={username})', 'userpassword', ['email']);`
	`339`	`+ $provider = new LdapUserProvider($ldap, 'ou=MyBusiness,dc=symfony,dc=com', null, null, [], 'sAMAccountName', '({uid_key}={user_identifier})', 'userpassword', ['email']);`
`340`	`340`
`341`	`341`	`$user = new LdapUser(new Entry('foo'), 'foo', 'bar', ['ROLE_DUMMY'], ['email' => 'foo@symfony.com']);`
`342`	`342`