RedisQueueTest::testSearchTasks() - Code Metrics - bricev/JobQueue - Measure and Improve Code Quality continuously with Scrutinizer

RedisQueueTest::testSearchTasks() A
last analyzed 2018-05-30 15:01 UTC

↳ Parent: RedisQueueTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	9
rs	9.6666
c	0
b	0
f	0
cc	1
eloc	7
nc	1
nop	1

<?php

namespace JobQueue\Tests\Infrastructure;

use JobQueue\Domain\Task\Profile;
use JobQueue\Domain\Task\Queue;
use JobQueue\Domain\Task\Status;
use JobQueue\Domain\Task\Task;
use JobQueue\Infrastructure\RedisQueue;
use JobQueue\Tests\Domain\Job\DummyJob;
use PHPUnit\Framework\TestCase;
use Predis\Client;

final class RedisQueueTest extends TestCase
{
    /**
     *
     * @var Task[]
     */
    private static $tasks = [];

    public static function setUpBeforeClass()
    {
        self::$tasks[] = new Task(
            new Profile('profile1'),
            new DummyJob,
            [
                'param1' => 'value1a',
                'param2' => 'value2a',
            ],
            [
                'tag1',
                'tag2',
            ]
        );
        self::$tasks[] = new Task(
            new Profile('profile1'),
            new DummyJob,
            [
                'param1' => 'value1b',
                'param3' => 'value3b',
            ],
            [
                'tag1',
                'tag3',
            ]
        );
        self::$tasks[] = new Task(
            new Profile('profile2'),
            new DummyJob,
            [
                'param2' => 'value2c',
                'param3' => 'value3c',
            ],
            [
                'tag2',
                'tag4',
            ]
        );
    }

    /**
     *
     * @return RedisQueue
     */
    public function testCreateQueue(): RedisQueue
    {
        $queue = new RedisQueue(new Client);

        $this->assertInstanceOf(Queue::class, $queue);

        return $queue;
    }

    /**
     *
     * @param RedisQueue $queue
     * @depends testCreateQueue
     */
    public function testAddTasks(RedisQueue $queue)
    {
        foreach (self::$tasks as $task) {
            $queue->add($task);
        }

        $this->assertEquals(3, count($queue->search()));
    }

    /**
     *
     * @param RedisQueue $queue
     * @depends testCreateQueue
     */
    public function testFindTask(RedisQueue $queue)
    {
        $identifier = (string) self::$tasks[0]->getIdentifier();

        $task = $queue->find($identifier);

        $this->assertEquals($identifier, (string) $task->getIdentifier());
    }

    /**
     *
     * @param RedisQueue $queue
     * @return RedisQueue
     * @depends testCreateQueue
     */
    public function testFetchTask(RedisQueue $queue): RedisQueue
    {
        $task = $queue->fetch(new Profile('profile1'));

        $this->assertEquals(Status::RUNNING, (string) $task->getStatus());
        $this->assertEquals((string) self::$tasks[0]->getIdentifier(), (string) $task->getIdentifier());

        return $queue;
    }

    /**
     *
     * @param RedisQueue $queue
     * @depends testFetchTask
     */
    public function testSearchTasks(RedisQueue $queue)
    {
        $this->assertEquals(2, count($queue->search(new Profile('profile1'))));
        $this->assertEquals(1, count($queue->search(new Profile('profile2'))));
        $this->assertEquals(2, count($queue->search(null, new Status(Status::WAITING))));
        $this->assertEquals(1, count($queue->search(null, new Status(Status::RUNNING))));
        $this->assertEquals(2, count($queue->search(null, null, ['tag1'])));
        $this->assertEquals(1, count($queue->search(null, null, ['tag4'])));
        $this->assertEquals(3, count($queue->search(null, null, ['tag1', 'tag4'])));
    }

    /**
     *
     * @param RedisQueue $queue
     * @return RedisQueue
     * @depends testFetchTask
     */
    public function testUpdateTask(RedisQueue $queue): RedisQueue
    {
        $identifier = (string) self::$tasks[1]->getIdentifier();

        $task = $queue->fetch(new Profile('profile1'));
        $this->assertEquals(Status::RUNNING, (string) $task->getStatus());
        $this->assertEquals($identifier, (string) $task->getIdentifier());

        $queue->updateStatus($task, new Status(Status::FINISHED));
        $task = $queue->find($identifier);
        $this->assertEquals(Status::FINISHED, (string) $task->getStatus());

        return $queue;
    }

    /**
     *
     * @param RedisQueue $queue
     * @depends testUpdateTask
     */
    public function testDeleteTask(RedisQueue $queue)
    {
        $identifier = (string) self::$tasks[2]->getIdentifier();

        $queue->delete($identifier);

        $this->expectExceptionMessage(sprintf('Task %s does not exists', $identifier));
        $queue->find($identifier);
    }

    /**
     *
     * @param RedisQueue $queue
     * @return RedisQueue
     * @depends testUpdateTask
     */
    public function testRestoreTask(RedisQueue $queue): RedisQueue
    {
        $queue->restore();

        foreach ($queue->search() as $task) {
            $this->assertTrue(in_array((string) $task->getStatus(), [
                Status::WAITING,
                Status::FINISHED,
            ]));
        }

        return $queue;
    }

    /**
     *
     * @param RedisQueue $queue
     * @depends testRestoreTask
     */
    public function testFlushTask(RedisQueue $queue)
    {
        $queue->flush();
        $this->assertEmpty($queue->search());
    }
}


1			<?php
2
3			namespace JobQueue\Tests\Infrastructure;
4
5			use JobQueue\Domain\Task\Profile;
6			use JobQueue\Domain\Task\Queue;
7			use JobQueue\Domain\Task\Status;
8			use JobQueue\Domain\Task\Task;
9			use JobQueue\Infrastructure\RedisQueue;
10			use JobQueue\Tests\Domain\Job\DummyJob;
11			use PHPUnit\Framework\TestCase;
12			use Predis\Client;
13
14			final class RedisQueueTest extends TestCase
15			{
16			/**
17			*
18			* @var Task[]
19			*/
20			private static $tasks = [];
21
22			public static function setUpBeforeClass()
23			{
24			self::$tasks[] = new Task(
25			new Profile('profile1'),
26			new DummyJob,
27			[
28			'param1' => 'value1a',
29			'param2' => 'value2a',
30			],
31			[
32			'tag1',
33			'tag2',
34			]
35			);
36			self::$tasks[] = new Task(
37			new Profile('profile1'),
38			new DummyJob,
39			[
40			'param1' => 'value1b',
41			'param3' => 'value3b',
42			],
43			[
44			'tag1',
45			'tag3',
46			]
47			);
48			self::$tasks[] = new Task(
49			new Profile('profile2'),
50			new DummyJob,
51			[
52			'param2' => 'value2c',
53			'param3' => 'value3c',
54			],
55			[
56			'tag2',
57			'tag4',
58			]
59			);
60			}
61
62			/**
63			*
64			* @return RedisQueue
65			*/
66			public function testCreateQueue(): RedisQueue
67			{
68			$queue = new RedisQueue(new Client);
69
70			$this->assertInstanceOf(Queue::class, $queue);
71
72			return $queue;
73			}
74
75			/**
76			*
77			* @param RedisQueue $queue
78			* @depends testCreateQueue
79			*/
80			public function testAddTasks(RedisQueue $queue)
81			{
82			foreach (self::$tasks as $task) {
83			$queue->add($task);
84			}
85
86			$this->assertEquals(3, count($queue->search()));
87			}
88
89			/**
90			*
91			* @param RedisQueue $queue
92			* @depends testCreateQueue
93			*/
94			public function testFindTask(RedisQueue $queue)
95			{
96			$identifier = (string) self::$tasks[0]->getIdentifier();
97
98			$task = $queue->find($identifier);
99
100			$this->assertEquals($identifier, (string) $task->getIdentifier());
101			}
102
103			/**
104			*
105			* @param RedisQueue $queue
106			* @return RedisQueue
107			* @depends testCreateQueue
108			*/
109			public function testFetchTask(RedisQueue $queue): RedisQueue
110			{
111			$task = $queue->fetch(new Profile('profile1'));
112
113			$this->assertEquals(Status::RUNNING, (string) $task->getStatus());
114			$this->assertEquals((string) self::$tasks[0]->getIdentifier(), (string) $task->getIdentifier());
115
116			return $queue;
117			}
118
119			/**
120			*
121			* @param RedisQueue $queue
122			* @depends testFetchTask
123			*/
124			public function testSearchTasks(RedisQueue $queue)
125			{
126			$this->assertEquals(2, count($queue->search(new Profile('profile1'))));
127			$this->assertEquals(1, count($queue->search(new Profile('profile2'))));
128			$this->assertEquals(2, count($queue->search(null, new Status(Status::WAITING))));
129			$this->assertEquals(1, count($queue->search(null, new Status(Status::RUNNING))));
130			$this->assertEquals(2, count($queue->search(null, null, ['tag1'])));
131			$this->assertEquals(1, count($queue->search(null, null, ['tag4'])));
132			$this->assertEquals(3, count($queue->search(null, null, ['tag1', 'tag4'])));
133			}
134
135			/**
136			*
137			* @param RedisQueue $queue
138			* @return RedisQueue
139			* @depends testFetchTask
140			*/
141			public function testUpdateTask(RedisQueue $queue): RedisQueue
142			{
143			$identifier = (string) self::$tasks[1]->getIdentifier();
144
145			$task = $queue->fetch(new Profile('profile1'));
146			$this->assertEquals(Status::RUNNING, (string) $task->getStatus());
147			$this->assertEquals($identifier, (string) $task->getIdentifier());
148
149			$queue->updateStatus($task, new Status(Status::FINISHED));
150			$task = $queue->find($identifier);
151			$this->assertEquals(Status::FINISHED, (string) $task->getStatus());
152
153			return $queue;
154			}
155
156			/**
157			*
158			* @param RedisQueue $queue
159			* @depends testUpdateTask
160			*/
161			public function testDeleteTask(RedisQueue $queue)
162			{
163			$identifier = (string) self::$tasks[2]->getIdentifier();
164
165			$queue->delete($identifier);
166
167			$this->expectExceptionMessage(sprintf('Task %s does not exists', $identifier));
168			$queue->find($identifier);
169			}
170
171			/**
172			*
173			* @param RedisQueue $queue
174			* @return RedisQueue
175			* @depends testUpdateTask
176			*/
177			public function testRestoreTask(RedisQueue $queue): RedisQueue
178			{
179			$queue->restore();
180
181			foreach ($queue->search() as $task) {
182			$this->assertTrue(in_array((string) $task->getStatus(), [
183			Status::WAITING,
184			Status::FINISHED,
185			]));
186			}
187
188			return $queue;
189			}
190
191			/**
192			*
193			* @param RedisQueue $queue
194			* @depends testRestoreTask
195			*/
196			public function testFlushTask(RedisQueue $queue)
197			{
198			$queue->flush();
199			$this->assertEmpty($queue->search());
200			}
201			}
202

bricev / JobQueue

RedisQueueTest::testSearchTasks() A last analyzed 2018-05-30 15:01 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

RedisQueueTest::testSearchTasks() A
last analyzed 2018-05-30 15:01 UTC