JobManagerTest::getBaseStatus() - Code Metrics - Inspection of "Issue #42 expand redis statistics for Count Comman..." - mmucklo/DtcQueueBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 165f6b...2c48ba )

by Matthew

created 2018-01-22 05:41 UTC

JobManagerTest::getBaseStatus() A

↳ Parent: JobManagerTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	21
Code Lines	16

Duplication

Lines	21
Ratio	100 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	21
loc	21
rs	9.3142
cc	1
eloc	16
nc	1
nop	0

<?php

namespace Dtc\QueueBundle\Tests\Redis;

use Dtc\QueueBundle\Model\BaseJob;
use Dtc\QueueBundle\Model\Job;
use Dtc\QueueBundle\Model\JobTiming;
use Dtc\QueueBundle\Manager\JobTimingManager;
use Dtc\QueueBundle\Model\RetryableJob;
use Dtc\QueueBundle\Model\Run;
use Dtc\QueueBundle\Manager\RunManager;
use Dtc\QueueBundle\Redis\JobManager;
use Dtc\QueueBundle\Redis\Predis;
use Dtc\QueueBundle\Tests\FibonacciWorker;
use Dtc\QueueBundle\Tests\Manager\AutoRetryTrait;
use Dtc\QueueBundle\Tests\Manager\BaseJobManagerTest;
use Dtc\QueueBundle\Tests\Manager\PriorityTestTrait;
use Dtc\QueueBundle\Tests\Manager\RetryableTrait;
use Dtc\QueueBundle\Util\Util;
use Predis\Client;

/**
 * @author David
 *
 * This test requires local beanstalkd running
 */
class JobManagerTest extends BaseJobManagerTest
{
    use PriorityTestTrait;
    use AutoRetryTrait;
    use RetryableTrait;
    public static $connection;

    public static function setUpBeforeClass()
    {
        $host = getenv('REDIS_HOST');
        $port = getenv('REDIS_PORT') ?: 6379;
        $jobTimingClass = JobTiming::class;
        $runClass = Run::class;
        $predisClient = new Client(['scheme' => 'tcp', 'host' => $host, 'port' => $port]);
        $predisClient->flushall();
        $predis = new Predis($predisClient);

        self::$jobTimingManager = new JobTimingManager($jobTimingClass, false);
        self::$runManager = new RunManager($runClass);
        self::$jobManager = new JobManager(self::$runManager, self::$jobTimingManager, \Dtc\QueueBundle\Redis\Job::class, 'test_cache_key');
        self::$jobManager->setRedis($predis);
        self::$jobManager->setMaxPriority(255);
        self::$worker = new FibonacciWorker();
        parent::setUpBeforeClass();
    }

    public function testConstructor()

    {
        $test = null;
        try {
            $test = new JobManager(self::$runManager, self::$jobTimingManager, Job::class, 'something');
        } catch (\Exception $exception) {
            self::fail("shouldn't get here");
        }
        self::assertNotNull($test);
    }

    public function testGetJobByWorker()

    {
        $failed = false;
        try {
            self::$jobManager->getJob(self::$worker->getName());
            $failed = true;
        } catch (\Exception $exception) {
            self::assertTrue(true);
        }
        self::assertFalse($failed);
    }

    public function testExpiredJob()

    {
        $job = new self::$jobClass(self::$worker, false, null);
        $time = time() - 1;
        $job->setExpiresAt(new \DateTime("@$time"))->fibonacci(1);
        self::assertNotNull($job->getId(), 'Job id should be generated');

        $jobInQueue = self::$jobManager->getJob();
        self::assertNull($jobInQueue, 'The job should have been dropped...');

        $job = new self::$jobClass(self::$worker, false, null);
        $time = time() - 1;
        $job->setExpiresAt(new \DateTime("@$time"))->fibonacci(1);

        $job = new self::$jobClass(self::$worker, false, null);
        $time = time() - 1;
        $job->setExpiresAt(new \DateTime("@$time"))->fibonacci(5);

        $job = new self::$jobClass(self::$worker, false, null);
        $time = time() - 1;
        $job->setExpiresAt(new \DateTime("@$time"))->fibonacci(2);

        $job = new self::$jobClass(self::$worker, false, null);
        $job->fibonacci(1);
        $jobInQueue = self::$jobManager->getJob();
        self::assertNotNull($jobInQueue, 'There should be a job.');
        self::assertEquals(
            $job->getId(),
            $jobInQueue->getId(),
            'Job id returned by manager should be the same'
        );
    }

    public function testBatchJobs()
    {
        $limit = 10000;
        while ($limit && self::$jobManager->getJob()) {
            --$limit;
        }
        self::assertGreaterThan(0, $limit);

        /** @var JobManager|\Dtc\QueueBundle\ORM\JobManager $jobManager */
        $worker = self::$worker;
        $job1 = $worker->later()->fibonacci(1);
        $job2 = $worker->batchLater()->fibonacci(1);

        self::assertEquals($job1->getId(), $job2->getId());

        $job = self::$jobManager->getJob();
        self::assertEquals($job1->getId(), $job->getId());
        self::assertEquals($job1->getPriority(), $job->getPriority());

        $job = self::$jobManager->getJob();
        self::assertNull($job);

        $job1 = $worker->later()->fibonacci(1);
        $job2 = $worker->batchLater()->setPriority(3)->fibonacci(1);
        self::assertEquals($job1->getId(), $job2->getId());
        self::assertNotEquals($job1->getPriority(), $job2->getPriority());

        $job = self::$jobManager->getJob();
        self::assertNotNull($job);
        self::assertEquals($job1->getId(), $job->getId());
        self::assertEquals($job->getPriority(), $job2->getPriority());

        $job = self::$jobManager->getJob();
        self::assertNull($job);

        $job1 = $worker->later(100)->fibonacci(1);
        $time1 = new \DateTime('@'.time());
        $job2 = $worker->batchLater(0)->fibonacci(1);
        $time2 = Util::getDateTimeFromDecimalFormat(Util::getMicrotimeDecimal());

        self::assertEquals($job1->getId(), $job2->getId());
        self::assertGreaterThanOrEqual($time1, $job2->getWhenAt());
        self::assertLessThanOrEqual($time2, $job2->getWhenAt());

        $job = self::$jobManager->getJob();
        self::assertNotNull($job);
        self::assertEquals($job1->getId(), $job->getId());
        self::assertNotNull($job->getPriority());
        self::assertGreaterThanOrEqual($time1, $job->getWhenAt());
        self::assertLessThanOrEqual($time2, $job->getWhenAt());

        $job1 = $worker->later(100)->setPriority(3)->fibonacci(1);
        $priority1 = $job1->getPriority();
        $time1 = Util::getDateTimeFromDecimalFormat(Util::getMicrotimeDecimal());
        $job2 = $worker->batchLater(0)->setPriority(1)->fibonacci(1);
        $time2 = Util::getDateTimeFromDecimalFormat(Util::getMicrotimeDecimal());
        self::assertEquals($job1->getId(), $job2->getId());
        self::assertNotEquals($priority1, $job2->getPriority());

        self::assertGreaterThanOrEqual($time1, $job2->getWhenAt());
        self::assertLessThanOrEqual($time2, $job2->getWhenAt());

        $limit = 10000;
        while ($limit && self::$jobManager->getJob()) {
            --$limit;
        }
    }

    public function testSaveJob()

    {
        // Make sure a job proper type
        $failed = false;
        try {
            $job = new Job();
            self::$jobManager->save($job);
            $failed = true;
        } catch (\Exception $exception) {
            self::assertTrue(true);
        }
        self::assertFalse($failed);

        $job = new self::$jobClass(self::$worker, false, null);
        try {
            $job->setPriority(256)->fibonacci(1);
            $failed = true;
        } catch (\Exception $exception) {
            self::assertTrue(true);
        }
        self::assertFalse($failed);

        $job = new self::$jobClass(self::$worker, false, null);
        $job->setPriority(100)->fibonacci(1);
        self::assertNotNull($job->getId(), 'Job id should be generated');

        $jobInQueue = self::$jobManager->getJob();
        self::assertNotNull($jobInQueue, 'There should be a job.');
        self::$jobManager->saveHistory($jobInQueue);

        $job = new self::$jobClass(self::$worker, false, null);
        $job->fibonacci(1);
        self::assertNotNull($job->getId(), 'Job id should be generated');

        $failed = false;
        try {
            self::$jobManager->getJob('fibonacci');
            $failed = true;
        } catch (\Exception $exception) {
            self::assertTrue(true);
        }
        self::assertFalse($failed);

        $failed = false;
        try {
            self::$jobManager->getJob(null, 'fibonacci');
            $failed = true;
        } catch (\Exception $exception) {
            self::assertTrue(true);
        }
        self::assertFalse($failed);

        $jobInQueue = self::$jobManager->getJob();
        self::assertNotNull($jobInQueue, 'There should be a job.');
        self::assertEquals(
            $job->getId(),
            $jobInQueue->getId(),
            'Job id returned by manager should be the same'
        );

        $job->setStatus(BaseJob::STATUS_SUCCESS);
        $badJob = new Job();
        $failed = false;
        try {
            self::$jobManager->saveHistory($badJob);
            $failed = true;
        } catch (\Exception $exception) {
            self::assertTrue(true);
        }
        self::assertFalse($failed);
        self::$jobManager->saveHistory($jobInQueue);
    }

    public function testGetStatus()
    {
        list(, $status1) = $this->getBaseStatus();
        list(, $status2) = $this->getBaseStatus();
        $fibonacciStatus1 = $status1['fibonacci->fibonacci()'];
        $fibonacciStatus2 = $status2['fibonacci->fibonacci()'];

        self::assertEquals($fibonacciStatus1[BaseJob::STATUS_NEW] + 1, $fibonacciStatus2[BaseJob::STATUS_NEW]);
    }

    protected function getBaseStatus()

    {
        /** @var JobManager|\Dtc\QueueBundle\ORM\JobManager $jobManager */
        $jobManager = self::$jobManager;
        $job = new self::$jobClass(self::$worker, false, null);
        $job->fibonacci(1);
        $status = $jobManager->getStatus();
        self::assertArrayHasKey('fibonacci->fibonacci()', $status);
        $fibonacciStatus = $status['fibonacci->fibonacci()'];

        self::assertArrayHasKey(BaseJob::STATUS_NEW, $fibonacciStatus);
        self::assertArrayHasKey(BaseJob::STATUS_EXCEPTION, $fibonacciStatus);
        self::assertArrayHasKey(BaseJob::STATUS_RUNNING, $fibonacciStatus);
        self::assertArrayHasKey(BaseJob::STATUS_SUCCESS, $fibonacciStatus);
        self::assertArrayHasKey(Job::STATUS_EXPIRED, $fibonacciStatus);
        self::assertArrayHasKey(RetryableJob::STATUS_MAX_EXCEPTIONS, $fibonacciStatus);
        self::assertArrayHasKey(RetryableJob::STATUS_MAX_FAILURES, $fibonacciStatus);
        self::assertArrayHasKey(RetryableJob::STATUS_MAX_RETRIES, $fibonacciStatus);

        return [$job, $status];
    }
}


1		<?php
2
3		namespace Dtc\QueueBundle\Tests\Redis;
4
5		use Dtc\QueueBundle\Model\BaseJob;
6		use Dtc\QueueBundle\Model\Job;
7		use Dtc\QueueBundle\Model\JobTiming;
8		use Dtc\QueueBundle\Manager\JobTimingManager;
9		use Dtc\QueueBundle\Model\RetryableJob;
10		use Dtc\QueueBundle\Model\Run;
11		use Dtc\QueueBundle\Manager\RunManager;
12		use Dtc\QueueBundle\Redis\JobManager;
13		use Dtc\QueueBundle\Redis\Predis;
14		use Dtc\QueueBundle\Tests\FibonacciWorker;
15		use Dtc\QueueBundle\Tests\Manager\AutoRetryTrait;
16		use Dtc\QueueBundle\Tests\Manager\BaseJobManagerTest;
17		use Dtc\QueueBundle\Tests\Manager\PriorityTestTrait;
18		use Dtc\QueueBundle\Tests\Manager\RetryableTrait;
19		use Dtc\QueueBundle\Util\Util;
20		use Predis\Client;
21
22		/**
23		* @author David
24		*
25		* This test requires local beanstalkd running
26		*/
27		class JobManagerTest extends BaseJobManagerTest
28		{
29		use PriorityTestTrait;
30		use AutoRetryTrait;
31		use RetryableTrait;
32		public static $connection;
33
34		public static function setUpBeforeClass()
35		{
36		$host = getenv('REDIS_HOST');
37		$port = getenv('REDIS_PORT') ?: 6379;
38		$jobTimingClass = JobTiming::class;
39		$runClass = Run::class;
40		$predisClient = new Client(['scheme' => 'tcp', 'host' => $host, 'port' => $port]);
41		$predisClient->flushall();
42		$predis = new Predis($predisClient);
43
44		self::$jobTimingManager = new JobTimingManager($jobTimingClass, false);
45		self::$runManager = new RunManager($runClass);
46		self::$jobManager = new JobManager(self::$runManager, self::$jobTimingManager, \Dtc\QueueBundle\Redis\Job::class, 'test_cache_key');
47		self::$jobManager->setRedis($predis);
48		self::$jobManager->setMaxPriority(255);
49		self::$worker = new FibonacciWorker();
50		parent::setUpBeforeClass();
51		}
52
53	View Code Duplication	public function testConstructor()
		0 ignored issues – show Duplication introduced 2018-01-07 01:22 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...
54		{
55		$test = null;
56		try {
57		$test = new JobManager(self::$runManager, self::$jobTimingManager, Job::class, 'something');
58		} catch (\Exception $exception) {
59		self::fail("shouldn't get here");
60		}
61		self::assertNotNull($test);
62		}
63
64	View Code Duplication	public function testGetJobByWorker()
		0 ignored issues – show Duplication introduced 2018-01-07 01:22 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...
65		{
66		$failed = false;
67		try {
68		self::$jobManager->getJob(self::$worker->getName());
69		$failed = true;
70		} catch (\Exception $exception) {
71		self::assertTrue(true);
72		}
73		self::assertFalse($failed);
74		}
75
76	View Code Duplication	public function testExpiredJob()
		0 ignored issues – show Duplication introduced 2018-01-07 01:22 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...
77		{
78		$job = new self::$jobClass(self::$worker, false, null);
79		$time = time() - 1;
80		$job->setExpiresAt(new \DateTime("@$time"))->fibonacci(1);
81		self::assertNotNull($job->getId(), 'Job id should be generated');
82
83		$jobInQueue = self::$jobManager->getJob();
84		self::assertNull($jobInQueue, 'The job should have been dropped...');
85
86		$job = new self::$jobClass(self::$worker, false, null);
87		$time = time() - 1;
88		$job->setExpiresAt(new \DateTime("@$time"))->fibonacci(1);
89
90		$job = new self::$jobClass(self::$worker, false, null);
91		$time = time() - 1;
92		$job->setExpiresAt(new \DateTime("@$time"))->fibonacci(5);
93
94		$job = new self::$jobClass(self::$worker, false, null);
95		$time = time() - 1;
96		$job->setExpiresAt(new \DateTime("@$time"))->fibonacci(2);
97
98		$job = new self::$jobClass(self::$worker, false, null);
99		$job->fibonacci(1);
100		$jobInQueue = self::$jobManager->getJob();
101		self::assertNotNull($jobInQueue, 'There should be a job.');
102		self::assertEquals(
103		$job->getId(),
104		$jobInQueue->getId(),
105		'Job id returned by manager should be the same'
106		);
107		}
108
109		public function testBatchJobs()
110		{
111		$limit = 10000;
112		while ($limit && self::$jobManager->getJob()) {
113		--$limit;
114		}
115		self::assertGreaterThan(0, $limit);
116
117		/** @var JobManager\|\Dtc\QueueBundle\ORM\JobManager $jobManager */
118		$worker = self::$worker;
119		$job1 = $worker->later()->fibonacci(1);
120		$job2 = $worker->batchLater()->fibonacci(1);
121
122		self::assertEquals($job1->getId(), $job2->getId());
123
124		$job = self::$jobManager->getJob();
125		self::assertEquals($job1->getId(), $job->getId());
126		self::assertEquals($job1->getPriority(), $job->getPriority());
127
128		$job = self::$jobManager->getJob();
129		self::assertNull($job);
130
131		$job1 = $worker->later()->fibonacci(1);
132		$job2 = $worker->batchLater()->setPriority(3)->fibonacci(1);
133		self::assertEquals($job1->getId(), $job2->getId());
134		self::assertNotEquals($job1->getPriority(), $job2->getPriority());
135
136		$job = self::$jobManager->getJob();
137		self::assertNotNull($job);
138		self::assertEquals($job1->getId(), $job->getId());
139		self::assertEquals($job->getPriority(), $job2->getPriority());
140
141		$job = self::$jobManager->getJob();
142		self::assertNull($job);
143
144		$job1 = $worker->later(100)->fibonacci(1);
145		$time1 = new \DateTime('@'.time());
146		$job2 = $worker->batchLater(0)->fibonacci(1);
147		$time2 = Util::getDateTimeFromDecimalFormat(Util::getMicrotimeDecimal());
148
149		self::assertEquals($job1->getId(), $job2->getId());
150		self::assertGreaterThanOrEqual($time1, $job2->getWhenAt());
151		self::assertLessThanOrEqual($time2, $job2->getWhenAt());
152
153		$job = self::$jobManager->getJob();
154		self::assertNotNull($job);
155		self::assertEquals($job1->getId(), $job->getId());
156		self::assertNotNull($job->getPriority());
157		self::assertGreaterThanOrEqual($time1, $job->getWhenAt());
158		self::assertLessThanOrEqual($time2, $job->getWhenAt());
159
160		$job1 = $worker->later(100)->setPriority(3)->fibonacci(1);
161		$priority1 = $job1->getPriority();
162		$time1 = Util::getDateTimeFromDecimalFormat(Util::getMicrotimeDecimal());
163		$job2 = $worker->batchLater(0)->setPriority(1)->fibonacci(1);
164		$time2 = Util::getDateTimeFromDecimalFormat(Util::getMicrotimeDecimal());
165		self::assertEquals($job1->getId(), $job2->getId());
166		self::assertNotEquals($priority1, $job2->getPriority());
167
168		self::assertGreaterThanOrEqual($time1, $job2->getWhenAt());
169		self::assertLessThanOrEqual($time2, $job2->getWhenAt());
170
171		$limit = 10000;
172		while ($limit && self::$jobManager->getJob()) {
173		--$limit;
174		}
175		}
176
177	View Code Duplication	public function testSaveJob()
		0 ignored issues – show Duplication introduced 2018-01-07 01:22 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...
178		{
179		// Make sure a job proper type
180		$failed = false;
181		try {
182		$job = new Job();
183		self::$jobManager->save($job);
184		$failed = true;
185		} catch (\Exception $exception) {
186		self::assertTrue(true);
187		}
188		self::assertFalse($failed);
189
190		$job = new self::$jobClass(self::$worker, false, null);
191		try {
192		$job->setPriority(256)->fibonacci(1);
193		$failed = true;
194		} catch (\Exception $exception) {
195		self::assertTrue(true);
196		}
197		self::assertFalse($failed);
198
199		$job = new self::$jobClass(self::$worker, false, null);
200		$job->setPriority(100)->fibonacci(1);
201		self::assertNotNull($job->getId(), 'Job id should be generated');
202
203		$jobInQueue = self::$jobManager->getJob();
204		self::assertNotNull($jobInQueue, 'There should be a job.');
205		self::$jobManager->saveHistory($jobInQueue);
206
207		$job = new self::$jobClass(self::$worker, false, null);
208		$job->fibonacci(1);
209		self::assertNotNull($job->getId(), 'Job id should be generated');
210
211		$failed = false;
212		try {
213		self::$jobManager->getJob('fibonacci');
214		$failed = true;
215		} catch (\Exception $exception) {
216		self::assertTrue(true);
217		}
218		self::assertFalse($failed);
219
220		$failed = false;
221		try {
222		self::$jobManager->getJob(null, 'fibonacci');
223		$failed = true;
224		} catch (\Exception $exception) {
225		self::assertTrue(true);
226		}
227		self::assertFalse($failed);
228
229		$jobInQueue = self::$jobManager->getJob();
230		self::assertNotNull($jobInQueue, 'There should be a job.');
231		self::assertEquals(
232		$job->getId(),
233		$jobInQueue->getId(),
234		'Job id returned by manager should be the same'
235		);
236
237		$job->setStatus(BaseJob::STATUS_SUCCESS);
238		$badJob = new Job();
239		$failed = false;
240		try {
241		self::$jobManager->saveHistory($badJob);
242		$failed = true;
243		} catch (\Exception $exception) {
244		self::assertTrue(true);
245		}
246		self::assertFalse($failed);
247		self::$jobManager->saveHistory($jobInQueue);
248		}
249
250		public function testGetStatus()
251		{
252		list(, $status1) = $this->getBaseStatus();
253		list(, $status2) = $this->getBaseStatus();
254		$fibonacciStatus1 = $status1['fibonacci->fibonacci()'];
255		$fibonacciStatus2 = $status2['fibonacci->fibonacci()'];
256
257		self::assertEquals($fibonacciStatus1[BaseJob::STATUS_NEW] + 1, $fibonacciStatus2[BaseJob::STATUS_NEW]);
258		}
259
260	View Code Duplication	protected function getBaseStatus()
		0 ignored issues – show Duplication introduced 2018-01-22 04:47 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...
261		{
262		/** @var JobManager\|\Dtc\QueueBundle\ORM\JobManager $jobManager */
263		$jobManager = self::$jobManager;
264		$job = new self::$jobClass(self::$worker, false, null);
265		$job->fibonacci(1);
266		$status = $jobManager->getStatus();
267		self::assertArrayHasKey('fibonacci->fibonacci()', $status);
268		$fibonacciStatus = $status['fibonacci->fibonacci()'];
269
270		self::assertArrayHasKey(BaseJob::STATUS_NEW, $fibonacciStatus);
271		self::assertArrayHasKey(BaseJob::STATUS_EXCEPTION, $fibonacciStatus);
272		self::assertArrayHasKey(BaseJob::STATUS_RUNNING, $fibonacciStatus);
273		self::assertArrayHasKey(BaseJob::STATUS_SUCCESS, $fibonacciStatus);
274		self::assertArrayHasKey(Job::STATUS_EXPIRED, $fibonacciStatus);
275		self::assertArrayHasKey(RetryableJob::STATUS_MAX_EXCEPTIONS, $fibonacciStatus);
276		self::assertArrayHasKey(RetryableJob::STATUS_MAX_FAILURES, $fibonacciStatus);
277		self::assertArrayHasKey(RetryableJob::STATUS_MAX_RETRIES, $fibonacciStatus);
278
279		return [$job, $status];
280		}
281		}
282

mmucklo / DtcQueueBundle

Push — master ( 165f6b...2c48ba )

JobManagerTest::getBaseStatus() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like