QueueServiceTest::testSavingScheduledQueue() - Code Metrics - Inspection of "fix delay queue saving (#12)" - lamoda/queue-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 51c8d9...38822b )

by Lexey

created 2020-02-11 12:44 UTC

QueueServiceTest::testSavingScheduledQueue() A

↳ Parent: QueueServiceTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	32
rs	9.408
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

declare(strict_types=1);

namespace Lamoda\QueueBundle\Tests\Unit\Service;

use DateTime;
use Lamoda\QueueBundle\Entity\QueueRepository;
use Lamoda\QueueBundle\Event\QueueAttemptsReachedEvent;
use Lamoda\QueueBundle\Exception\AttemptsReachedException;
use Lamoda\QueueBundle\Exception\UnexpectedValueException;
use Lamoda\QueueBundle\Factory\EntityFactory;
use Lamoda\QueueBundle\Publisher;
use Lamoda\QueueBundle\Service\DelayService;
use Lamoda\QueueBundle\Service\QueueService;
use Lamoda\QueueBundle\Tests\Unit\Job\StubJob;
use Lamoda\QueueBundle\Tests\Unit\QueueCommonServicesTrait;
use Lamoda\QueueBundle\Tests\Unit\QueueEntity;
use Lamoda\QueueBundle\Tests\Unit\SymfonyMockTrait;
use OldSound\RabbitMqBundle\RabbitMq\Producer;
use PHPUnit_Framework_TestCase;
use Psr\Log\NullLogger;
use Symfony\Component\EventDispatcher\EventDispatcher;

class QueueServiceTest extends PHPUnit_Framework_TestCase

{
    use QueueCommonServicesTrait;
    use SymfonyMockTrait;

    /** @var int */
    protected $maxAttempts = 5;

    /**
     * @throws \Doctrine\ORM\TransactionRequiredException
     */
    public function testGetToRestore(): void
    {
        $limit = 10;

        $queueRepository = $this->getQueueRepository();
        $queueRepository
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('getToRestore')
            ->with($this->maxAttempts, $limit);

        $this->createService($queueRepository)->getToRestore($limit);
    }

    /**
     * @param QueueEntity $queue
     *
     * @throws \Exception
     *
     * @dataProvider dataGetToProcess()
     */
    public function testGetToProcess(QueueEntity $queue): void
    {
        $queueRepository = $this->getQueueRepository();
        $queueRepository
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('find')
            ->willReturn($queue);
        $queueRepository
            ->expects($this->once())
            ->method('save')
            ->with($queue);

        $this->assertEquals($queue, $this->createService($queueRepository)->getToProcess(1));
        $this->assertEquals(QueueEntity::STATUS_IN_PROGRESS_TITLE, $queue->getStatusAsString());
    }

    public function dataGetToProcess(): array
    {
        return [
            'new status' => [(new QueueEntity('queue', 'exchange', 'ClassJob', ['id' => 1]))->setNew()],
            'in progress status' => [(new QueueEntity('queue', 'exchange', 'ClassJob', ['id' => 1]))->setInProgress()],
        ];
    }

    /**
     * @param null | QueueEntity $queueEntity
     * @param string $expectedExceptionMessage
     *
     * @throws \Exception
     *
     * @dataProvider dataGetToProcessQueueNotFound
     */
    public function testGetToProcessQueueNotFound(?QueueEntity $queueEntity, string $expectedExceptionMessage): void
    {
        $this->expectException(UnexpectedValueException::class);
        $this->expectExceptionMessage($expectedExceptionMessage);

        $queueRepository = $this->getQueueRepository();

        $queueRepository
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('find')
            ->willReturn($queueEntity);

        $this->createService($queueRepository)->getToProcess(1);
    }

    public function dataGetToProcessQueueNotFound(): array
    {
        return [
            'Not found' => [
                null,
                'The queue with id "1" was not found',
            ],
            'Status not NEW' => [
                new QueueEntity('queue', 'exchange', 'ClassJob', ['id' => 1]),
                'The queue "queue" with job "ClassJob" was not found in suitable status. Actual status is "initial"',
            ],
        ];
    }

    /**
     * @throws \Exception
     */
    public function testGetToProcessAttemptsReached(): void
    {
        $this->expectException(AttemptsReachedException::class);

        $queue = new QueueEntity('queue', 'exchange', 'ClassJob', ['id' => 1]);
        $queue->setNew();

        $this->maxAttempts = 0;

        $queueRepository = $this->getQueueRepository();
        $queueRepository
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('find')
            ->willReturn($queue);
        $queueRepository
            ->expects($this->once())
            ->method('save')
            ->with($queue);

        $attemptsReachedEvent = new QueueAttemptsReachedEvent($queue);

        $eventDispatcher = $this->getEventDispatcher();
        $eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('dispatch')
            ->with('queue.attempts.reached.event', $attemptsReachedEvent);

        $this->assertEquals(
            $queue,
            $this->createService($queueRepository, null, $eventDispatcher)->getToProcess(1)
        );
        $this->assertEquals(QueueEntity::STATUS_ATTEMPTS_REACHED_TITLE, $queue->getStatusAsString());
    }

    public function testSave(): void
    {
        $queue = new QueueEntity('queue', 'exchange', 'ClassJob', ['id' => 1]);

        $queueRepository = $this->getQueueRepository();
        $queueRepository
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('save')
            ->with($queue)
            ->willReturnArgument(0);

        $this->assertEquals(
            $queue,
            $this->createService($queueRepository)->save($queue)
        );
    }

    public function testCreateQueue(): void
    {
        $job = new StubJob(1);
        $queue = new QueueEntity('queue', 'exchange', StubJob::class, ['id' => 1]);

        $entityFactory = $this->getEntityFactory();
        $entityFactory
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('createQueue')
            ->with($job)
            ->willReturn($queue);

        $queueRepository = $this->getQueueRepository();

        $this->assertEquals(
            $queue,
            $this->createService($queueRepository, $entityFactory)->createQueue($job)
        );
    }

    public function testSavingScheduledQueue(): void
    {
        $dateTime = new DateTime();
        $job = new StubJob(1);
        $queue = new QueueEntity('queue', 'exchange', StubJob::class, ['id' => 1]);
        $queue->setScheduled($dateTime);

        $queueRepository = $this->getQueueRepository();
        $queueRepository
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('save')
            ->with($queue)
            ->willReturnArgument(0);

        $entityFactory = $this->getEntityFactory();
        $entityFactory
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once()) #at least once
            ->method('createQueue')
            ->willReturn($queue);

        $queueService = $this->createService($queueRepository, $entityFactory);
        $publisher = new Publisher(
            $this->createMock(Producer::class),
            $queueService,
            new NullLogger(),
            $this->createMock(DelayService::class)
        );

        $createdQueue = $queueService->createQueue($job);
        $publisher->prepareQueueForPublish($createdQueue);
        $publisher->release();
    }
    
    public function testIsTransactionActive(): void
    {
        $expected = true;

        $queueRepository = $this->getQueueRepository();
        $queueRepository
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('isTransactionActive')
            ->willReturn($expected);

        $this->assertEquals(
            $expected,
            $this->createService($queueRepository)->isTransactionActive()
        );
    }

    private function createService(
        ?QueueRepository $repository = null,
        ?EntityFactory $entityFactory = null,
        ?EventDispatcher $eventDispatcher = null
    ): QueueService {
        return new QueueService(
            $repository ?? $this->getQueueRepository(),
            $entityFactory ?? $this->getEntityFactory(),
            $eventDispatcher ?? $this->getEventDispatcher(),
            $this->maxAttempts
        );
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|QueueRepository
     */
    private function getQueueRepository()
    {
        return $this->getMockQueueRepository(
            [
                'find',
                'getToRestore',
                'save',
                'isTransactionActive',
            ]
        );
    }

    /**
     * @return EntityFactory|\PHPUnit_Framework_MockObject_MockObject
     */
    private function getEntityFactory()
    {
        return $this->getMockEntityFactory(['createQueue']);
    }

    /**
     * @return EventDispatcher|\PHPUnit_Framework_MockObject_MockObject
     */
    private function getEventDispatcher()
    {
        return $this->getMockEventDispatcher(['dispatch']);
    }
}


Push — master ( 51c8d9...38822b )

QueueServiceTest::testSavingScheduledQueue() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php
2
3			declare(strict_types=1);
4
5			namespace Lamoda\QueueBundle\Tests\Unit\Service;
6
7			use DateTime;
8			use Lamoda\QueueBundle\Entity\QueueRepository;
9			use Lamoda\QueueBundle\Event\QueueAttemptsReachedEvent;
10			use Lamoda\QueueBundle\Exception\AttemptsReachedException;
11			use Lamoda\QueueBundle\Exception\UnexpectedValueException;
12			use Lamoda\QueueBundle\Factory\EntityFactory;
13			use Lamoda\QueueBundle\Publisher;
14			use Lamoda\QueueBundle\Service\DelayService;
15			use Lamoda\QueueBundle\Service\QueueService;
16			use Lamoda\QueueBundle\Tests\Unit\Job\StubJob;
17			use Lamoda\QueueBundle\Tests\Unit\QueueCommonServicesTrait;
18			use Lamoda\QueueBundle\Tests\Unit\QueueEntity;
19			use Lamoda\QueueBundle\Tests\Unit\SymfonyMockTrait;
20			use OldSound\RabbitMqBundle\RabbitMq\Producer;
21			use PHPUnit_Framework_TestCase;
22			use Psr\Log\NullLogger;
23			use Symfony\Component\EventDispatcher\EventDispatcher;
24
25			class QueueServiceTest 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...
26			{
27			use QueueCommonServicesTrait;
28			use SymfonyMockTrait;
29
30			/** @var int */
31			protected $maxAttempts = 5;
32
33			/**
34			* @throws \Doctrine\ORM\TransactionRequiredException
35			*/
36			public function testGetToRestore(): void
37			{
38			$limit = 10;
39
40			$queueRepository = $this->getQueueRepository();
41			$queueRepository
			0 ignored issues – show Bug introduced 2019-03-20 17:19 UTC by Report Bug Copy Issue Report The method `expects` does only exist in `PHPUnit_Framework_MockObject_MockObject`, but not in `Lamoda\QueueBundle\Entity\QueueRepository`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
42			->expects($this->once())
43			->method('getToRestore')
44			->with($this->maxAttempts, $limit);
45
46			$this->createService($queueRepository)->getToRestore($limit);
47			}
48
49			/**
50			* @param QueueEntity $queue
51			*
52			* @throws \Exception
53			*
54			* @dataProvider dataGetToProcess()
55			*/
56			public function testGetToProcess(QueueEntity $queue): void
57			{
58			$queueRepository = $this->getQueueRepository();
59			$queueRepository
			0 ignored issues – show Bug introduced 2019-03-20 17:19 UTC by Report Bug Copy Issue Report The method `expects` does only exist in `PHPUnit_Framework_MockObject_MockObject`, but not in `Lamoda\QueueBundle\Entity\QueueRepository`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
60			->expects($this->once())
61			->method('find')
62			->willReturn($queue);
63			$queueRepository
64			->expects($this->once())
65			->method('save')
66			->with($queue);
67
68			$this->assertEquals($queue, $this->createService($queueRepository)->getToProcess(1));
69			$this->assertEquals(QueueEntity::STATUS_IN_PROGRESS_TITLE, $queue->getStatusAsString());
70			}
71
72			public function dataGetToProcess(): array
73			{
74			return [
75			'new status' => [(new QueueEntity('queue', 'exchange', 'ClassJob', ['id' => 1]))->setNew()],
76			'in progress status' => [(new QueueEntity('queue', 'exchange', 'ClassJob', ['id' => 1]))->setInProgress()],
77			];
78			}
79
80			/**
81			* @param null \| QueueEntity $queueEntity
82			* @param string $expectedExceptionMessage
83			*
84			* @throws \Exception
85			*
86			* @dataProvider dataGetToProcessQueueNotFound
87			*/
88			public function testGetToProcessQueueNotFound(?QueueEntity $queueEntity, string $expectedExceptionMessage): void
89			{
90			$this->expectException(UnexpectedValueException::class);
91			$this->expectExceptionMessage($expectedExceptionMessage);
92
93			$queueRepository = $this->getQueueRepository();
94
95			$queueRepository
			0 ignored issues – show Bug introduced 2019-03-20 17:19 UTC by Report Bug Copy Issue Report The method `expects` does only exist in `PHPUnit_Framework_MockObject_MockObject`, but not in `Lamoda\QueueBundle\Entity\QueueRepository`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
96			->expects($this->once())
97			->method('find')
98			->willReturn($queueEntity);
99
100			$this->createService($queueRepository)->getToProcess(1);
101			}
102
103			public function dataGetToProcessQueueNotFound(): array
104			{
105			return [
106			'Not found' => [
107			null,
108			'The queue with id "1" was not found',
109			],
110			'Status not NEW' => [
111			new QueueEntity('queue', 'exchange', 'ClassJob', ['id' => 1]),
112			'The queue "queue" with job "ClassJob" was not found in suitable status. Actual status is "initial"',
113			],
114			];
115			}
116
117			/**
118			* @throws \Exception
119			*/
120			public function testGetToProcessAttemptsReached(): void
121			{
122			$this->expectException(AttemptsReachedException::class);
123
124			$queue = new QueueEntity('queue', 'exchange', 'ClassJob', ['id' => 1]);
125			$queue->setNew();
126
127			$this->maxAttempts = 0;
128
129			$queueRepository = $this->getQueueRepository();
130			$queueRepository
			0 ignored issues – show Bug introduced 2019-03-20 17:19 UTC by Report Bug Copy Issue Report The method `expects` does only exist in `PHPUnit_Framework_MockObject_MockObject`, but not in `Lamoda\QueueBundle\Entity\QueueRepository`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
131			->expects($this->once())
132			->method('find')
133			->willReturn($queue);
134			$queueRepository
135			->expects($this->once())
136			->method('save')
137			->with($queue);
138
139			$attemptsReachedEvent = new QueueAttemptsReachedEvent($queue);
140
141			$eventDispatcher = $this->getEventDispatcher();
142			$eventDispatcher
			0 ignored issues – show Bug introduced 2019-03-20 17:19 UTC by Report Bug Copy Issue Report The method `expects` does only exist in `PHPUnit_Framework_MockObject_MockObject`, but not in `Symfony\Component\EventDispatcher\EventDispatcher`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
143			->expects($this->once())
144			->method('dispatch')
145			->with('queue.attempts.reached.event', $attemptsReachedEvent);
146
147			$this->assertEquals(
148			$queue,
149			$this->createService($queueRepository, null, $eventDispatcher)->getToProcess(1)
150			);
151			$this->assertEquals(QueueEntity::STATUS_ATTEMPTS_REACHED_TITLE, $queue->getStatusAsString());
152			}
153
154			public function testSave(): void
155			{
156			$queue = new QueueEntity('queue', 'exchange', 'ClassJob', ['id' => 1]);
157
158			$queueRepository = $this->getQueueRepository();
159			$queueRepository
			0 ignored issues – show Bug introduced 2019-03-20 17:19 UTC by Report Bug Copy Issue Report The method `expects` does only exist in `PHPUnit_Framework_MockObject_MockObject`, but not in `Lamoda\QueueBundle\Entity\QueueRepository`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
160			->expects($this->once())
161			->method('save')
162			->with($queue)
163			->willReturnArgument(0);
164
165			$this->assertEquals(
166			$queue,
167			$this->createService($queueRepository)->save($queue)
168			);
169			}
170
171			public function testCreateQueue(): void
172			{
173			$job = new StubJob(1);
174			$queue = new QueueEntity('queue', 'exchange', StubJob::class, ['id' => 1]);
175
176			$entityFactory = $this->getEntityFactory();
177			$entityFactory
			0 ignored issues – show Bug introduced 2019-03-20 17:19 UTC by Report Bug Copy Issue Report The method `expects` does only exist in `PHPUnit_Framework_MockObject_MockObject`, but not in `Lamoda\QueueBundle\Factory\EntityFactory`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
178			->expects($this->once())
179			->method('createQueue')
180			->with($job)
181			->willReturn($queue);
182
183			$queueRepository = $this->getQueueRepository();
184
185			$this->assertEquals(
186			$queue,
187			$this->createService($queueRepository, $entityFactory)->createQueue($job)
188			);
189			}
190
191			public function testSavingScheduledQueue(): void
192			{
193			$dateTime = new DateTime();
194			$job = new StubJob(1);
195			$queue = new QueueEntity('queue', 'exchange', StubJob::class, ['id' => 1]);
196			$queue->setScheduled($dateTime);
197
198			$queueRepository = $this->getQueueRepository();
199			$queueRepository
			0 ignored issues – show Bug introduced 2019-03-20 17:19 UTC by Report Bug Copy Issue Report The method `expects` does only exist in `PHPUnit_Framework_MockObject_MockObject`, but not in `Lamoda\QueueBundle\Entity\QueueRepository`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
200			->expects($this->once())
201			->method('save')
202			->with($queue)
203			->willReturnArgument(0);
204
205			$entityFactory = $this->getEntityFactory();
206			$entityFactory
			0 ignored issues – show Bug introduced 2020-02-11 11:21 UTC by Report Bug Copy Issue Report The method `expects` does only exist in `PHPUnit_Framework_MockObject_MockObject`, but not in `Lamoda\QueueBundle\Factory\EntityFactory`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
207			->expects($this->once()) #at least once
208			->method('createQueue')
209			->willReturn($queue);
210
211			$queueService = $this->createService($queueRepository, $entityFactory);
212			$publisher = new Publisher(
213			$this->createMock(Producer::class),
214			$queueService,
215			new NullLogger(),
216			$this->createMock(DelayService::class)
217			);
218
219			$createdQueue = $queueService->createQueue($job);
220			$publisher->prepareQueueForPublish($createdQueue);
221			$publisher->release();
222			}
223
224			public function testIsTransactionActive(): void
225			{
226			$expected = true;
227
228			$queueRepository = $this->getQueueRepository();
229			$queueRepository
			0 ignored issues – show Bug introduced 2019-03-20 17:19 UTC by Report Bug Copy Issue Report The method `expects` does only exist in `PHPUnit_Framework_MockObject_MockObject`, but not in `Lamoda\QueueBundle\Entity\QueueRepository`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
230			->expects($this->once())
231			->method('isTransactionActive')
232			->willReturn($expected);
233
234			$this->assertEquals(
235			$expected,
236			$this->createService($queueRepository)->isTransactionActive()
237			);
238			}
239
240			private function createService(
241			?QueueRepository $repository = null,
242			?EntityFactory $entityFactory = null,
243			?EventDispatcher $eventDispatcher = null
244			): QueueService {
245			return new QueueService(
246			$repository ?? $this->getQueueRepository(),
247			$entityFactory ?? $this->getEntityFactory(),
248			$eventDispatcher ?? $this->getEventDispatcher(),
249			$this->maxAttempts
250			);
251			}
252
253			/**
254			* @return \PHPUnit_Framework_MockObject_MockObject\|QueueRepository
255			*/
256			private function getQueueRepository()
257			{
258			return $this->getMockQueueRepository(
259			[
260			'find',
261			'getToRestore',
262			'save',
263			'isTransactionActive',
264			]
265			);
266			}
267
268			/**
269			* @return EntityFactory\|\PHPUnit_Framework_MockObject_MockObject
270			*/
271			private function getEntityFactory()
272			{
273			return $this->getMockEntityFactory(['createQueue']);
274			}
275
276			/**
277			* @return EventDispatcher\|\PHPUnit_Framework_MockObject_MockObject
278			*/
279			private function getEventDispatcher()
280			{
281			return $this->getMockEventDispatcher(['dispatch']);
282			}
283			}
284

lamoda / queue-bundle

Push — master ( 51c8d9...38822b )

QueueServiceTest::testSavingScheduledQueue() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like