Bunq\Tests\HttpClientFactoryTest

Complexity

Total Complexity

2

Size/Duplication

Total Lines	87
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	12

Importance

Changes

0

2 Methods

Rating	Name	Duplication	Size	Complexity
B	itCreatesAInstallationClient()	0	32	1
B	itCreatesADefaultClient()	0	45	1

<?php

namespace Bunq\Tests;

use Bunq\Certificate\CertificateType;
use Bunq\Certificate\DefaultCertificate;
use Bunq\Certificate\Storage\CertificateStorage;
use Bunq\HttpClientFactory;
use Bunq\Middleware\RequestAuthenticationMiddleware;
use Bunq\Middleware\RequestIdMiddleware;
use Bunq\Middleware\RequestSignatureMiddleware;
use Bunq\Middleware\ResponseSignatureMiddleware;
use Bunq\Service\TokenService;
use Bunq\Token\DefaultToken;
use GuzzleHttp\HandlerStack;
use GuzzleHttp\Middleware;
use PHPUnit\Framework\TestCase;
use Prophecy\Prophecy\ObjectProphecy;

final class HttpClientFactoryTest extends TestCase
{
    /**
     * @test
     */
    public function itCreatesAInstallationClient()
    {
        $baseUrl            = 'uri';
        $privateCertificate = DefaultCertificate::fromString('private-certificate');

        /** @var CertificateStorage|ObjectProphecy $certificateStorage */
        $certificateStorage = $this->prophesize(CertificateStorage::class);
        $certificateStorage->load(CertificateType::PRIVATE_KEY())->willReturn($privateCertificate);

The method load does only exist in Bunq\Certificate\Storage\CertificateStorage, but not in Prophecy\Prophecy\ObjectProphecy.

        $client = HttpClientFactory::createInstallationClient($baseUrl, $certificateStorage->reveal());

The method reveal does only exist in Prophecy\Prophecy\ObjectProphecy, but not in Bunq\Certificate\Storage\CertificateStorage.

        $expectedHandlerStack = HandlerStack::create();
        $expectedHandlerStack->push(
            Middleware::mapRequest(new RequestIdMiddleware())
        );
        $expectedHandlerStack->push(
            Middleware::mapRequest(new RequestSignatureMiddleware($privateCertificate))
        );

        $expectedClient = new \GuzzleHttp\Client(
            [
                'base_uri' => $baseUrl,
                'handler'  => $expectedHandlerStack,
                'headers'  => [
                    'Content-Type' => 'application/json',
                    'User-Agent'   => 'bunq-api-client:user',
                ],
            ]
        );

        $this->assertEquals($expectedClient, $client);
    }

    /**
     * @test
     */
    public function itCreatesADefaultClient()
    {
        $baseUrl = 'uri';

        $privateCertificate = DefaultCertificate::fromString('private-certificate');
        $bunqCertificate    = DefaultCertificate::fromString('bunq-certificate');
        /** @var CertificateStorage|ObjectProphecy $certificateStorage */
        $certificateStorage = $this->prophesize(CertificateStorage::class);
        $certificateStorage->load(CertificateType::PRIVATE_KEY())->willReturn($privateCertificate);

The method load does only exist in Bunq\Certificate\Storage\CertificateStorage, but not in Prophecy\Prophecy\ObjectProphecy.

        $certificateStorage->load(CertificateType::BUNQ_SERVER_KEY())->willReturn($bunqCertificate);

        $sessionToken = DefaultToken::fromString('session-token');
        /** @var TokenService|ObjectProphecy $tokenService */
        $tokenService = $this->prophesize(TokenService::class);
        $tokenService->sessionToken()->willReturn($sessionToken);

The method sessionToken does only exist in Bunq\Service\TokenService, but not in Prophecy\Prophecy\ObjectProphecy.

        $client = HttpClientFactory::create($baseUrl, $tokenService->reveal(), $certificateStorage->reveal());

The method reveal does only exist in Prophecy\Prophecy\ObjectProphecy, but not in Bunq\Service\TokenService.

The method reveal does only exist in Prophecy\Prophecy\ObjectProphecy, but not in Bunq\Certificate\Storage\CertificateStorage.

        $expectedHandlerStack = HandlerStack::create();
        $expectedHandlerStack->push(
            Middleware::mapRequest(new RequestIdMiddleware())
        );
        $expectedHandlerStack->push(
            Middleware::mapRequest(new RequestAuthenticationMiddleware($sessionToken))
        );
        $expectedHandlerStack->push(
            Middleware::mapRequest(new RequestSignatureMiddleware($bunqCertificate))
        );
        $expectedHandlerStack->push(
            Middleware::mapResponse(new ResponseSignatureMiddleware($bunqCertificate))
        );

        $expectedClient = new \GuzzleHttp\Client(
            [
                'base_uri' => $baseUrl,
                'handler'  => $expectedHandlerStack,
                'headers'  => [
                    'Content-Type' => 'application/json',
                    'User-Agent'   => 'bunq-api-client:user',
                ],
            ]
        );

        $this->assertEquals($expectedClient, $client);
    }
}