Facile\OpenIDClient\ConformanceTest\RpTest\AbstractRpTest

Complexity

Total Complexity

10

Size/Duplication

Total Lines	88
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	registerClient()	0	37	3
A	simulateAuthRedirect()	0	10	1
A	getContainer()	0	3	1
A	__construct()	0	3	1
A	httpGet()	0	17	4

<?php

declare(strict_types=1);

namespace Facile\OpenIDClient\ConformanceTest\RpTest;

use Facile\JoseVerifier\JWK\MemoryJwksProvider;
use Http\Discovery\Psr17FactoryDiscovery;
use Http\Discovery\Psr18ClientDiscovery;
use Psr\Http\Client\ClientInterface as HttpClient;
use Psr\Http\Message\RequestFactoryInterface;
use Psr\Http\Message\ResponseInterface;
use Facile\OpenIDClient\Client\ClientBuilder;
use Facile\OpenIDClient\Issuer\IssuerBuilder;
use Facile\OpenIDClient\Service\RegistrationService;
use function array_merge;
use Http\Client\Common\HttpMethodsClientInterface;
use Jose\Component\Core\JWKSet;
use Psr\Container\ContainerInterface;
use Psr\Http\Message\ServerRequestInterface;
use Facile\OpenIDClient\Client\ClientInterface;
use Facile\OpenIDClient\ConformanceTest\TestInfo;
use Facile\OpenIDClient\Exception\OAuth2Exception;
use Facile\OpenIDClient\Exception\RemoteException;
use Facile\OpenIDClient\Client\Metadata\ClientMetadata;
use Laminas\Diactoros\ServerRequestFactory;
use function json_decode;
use function json_encode;

abstract class AbstractRpTest implements RpTestInterface
{
    protected const REDIRECT_URI = 'https://rp.test/callback';

    /** @var ContainerInterface */
    private $container;

    public function __construct(ContainerInterface $container)
    {
        $this->container = $container;
    }

    /**
     * @return ContainerInterface
     */
    public function getContainer(): ContainerInterface
    {
        return $this->container;
    }

    public function registerClient(TestInfo $testInfo, array $metadata = [], JWKSet $jwks = null): ClientInterface
    {
        $issuer = (new IssuerBuilder())
            ->build($testInfo->getRpUri() . '/' . $this->getTestId() . '/.well-known/openid-configuration');

        $registrationService = new RegistrationService();

The call to Facile\OpenIDClient\Service\RegistrationService::__construct() has too few arguments starting with client.

        $metadata = array_merge([
            'client_name' => 'php-openid-client/v1.x (https://github.com/facile-it/php-openid-client)',
            'redirect_uris' => [static::REDIRECT_URI],
            'contacts' => [
                'tvargiu@gmail.com',
            ],
            'grant_types' => [
                'authorization_code',
                'implicit',
            ],
            'response_types' => [
                $testInfo->getResponseType(),
            ],
        ], $metadata);

        try {
            $clientMetadata = ClientMetadata::fromArray($registrationService->register($issuer, $metadata));
        } catch (OAuth2Exception $e) {
            echo sprintf('%s (%s)', $e->getMessage(), $e->getDescription()) . PHP_EOL;
            throw $e;
        } catch (RemoteException $e) {
            echo $e->getResponse()->getBody() . PHP_EOL;
            throw $e;
        }

        return (new ClientBuilder())
            ->setIssuer($issuer)
            ->setClientMetadata($clientMetadata)
            ->setJwksProvider(new MemoryJwksProvider(json_decode(json_encode($jwks ?? ['keys' => []]), true)))
            ->build();
    }

    protected function httpGet(string $uri, array $headers = []): ResponseInterface
    {
        /** @var HttpClient $client */
        $httpClient = $this->getContainer()->has(HttpClient::class)
            ? $this->getContainer()->get(HttpClient::class)
            : Psr18ClientDiscovery::find();
        $requestFactory = $this->getContainer()->has(RequestFactoryInterface::class)
            ? $this->getContainer()->get(RequestFactoryInterface::class)
            : Psr17FactoryDiscovery::findRequestFactory();

        $request = $requestFactory->createRequest('GET', $uri);

        foreach ($headers as $key => $value) {
            $request = $request->withHeader($key, $value);
        }

        return $httpClient->sendRequest($request);
    }

    protected function simulateAuthRedirect(string $uri, string $accept = 'application/json'): ServerRequestInterface
    {
        $response = $this->httpGet($uri, ['accept' => $accept]);

        $serverRequestFactory = new ServerRequestFactory();

        /** @var string $location */
        $location = $response->getHeader('location')[0] ?? null;

        return $serverRequestFactory->createServerRequest('GET', $location);
    }
}