OAuth2Framework\Component\ClientConfigurationEndpoint\Tests\ClientConfigurationEndpointTest

Complexity

Total Complexity

7

Size/Duplication

Total Lines	113
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
B	theClientConfigurationEndpointCanReceiveGetRequestsAndRetrieveClientInformation()	0	24	1
B	theClientConfigurationEndpointCanReceivePutRequestsAndUpdateTheClient()	0	25	1
A	getClientConfigurationEndpoint()	0	13	2
A	getResponseFactory()	0	8	2
A	buildRequest()	0	12	1

<?php

declare(strict_types=1);

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2014-2018 Spomky-Labs
 *
 * This software may be modified and distributed under the terms
 * of the MIT license.  See the LICENSE file for details.
 */

namespace OAuth2Framework\Component\ClientConfigurationEndpoint\Tests;

use Http\Message\MessageFactory\DiactorosMessageFactory;
use Http\Message\ResponseFactory;
use Prophecy\Prophecy\ObjectProphecy;
use Psr\Http\Message\StreamInterface;
use Psr\Http\Server\RequestHandlerInterface;
use OAuth2Framework\Component\BearerTokenType\BearerToken;
use OAuth2Framework\Component\ClientConfigurationEndpoint\ClientConfigurationEndpoint;
use OAuth2Framework\Component\ClientRule\RuleManager;
use OAuth2Framework\Component\Core\Client\Client;
use OAuth2Framework\Component\Core\Client\ClientId;
use OAuth2Framework\Component\Core\Client\ClientRepository;
use OAuth2Framework\Component\Core\DataBag\DataBag;
use PHPUnit\Framework\TestCase;
use Prophecy\Argument;
use Psr\Http\Message\ServerRequestInterface;

/**
 * @group ClientConfigurationEndpoint
 */
final class ClientConfigurationEndpointTest extends TestCase
{
    /**
     * @test
     */
    public function theClientConfigurationEndpointCanReceiveGetRequestsAndRetrieveClientInformation()
    {
        $client = Client::createEmpty();
        $client = $client->create(
            ClientId::create('CLIENT_ID'),
            DataBag::create([
                'registration_access_token' => 'REGISTRATION_TOKEN',
            ]),
            null
        );
        $clientRepository = $this->prophesize(ClientRepository::class);

        $request = $this->prophesize(ServerRequestInterface::class);
        $request->getMethod()->willReturn('GET');
        $request->getAttribute('client')->willReturn($client);
        $request->getHeader('AUTHORIZATION')->willReturn(['Bearer REGISTRATION_TOKEN']);

        $handler = $this->prophesize(RequestHandlerInterface::class);

        $response = $this->getClientConfigurationEndpoint($clientRepository->reveal())->process($request->reveal(), $handler->reveal());
        $response->getBody()->rewind();
        self::assertEquals(200, $response->getStatusCode());
        self::assertEquals('{"registration_access_token":"REGISTRATION_TOKEN","client_id":"CLIENT_ID"}', $response->getBody()->getContents());
    }

    /**
     * @test
     */
    public function theClientConfigurationEndpointCanReceivePutRequestsAndUpdateTheClient()
    {
        $client = Client::createEmpty();
        $client = $client->create(
            ClientId::create('CLIENT_ID'),
            DataBag::create([
                'registration_access_token' => 'REGISTRATION_TOKEN',
            ]),
            null
        );
        $clientRepository = $this->prophesize(ClientRepository::class);
        $clientRepository->save(Argument::type(Client::class))->shouldBeCalled();

        $request = $this->buildRequest([]);
        $request->getMethod()->willReturn('PUT');
        $request->getAttribute('client')->willReturn($client);
        $request->getHeader('AUTHORIZATION')->willReturn(['Bearer REGISTRATION_TOKEN']);

        $handler = $this->prophesize(RequestHandlerInterface::class);

        $response = $this->getClientConfigurationEndpoint($clientRepository->reveal())->process($request->reveal(), $handler->reveal());
        $response->getBody()->rewind();
        self::assertEquals(200, $response->getStatusCode());
        self::assertEquals('{"client_id":"CLIENT_ID"}', $response->getBody()->getContents());
    }

    /**
     * @var null|ClientConfigurationEndpoint
     */
    private $clientConfigurationEndpoint = null;

    /**
     * @param ClientRepository $clientRepository
     *
     * @return ClientConfigurationEndpoint
     */
    private function getClientConfigurationEndpoint(ClientRepository $clientRepository): ClientConfigurationEndpoint
    {
        if (null === $this->clientConfigurationEndpoint) {
            $this->clientConfigurationEndpoint = new ClientConfigurationEndpoint(
                $clientRepository,
                new BearerToken('Client Manager', true, false, false),
                $this->getResponseFactory(),
                new RuleManager()
            );
        }

        return $this->clientConfigurationEndpoint;
    }

    /**
     * @var ResponseFactory|null
     */
    private $responseFactory = null;

    /**
     * @return ResponseFactory
     */
    private function getResponseFactory(): ResponseFactory
    {
        if (null === $this->responseFactory) {
            $this->responseFactory = new DiactorosMessageFactory();

It seems like new \Http\Message\MessageFactory\DiactorosMessageFactory() of type object<Http\Message\MessageFactory\DiactorosMessageFactory> is incompatible with the declared type object<Http\Message\ResponseFactory>|null of property $responseFactory.

        }

        return $this->responseFactory;
    }

    private function buildRequest(array $data): ObjectProphecy
    {
        $body = $this->prophesize(StreamInterface::class);
        $body->getContents()->willReturn(json_encode($data));
        $request = $this->prophesize(ServerRequestInterface::class);
        $request->hasHeader('Content-Type')->willReturn(true);
        $request->getHeader('Content-Type')->willReturn(['application/json']);
        $request->getBody()->willReturn($body->reveal());
        $request->getParsedBody()->willReturn([]);

        return $request;
    }
}