OAuth2Framework\Component\ClientRegistrationEndpoint\Tests\ClientRegistrationEndpointTest

Complexity

Total Complexity

6

Size/Duplication

Total Lines	86
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	getResponseFactory()	0	8	2
A	theClientRegistrationEndpointCanReceiveRegistrationRequests()	0	12	1
B	getClientRegistrationEndpoint()	0	29	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\ClientRegistrationEndpoint\Tests;

use Http\Message\MessageFactory\DiactorosMessageFactory;
use Http\Message\ResponseFactory;
use OAuth2Framework\Component\ClientRegistrationEndpoint\ClientRegistrationEndpoint;
use OAuth2Framework\Component\ClientRule\RuleManager;
use OAuth2Framework\Component\Core\Client\Client;
use OAuth2Framework\Component\Core\Client\ClientId;
use OAuth2Framework\Component\Core\Client\ClientIdGenerator;
use OAuth2Framework\Component\Core\Client\ClientRepository;
use OAuth2Framework\Component\Core\DataBag\DataBag;
use PHPUnit\Framework\TestCase;
use Prophecy\Argument;
use Prophecy\Prophecy\ObjectProphecy;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\StreamInterface;

/**
 * @group ClientRegistrationEndpoint
 */
final class ClientRegistrationEndpointTest extends TestCase
{
    /**
     * @test
     */
    public function theClientRegistrationEndpointCanReceiveRegistrationRequests()
    {
        $request = $this->buildRequest([]);
        $request->getMethod()->willReturn('POST');
        $request->getAttribute('initial_access_token')->willReturn(null);

        $response = $this->getClientRegistrationEndpoint()->process($request->reveal());

        self::assertEquals(201, $response->getStatusCode());
        $response->getBody()->rewind();
        self::assertEquals('{"client_id":"CLIENT_ID"}', $response->getBody()->getContents());
    }

    /**
     * @var null|ClientRegistrationEndpoint
     */
    private $clientRegistrationEndpoint = null;

    /**
     * @return ClientRegistrationEndpoint
     */
    private function getClientRegistrationEndpoint(): ClientRegistrationEndpoint
    {
        if (null === $this->clientRegistrationEndpoint) {
            $client = Client::createEmpty();
            $client = $client->create(
                ClientId::create('CLIENT_ID'),
                DataBag::create([]),
                null
            );
            $clientIdGenerator = $this->prophesize(ClientIdGenerator::class);
            $clientIdGenerator->createClientId()->willReturn(
                ClientId::create('CLIENT_ID')
            );

            $clientRepository = $this->prophesize(ClientRepository::class);
            $clientRepository->find(Argument::type(ClientId::class))->willReturn($client);
            $clientRepository->save(Argument::type(Client::class))->will(function (array $args) {

The parameter $args is not used and could be removed.

            });

            $this->clientRegistrationEndpoint = new ClientRegistrationEndpoint(
                $clientIdGenerator->reveal(),
                $clientRepository->reveal(),
                $this->getResponseFactory(),
                new RuleManager()
            );
        }

        return $this->clientRegistrationEndpoint;
    }

    /**
     * @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;
    }
}