AuthorizationSubscriberTest - Code Metrics - Inspection of "added ORM mapping PROCERGS#666" - PROCERGS/login-cidadao - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — issue#666 ( 928a8e...2654e9 )

by Guilherme

created 2017-11-30 11:37 UTC

AuthorizationSubscriberTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	209
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

Metric	Value
dl	0
loc	209
rs	10
c	0
b	0
f	0
wmc	16
lcom	1
cbo	4

15 Methods

Rating	Name	Size	Complexity
A	testGetSubscribedEvents()	10	1
B	testOnNewAuthorizationRequest()	27	1
B	testOnRemoteClaimNotFound()	27	1
A	testOnNewAuthorization()	12	1
A	testOnUpdateAuthorization()	12	1
A	testOnRevokeAuthorizationWithRemoteClaims()	18	1
A	testOnRevokeAuthorizationWithoutRemoteClaims()	11	1
A	prepareEnforceRemoteClaimsTest()	21	1
A	getRemoteClaim()	6	1
A	getCompleteRemoteClaim()	12	2
A	getRemoteClaimManager()	4	1
A	getRemoteClaimFetcher()	4	1
A	getClient()	4	1
A	getEvent()	5	1
A	getPerson()	4	1

<?php
/**
 * This file is part of the login-cidadao project or it's bundles.
 *
 * (c) Guilherme Donato <guilhermednt on github>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace LoginCidadao\RemoteClaimsBundle\Tests\EventSubscriber;

use LoginCidadao\CoreBundle\Model\PersonInterface;
use LoginCidadao\OpenIDBundle\Event\AuthorizationEvent;
use LoginCidadao\OpenIDBundle\LoginCidadaoOpenIDEvents;
use LoginCidadao\RemoteClaimsBundle\EventSubscriber\AuthorizationSubscriber;
use LoginCidadao\RemoteClaimsBundle\Model\RemoteClaimFetcherInterface;
use LoginCidadao\RemoteClaimsBundle\Model\RemoteClaimManagerInterface;
use LoginCidadao\OAuthBundle\Model\ClientInterface;
use LoginCidadao\RemoteClaimsBundle\Model\TagUri;
use Psr\Log\LoggerInterface;
use Psr\Log\LogLevel;

class AuthorizationSubscriberTest extends \PHPUnit_Framework_TestCase
{
    public function testGetSubscribedEvents()
    {
        $this->assertEquals([
            LoginCidadaoOpenIDEvents::NEW_AUTHORIZATION_REQUEST => 'onNewAuthorizationRequest',
            LoginCidadaoOpenIDEvents::NEW_AUTHORIZATION => 'onNewAuthorization',
            LoginCidadaoOpenIDEvents::UPDATE_AUTHORIZATION => 'onUpdateAuthorization',
            LoginCidadaoOpenIDEvents::REVOKE_AUTHORIZATION => 'onRevokeAuthorization',
        ], AuthorizationSubscriber::getSubscribedEvents()
        );
    }

    public function testOnNewAuthorizationRequest()
    {
        $scope = [
            'openid',
            'simple_claim',
            'https://claim.provider.example.com/my-claim',
            'tag:example.com,2017:my_claim',
        ];

        $remoteClaims = [];

        $fetcher = $this->getRemoteClaimFetcher();
        $fetcher->expects($this->atLeastOnce())->method('getRemoteClaim')
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->willReturnCallback(function ($scope) use (&$remoteClaims) {
                $remoteClaims[] = $scope;

                return $this->getRemoteClaim();
            });

        $event = $this->getEvent();
        $event->expects($this->atLeastOnce())->method('getScope')->willReturn($scope);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $subscriber = new AuthorizationSubscriber($this->getRemoteClaimManager(), $fetcher);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        $subscriber->onNewAuthorizationRequest($event);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $this->assertCount(2, $remoteClaims);
    }

    public function testOnRemoteClaimNotFound()
    {
        $scope = [
            'openid',
            'simple_claim',
            'https://not.actually.a.remote.claim/fake',
        ];

        $remoteClaims = [];

        $fetcher = $this->getRemoteClaimFetcher();
        $fetcher->expects($this->atLeastOnce())->method('getRemoteClaim')
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->willThrowException(new \RuntimeException('Random error'));

        /** @var \PHPUnit_Framework_MockObject_MockObject|LoggerInterface $logger */
        $logger = $this->getMock('Psr\Log\LoggerInterface');
        $logger->expects($this->once())->method('log')->with(LogLevel::ERROR);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $event = $this->getEvent();
        $event->expects($this->atLeastOnce())->method('getScope')->willReturn($scope);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $subscriber = new AuthorizationSubscriber($this->getRemoteClaimManager(), $fetcher);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        $subscriber->setLogger($logger);
        $subscriber->onNewAuthorizationRequest($event);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $this->assertEmpty($remoteClaims);
    }

    public function testOnNewAuthorization()
    {
        $test = $this->prepareEnforceRemoteClaimsTest();

        /** @var AuthorizationSubscriber $subscriber */
        $subscriber = $test['subscriber'];

        /** @var AuthorizationEvent $event */
        $event = $test['event'];

        $subscriber->onNewAuthorization($event);
    }

    public function testOnUpdateAuthorization()
    {
        $test = $this->prepareEnforceRemoteClaimsTest();

        /** @var AuthorizationSubscriber $subscriber */
        $subscriber = $test['subscriber'];

        /** @var AuthorizationEvent $event */
        $event = $test['event'];

        $subscriber->onUpdateAuthorization($event);
    }

    public function testOnRevokeAuthorizationWithRemoteClaims()
    {
        $remoteClaims = [$this->getCompleteRemoteClaim(), $this->getCompleteRemoteClaim()];

        $authorization = $this->getMock('LoginCidadao\CoreBundle\Entity\Authorization');

        $event = $this->getEvent();
        $event->expects($this->once())->method('getRemoteClaims')->willReturn($remoteClaims);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $event->expects($this->once())->method('getAuthorization')->willReturn($authorization);

        $manager = $this->getRemoteClaimManager();
        $manager->expects($this->once())
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->method('revokeAllAuthorizations')
            ->with($this->isInstanceOf('LoginCidadao\CoreBundle\Entity\Authorization'));

        $subscriber = new AuthorizationSubscriber($manager, $this->getRemoteClaimFetcher());
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        $subscriber->onRevokeAuthorization($event);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }

    public function testOnRevokeAuthorizationWithoutRemoteClaims()
    {
        $event = $this->getEvent();
        $event->expects($this->once())->method('getRemoteClaims')->willReturn(null);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $manager = $this->getRemoteClaimManager();
        $manager->expects($this->never())->method('revokeAllAuthorizations');
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $subscriber = new AuthorizationSubscriber($manager, $this->getRemoteClaimFetcher());
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        $subscriber->onRevokeAuthorization($event);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }

    private function prepareEnforceRemoteClaimsTest()
    {
        $remoteClaims = [$this->getCompleteRemoteClaim(), $this->getCompleteRemoteClaim()];

        $event = $this->getEvent();
        $event->expects($this->once())->method('getRemoteClaims')->willReturn($remoteClaims);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $event->expects($this->exactly(2))->method('getClient')->willReturn($this->getClient());
        $event->expects($this->exactly(2))->method('getPerson')->willReturn($this->getPerson());

        $manager = $this->getRemoteClaimManager();
        $manager->expects($this->exactly(2))
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->method('enforceAuthorization')
            ->with($this->isInstanceOf('LoginCidadao\RemoteClaimsBundle\Model\RemoteClaimAuthorizationInterface'));

        $subscriber = new AuthorizationSubscriber($manager, $this->getRemoteClaimFetcher());
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        return [
            'subscriber' => $subscriber,
            'event' => $event,
        ];
    }

    private function getRemoteClaim()

    {
        $remoteClaim = $this->getMock('LoginCidadao\RemoteClaimsBundle\Model\RemoteClaimInterface');

        return $remoteClaim;
    }

    private function getCompleteRemoteClaim($name = null)

    {
        $provider = $this->getMock('LoginCidadao\RemoteClaimsBundle\Model\ClaimProviderInterface');

        $remoteClaim = $this->getRemoteClaim();
        $remoteClaim->expects($this->any())->method('getProvider')
            ->willReturn($provider);
        $remoteClaim->expects($this->any())->method('getName')
            ->willReturn($name ?: TagUri::createFromString('tag:example.com,2017:my_claim'));

        return $remoteClaim;
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|RemoteClaimManagerInterface
     */
    private function getRemoteClaimManager()
    {
        return $this->getMock('LoginCidadao\RemoteClaimsBundle\Model\RemoteClaimManagerInterface');
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|RemoteClaimFetcherInterface
     */
    private function getRemoteClaimFetcher()
    {
        return $this->getMock('LoginCidadao\RemoteClaimsBundle\Model\RemoteClaimFetcherInterface');
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|ClientInterface
     */
    private function getClient()
    {
        return $this->getMock('LoginCidadao\OAuthBundle\Model\ClientInterface');
    }

    /**
     * @return AuthorizationEvent|\PHPUnit_Framework_MockObject_MockObject
     */
    private function getEvent()
    {
        return $this->getMockBuilder('LoginCidadao\OpenIDBundle\Event\AuthorizationEvent')
            ->disableOriginalConstructor()->getMock();
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|PersonInterface
     */
    private function getPerson()
    {
        return $this->getMock('LoginCidadao\CoreBundle\Model\PersonInterface');
    }
}


Push — issue#666 ( 928a8e...2654e9 )

AuthorizationSubscriberTest A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

15 Methods

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php
2			/**
3			* This file is part of the login-cidadao project or it's bundles.
4			*
5			* (c) Guilherme Donato <guilhermednt on github>
6			*
7			* For the full copyright and license information, please view the LICENSE
8			* file that was distributed with this source code.
9			*/
10
11			namespace LoginCidadao\RemoteClaimsBundle\Tests\EventSubscriber;
12
13			use LoginCidadao\CoreBundle\Model\PersonInterface;
14			use LoginCidadao\OpenIDBundle\Event\AuthorizationEvent;
15			use LoginCidadao\OpenIDBundle\LoginCidadaoOpenIDEvents;
16			use LoginCidadao\RemoteClaimsBundle\EventSubscriber\AuthorizationSubscriber;
17			use LoginCidadao\RemoteClaimsBundle\Model\RemoteClaimFetcherInterface;
18			use LoginCidadao\RemoteClaimsBundle\Model\RemoteClaimManagerInterface;
19			use LoginCidadao\OAuthBundle\Model\ClientInterface;
20			use LoginCidadao\RemoteClaimsBundle\Model\TagUri;
21			use Psr\Log\LoggerInterface;
22			use Psr\Log\LogLevel;
23
24			class AuthorizationSubscriberTest extends \PHPUnit_Framework_TestCase
25			{
26			public function testGetSubscribedEvents()
27			{
28			$this->assertEquals([
29			LoginCidadaoOpenIDEvents::NEW_AUTHORIZATION_REQUEST => 'onNewAuthorizationRequest',
30			LoginCidadaoOpenIDEvents::NEW_AUTHORIZATION => 'onNewAuthorization',
31			LoginCidadaoOpenIDEvents::UPDATE_AUTHORIZATION => 'onUpdateAuthorization',
32			LoginCidadaoOpenIDEvents::REVOKE_AUTHORIZATION => 'onRevokeAuthorization',
33			], AuthorizationSubscriber::getSubscribedEvents()
34			);
35			}
36
37			public function testOnNewAuthorizationRequest()
38			{
39			$scope = [
40			'openid',

PROCERGS / login-cidadao

Push — issue#666 ( 928a8e...2654e9 )

AuthorizationSubscriberTest A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

15 Methods

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like