AuthorizationServiceTest::testFetchTokenFromCode() - Code Metrics - facile-it/php-openid-client - Measure and Improve Code Quality continuously with Scrutinizer

AuthorizationServiceTest::testFetchTokenFromCode() A
last analyzed 2021-05-07 08:22 UTC

↳ Parent: AuthorizationServiceTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	65
Code Lines	53

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	53
nc	1
nop	0
dl	0
loc	65
rs	9.0254
c	1
b	0
f	0

How to fix Long Method

<?php

declare(strict_types=1);

namespace Facile\OpenIDClientTest\Service;

use Facile\OpenIDClient\AuthMethod\AuthMethodFactoryInterface;
use Facile\OpenIDClient\AuthMethod\AuthMethodInterface;
use Facile\OpenIDClient\Client\ClientInterface as OpenIDClient;
use Facile\OpenIDClient\Client\Metadata\ClientMetadataInterface;
use Facile\OpenIDClient\Issuer\IssuerInterface;
use Facile\OpenIDClient\Issuer\Metadata\IssuerMetadataInterface;
use Facile\OpenIDClient\Service\AuthorizationService;
use Facile\OpenIDClient\Token\IdTokenVerifierBuilderInterface;
use Facile\OpenIDClient\Token\TokenSetFactoryInterface;
use Facile\OpenIDClient\Token\TokenSetInterface;
use Facile\OpenIDClient\Token\TokenVerifierBuilderInterface;
use Facile\OpenIDClientTest\TestCase;
use Psr\Http\Client\ClientInterface;
use Psr\Http\Message\RequestFactoryInterface;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\StreamInterface;

class AuthorizationServiceTest extends TestCase
{
    public function testGetAuthorizationUri(): void
    {
        $tokenSetFactory = $this->prophesize(TokenSetFactoryInterface::class);
        $client = $this->prophesize(ClientInterface::class);
        $requestFactory = $this->prophesize(RequestFactoryInterface::class);
        $idTokenVerifierBuilder = $this->prophesize(IdTokenVerifierBuilderInterface::class);
        $tokenVerifierBuilder = $this->prophesize(TokenVerifierBuilderInterface::class);

        $service = new AuthorizationService(
            $tokenSetFactory->reveal(),
            $client->reveal(),
            $requestFactory->reveal(),
            $idTokenVerifierBuilder->reveal(),
            $tokenVerifierBuilder->reveal()
        );

        $openIdClient = $this->prophesize(OpenIDClient::class);
        $clientMetadata = $this->prophesize(ClientMetadataInterface::class);
        $issuer = $this->prophesize(IssuerInterface::class);
        $issuerMetadata = $this->prophesize(IssuerMetadataInterface::class);

        $openIdClient->getIssuer()->willReturn($issuer->reveal());
        $openIdClient->getMetadata()->willReturn($clientMetadata->reveal());
        $openIdClient->getHttpClient()->willReturn(null);
        $clientMetadata->getClientId()->willReturn('clientId');
        $clientMetadata->getResponseTypes()->willReturn(['code']);
        $clientMetadata->getRedirectUris()->willReturn(['redirect_uri_1']);
        $issuer->getMetadata()->willReturn($issuerMetadata);
        $issuerMetadata->getAuthorizationEndpoint()->willReturn('https://foo-endpoint');

        static::assertSame('https://foo-endpoint?client_id=clientId&scope=openid&response_type=code&redirect_uri=redirect_uri_1', $service->getAuthorizationUri($openIdClient->reveal()));
    }

    public function testFetchTokenFromCode(): void
    {
        $tokenSetFactory = $this->prophesize(TokenSetFactoryInterface::class);
        $client = $this->prophesize(ClientInterface::class);
        $requestFactory = $this->prophesize(RequestFactoryInterface::class);
        $idTokenVerifierBuilder = $this->prophesize(IdTokenVerifierBuilderInterface::class);
        $tokenVerifierBuilder = $this->prophesize(TokenVerifierBuilderInterface::class);

        $service = new AuthorizationService(
            $tokenSetFactory->reveal(),
            $client->reveal(),
            $requestFactory->reveal(),
            $idTokenVerifierBuilder->reveal(),
            $tokenVerifierBuilder->reveal()
        );

        $openIdClient = $this->prophesize(OpenIDClient::class);
        $openIdClient->getHttpClient()->willReturn(null);
        $metadata = $this->prophesize(ClientMetadataInterface::class);
        $authMethodFactory = $this->prophesize(AuthMethodFactoryInterface::class);
        $authMethod = $this->prophesize(AuthMethodInterface::class);
        $request = $this->prophesize(RequestInterface::class);
        $tokenRequest1 = $this->prophesize(RequestInterface::class);
        $tokenRequest2 = $this->prophesize(RequestInterface::class);
        $response = $this->prophesize(ResponseInterface::class);
        $stream = $this->prophesize(StreamInterface::class);
        $issuer = $this->prophesize(IssuerInterface::class);
        $issuerMetadata = $this->prophesize(IssuerMetadataInterface::class);

        $claims = [
            'grant_type' => 'authorization_code',
            'code' => 'foo-code',
            'redirect_uri' => 'redirect-uri',
        ];

        $requestFactory->createRequest('POST', 'token-endpoint')
            ->willReturn($request->reveal());
        $request->withHeader('content-type', 'application/x-www-form-urlencoded')
            ->willReturn($tokenRequest1->reveal());
        $openIdClient->getIssuer()->willReturn($issuer->reveal());
        $issuer->getMetadata()->willReturn($issuerMetadata->reveal());
        $issuerMetadata->getTokenEndpoint()->willReturn('token-endpoint');
        $issuerMetadata->get('token_endpoint')->willReturn('token-endpoint');
        $openIdClient->getMetadata()->willReturn($metadata->reveal());
        $openIdClient->getAuthMethodFactory()->willReturn($authMethodFactory->reveal());
        $metadata->getTokenEndpointAuthMethod()->willReturn('auth-method');
        $metadata->get('token_endpoint_auth_method')->willReturn('auth-method');
        $authMethodFactory->create('auth-method')->willReturn($authMethod->reveal());
        $authMethod->createRequest(
            $tokenRequest1->reveal(),
            $openIdClient->reveal(),
            $claims
        )
            ->willReturn($tokenRequest2->reveal());

        $client->sendRequest($tokenRequest2->reveal())
            ->willReturn($response->reveal());
        $response->getStatusCode()->willReturn(200);
        $response->getBody()->willReturn($stream->reveal());
        $stream->__toString()->willReturn('{"foo":"bar"}');

        $tokenSet = $this->prophesize(TokenSetInterface::class);
        $tokenSetFactory->fromArray(['foo' => 'bar'])->willReturn($tokenSet->reveal());

        static::assertSame($tokenSet->reveal(), $service->grant($openIdClient->reveal(), $claims));
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Facile\OpenIDClientTest\Service;
6
7			use Facile\OpenIDClient\AuthMethod\AuthMethodFactoryInterface;
8			use Facile\OpenIDClient\AuthMethod\AuthMethodInterface;
9			use Facile\OpenIDClient\Client\ClientInterface as OpenIDClient;
10			use Facile\OpenIDClient\Client\Metadata\ClientMetadataInterface;
11			use Facile\OpenIDClient\Issuer\IssuerInterface;
12			use Facile\OpenIDClient\Issuer\Metadata\IssuerMetadataInterface;
13			use Facile\OpenIDClient\Service\AuthorizationService;
14			use Facile\OpenIDClient\Token\IdTokenVerifierBuilderInterface;
15			use Facile\OpenIDClient\Token\TokenSetFactoryInterface;
16			use Facile\OpenIDClient\Token\TokenSetInterface;
17			use Facile\OpenIDClient\Token\TokenVerifierBuilderInterface;
18			use Facile\OpenIDClientTest\TestCase;
19			use Psr\Http\Client\ClientInterface;
20			use Psr\Http\Message\RequestFactoryInterface;
21			use Psr\Http\Message\RequestInterface;
22			use Psr\Http\Message\ResponseInterface;
23			use Psr\Http\Message\StreamInterface;
24
25			class AuthorizationServiceTest extends TestCase
26			{
27			public function testGetAuthorizationUri(): void
28			{
29			$tokenSetFactory = $this->prophesize(TokenSetFactoryInterface::class);
30			$client = $this->prophesize(ClientInterface::class);
31			$requestFactory = $this->prophesize(RequestFactoryInterface::class);
32			$idTokenVerifierBuilder = $this->prophesize(IdTokenVerifierBuilderInterface::class);
33			$tokenVerifierBuilder = $this->prophesize(TokenVerifierBuilderInterface::class);
34
35			$service = new AuthorizationService(
36			$tokenSetFactory->reveal(),
37			$client->reveal(),
38			$requestFactory->reveal(),
39			$idTokenVerifierBuilder->reveal(),
40			$tokenVerifierBuilder->reveal()
41			);
42
43			$openIdClient = $this->prophesize(OpenIDClient::class);
44			$clientMetadata = $this->prophesize(ClientMetadataInterface::class);
45			$issuer = $this->prophesize(IssuerInterface::class);
46			$issuerMetadata = $this->prophesize(IssuerMetadataInterface::class);
47
48			$openIdClient->getIssuer()->willReturn($issuer->reveal());
49			$openIdClient->getMetadata()->willReturn($clientMetadata->reveal());
50			$openIdClient->getHttpClient()->willReturn(null);
51			$clientMetadata->getClientId()->willReturn('clientId');
52			$clientMetadata->getResponseTypes()->willReturn(['code']);
53			$clientMetadata->getRedirectUris()->willReturn(['redirect_uri_1']);
54			$issuer->getMetadata()->willReturn($issuerMetadata);
55			$issuerMetadata->getAuthorizationEndpoint()->willReturn('https://foo-endpoint');
56
57			static::assertSame('https://foo-endpoint?client_id=clientId&scope=openid&response_type=code&redirect_uri=redirect_uri_1', $service->getAuthorizationUri($openIdClient->reveal()));
58			}
59
60			public function testFetchTokenFromCode(): void
61			{
62			$tokenSetFactory = $this->prophesize(TokenSetFactoryInterface::class);
63			$client = $this->prophesize(ClientInterface::class);
64			$requestFactory = $this->prophesize(RequestFactoryInterface::class);
65			$idTokenVerifierBuilder = $this->prophesize(IdTokenVerifierBuilderInterface::class);
66			$tokenVerifierBuilder = $this->prophesize(TokenVerifierBuilderInterface::class);
67
68			$service = new AuthorizationService(
69			$tokenSetFactory->reveal(),
70			$client->reveal(),
71			$requestFactory->reveal(),
72			$idTokenVerifierBuilder->reveal(),
73			$tokenVerifierBuilder->reveal()
74			);
75
76			$openIdClient = $this->prophesize(OpenIDClient::class);
77			$openIdClient->getHttpClient()->willReturn(null);
78			$metadata = $this->prophesize(ClientMetadataInterface::class);
79			$authMethodFactory = $this->prophesize(AuthMethodFactoryInterface::class);
80			$authMethod = $this->prophesize(AuthMethodInterface::class);
81			$request = $this->prophesize(RequestInterface::class);
82			$tokenRequest1 = $this->prophesize(RequestInterface::class);
83			$tokenRequest2 = $this->prophesize(RequestInterface::class);
84			$response = $this->prophesize(ResponseInterface::class);
85			$stream = $this->prophesize(StreamInterface::class);
86			$issuer = $this->prophesize(IssuerInterface::class);
87			$issuerMetadata = $this->prophesize(IssuerMetadataInterface::class);
88
89			$claims = [
90			'grant_type' => 'authorization_code',
91			'code' => 'foo-code',
92			'redirect_uri' => 'redirect-uri',
93			];
94
95			$requestFactory->createRequest('POST', 'token-endpoint')
96			->willReturn($request->reveal());
97			$request->withHeader('content-type', 'application/x-www-form-urlencoded')
98			->willReturn($tokenRequest1->reveal());
99			$openIdClient->getIssuer()->willReturn($issuer->reveal());
100			$issuer->getMetadata()->willReturn($issuerMetadata->reveal());
101			$issuerMetadata->getTokenEndpoint()->willReturn('token-endpoint');
102			$issuerMetadata->get('token_endpoint')->willReturn('token-endpoint');
103			$openIdClient->getMetadata()->willReturn($metadata->reveal());
104			$openIdClient->getAuthMethodFactory()->willReturn($authMethodFactory->reveal());
105			$metadata->getTokenEndpointAuthMethod()->willReturn('auth-method');
106			$metadata->get('token_endpoint_auth_method')->willReturn('auth-method');
107			$authMethodFactory->create('auth-method')->willReturn($authMethod->reveal());
108			$authMethod->createRequest(
109			$tokenRequest1->reveal(),
110			$openIdClient->reveal(),
111			$claims
112			)
113			->willReturn($tokenRequest2->reveal());
114
115			$client->sendRequest($tokenRequest2->reveal())
116			->willReturn($response->reveal());
117			$response->getStatusCode()->willReturn(200);
118			$response->getBody()->willReturn($stream->reveal());
119			$stream->__toString()->willReturn('{"foo":"bar"}');
120
121			$tokenSet = $this->prophesize(TokenSetInterface::class);
122			$tokenSetFactory->fromArray(['foo' => 'bar'])->willReturn($tokenSet->reveal());
123
124			static::assertSame($tokenSet->reveal(), $service->grant($openIdClient->reveal(), $claims));
125			}
126			}
127

facile-it / php-openid-client

AuthorizationServiceTest::testFetchTokenFromCode() A last analyzed 2021-05-07 08:22 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

AuthorizationServiceTest::testFetchTokenFromCode() A
last analyzed 2021-05-07 08:22 UTC