ScayTrase\Api\Rpc\Tests\DecoratorTest

Complexity

Total Complexity

6

Size/Duplication

Total Lines	83
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes	1
Bugs	0	Features	0

<?php

final class DecoratorTest extends TestCase
{
    use RpcRequestTrait;

    public function testLoggableClient()
    {
        if (!interface_exists(LoggerInterface::class)) {
            self::markTestSkipped('install psr/log in order to run these tests');
        }

        $logger = self::getMockBuilder(AbstractLogger::class)->setMethods(['log'])->getMock();
        $logger->expects(self::atLeastOnce())->method('log');

        $rq1 = $this->getRequestMock('/test1', ['param1' => 'test']);
        $rs1 = $this->getResponseMock(true, ['param1' => 'test']);
        /** @var RpcRequestInterface[] $requests */
        $requests = [$rq1];

        $client = new LoggableRpcClient($this->getClientMock([$rq1], [$rs1]), $logger);

        self::assertEquals($rs1, $client->invoke($requests)->getResponse($rq1));
    }

    public function testCacheableClient()
    {
        if (!interface_exists(CacheItemPoolInterface::class)) {
            self::markTestSkipped('install psr/cache in order to run these tests');
        }

        $rq1 = $this->getRequestMock('/test1', ['param1' => 'test']);
        $rq2 = $this->getRequestMock('/test1', ['param1' => 'test']);
        $rs1 = $this->getResponseMock(true, ['payload' => bin2hex(random_bytes(20))]);

        $cache = $this->getCache();

        $client   = new CacheableRpcClient($this->getClientMock([$rq1], [$rs1]), $cache, 5);
        $response = $client->invoke([$rq1])->getResponse($rq1);
        self::assertEquals($rs1, $response);

        $client   = new CacheableRpcClient($this->getClientMock(), $cache, 5);
        $response = $client->invoke([$rq2])->getResponse($rq2);
        self::assertEquals($rs1, $response);
    }

    /**
     * @return CacheItemPoolInterface
     */
    private function getCache()
    {
        static $items = [];
        $cache = $this->prophesize(CacheItemPoolInterface::class);
        $that  = $this;
        $cache->getItem(Argument::type('string'))->will(
            function ($args) use (&$items, $that) {
                $key = $args[0];
                if (!array_key_exists($key, $items)) {
                    $item = $that->prophesize(CacheItemInterface::class);

                    $item->getKey()->willReturn($key);
                    $item->isHit()->willReturn(false);
                    $item->set(Argument::any())->will(
                        function ($args) use ($item) {
                            $item->get()->willReturn($args[0]);
                        }
                    );
                    $item->expiresAfter(Argument::type('int'))->willReturn($item);
                    $item->expiresAfter(Argument::exact(null))->willReturn($item);
                    $item->expiresAfter(Argument::type(\DateInterval::class))->willReturn($item);
                    $item->expiresAt(Argument::type(\DateTimeInterface::class))->willReturn($item);
                    $items[$key] = $item;
                }

                return $items[$key]->reveal();
            }
        );
        $cache->save(Argument::type(CacheItemInterface::class))->will(
            function ($args) use (&$items) {
                $item = $args[0];
                $items[$item->getKey()]->isHit()->willReturn(true);
            }
        );

        return $cache->reveal();