Lamoda\QueueBundle\Tests\Unit\Service\DelayServiceTest::createStrategy()

Complexity

Conditions	1
Paths	1

Size

Total Lines

14

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	DelayServiceTest.php$0 ➔ generateInterval()	0	4	1
A	DelayServiceTest.php$0 ➔ getInterval()	0	4	1

<?php

declare(strict_types=1);

namespace Lamoda\QueueBundle\Tests\Unit\Service;

use DateInterval;
use DateTime;
use Lamoda\QueueBundle\Entity\QueueEntityInterface;
use Lamoda\QueueBundle\Service\DelayService;
use Lamoda\QueueBundle\Service\ResolverStrategyService;
use Lamoda\QueueBundle\Strategy\Delay\DelayStrategyInterface;
use Lamoda\QueueBundle\Tests\Unit\QueueEntity;
use PHPUnit_Framework_TestCase;

class DelayServiceTest extends PHPUnit_Framework_TestCase
{
    /**
     * @param QueueEntityInterface $queue
     * @param QueueEntityInterface $expectedQueue
     * @param DateTime             $dateTime
     *
     * @dataProvider dataDelayQueue
     */
    public function testDelayQueue(
        QueueEntityInterface $queue,
        QueueEntityInterface $expectedQueue,
        DateTime $dateTime
    ): void {
        $strategyService = $this->createResolverStrategyService();
        /** @var DelayService | \PHPUnit_Framework_MockObject_MockObject $delayService */
        $delayService = $this->getMockBuilder(DelayService::class)
            ->setConstructorArgs([$strategyService])
            ->setMethods(['getStartDateTime'])
            ->getMock();
        $delayService->method('getStartDateTime')
            ->willReturn($dateTime);

        $actualQueue = $delayService->delayQueue($queue);
        $this->assertEquals($expectedQueue, $actualQueue);
    }

    /**
     * @return array
     * @throws \Exception
     *
     */
    public function dataDelayQueue(): array
    {
        $strategyService = $this->createResolverStrategyService();
        $dateTime        = new DateTime();
        $queue           = $this->createQueue();
        $strategy        = $strategyService->getStrategy($queue->getName());
        $expected        = clone $queue;
        $expected->setWaiting($dateTime->add($strategy::getInterval()));

        return [
            [
                $queue,
                $expected,
                $dateTime,
            ],
        ];
    }

    private function createQueue(): QueueEntity
    {
        return new QueueEntity('queue', 'exchange', 'ClassJob', []);
    }

    private function createResolverStrategyService(): ResolverStrategyService
    {
        $strategy = new class() implements DelayStrategyInterface {
            public function generateInterval(int $iteration): DateInterval
            {
                return static::getInterval();
            }

            public static function getInterval(): DateInterval
            {
                return new DateInterval('PT1M');
            }
        };

        return new ResolverStrategyService($this->createStrategiesList(['test_strategy_key' => $strategy]), ['queue' => 'test_strategy_key']);
    }

    private function createStrategiesList(array $strategies)
    {
        return new class($strategies) implements \Iterator {
            /**
             * @var array
             */
            protected $strategies;

            public function __construct(array $strategies)
            {
                $this->strategies = $strategies;
            }

            public function current()
            {
                return current($this->strategies);
            }

            public function next()
            {
                return next($this->strategies);
            }

            public function key()
            {
                return key($this->strategies);
            }

            public function valid()
            {
                return key($this->strategies) !== null;
            }

            public function rewind()
            {
                return reset($this->strategies);
            }

        };
    }
}