RemoteClaimFetcherTest::testFetchByTagUri() - Code Metrics - Inspection of "adding remote claims to the authorization page. PR..." - PROCERGS/login-cidadao - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — issue#666 ( 5bb037...827179 )

by Guilherme

created 2017-11-21 14:15 UTC

RemoteClaimFetcherTest::testFetchByTagUri() B

↳ Parent: RemoteClaimFetcherTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	28
Code Lines	20

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	20
c	0
b	0
f	0
nc	1
nop	0
dl	0
loc	28
rs	8.8571

<?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\Fetcher;

use Doctrine\ORM\EntityManagerInterface;
use LoginCidadao\OAuthBundle\Entity\ClientRepository;
use LoginCidadao\RemoteClaimsBundle\Entity\RemoteClaimRepository;
use LoginCidadao\RemoteClaimsBundle\Fetcher\RemoteClaimFetcher;
use LoginCidadao\RemoteClaimsBundle\Model\HttpUri;
use LoginCidadao\RemoteClaimsBundle\Tests\Http\HttpMocker;
use LoginCidadao\RemoteClaimsBundle\Tests\Parser\RemoteClaimParserTest;

class RemoteClaimFetcherTest extends \PHPUnit_Framework_TestCase
{
    /**
     * Test the Claim fetch using HTTP URI.
     */
    public function testFetchByHttpUri()
    {
        $uri = 'https://dummy.com';

        $data = RemoteClaimParserTest::$claimMetadata;

        $fetcher = $this->getFetcher(new HttpMocker($data));
        $remoteClaim = $fetcher->fetchRemoteClaim($uri);

        $this->assertInstanceOf('LoginCidadao\RemoteClaimsBundle\Model\RemoteClaimInterface', $remoteClaim);
        $this->assertEquals($data['claim_display_name'], $remoteClaim->getDisplayName());
    }

    /**
     * Test the Claim fetch using Tag URI.
     */
    public function testFetchByTagUri()
    {
        $uri = 'https://dummy.com';

        $data = RemoteClaimParserTest::$claimMetadata;
        $tagUri = $data['claim_name'];

        $httpMocker = new HttpMocker($data, $uri);
        $fetcher = $this->getFetcher($httpMocker);
        $remoteClaim = $fetcher->fetchRemoteClaim($tagUri);

        $requests = $httpMocker->getHistory()->getRequests();
        $firstRequest = reset($requests);

        $this->assertInstanceOf('LoginCidadao\RemoteClaimsBundle\Model\RemoteClaimInterface', $remoteClaim);
        $this->assertEquals($data['claim_display_name'], $remoteClaim->getDisplayName());
        $this->assertCount(2, $requests);

        $webFingerUrl = HttpUri::createFromString($firstRequest->getUrl());
        $this->assertEquals('https', $webFingerUrl->getScheme());
        $this->assertEquals('example.com', $webFingerUrl->getHost());
        $this->assertEquals('/.well-known/webfinger', $webFingerUrl->getPath());

        $webFingerParams = explode('&', $webFingerUrl->getQuery());
        $this->assertContains('rel=http%3A%2F%2Fopenid.net%2Fspecs%2Fconnect%2F1.0%2Fclaim', $webFingerParams);
        $encodedTag = urlencode($tagUri);
        $this->assertContains("resource={$encodedTag}", $webFingerParams);
    }

    public function testFetchNotFound()
    {
        $this->setExpectedException('Symfony\Component\HttpKernel\Exception\NotFoundHttpException');

        $tagUri = 'tag:example.com,2018:my_claim';
        $fetcher = $this->getFetcher();
        $fetcher->fetchRemoteClaim($tagUri);
    }

    /**
     * This test assumes the Remote Claim is already known by the IdP.
     * The existing Remote Claim is expected to be returned.
     */
    public function testExistingClaim()
    {
        $claimUri = 'https://dummy.com';

        $provider = $this->getMock('LoginCidadao\RemoteClaimsBundle\Model\ClaimProviderInterface');
        $provider->expects($this->once())->method('getRedirectUris')->willReturn(['https://redirect.uri']);

        $existingClaim = $this->getMock('LoginCidadao\RemoteClaimsBundle\Model\RemoteClaimInterface');
        $existingClaim->expects($this->once())->method('getProvider')->willReturn($provider);

        $claimRepository = $this->getClaimRepository();
        $claimRepository->expects($this->once())->method('findOneBy')->willReturn($existingClaim);
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.
}

        $clientRepository = $this->getClientRepository();
        $clientRepository->expects($this->once())->method('findByRedirectUris')->willReturn([$provider]);
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.
}

        $em = $this->getEntityManager();
        $em->expects($this->never())->method('persist');
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.
}

        $fetcher = $this->getFetcher(null, $em, $claimRepository, $clientRepository);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        $actual = $fetcher->getRemoteClaim($claimUri);

        $this->assertEquals($existingClaim, $actual);
    }

    /**
     * This method tests a new Remote Claim, unknown by the IdP.
     * The Claim MUST be fetched and persisted.
     */
    public function testNewClaim()
    {
        $claimUri = 'https://dummy.com';

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

        $existingClaim = null;

        $claimRepository = $this->getClaimRepository();
        $claimRepository->expects($this->once())->method('findOneBy')->willReturn($existingClaim);
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.
}

        $clientRepository = $this->getClientRepository();
        $clientRepository->expects($this->once())->method('findByRedirectUris')->willReturn([$provider]);
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.
}

        $em = $this->getEntityManager();
        $em->expects($this->once())->method('persist')
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.
}
            ->with($this->isInstanceOf('LoginCidadao\RemoteClaimsBundle\Model\RemoteClaimInterface'));

        $fetcher = $this->getFetcher(null, $em, $claimRepository, $clientRepository);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        $actual = $fetcher->getRemoteClaim($claimUri);

        $this->assertInstanceOf('LoginCidadao\RemoteClaimsBundle\Model\RemoteClaimInterface', $actual);
    }

    /**
     * Test that the method fails when the Claim Provider is not already persisted.
     */
    public function testNonExistentProvider()
    {
        $this->setExpectedException('LoginCidadao\RemoteClaimsBundle\Exception\ClaimProviderNotFoundException');
        $claimUri = 'https://dummy.com';

        $clientRepository = $this->getClientRepository();
        $clientRepository->expects($this->once())->method('findByRedirectUris')->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.
}

        $em = $this->getEntityManager();
        $em->expects($this->never())->method('persist');
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.
}

        $fetcher = $this->getFetcher(null, $em, null, $clientRepository);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        $fetcher->getRemoteClaim($claimUri);
    }

    /**
     * It should also fail when more than one Claim Provider is found.
     */
    public function testManyProviders()
    {
        $this->setExpectedException('\InvalidArgumentException');
        $claimUri = 'https://dummy.com';

        $provider1 = $this->getMock('LoginCidadao\RemoteClaimsBundle\Model\ClaimProviderInterface');
        $provider2 = $this->getMock('LoginCidadao\RemoteClaimsBundle\Model\ClaimProviderInterface');

        $clientRepository = $this->getClientRepository();
        $clientRepository->expects($this->once())->method('findByRedirectUris')->willReturn([$provider1, $provider2]);
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.
}

        $em = $this->getEntityManager();
        $em->expects($this->never())->method('persist');
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.
}

        $fetcher = $this->getFetcher(null, $em, null, $clientRepository);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        $fetcher->getRemoteClaim($claimUri);
    }

    /**
     * @param HttpMocker|null $httpMocker
     * @param EntityManagerInterface|null $em
     * @param RemoteClaimRepository|null $claimRepository
     * @param ClientRepository|null $clientRepository
     * @return RemoteClaimFetcher
     */
    private function getFetcher(
        HttpMocker $httpMocker = null,
        EntityManagerInterface $em = null,
        RemoteClaimRepository $claimRepository = null,
        ClientRepository $clientRepository = null
    ) {
        if ($httpMocker === null) {
            $httpMocker = new HttpMocker();
        }
        if ($em === null) {
            $em = $this->getEntityManager();
        }
        if ($claimRepository === null) {
            $claimRepository = $this->getClaimRepository();
        }
        if ($clientRepository === null) {
            $clientRepository = $this->getClientRepository();
        }
        $httpClient = $httpMocker->getClient();

        $fetcher = new RemoteClaimFetcher($httpClient, $em, $claimRepository, $clientRepository);

        return $fetcher;
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|EntityManagerInterface
     */
    private function getEntityManager()
    {
        $em = $this->getMock('Doctrine\ORM\EntityManagerInterface');

        return $em;
    }

    /**
     * @return RemoteClaimRepository|\PHPUnit_Framework_MockObject_MockObject
     */
    private function getClaimRepository()
    {
        return $this->getMockBuilder('LoginCidadao\RemoteClaimsBundle\Entity\RemoteClaimRepository')
            ->disableOriginalConstructor()
            ->getMock();
    }

    /**
     * @return ClientRepository|\PHPUnit_Framework_MockObject_MockObject
     */
    private function getClientRepository()
    {
        $repo = $this->getMockBuilder('LoginCidadao\OAuthBundle\Entity\ClientRepository')
            ->disableOriginalConstructor()->getMock();

        return $repo;
    }
}


Push — issue#666 ( 5bb037...827179 )

RemoteClaimFetcherTest::testFetchByTagUri() B

Complexity

Size

Duplication

Importance

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\Fetcher;
12
13			use Doctrine\ORM\EntityManagerInterface;
14			use LoginCidadao\OAuthBundle\Entity\ClientRepository;
15			use LoginCidadao\RemoteClaimsBundle\Entity\RemoteClaimRepository;
16			use LoginCidadao\RemoteClaimsBundle\Fetcher\RemoteClaimFetcher;
17			use LoginCidadao\RemoteClaimsBundle\Model\HttpUri;
18			use LoginCidadao\RemoteClaimsBundle\Tests\Http\HttpMocker;
19			use LoginCidadao\RemoteClaimsBundle\Tests\Parser\RemoteClaimParserTest;
20
21			class RemoteClaimFetcherTest extends \PHPUnit_Framework_TestCase
22			{
23			/**
24			* Test the Claim fetch using HTTP URI.
25			*/
26			public function testFetchByHttpUri()
27			{
28			$uri = 'https://dummy.com';
29
30			$data = RemoteClaimParserTest::$claimMetadata;
31
32			$fetcher = $this->getFetcher(new HttpMocker($data));
33			$remoteClaim = $fetcher->fetchRemoteClaim($uri);
34
35			$this->assertInstanceOf('LoginCidadao\RemoteClaimsBundle\Model\RemoteClaimInterface', $remoteClaim);
36			$this->assertEquals($data['claim_display_name'], $remoteClaim->getDisplayName());
37			}
38
39			/**
40			* Test the Claim fetch using Tag URI.

PROCERGS / login-cidadao

Push — issue#666 ( 5bb037...827179 )

RemoteClaimFetcherTest::testFetchByTagUri() B

Complexity

Size

Duplication

Importance

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