JobQueueTest - Code Metrics - sfcod/jobqueue - Measure and Improve Code Quality continuously with Scrutinizer

JobQueueTest A
last analyzed 2021-05-24 05:03 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	225
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

Metric	Value
wmc	9
lcom	1
cbo	5
dl	0
loc	225
rs	10
c	0
b	0
f	0

8 Methods

Rating	Name	Size	Complexity
A	mockJobQueue()	9	1
A	mockManager()	13	1
A	setUp()	4	1
A	testPush()	18	1
A	testPushUnique()	48	1
A	testBulk()	23	2
A	testLater()	19	1
A	testLaterUnique()	49	1

<?php

namespace SfCod\QueueBundle\Tests\Service;

use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
use SfCod\QueueBundle\Queue\QueueInterface;
use SfCod\QueueBundle\Service\JobQueue;
use SfCod\QueueBundle\Service\QueueManager;
use SfCod\QueueBundle\Tests\Data\LoadTrait;

/**
 * Class JobQueueTest
 *
 * @author Virchenko Maksim <[email protected]>
 *
 * @package SfCod\QueueBundle\Tests\Service
 */
class JobQueueTest extends TestCase
{
    use LoadTrait;

    /**
     * Set up test
     */
    protected function setUp()
    {
        $this->configure();
    }

    /**
     * Test pushing into queue
     */
    public function testPush()
    {
        $job = uniqid('job_');
        $data = array_rand(range(0, 100), 10);
        $queue = uniqid('queue_');
        $connection = uniqid('connection_');

        $manager = $this->mockManager();
        $manager
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(self::once())
            ->method('push')
            ->with($job, $data, $queue, $connection)
            ->willReturn(true);

        $jobQueue = $this->mockJobQueue($manager);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        self::assertTrue($jobQueue->push($job, $data, $queue, $connection));
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.
}
    }

    /**
     * Test push unique job into queue
     */
    public function testPushUnique()
    {
        $job = uniqid('job_');
        $data = array_rand(range(0, 100), 10);
        $queue = uniqid('queue_');
        $connection = uniqid('connection_');

        $connectionMock = $this->createMock(QueueInterface::class);
        $connectionMock
            ->expects(self::once())
            ->method('exists')
            ->with(self::equalTo($job), self::equalTo($data), self::equalTo($queue))
            ->willReturn(false);

        $manager = $this->mockManager();
        $manager
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(self::once())
            ->method('connection')
            ->with(self::equalTo($connection))
            ->willReturn($connectionMock);
        $manager
            ->expects(self::once())
            ->method('push')
            ->with($job, $data, $queue, $connection)
            ->willReturn(true);

        $jobQueue = $this->mockJobQueue($manager);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        self::assertTrue($jobQueue->pushUnique($job, $data, $queue, $connection));
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.
}

        $connectionMock = $this->createMock(QueueInterface::class);
        $connectionMock
            ->expects(self::once())
            ->method('exists')
            ->with(self::equalTo($job), self::equalTo($data), self::equalTo($queue))
            ->willReturn(true);

        $manager = $this->mockManager();
        $manager
            ->expects(self::once())
            ->method('connection')
            ->with(self::equalTo($connection))
            ->willReturn($connectionMock);

        $jobQueue = $this->mockJobQueue($manager);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        self::assertNull($jobQueue->pushUnique($job, $data, $queue, $connection));
    }

    /**
     * Test bulk pushing into queue
     */
    public function testBulk()
    {
        $jobs = [];

        for ($i = 0; $i < 10; ++$i) {
            $jobs[] = uniqid('job_' . $i);
        }

        $data = array_rand(range(0, 100), 10);
        $queue = uniqid('queue_');
        $connection = uniqid('connection_');

        $manager = $this->mockManager();
        $manager
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(self::once())
            ->method('bulk')
            ->with($jobs, $data, $queue, $connection)
            ->willReturn(true);

        $jobQueue = $this->mockJobQueue($manager);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        self::assertTrue($jobQueue->bulk($jobs, $data, $queue, $connection));
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.
}
    }

    /**
     * Test pushing job with delay
     */
    public function testLater()
    {
        $delay = rand(1, 1000);
        $job = uniqid('job_');
        $data = array_rand(range(0, 100), 10);
        $queue = uniqid('queue_');
        $connection = uniqid('connection_');

        $manager = $this->mockManager();
        $manager
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(self::once())
            ->method('later')
            ->with($delay, $job, $data, $queue, $connection)
            ->willReturn(true);

        $jobQueue = $this->mockJobQueue($manager);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        self::assertTrue($jobQueue->later($delay, $job, $data, $queue, $connection));
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.
}
    }

    /**
     * Test push unique job with delay into queue
     */
    public function testLaterUnique()
    {
        $delay = rand(1, 1000);
        $job = uniqid('job_');
        $data = array_rand(range(0, 100), 10);
        $queue = uniqid('queue_');
        $connection = uniqid('connection_');

        $connectionMock = $this->createMock(QueueInterface::class);
        $connectionMock
            ->expects(self::once())
            ->method('exists')
            ->with(self::equalTo($job), self::equalTo($data), self::equalTo($queue))
            ->willReturn(false);

        $manager = $this->mockManager();
        $manager
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(self::once())
            ->method('connection')
            ->with(self::equalTo($connection))
            ->willReturn($connectionMock);
        $manager
            ->expects(self::once())
            ->method('later')
            ->with($delay, $job, $data, $queue, $connection)
            ->willReturn(true);

        $jobQueue = $this->mockJobQueue($manager);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        self::assertTrue($jobQueue->laterUnique($delay, $job, $data, $queue, $connection));
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.
}

        $connectionMock = $this->createMock(QueueInterface::class);
        $connectionMock
            ->expects(self::once())
            ->method('exists')
            ->with(self::equalTo($job), self::equalTo($data), self::equalTo($queue))
            ->willReturn(true);

        $manager = $this->mockManager();
        $manager
            ->expects(self::once())
            ->method('connection')
            ->with(self::equalTo($connection))
            ->willReturn($connectionMock);

        $jobQueue = $this->mockJobQueue($manager);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        self::assertNull($jobQueue->laterUnique($delay, $job, $data, $queue, $connection));
    }

    /**
     * Mock job queue
     *
     * @param QueueManager $manager
     *
     * @return JobQueue|MockObject
     */
    private function mockJobQueue(QueueManager $manager): JobQueue
    {
        $jobQueue = $this->getMockBuilder(JobQueue::class)
            ->setConstructorArgs([$manager])
            ->setMethods(null)
            ->getMock();

        return $jobQueue;
    }

    /**
     * Mock manager
     *
     * @return QueueManager|MockObject
     */
    private function mockManager(): QueueManager
    {
        $manager = $this->getMockBuilder(QueueManager::class)
            ->setMethods([
                'push',
                'bulk',
                'later',
                'connection',
            ])
            ->getMock();

        return $manager;
    }
}


JobQueueTest A
last analyzed 2021-05-24 05:03 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

8 Methods

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php
2
3			namespace SfCod\QueueBundle\Tests\Service;
4
5			use PHPUnit\Framework\MockObject\MockObject;
6			use PHPUnit\Framework\TestCase;
7			use SfCod\QueueBundle\Queue\QueueInterface;
8			use SfCod\QueueBundle\Service\JobQueue;
9			use SfCod\QueueBundle\Service\QueueManager;
10			use SfCod\QueueBundle\Tests\Data\LoadTrait;
11
12			/**
13			* Class JobQueueTest
14			*
15			* @author Virchenko Maksim <[email protected]>
16			*
17			* @package SfCod\QueueBundle\Tests\Service
18			*/
19			class JobQueueTest extends TestCase
20			{
21			use LoadTrait;
22
23			/**
24			* Set up test
25			*/
26			protected function setUp()
27			{
28			$this->configure();
29			}
30
31			/**
32			* Test pushing into queue
33			*/
34			public function testPush()
35			{
36			$job = uniqid('job_');
37			$data = array_rand(range(0, 100), 10);
38			$queue = uniqid('queue_');
39			$connection = uniqid('connection_');
40

sfcod / jobqueue

JobQueueTest A last analyzed 2021-05-24 05:03 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

8 Methods

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

JobQueueTest A
last analyzed 2021-05-24 05:03 UTC