QueueRepublishServiceTest::dataRestoreQueuesFailedOnPublisherReleaseFailed() - Code Metrics - Inspection of "Fixed batch republishing bug" - lamoda/queue-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 49a196...e8b010 )

unknown

created 2019-04-25 15:12 UTC

dataRestoreQueuesFailedOnPublisherReleaseFailed() A

↳ Parent: QueueRepublishServiceTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	16
Ratio	100 %

Importance

Changes

Metric	Value
dl	16
loc	16
rs	9.7333
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

declare(strict_types=1);

namespace Lamoda\QueueBundle\Tests\Unit\Service;

use Lamoda\QueueBundle\Factory\PublisherFactory;
use Lamoda\QueueBundle\Service\QueueRepublishService;
use Lamoda\QueueBundle\Service\QueueService;
use Lamoda\QueueBundle\Tests\Unit\QueueCommonServicesTrait;
use Lamoda\QueueBundle\Tests\Unit\QueueEntity;
use Lamoda\QueueBundle\Tests\Unit\Reflection;
use PHPUnit_Framework_TestCase;
use Symfony\Component\HttpKernel\Tests\Logger;

class QueueRepublishServiceTest extends PHPUnit_Framework_TestCase

{
    use QueueCommonServicesTrait;

    /**
     * @param array $queueMessages
     *
     * @dataProvider dataRestoreQueues
     */
    public function testRestoreQueues(array $queueMessages): void
    {
        $mockQueueService = $this->getMockQueueService(
            [
                'getToRepublish',
                'beginTransaction',
                'commit',
                'flush',
                'isTransactionActive',
            ]
        );
        $mockQueueService
            ->expects($this->once())
            ->method('beginTransaction');
        $mockQueueService
            ->expects($this->once())
            ->method('commit');
        $mockQueueService
            ->expects($this->once())
            ->method('flush');
        $mockQueueService
            ->expects($this->once())
            ->method('getToRepublish')
            ->willReturn($queueMessages);
        $mockPublisherFactory = $this->getMockPublisherFactory(['republish', 'releaseAll']);
        $mockPublisherFactory
            ->expects($this->exactly(count($queueMessages)))
            ->method('republish');
        $mockPublisherFactory
            ->expects($this->once())
            ->method('releaseAll');

        $queueRepublishService = $this->createService($mockPublisherFactory, $mockQueueService);

        $this->assertTrue($queueRepublishService->republishQueues(5));
    }

    /**
     * @throws \Exception
     *
     * @return array
     */
    public function dataRestoreQueues(): array

    {
        $queueEntity = $this->getQueueEntity();
        $queueEntity2 = $this->getQueueEntity();
        Reflection::setProtectedProperty($queueEntity, 'id', 1);
        Reflection::setProtectedProperty($queueEntity2, 'id', 2);

        return [
            [
                [
                    $queueEntity,
                    $queueEntity2,
                ],
            ],
        ];
    }

    /**
     * @param array $queueMessages
     *
     * @dataProvider dataBatchRestoreQueues
     */
    public function testBatchRestoreQueues(array $queueMessages): void
    {
        $mockQueueService = $this->getMockQueueService(
            [
                'getToRepublish',
                'beginTransaction',
                'commit',
                'flush',
                'isTransactionActive',
            ]
        );
        $mockQueueService
            ->expects($this->exactly(4))
            ->method('beginTransaction');
        $mockQueueService
            ->expects($this->exactly(4))
            ->method('commit');
        $mockQueueService
            ->expects($this->exactly(4))
            ->method('flush');

        $mockQueueService
            ->expects($this->exactly(4))
            ->method('getToRepublish')
            ->willReturnOnConsecutiveCalls(
                $queueMessages,
                $queueMessages,
                $queueMessages,
                []
            );

        $mockPublisherFactory = $this->getMockPublisherFactory(['republish', 'releaseAll']);
        $mockPublisherFactory
            ->expects($this->exactly(3))
            ->method('republish');
        $mockPublisherFactory
            ->expects($this->exactly(4))
            ->method('releaseAll');

        $queueRepublishService = $this->createService($mockPublisherFactory, $mockQueueService);

        $this->assertTrue($queueRepublishService->republishQueues(1));
    }

    /**
     * @throws \Exception
     *
     * @return array
     */
    public function dataBatchRestoreQueues(): array
    {
        $queueEntity = $this->getQueueEntity();
        Reflection::setProtectedProperty($queueEntity, 'id', 1);

        return [
            [
                [
                    $queueEntity,
                ],
            ],
        ];
    }

    public function testRestoreQueuesFailed(): void
    {
        $mockQueueService = $this->getMockQueueService(
            [
                'getToRepublish',
                'beginTransaction',
                'commit',
                'flush',
                'isTransactionActive',
                'rollback',
            ]
        );
        $mockQueueService
            ->expects($this->once())
            ->method('beginTransaction');
        $mockQueueService
            ->expects($this->never())
            ->method('commit');
        $mockQueueService
            ->expects($this->never())
            ->method('flush');
        $mockQueueService
            ->expects($this->once())
            ->method('isTransactionActive')
            ->willReturn(true);
        $mockQueueService
            ->expects($this->once())
            ->method('rollback');
        $mockQueueService
            ->expects($this->once())
            ->method('getToRepublish')
            ->will($this->throwException(new \Exception('Something broken')));
        $queueRepublishService = $this->createService($this->getMockPublisherFactory(), $mockQueueService);

        $this->assertFalse($queueRepublishService->republishQueues(5));
    }

    /**
     * @param array $queueMessages
     *
     * @dataProvider dataRestoreQueuesFailedOnPublisherReleaseFailed
     */
    public function testRestoreQueuesFailedOnPublisherReleaseFailed(array $queueMessages): void
    {
        $mockQueueService = $this->getMockQueueService(
            [
                'getToRepublish',
                'beginTransaction',
                'commit',
                'flush',
                'isTransactionActive',
                'rollback',
            ]
        );
        $mockQueueService
            ->expects($this->once())
            ->method('beginTransaction');
        $mockQueueService
            ->expects($this->once())
            ->method('commit');
        $mockQueueService
            ->expects($this->once())
            ->method('flush');
        $mockQueueService
            ->expects($this->once())
            ->method('isTransactionActive')
            ->willReturn(false);
        $mockQueueService
            ->expects($this->never())
            ->method('rollback');
        $mockQueueService
            ->expects($this->once())
            ->method('getToRepublish')
            ->willReturn($queueMessages);

        $publisherFactory = $this->getMockPublisherFactory(['republish', 'releaseAll']);
        $publisherFactory
            ->expects($this->once())
            ->method('releaseAll')
            ->will($this->throwException(new \Exception('Something broken')));

        $queueRepublishService = $this->createService($publisherFactory, $mockQueueService);

        $this->assertFalse($queueRepublishService->republishQueues(5));
    }

    /**
     * @throws \Exception
     *
     * @return array
     */
    public function dataRestoreQueuesFailedOnPublisherReleaseFailed(): array

    {
        $queueEntity = $this->getQueueEntity();
        $queueEntity2 = $this->getQueueEntity();
        Reflection::setProtectedProperty($queueEntity, 'id', 1);
        Reflection::setProtectedProperty($queueEntity2, 'id', 2);

        return [
            [
                [
                    $queueEntity,
                    $queueEntity2,
                ],
            ],
        ];
    }

    /**
     * @param string $jobName
     * @param string $exchange
     * @param string $queueName
     * @param array  $data
     *
     * @throws \Exception
     *
     * @return QueueEntity
     */
    protected function getQueueEntity(
        string $jobName = 'someJobName',
        string $exchange = 'exchange',
        string $queueName = 'some_queue_name',
        array $data = ['id' => 1]
    ): QueueEntity {
        $queue = new QueueEntity($queueName, $exchange, $jobName, $data);

        Reflection::setProtectedProperty($queue, 'id', 1);

        return $queue;
    }

    protected function createService(
        PublisherFactory $publisherFactory,
        QueueService $queueService
    ): QueueRepublishService {
        return new QueueRepublishService(
            $publisherFactory,
            $queueService,
            new Logger()
        );
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Lamoda\QueueBundle\Tests\Unit\Service;
6
7		use Lamoda\QueueBundle\Factory\PublisherFactory;
8		use Lamoda\QueueBundle\Service\QueueRepublishService;
9		use Lamoda\QueueBundle\Service\QueueService;
10		use Lamoda\QueueBundle\Tests\Unit\QueueCommonServicesTrait;
11		use Lamoda\QueueBundle\Tests\Unit\QueueEntity;
12		use Lamoda\QueueBundle\Tests\Unit\Reflection;
13		use PHPUnit_Framework_TestCase;
14		use Symfony\Component\HttpKernel\Tests\Logger;
15
16		class QueueRepublishServiceTest extends PHPUnit_Framework_TestCase
		0 ignored issues – show Bug introduced 2019-03-20 17:19 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...
17		{
18		use QueueCommonServicesTrait;
19
20		/**
21		* @param array $queueMessages
22		*
23		* @dataProvider dataRestoreQueues
24		*/
25		public function testRestoreQueues(array $queueMessages): void
26		{
27		$mockQueueService = $this->getMockQueueService(
28		[
29		'getToRepublish',
30		'beginTransaction',
31		'commit',
32		'flush',
33		'isTransactionActive',
34		]
35		);
36		$mockQueueService
37		->expects($this->once())
38		->method('beginTransaction');
39		$mockQueueService
40		->expects($this->once())
41		->method('commit');
42		$mockQueueService
43		->expects($this->once())
44		->method('flush');
45		$mockQueueService
46		->expects($this->once())
47		->method('getToRepublish')
48		->willReturn($queueMessages);
49		$mockPublisherFactory = $this->getMockPublisherFactory(['republish', 'releaseAll']);
50		$mockPublisherFactory
51		->expects($this->exactly(count($queueMessages)))
52		->method('republish');
53		$mockPublisherFactory
54		->expects($this->once())
55		->method('releaseAll');
56
57		$queueRepublishService = $this->createService($mockPublisherFactory, $mockQueueService);
58
59		$this->assertTrue($queueRepublishService->republishQueues(5));
60		}
61
62		/**
63		* @throws \Exception
64		*
65		* @return array
66		*/
67	View Code Duplication	public function dataRestoreQueues(): array
		0 ignored issues – show Duplication introduced 2019-04-25 09:12 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...
68		{
69		$queueEntity = $this->getQueueEntity();
70		$queueEntity2 = $this->getQueueEntity();
71		Reflection::setProtectedProperty($queueEntity, 'id', 1);
72		Reflection::setProtectedProperty($queueEntity2, 'id', 2);
73
74		return [
75		[
76		[
77		$queueEntity,
78		$queueEntity2,
79		],
80		],
81		];
82		}
83
84		/**
85		* @param array $queueMessages
86		*
87		* @dataProvider dataBatchRestoreQueues
88		*/
89		public function testBatchRestoreQueues(array $queueMessages): void
90		{
91		$mockQueueService = $this->getMockQueueService(
92		[
93		'getToRepublish',
94		'beginTransaction',
95		'commit',
96		'flush',
97		'isTransactionActive',
98		]
99		);
100		$mockQueueService
101		->expects($this->exactly(4))
102		->method('beginTransaction');
103		$mockQueueService
104		->expects($this->exactly(4))
105		->method('commit');
106		$mockQueueService
107		->expects($this->exactly(4))
108		->method('flush');
109
110		$mockQueueService
111		->expects($this->exactly(4))
112		->method('getToRepublish')
113		->willReturnOnConsecutiveCalls(
114		$queueMessages,
115		$queueMessages,
116		$queueMessages,
117		[]
118		);
119
120		$mockPublisherFactory = $this->getMockPublisherFactory(['republish', 'releaseAll']);
121		$mockPublisherFactory
122		->expects($this->exactly(3))
123		->method('republish');
124		$mockPublisherFactory
125		->expects($this->exactly(4))
126		->method('releaseAll');
127
128		$queueRepublishService = $this->createService($mockPublisherFactory, $mockQueueService);
129
130		$this->assertTrue($queueRepublishService->republishQueues(1));
131		}
132
133		/**
134		* @throws \Exception
135		*
136		* @return array
137		*/
138		public function dataBatchRestoreQueues(): array
139		{
140		$queueEntity = $this->getQueueEntity();
141		Reflection::setProtectedProperty($queueEntity, 'id', 1);
142
143		return [
144		[
145		[
146		$queueEntity,
147		],
148		],
149		];
150		}
151
152		public function testRestoreQueuesFailed(): void
153		{
154		$mockQueueService = $this->getMockQueueService(
155		[
156		'getToRepublish',
157		'beginTransaction',
158		'commit',
159		'flush',
160		'isTransactionActive',
161		'rollback',
162		]
163		);
164		$mockQueueService
165		->expects($this->once())
166		->method('beginTransaction');
167		$mockQueueService
168		->expects($this->never())
169		->method('commit');
170		$mockQueueService
171		->expects($this->never())
172		->method('flush');
173		$mockQueueService
174		->expects($this->once())
175		->method('isTransactionActive')
176		->willReturn(true);
177		$mockQueueService
178		->expects($this->once())
179		->method('rollback');
180		$mockQueueService
181		->expects($this->once())
182		->method('getToRepublish')
183		->will($this->throwException(new \Exception('Something broken')));
184		$queueRepublishService = $this->createService($this->getMockPublisherFactory(), $mockQueueService);
185
186		$this->assertFalse($queueRepublishService->republishQueues(5));
187		}
188
189		/**
190		* @param array $queueMessages
191		*
192		* @dataProvider dataRestoreQueuesFailedOnPublisherReleaseFailed
193		*/
194		public function testRestoreQueuesFailedOnPublisherReleaseFailed(array $queueMessages): void
195		{
196		$mockQueueService = $this->getMockQueueService(
197		[
198		'getToRepublish',
199		'beginTransaction',
200		'commit',
201		'flush',
202		'isTransactionActive',
203		'rollback',
204		]
205		);
206		$mockQueueService
207		->expects($this->once())
208		->method('beginTransaction');
209		$mockQueueService
210		->expects($this->once())
211		->method('commit');
212		$mockQueueService
213		->expects($this->once())
214		->method('flush');
215		$mockQueueService
216		->expects($this->once())
217		->method('isTransactionActive')
218		->willReturn(false);
219		$mockQueueService
220		->expects($this->never())
221		->method('rollback');
222		$mockQueueService
223		->expects($this->once())
224		->method('getToRepublish')
225		->willReturn($queueMessages);
226
227		$publisherFactory = $this->getMockPublisherFactory(['republish', 'releaseAll']);
228		$publisherFactory
229		->expects($this->once())
230		->method('releaseAll')
231		->will($this->throwException(new \Exception('Something broken')));
232
233		$queueRepublishService = $this->createService($publisherFactory, $mockQueueService);
234
235		$this->assertFalse($queueRepublishService->republishQueues(5));
236		}
237
238		/**
239		* @throws \Exception
240		*
241		* @return array
242		*/
243	View Code Duplication	public function dataRestoreQueuesFailedOnPublisherReleaseFailed(): array
		0 ignored issues – show Duplication introduced 2019-04-25 09:12 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...
244		{
245		$queueEntity = $this->getQueueEntity();
246		$queueEntity2 = $this->getQueueEntity();
247		Reflection::setProtectedProperty($queueEntity, 'id', 1);
248		Reflection::setProtectedProperty($queueEntity2, 'id', 2);
249
250		return [
251		[
252		[
253		$queueEntity,
254		$queueEntity2,
255		],
256		],
257		];
258		}
259
260		/**
261		* @param string $jobName
262		* @param string $exchange
263		* @param string $queueName
264		* @param array $data
265		*
266		* @throws \Exception
267		*
268		* @return QueueEntity
269		*/
270		protected function getQueueEntity(
271		string $jobName = 'someJobName',
272		string $exchange = 'exchange',
273		string $queueName = 'some_queue_name',
274		array $data = ['id' => 1]
275		): QueueEntity {
276		$queue = new QueueEntity($queueName, $exchange, $jobName, $data);
277
278		Reflection::setProtectedProperty($queue, 'id', 1);
279
280		return $queue;
281		}
282
283		protected function createService(
284		PublisherFactory $publisherFactory,
285		QueueService $queueService
286		): QueueRepublishService {
287		return new QueueRepublishService(
288		$publisherFactory,
289		$queueService,
290		new Logger()
291		);
292		}
293		}
294

lamoda / queue-bundle

Push — master ( 49a196...e8b010 )

dataRestoreQueuesFailedOnPublisherReleaseFailed() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like