anonymous//tests/unit/Service/DelayServiceTest.php$1 - Code Metrics - Inspection of "SCENTRE-5889 Add availability of select special st..." - lamoda/queue-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#10)

unknown

created 2020-02-03 11:20 UTC

ceTest.php$1 A

↳ Parent: DelayServiceTest::createStrategiesList()

Complexity

Total Complexity

Size/Duplication

Total Lines	37
Duplicated Lines	100 %

Coupling/Cohesion

Dependencies

Importance

Changes

Metric	Value
wmc	6
cbo	0
dl	37
loc	37
c	0
b	0
f	0
rs	10

How to fix Duplicated Code

<?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\DelayStrategyResolver;
use Lamoda\QueueBundle\Strategy\Delay\DelayStrategyInterface;
use Lamoda\QueueBundle\Tests\Unit\QueueEntity;
use Lamoda\QueueBundle\Tests\Unit\SymfonyMockTrait;
use PHPUnit_Framework_TestCase;

class DelayServiceTest extends PHPUnit_Framework_TestCase

{
    use SymfonyMockTrait;

    /**
     * @param QueueEntityInterface $queue
     * @param QueueEntityInterface $expectedQueue
     * @param DateTime             $dateTime
     *
     * @dataProvider dataDelayQueue
     */
    public function testDelayQueue(
        QueueEntityInterface $queue,
        QueueEntityInterface $expectedQueue,
        DateTime $dateTime
    ): void {
        $strategyService = $this->createDelayStrategyResolver();
        $logger          = $this->getMockLogger();
        /** @var DelayService | \PHPUnit_Framework_MockObject_MockObject $delayService */
        $delayService = $this->getMockBuilder(DelayService::class)
            ->setConstructorArgs([$strategyService, $logger])
            ->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->createDelayStrategyResolver();
        $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 createDelayStrategyResolver(): DelayStrategyResolver
    {
        $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 DelayStrategyResolver($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);
            }

        };
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Lamoda\QueueBundle\Tests\Unit\Service;
6
7		use DateInterval;
8		use DateTime;
9		use Lamoda\QueueBundle\Entity\QueueEntityInterface;
10		use Lamoda\QueueBundle\Service\DelayService;
11		use Lamoda\QueueBundle\Service\DelayStrategyResolver;
12		use Lamoda\QueueBundle\Strategy\Delay\DelayStrategyInterface;
13		use Lamoda\QueueBundle\Tests\Unit\QueueEntity;
14		use Lamoda\QueueBundle\Tests\Unit\SymfonyMockTrait;
15		use PHPUnit_Framework_TestCase;
16
17		class DelayServiceTest extends PHPUnit_Framework_TestCase
		0 ignored issues – show Bug introduced 2020-02-03 11:23 UTC by Report Bug Copy Issue Report There is one abstract method `getMockBuilder` in this class; you could implement it, or declare this class as abstract. Loading history...
18		{
19		use SymfonyMockTrait;
20
21		/**
22		* @param QueueEntityInterface $queue
23		* @param QueueEntityInterface $expectedQueue
24		* @param DateTime $dateTime
25		*
26		* @dataProvider dataDelayQueue
27		*/
28		public function testDelayQueue(
29		QueueEntityInterface $queue,
30		QueueEntityInterface $expectedQueue,
31		DateTime $dateTime
32		): void {
33		$strategyService = $this->createDelayStrategyResolver();
34		$logger = $this->getMockLogger();
35		/** @var DelayService \| \PHPUnit_Framework_MockObject_MockObject $delayService */
36		$delayService = $this->getMockBuilder(DelayService::class)
37		->setConstructorArgs([$strategyService, $logger])
38		->setMethods(['getStartDateTime'])
39		->getMock();
40		$delayService->method('getStartDateTime')
41		->willReturn($dateTime);
42
43		$actualQueue = $delayService->delayQueue($queue);
44		$this->assertEquals($expectedQueue, $actualQueue);
45		}
46
47		/**
48		* @return array
49		* @throws \Exception
50		*
51		*/
52		public function dataDelayQueue(): array
53		{
54		$strategyService = $this->createDelayStrategyResolver();
55		$dateTime = new DateTime();
56		$queue = $this->createQueue();
57		$strategy = $strategyService->getStrategy($queue->getName());
58		$expected = clone $queue;
59		$expected->setWaiting($dateTime->add($strategy::getInterval()));
60
61		return [
62		[
63		$queue,
64		$expected,
65		$dateTime,
66		],
67		];
68		}
69
70		private function createQueue(): QueueEntity
71		{
72		return new QueueEntity('queue', 'exchange', 'ClassJob', []);
73		}
74
75		private function createDelayStrategyResolver(): DelayStrategyResolver
76		{
77		$strategy = new class() implements DelayStrategyInterface {
78		public function generateInterval(int $iteration): DateInterval
79		{
80		return static::getInterval();
81		}
82
83		public static function getInterval(): DateInterval
84		{
85		return new DateInterval('PT1M');
86		}
87		};
88
89		return new DelayStrategyResolver($this->createStrategiesList(['test_strategy_key' => $strategy]), ['queue' => 'test_strategy_key']);
90		}
91
92	View Code Duplication	private function createStrategiesList(array $strategies)
		0 ignored issues – show Duplication introduced 2020-02-03 11:23 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
93		{
94		return new class($strategies) implements \Iterator {
95		/**
96		* @var array
97		*/
98		protected $strategies;
99
100		public function __construct(array $strategies)
101		{
102		$this->strategies = $strategies;
103		}
104
105		public function current()
106		{
107		return current($this->strategies);
108		}
109
110		public function next()
111		{
112		return next($this->strategies);
113		}
114
115		public function key()
116		{
117		return key($this->strategies);
118		}
119
120		public function valid()
121		{
122		return key($this->strategies) !== null;
123		}
124
125		public function rewind()
126		{
127		return reset($this->strategies);
128		}
129
130		};
131		}
132		}
133

lamoda / queue-bundle

Pull Request — master (#10)

ceTest.php$1 A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like