MockOAuth2Server::oauth2Token() - Code Metrics - Inspection of "[STB-71] [ID-27] Update Guzzle to latest version" - commerceguys/guzzle-oauth2-plugin - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#30)

by Daniel

created 2016-05-18 15:21 UTC

MockOAuth2Server::oauth2Token() B

↳ Parent: MockOAuth2Server

Complexity

Conditions	5
Paths	5

Size

Total Lines	21
Code Lines	15

Duplication

Lines	0
Ratio	0 %

Metric	Value
dl	0
loc	21
rs	8.7624
cc	5
eloc	15
nc	5
nop	2

<?php

namespace Sainsburys\Guzzle\Oauth2\Tests;


use GuzzleHttp\Exception\RequestException;
use GuzzleHttp\Handler\MockHandler;
use GuzzleHttp\HandlerStack;
use GuzzleHttp\Psr7\Response;
use Psr\Http\Message\RequestInterface;

class MockOAuth2Server
{
    const KEY_TOKEN_EXPIRES_IN = 'tokenExpiresIn';
    const KEY_TOKEN_PATH = 'tokenPath';
    const KEY_TOKEN_INVALID_COUNT = 'tokenInvalidCount';
    const KEY_EXPECTED_QUERY_COUNT = 'expectedQueryCount';

    /** @var array */
    protected $options;

    /**
     * @var HandlerStack
     */
    private $handlerStack;

    /**
     * @var int
     */
    private $tokenInvalidCount = 0;

    /**
     * @param array $options
     */
    public function __construct(array $options = [])
    {
        $defaults = [
            self::KEY_TOKEN_EXPIRES_IN => 3600,
            self::KEY_TOKEN_PATH => '/oauth2/token',
            self::KEY_EXPECTED_QUERY_COUNT => 1
        ];

        $this->options = $options + $defaults;

        $handler = new MockHandler(
            $this->options[self::KEY_EXPECTED_QUERY_COUNT] > 0 ?
                array_fill(
                    0,
                    $this->options[self::KEY_EXPECTED_QUERY_COUNT],
                    function (RequestInterface $request, array $options) {
                        return $this->getResult($request, $options);
                    }
                )
                : []
        );

        $this->handlerStack = HandlerStack::create($handler);
    }

    /**
     * @return HandlerStack
     */
    public function getHandlerStack()
    {
        return $this->handlerStack;
    }

    /**
     * @param RequestInterface $request
     * @param array            $options
     *
     * @return array
     */
    protected function getResult(RequestInterface $request, array $options)
    {
        if ($request->getUri()->getPath() === $this->options[self::KEY_TOKEN_PATH]) {
            $response = $this->oauth2Token($request, $options);
        } elseif (strpos($request->getUri()->getPath(), '/api/') !== false) {
            $response = $this->mockApiCall($request);
        }
        if (!isset($response)) {
            throw new \RuntimeException("Mock server cannot handle given request URI");
        }

        return $response;
    }

    /**
     * @param RequestInterface $request
     * @param array            $options
     *
     * @return array
     */
    protected function oauth2Token(RequestInterface $request, $options)
    {
        $body = $request->getBody()->__toString();
        $requestBody = [];
        parse_str($body, $requestBody);
        $grantType = $requestBody['grant_type'];
        switch ($grantType) {
            case 'password':
                return $this->grantTypePassword($requestBody);

            case 'client_credentials':
                return $this->grantTypeClientCredentials($options);

            case 'refresh_token':
                return $this->grantTypeRefreshToken($requestBody);

            case 'urn:ietf:params:oauth:grant-type:jwt-bearer':
                return $this->grantTypeJwtBearer($requestBody);
        }
        throw new \RuntimeException("Test grant type not implemented: $grantType");
    }

    /**
     * @return array
     */
    protected function validTokenResponse()
    {
        $token = [
            'access_token' => 'token',
            'refresh_token' => 'refreshToken',
            'token_type' => 'bearer',
        ];

        if (isset($this->options[self::KEY_TOKEN_INVALID_COUNT])) {
            $token['access_token'] = 'tokenInvalid';
        } elseif (isset($this->options[self::KEY_TOKEN_EXPIRES_IN])) {
            $token['expires_in'] = $this->options[self::KEY_TOKEN_EXPIRES_IN];
        }

        return new Response(200, [], json_encode($token));
    }

    /**
     * @param array  $requestBody
     *
     * @return array
     *   The response as expected by the MockHandler.
     */
    protected function grantTypePassword(array $requestBody)
    {
        if ($requestBody['username'] != 'validUsername' || $requestBody['password'] != 'validPassword') {
            // @todo correct response headers
            return new Response(401);
        }

        return $this->validTokenResponse();
    }

    /**
     * @param array  $options
     *
     * @return array
     *   The response as expected by the MockHandler.
     */
    protected function grantTypeClientCredentials(array $options)
    {
        if (!isset($options['auth']) || !isset($options['auth'][1]) || $options['auth'][1] != 'testSecret') {
            // @todo correct response headers
            return new Response(401);
        }

        return $this->validTokenResponse();
    }

    /**
     * @param array  $requestBody
     *
     * @return array
     */
    protected function grantTypeRefreshToken(array $requestBody)
    {
        if ($requestBody['refresh_token'] == 'refreshTokenInvalid') {
            return new Response(401);
        }

        return $this->validTokenResponse();
    }

    /**
     * @param array  $requestBody
     *
     * @return array
     */
    protected function grantTypeJwtBearer(array $requestBody)
    {
        if (!array_key_exists('assertion', $requestBody)) {
            return new Response(401);
        }

        return $this->validTokenResponse();
    }

    /**
     * @param RequestInterface $request
     *
     * @return array
     */
    protected function mockApiCall(RequestInterface $request)
    {
        if (
            empty($request->getHeader('Authorization')) ||
            (
                $request->getHeader('Authorization')[0] == 'Bearer tokenInvalid' &&
                isset($this->options[self::KEY_TOKEN_INVALID_COUNT]) &&
                $this->tokenInvalidCount < $this->options[self::KEY_TOKEN_INVALID_COUNT]
            )
        ) {
            if ($request->getHeader('Authorization')[0] == 'Bearer tokenInvalid') {
                ++$this->tokenInvalidCount;
            }

            return new Response(401);
        }

        return new Response(200, [], json_encode('Hello World!'));
    }
}


1			<?php
2
3			namespace Sainsburys\Guzzle\Oauth2\Tests;
4
5
6			use GuzzleHttp\Exception\RequestException;
7			use GuzzleHttp\Handler\MockHandler;
8			use GuzzleHttp\HandlerStack;
9			use GuzzleHttp\Psr7\Response;
10			use Psr\Http\Message\RequestInterface;
11
12			class MockOAuth2Server
13			{
14			const KEY_TOKEN_EXPIRES_IN = 'tokenExpiresIn';
15			const KEY_TOKEN_PATH = 'tokenPath';
16			const KEY_TOKEN_INVALID_COUNT = 'tokenInvalidCount';
17			const KEY_EXPECTED_QUERY_COUNT = 'expectedQueryCount';
18
19			/** @var array */
20			protected $options;
21
22			/**
23			* @var HandlerStack
24			*/
25			private $handlerStack;
26
27			/**
28			* @var int
29			*/
30			private $tokenInvalidCount = 0;
31
32			/**
33			* @param array $options
34			*/
35			public function __construct(array $options = [])
36			{
37			$defaults = [
38			self::KEY_TOKEN_EXPIRES_IN => 3600,
39			self::KEY_TOKEN_PATH => '/oauth2/token',
40			self::KEY_EXPECTED_QUERY_COUNT => 1
41			];
42
43			$this->options = $options + $defaults;
44
45			$handler = new MockHandler(
46			$this->options[self::KEY_EXPECTED_QUERY_COUNT] > 0 ?
47			array_fill(
48			0,
49			$this->options[self::KEY_EXPECTED_QUERY_COUNT],
50			function (RequestInterface $request, array $options) {
51			return $this->getResult($request, $options);
52			}
53			)
54			: []
55			);
56
57			$this->handlerStack = HandlerStack::create($handler);
58			}
59
60			/**
61			* @return HandlerStack
62			*/
63			public function getHandlerStack()
64			{
65			return $this->handlerStack;
66			}
67
68			/**
69			* @param RequestInterface $request
70			* @param array $options
71			*
72			* @return array
73			*/
74			protected function getResult(RequestInterface $request, array $options)
75			{
76			if ($request->getUri()->getPath() === $this->options[self::KEY_TOKEN_PATH]) {
77			$response = $this->oauth2Token($request, $options);
78			} elseif (strpos($request->getUri()->getPath(), '/api/') !== false) {
79			$response = $this->mockApiCall($request);
80			}
81			if (!isset($response)) {
82			throw new \RuntimeException("Mock server cannot handle given request URI");
83			}
84
85			return $response;
86			}
87
88			/**
89			* @param RequestInterface $request
90			* @param array $options
91			*
92			* @return array
93			*/
94			protected function oauth2Token(RequestInterface $request, $options)
95			{
96			$body = $request->getBody()->__toString();
97			$requestBody = [];
98			parse_str($body, $requestBody);
99			$grantType = $requestBody['grant_type'];
100			switch ($grantType) {
101			case 'password':
102			return $this->grantTypePassword($requestBody);
103
104			case 'client_credentials':
105			return $this->grantTypeClientCredentials($options);
106
107			case 'refresh_token':
108			return $this->grantTypeRefreshToken($requestBody);
109
110			case 'urn:ietf:params:oauth:grant-type:jwt-bearer':
111			return $this->grantTypeJwtBearer($requestBody);
112			}
113			throw new \RuntimeException("Test grant type not implemented: $grantType");
114			}
115
116			/**
117			* @return array
118			*/
119			protected function validTokenResponse()
120			{
121			$token = [
122			'access_token' => 'token',
123			'refresh_token' => 'refreshToken',
124			'token_type' => 'bearer',
125			];
126
127			if (isset($this->options[self::KEY_TOKEN_INVALID_COUNT])) {
128			$token['access_token'] = 'tokenInvalid';
129			} elseif (isset($this->options[self::KEY_TOKEN_EXPIRES_IN])) {
130			$token['expires_in'] = $this->options[self::KEY_TOKEN_EXPIRES_IN];
131			}
132
133			return new Response(200, [], json_encode($token));
134			}
135
136			/**
137			* @param array $requestBody
138			*
139			* @return array
140			* The response as expected by the MockHandler.
141			*/
142			protected function grantTypePassword(array $requestBody)
143			{
144			if ($requestBody['username'] != 'validUsername' \|\| $requestBody['password'] != 'validPassword') {
145			// @todo correct response headers
146			return new Response(401);
147			}
148
149			return $this->validTokenResponse();
150			}
151
152			/**
153			* @param array $options
154			*
155			* @return array
156			* The response as expected by the MockHandler.
157			*/
158			protected function grantTypeClientCredentials(array $options)
159			{
160			if (!isset($options['auth']) \|\| !isset($options['auth'][1]) \|\| $options['auth'][1] != 'testSecret') {
161			// @todo correct response headers
162			return new Response(401);
163			}
164
165			return $this->validTokenResponse();
166			}
167
168			/**
169			* @param array $requestBody
170			*
171			* @return array
172			*/
173			protected function grantTypeRefreshToken(array $requestBody)
174			{
175			if ($requestBody['refresh_token'] == 'refreshTokenInvalid') {
176			return new Response(401);
177			}
178
179			return $this->validTokenResponse();
180			}
181
182			/**
183			* @param array $requestBody
184			*
185			* @return array
186			*/
187			protected function grantTypeJwtBearer(array $requestBody)
188			{
189			if (!array_key_exists('assertion', $requestBody)) {
190			return new Response(401);
191			}
192
193			return $this->validTokenResponse();
194			}
195
196			/**
197			* @param RequestInterface $request
198			*
199			* @return array
200			*/
201			protected function mockApiCall(RequestInterface $request)
202			{
203			if (
204			empty($request->getHeader('Authorization')) \|\|
205			(
206			$request->getHeader('Authorization')[0] == 'Bearer tokenInvalid' &&
207			isset($this->options[self::KEY_TOKEN_INVALID_COUNT]) &&
208			$this->tokenInvalidCount < $this->options[self::KEY_TOKEN_INVALID_COUNT]
209			)
210			) {
211			if ($request->getHeader('Authorization')[0] == 'Bearer tokenInvalid') {
212			++$this->tokenInvalidCount;
213			}
214
215			return new Response(401);
216			}
217
218			return new Response(200, [], json_encode('Hello World!'));
219			}
220			}
221

commerceguys / guzzle-oauth2-plugin

Pull Request — master (#30)

MockOAuth2Server::oauth2Token() B

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like