DoL\LdapBundle\Tests\Security\Authentication\LdapAuthenticationProviderTest

Complexity

Total Complexity

18

Size/Duplication

Total Lines	249
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	createToken()	0	3	1
A	createUserMock()	0	8	1
A	willBind()	0	6	1
A	testCheckAuthenticationKnownUserCredentialsAreErased()	0	8	1
A	assertValidAuthenticatedToken()	0	8	1
A	validTokensProvider()	0	5	1
A	testRetrieveUserUnexpectedError()	0	12	2
A	willRetrieveUser()	0	11	2
A	testAuthenticate()	0	11	1
A	testRetrieveUserReturnsUserFromTokenOnReauthentication()	0	14	1
A	testCheckAuthenticationWhenTokenNeedsReauthenticationWorksWithoutOriginalCredentials()	0	12	1
A	testCheckAuthenticationUnknownUserBadCredentials()	0	11	1
A	setUp()	0	10	1
A	testCheckAuthenticationKnownUserCredentialsChanged()	0	10	1
A	testRetrieveUserNotFound()	0	8	1
A	testCheckAuthenticationUnknownUserPasswordEmpty()	0	10	1

<?php

namespace DoL\LdapBundle\Tests\Security\Authentication;

use Exception;
use DoL\LdapBundle\Security\Authentication\LdapAuthenticationProvider;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Core\Authentication\Token\UsernamePasswordToken;
use Symfony\Component\Security\Core\Exception\AuthenticationServiceException;
use Symfony\Component\Security\Core\Exception\UsernameNotFoundException;
use Symfony\Component\Security\Core\User\UserCheckerInterface;
use Symfony\Component\Security\Core\User\UserInterface;

/**
 * @covers \DoL\LdapBundle\Security\Authentication\LdapAuthenticationProvider
 */
class LdapAuthenticationProviderTest extends \PHPUnit_Framework_TestCase
{
    /**
     * @var LdapAuthenticationProvider
     */
    protected $ldapAuthenticationProvider;

    /**
     * @var \Symfony\Component\Security\Core\User\UserProviderInterface|\PHPUnit_Framework_MockObject_MockObject
     */
    protected $userProvider;

    /**
     * @var \DoL\LdapBundle\Ldap\LdapManagerInterface|\PHPUnit_Framework_MockObject_MockObject
     */
    protected $ldapManager;

    /**
     * Sets up the fixture, for example, opens a network connection.
     * This method is called before a test is executed.
     */
    protected function setUp()
    {
        /** @var UserCheckerInterface|\PHPUnit_Framework_MockObject_MockObject $userChecker */
        $userChecker = $this->getMock('Symfony\Component\Security\Core\User\UserCheckerInterface');
        $providerKey = 'provider_key';
        $this->userProvider = $this->getMock('Symfony\Component\Security\Core\User\UserProviderInterface');
        $this->ldapManager = $this->getMock('DoL\LdapBundle\Ldap\LdapManagerInterface');
        $hideUserNotFoundExceptions = false;

        $this->ldapAuthenticationProvider = new LdapAuthenticationProvider($userChecker, $providerKey, $this->userProvider, $this->ldapManager, $hideUserNotFoundExceptions);
    }

    /**
     * @dataProvider validTokensProvider
     *
     * @param string $username
     * @param string $password
     */
    public function testAuthenticate($username, $password)
    {
        $user = $this->createUserMock();
        $token = $this->createToken($username, $password);

        $this->willRetrieveUser($username, $user);
        $this->willBind($user, $password);

        $authenticatedToken = $this->ldapAuthenticationProvider->authenticate($token);

        $this->assertValidAuthenticatedToken($authenticatedToken, $user);
    }

    public function validTokensProvider()
    {
        return [
            'normal' => ['test_username', 'password'],
            'password_0' => ['test_username', '0'],
        ];
    }

    /**
     * @expectedException \Symfony\Component\Security\Core\Exception\UsernameNotFoundException
     */
    public function testRetrieveUserNotFound()
    {
        $username = 'notfound_username';
        $token = $this->createToken($username, 'password');

        $this->willRetrieveUser($username, new UsernameNotFoundException(''));

        $this->ldapAuthenticationProvider->authenticate($token);
    }

    public function testRetrieveUserUnexpectedError()
    {
        $username = 'username';
        $token = $this->createToken($username, 'password');

        $this->willRetrieveUser($username, new Exception(''));

        try {
            $this->ldapAuthenticationProvider->authenticate($token);
            self::fail('Expected Symfony\Component\Security\Core\Exception\AuthenticationServiceException to be thrown');
        } catch (AuthenticationServiceException $authenticationException) {
            self::assertEquals($token, $authenticationException->getToken());
        }
    }

    public function testRetrieveUserReturnsUserFromTokenOnReauthentication()
    {
        $user = $this->createUserMock();
        $password = 'password';
        $token = $this->createToken($user, $password);

        $this->userProvider->expects($this->never())
            ->method('loadUserByUsername');

        $this->willBind($user, $password);

        $authenticatedToken = $this->ldapAuthenticationProvider->authenticate($token);

        $this->assertValidAuthenticatedToken($authenticatedToken, $user);
    }

    public function testCheckAuthenticationWhenTokenNeedsReauthenticationWorksWithoutOriginalCredentials()
    {
        $password = 'password';
        $user = $this->createUserMock();

        $token = $this->createToken($user, $password);

        $this->willBind($user, $password);

        $authenticatedToken = $this->ldapAuthenticationProvider->authenticate($token);

        $this->assertValidAuthenticatedToken($authenticatedToken, $user);
    }

    /**
     * @expectedException \Symfony\Component\Security\Core\Exception\BadCredentialsException
     * @expectedExceptionMessage The password in the token is empty. You may forgive turn off `erase_credentials` in your `security.yml`
     */
    public function testCheckAuthenticationKnownUserCredentialsAreErased()
    {
        $password = '';
        $user = $this->createUserMock();

        $token = $this->createToken($user, $password);

        $this->ldapAuthenticationProvider->authenticate($token);
    }

    /**
     * @expectedException \Symfony\Component\Security\Core\Exception\BadCredentialsException
     * @expectedExceptionMessage The credentials were changed from another session.
     */
    public function testCheckAuthenticationKnownUserCredentialsChanged()
    {
        $password = 'other_password';
        $user = $this->createUserMock();

        $token = $this->createToken($user, $password);

        $this->willBind($user, $password, false);

        $this->ldapAuthenticationProvider->authenticate($token);
    }

    /**
     * @expectedException \Symfony\Component\Security\Core\Exception\BadCredentialsException
     * @expectedExceptionMessage The presented password is invalid.
     */
    public function testCheckAuthenticationUnknownUserBadCredentials()
    {
        $username = 'test_username';
        $password = 'bad_password';
        $user = $this->createUserMock();
        $token = $this->createToken($username, $password);

        $this->willRetrieveUser($username, $user);
        $this->willBind($user, $password, false);

        $this->ldapAuthenticationProvider->authenticate($token);
    }

    /**
     * @expectedException \Symfony\Component\Security\Core\Exception\BadCredentialsException
     * @expectedExceptionMessage The presented password cannot be empty.
     */
    public function testCheckAuthenticationUnknownUserPasswordEmpty()
    {
        $username = 'test_username';
        $password = '';
        $user = $this->createUserMock();

        $this->willRetrieveUser($username, $user);
        $token = $this->createToken($username, $password);

        $this->ldapAuthenticationProvider->authenticate($token);
    }

    /**
     * @return UserInterface|\PHPUnit_Framework_MockObject_MockObject
     */
    private function createUserMock()
    {
        $user = $this->getMock('Symfony\Component\Security\Core\User\UserInterface');
        $user->expects($this->any())
            ->method('getRoles')
            ->willReturn([]);

        return $user;
    }

    /**
     * @param TokenInterface $authenticatedToken
     * @param UserInterface  $expectedUser
     */
    private function assertValidAuthenticatedToken($authenticatedToken, UserInterface $expectedUser)
    {
        self::assertInstanceOf(
            'Symfony\Component\Security\Core\Authentication\Token\TokenInterface',
            $authenticatedToken
        );

        self::assertEquals($expectedUser, $authenticatedToken->getUser());
        //self::assertTrue($authenticatedToken->isAuthenticated());
    }

    /**
     * @param UserInterface|string|object $user
     * @param string                      $credentials
     *
     * @return UsernamePasswordToken
     */
    private function createToken($user, $credentials)
    {
        return new UsernamePasswordToken($user, $credentials, 'provider_key');
    }

    /**
     * @param UserInterface $user
     * @param string        $password
     * @param bool          $result
     */
    private function willBind(UserInterface $user, $password, $result = true)
    {
        $this->ldapManager->expects($this->once())
            ->method('bind')
            ->with($this->equalTo($user), $this->equalTo($password))
            ->will($this->returnValue($result))
        ;
    }

    /**
     * @param string                  $username
     * @param UserInterface|Exception $userOrException
     */
    private function willRetrieveUser($username, $userOrException)
    {
        $mock = $this->userProvider->expects($this->atMost(1))
            ->method('loadUserByUsername')
            ->with($this->equalTo($username))
        ;

        if ($userOrException instanceof Exception) {
            $mock->will($this->throwException($userOrException));
        } else {
            $mock->will($this->returnValue($userOrException));
        }
    }
}