idanoo/php-resque
1
0
Fork 0
mirror of https://github.com/idanoo/php-resque synced 2025-07-01 05:32:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Added 48 hour TTL to worker:xxx:started keys to prevent db pollution

Browse source
This commit is contained in:
Daniel Mason 2018-05-30 08:25:02 +12:00
parent b235fce1bd
commit 493d6dc6d8
17 changed files with 158 additions and 141 deletions
Download patch file Download diff file Expand all files Collapse all files

66
test/Resque/Tests/EventTest.php
View file

@ -10,7 +10,7 @@
class Resque_Tests_EventTest extends Resque_Tests_TestCase
{
private $callbacksHit = array();
private $callbacksHit = [];
private $worker;
public function setUp()
@ -26,17 +26,17 @@ class Resque_Tests_EventTest extends Resque_Tests_TestCase
public function tearDown()
{
Resque_Event::clearListeners();
$this->callbacksHit = array();
$this->callbacksHit = [];
}
public function getEventTestJob()
{
$payload = array(
$payload = [
'class' => 'Test_Job',
'args' => array(
array('somevar'),
),
);
'args' => [
['somevar'],
],
];
$job = new Resque_Job('jobs', $payload);
$job->worker = $this->worker;
return $job;
@ -44,19 +44,21 @@ class Resque_Tests_EventTest extends Resque_Tests_TestCase
public function eventCallbackProvider()
{
return array(
array('beforePerform', 'beforePerformEventCallback'),
array('afterPerform', 'afterPerformEventCallback'),
array('afterFork', 'afterForkEventCallback'),
);
return [
['beforePerform', 'beforePerformEventCallback'],
['afterPerform', 'afterPerformEventCallback'],
['afterFork', 'afterForkEventCallback'],
];
}
/**
* @dataProvider eventCallbackProvider
* @param $event
* @param $callback
*/
public function testEventCallbacksFire($event, $callback)
{
Resque_Event::listen($event, array($this, $callback));
Resque_Event::listen($event, [$this, $callback]);
$job = $this->getEventTestJob();
$this->worker->perform($job);
@ -70,11 +72,11 @@ class Resque_Tests_EventTest extends Resque_Tests_TestCase
$event = 'beforeFork';
$callback = 'beforeForkEventCallback';
Resque_Event::listen($event, array($this, $callback));
Resque::enqueue('jobs', 'Test_Job', array(
Resque_Event::listen($event, [$this, $callback]);
Resque::enqueue('jobs', 'Test_Job', [
'somevar'
));
$job = $this->getEventTestJob();
]);
$this->getEventTestJob();
$this->worker->work(0);
$this->assertContains($callback, $this->callbacksHit, $event . ' callback (' . $callback . ') was not called');
}
@ -84,17 +86,17 @@ class Resque_Tests_EventTest extends Resque_Tests_TestCase
$event = 'beforeEnqueue';
$callback = 'beforeEnqueueEventCallback';
Resque_Event::listen($event, array($this, $callback));
Resque::enqueue('jobs', 'Test_Job', array(
Resque_Event::listen($event, [$this, $callback]);
Resque::enqueue('jobs', 'Test_Job', [
'somevar'
));
]);
$this->assertContains($callback, $this->callbacksHit, $event . ' callback (' . $callback . ') was not called');
}
public function testBeforePerformEventCanStopWork()
{
$callback = 'beforePerformEventDontPerformCallback';
Resque_Event::listen('beforePerform', array($this, $callback));
Resque_Event::listen('beforePerform', [$this, $callback]);
$job = $this->getEventTestJob();
@ -106,8 +108,8 @@ class Resque_Tests_EventTest extends Resque_Tests_TestCase
public function testBeforeEnqueueEventStopsJobCreation()
{
$callback = 'beforeEnqueueEventDontCreateCallback';
Resque_Event::listen('beforeEnqueue', array($this, $callback));
Resque_Event::listen('afterEnqueue', array($this, 'afterEnqueueEventCallback'));
Resque_Event::listen('beforeEnqueue', [$this, $callback]);
Resque_Event::listen('afterEnqueue', [$this, 'afterEnqueueEventCallback']);
$result = Resque::enqueue('test_job', 'TestClass');
$this->assertContains($callback, $this->callbacksHit, $callback . ' callback was not called');
@ -120,10 +122,10 @@ class Resque_Tests_EventTest extends Resque_Tests_TestCase
$callback = 'afterEnqueueEventCallback';
$event = 'afterEnqueue';
Resque_Event::listen($event, array($this, $callback));
Resque::enqueue('jobs', 'Test_Job', array(
Resque_Event::listen($event, [$this, $callback]);
Resque::enqueue('jobs', 'Test_Job', [
'somevar'
));
]);
$this->assertContains($callback, $this->callbacksHit, $event . ' callback (' . $callback . ') was not called');
}
@ -132,8 +134,8 @@ class Resque_Tests_EventTest extends Resque_Tests_TestCase
$callback = 'beforePerformEventCallback';
$event = 'beforePerform';
Resque_Event::listen($event, array($this, $callback));
Resque_Event::stopListening($event, array($this, $callback));
Resque_Event::listen($event, [$this, $callback]);
Resque_Event::stopListening($event, [$this, $callback]);
$job = $this->getEventTestJob();
$this->worker->perform($job);
@ -144,13 +146,13 @@ class Resque_Tests_EventTest extends Resque_Tests_TestCase
);
}
public function beforePerformEventDontPerformCallback($instance)
public function beforePerformEventDontPerformCallback()
{
$this->callbacksHit[] = __FUNCTION__;
throw new Resque_Job_DontPerform();
}
public function beforeEnqueueEventDontCreateCallback($queue, $class, $args, $track = false)
public function beforeEnqueueEventDontCreateCallback()
{
$this->callbacksHit[] = __FUNCTION__;
throw new Resque_Job_DontCreate();
@ -170,9 +172,9 @@ class Resque_Tests_EventTest extends Resque_Tests_TestCase
{
$this->callbacksHit[] = __FUNCTION__;
$this->assertEquals('Test_Job', $class);
$this->assertEquals(array(
$this->assertEquals([
'somevar',
), $args);
], $args);
}
public function beforeEnqueueEventCallback($job)

2
test/Resque/Tests/JobStatusTest.php
View file

@ -33,7 +33,7 @@ class Resque_Tests_JobStatusTest extends Resque_Tests_TestCase
public function testJobStatusIsReturnedViaJobInstance()
{
$token = Resque::enqueue('jobs', 'Test_Job', null, true);
Resque::enqueue('jobs', 'Test_Job', null, true);
$job = Resque_Job::reserve('jobs');
$this->assertEquals(Resque_Job_Status::STATUS_WAITING, $job->getStatus());

100
test/Resque/Tests/JobTest.php
View file

@ -51,17 +51,17 @@ class Resque_Tests_JobTest extends Resque_Tests_TestCase
public function testQueuedJobReturnsExactSamePassedInArguments()
{
$args = array(
$args = [
'int' => 123,
'numArray' => array(
'numArray' => [
1,
2,
),
'assocArray' => array(
],
'assocArray' => [
'key1' => 'value1',
'key2' => 'value2'
),
);
],
];
Resque::enqueue('jobs', 'Test_Job', $args);
$job = Resque_Job::reserve('jobs');
@ -77,17 +77,17 @@ class Resque_Tests_JobTest extends Resque_Tests_TestCase
public function testRecreatedJobMatchesExistingJob()
{
$args = array(
$args = [
'int' => 123,
'numArray' => array(
'numArray' => [
1,
2,
),
'assocArray' => array(
],
'assocArray' => [
'key1' => 'value1',
'key2' => 'value2'
),
);
],
];
Resque::enqueue('jobs', 'Test_Job', $args);
$job = Resque_Job::reserve('jobs');
@ -103,10 +103,10 @@ class Resque_Tests_JobTest extends Resque_Tests_TestCase
public function testFailedJobExceptionsAreCaught()
{
$payload = array(
$payload = [
'class' => 'Failing_Job',
'args' => null
);
];
$job = new Resque_Job('jobs', $payload);
$job->worker = $this->worker;
@ -140,13 +140,13 @@ class Resque_Tests_JobTest extends Resque_Tests_TestCase
public function testJobWithSetUpCallbackFiresSetUp()
{
$payload = array(
$payload = [
'class' => 'Test_Job_With_SetUp',
'args' => array(
'args' => [
'somevar',
'somevar2',
),
);
],
];
$job = new Resque_Job('jobs', $payload);
$job->perform();
@ -155,13 +155,13 @@ class Resque_Tests_JobTest extends Resque_Tests_TestCase
public function testJobWithTearDownCallbackFiresTearDown()
{
$payload = array(
$payload = [
'class' => 'Test_Job_With_TearDown',
'args' => array(
'args' => [
'somevar',
'somevar2',
),
);
],
];
$job = new Resque_Job('jobs', $payload);
$job->perform();
@ -170,12 +170,12 @@ class Resque_Tests_JobTest extends Resque_Tests_TestCase
public function testNamespaceNaming()
{
$fixture = array(
array('test' => 'more:than:one:with:', 'assertValue' => 'more:than:one:with:'),
array('test' => 'more:than:one:without', 'assertValue' => 'more:than:one:without:'),
array('test' => 'resque', 'assertValue' => 'resque:'),
array('test' => 'resque:', 'assertValue' => 'resque:'),
);
$fixture = [
['test' => 'more:than:one:with:', 'assertValue' => 'more:than:one:with:'],
['test' => 'more:than:one:without', 'assertValue' => 'more:than:one:without:'],
['test' => 'resque', 'assertValue' => 'resque:'],
['test' => 'resque:', 'assertValue' => 'resque:'],
];
foreach ($fixture as $item) {
Resque_Redis::prefix($item['test']);
@ -187,10 +187,10 @@ class Resque_Tests_JobTest extends Resque_Tests_TestCase
{
Resque_Redis::prefix('php');
$queue = 'jobs';
$payload = array('another_value');
$payload = ['another_value'];
Resque::enqueue($queue, 'Test_Job_With_TearDown', $payload);
$this->assertEquals(Resque::queues(), array('jobs'));
$this->assertEquals(Resque::queues(), ['jobs']);
$this->assertEquals(Resque::size($queue), 1);
Resque_Redis::prefix('resque');
@ -228,7 +228,7 @@ class Resque_Tests_JobTest extends Resque_Tests_TestCase
Resque::enqueue($queue, 'Test_Job_Dequeue1');
Resque::enqueue($queue, 'Test_Job_Dequeue2');
$this->assertEquals(Resque::size($queue), 2);
$test = array('Test_Job_Dequeue2');
$test = ['Test_Job_Dequeue2'];
$this->assertEquals(Resque::dequeue($queue, $test), 1);
$this->assertEquals(Resque::size($queue), 1);
}
@ -240,7 +240,7 @@ class Resque_Tests_JobTest extends Resque_Tests_TestCase
Resque::enqueue($queue, 'Test_Job_Dequeue2');
Resque::enqueue($queue, 'Test_Job_Dequeue3');
$this->assertEquals(Resque::size($queue), 3);
$test = array('Test_Job_Dequeue2', 'Test_Job_Dequeue3');
$test = ['Test_Job_Dequeue2', 'Test_Job_Dequeue3'];
$this->assertEquals(Resque::dequeue($queue, $test), 2);
$this->assertEquals(Resque::size($queue), 1);
}
@ -252,7 +252,7 @@ class Resque_Tests_JobTest extends Resque_Tests_TestCase
Resque::enqueue($queue, 'Test_Job_Dequeue2');
Resque::enqueue($queue, 'Test_Job_Dequeue3');
$this->assertEquals(Resque::size($queue), 3);
$test = array('Test_Job_Dequeue4');
$test = ['Test_Job_Dequeue4'];
$this->assertEquals(Resque::dequeue($queue, $test), 0);
$this->assertEquals(Resque::size($queue), 3);
}
@ -264,7 +264,7 @@ class Resque_Tests_JobTest extends Resque_Tests_TestCase
Resque::enqueue($queue, 'Test_Job_Dequeue2');
Resque::enqueue($queue, 'Test_Job_Dequeue3');
$this->assertEquals(Resque::size($queue), 3);
$test = array('Test_Job_Dequeue4', 'Test_Job_Dequeue1');
$test = ['Test_Job_Dequeue4', 'Test_Job_Dequeue1'];
$this->assertEquals(Resque::dequeue($queue, $test), 1);
$this->assertEquals(Resque::size($queue), 2);
}
@ -275,7 +275,7 @@ class Resque_Tests_JobTest extends Resque_Tests_TestCase
Resque::enqueue($queue, 'Test_Job_Dequeue');
$qid = Resque::enqueue($queue, 'Test_Job_Dequeue');
$this->assertEquals(Resque::size($queue), 2);
$test = array('Test_Job_Dequeue' => $qid);
$test = ['Test_Job_Dequeue' => $qid];
$this->assertEquals(Resque::dequeue($queue, $test), 1);
$this->assertEquals(Resque::size($queue), 1);
}
@ -287,7 +287,7 @@ class Resque_Tests_JobTest extends Resque_Tests_TestCase
$qid = Resque::enqueue($queue, 'Test_Job_Dequeue');
$this->assertEquals(Resque::size($queue), 2);
#qid right but class name is wrong
$test = array('Test_Job_Dequeue1' => $qid);
$test = ['Test_Job_Dequeue1' => $qid];
$this->assertEquals(Resque::dequeue($queue, $test), 0);
$this->assertEquals(Resque::size($queue), 2);
}
@ -296,9 +296,9 @@ class Resque_Tests_JobTest extends Resque_Tests_TestCase
{
$queue = 'jobs';
Resque::enqueue($queue, 'Test_Job_Dequeue');
$qid = Resque::enqueue($queue, 'Test_Job_Dequeue');
Resque::enqueue($queue, 'Test_Job_Dequeue');
$this->assertEquals(Resque::size($queue), 2);
$test = array('Test_Job_Dequeue' => 'r4nD0mH4sh3dId');
$test = ['Test_Job_Dequeue' => 'r4nD0mH4sh3dId'];
$this->assertEquals(Resque::dequeue($queue, $test), 0);
$this->assertEquals(Resque::size($queue), 2);
}
@ -328,7 +328,7 @@ class Resque_Tests_JobTest extends Resque_Tests_TestCase
// WHEN
$test = ['Test_Job_Dequeue9' => $removeArgs];
$removedItems = Resque::dequeue($queue, $test, "Dequeue one failed!");
$removedItems = Resque::dequeue($queue, $test);
// THEN
$this->assertEquals($removedItems, 2);
@ -341,12 +341,12 @@ class Resque_Tests_JobTest extends Resque_Tests_TestCase
public function testDequeueItemWithUnorderedArg()
{
$queue = 'jobs';
$arg = array('foo' => 1, 'bar' => 2);
$arg2 = array('bar' => 2, 'foo' => 1);
$arg = ['foo' => 1, 'bar' => 2];
$arg2 = ['bar' => 2, 'foo' => 1];
Resque::enqueue($queue, 'Test_Job_Dequeue');
Resque::enqueue($queue, 'Test_Job_Dequeue', $arg);
$this->assertEquals(Resque::size($queue), 2);
$test = array('Test_Job_Dequeue' => $arg2);
$test = ['Test_Job_Dequeue' => $arg2];
$this->assertEquals(Resque::dequeue($queue, $test), 1);
$this->assertEquals(Resque::size($queue), 1);
}
@ -354,22 +354,22 @@ class Resque_Tests_JobTest extends Resque_Tests_TestCase
public function testDequeueItemWithiWrongArg()
{
$queue = 'jobs';
$arg = array('foo' => 1, 'bar' => 2);
$arg2 = array('foo' => 2, 'bar' => 3);
$arg = ['foo' => 1, 'bar' => 2];
$arg2 = ['foo' => 2, 'bar' => 3];
Resque::enqueue($queue, 'Test_Job_Dequeue');
Resque::enqueue($queue, 'Test_Job_Dequeue', $arg);
$this->assertEquals(Resque::size($queue), 2);
$test = array('Test_Job_Dequeue' => $arg2);
$test = ['Test_Job_Dequeue' => $arg2];
$this->assertEquals(Resque::dequeue($queue, $test), 0);
$this->assertEquals(Resque::size($queue), 2);
}
public function testUseDefaultFactoryToGetJobInstance()
{
$payload = array(
$payload = [
'class' => 'Some_Job_Class',
'args' => null
);
];
$job = new Resque_Job('jobs', $payload);
$instance = $job->getInstance();
$this->assertInstanceOf('Some_Job_Class', $instance);
@ -377,10 +377,10 @@ class Resque_Tests_JobTest extends Resque_Tests_TestCase
public function testUseFactoryToGetJobInstance()
{
$payload = array(
$payload = [
'class' => 'Some_Job_Class',
'args' => array(array())
);
'args' => [[]]
];
$job = new Resque_Job('jobs', $payload);
$factory = new Some_Stub_Factory();
$job->setJobFactory($factory);

4
test/Resque/Tests/LogTest.php
View file

@ -13,7 +13,7 @@ class Resque_Tests_LogTest extends Resque_Tests_TestCase
public function testLogInterpolate()
{
$logger = new Resque_Log();
$actual = $logger->interpolate('string {replace}', array('replace' => 'value'));
$actual = $logger->interpolate('string {replace}', ['replace' => 'value']);
$expected = 'string value';
$this->assertEquals($expected, $actual);
@ -24,7 +24,7 @@ class Resque_Tests_LogTest extends Resque_Tests_TestCase
$logger = new Resque_Log();
$actual = $logger->interpolate(
'string {replace1} {replace2}',
array('replace1' => 'value1', 'replace2' => 'value2')
['replace1' => 'value1', 'replace2' => 'value2']
);
$expected = 'string value1 value2';

6
test/Resque/Tests/RedisTest.php
View file

@ -10,9 +10,6 @@
class Resque_Tests_RedisTest extends Resque_Tests_TestCase
{
/**
* @expectedException Test basic redis functionality.
*/
public function testRedisGetSet()
{
$this->redis->set("testKey", 24);
@ -173,6 +170,8 @@ class Resque_Tests_RedisTest extends Resque_Tests_TestCase
/**
* @dataProvider validDsnStringProvider
* @param $dsn
* @param $expected
*/
public function testParsingValidDsnString($dsn, $expected)
{
@ -183,6 +182,7 @@ class Resque_Tests_RedisTest extends Resque_Tests_TestCase
/**
* @dataProvider bogusDsnStringProvider
* @expectedException InvalidArgumentException
* @param $dsn
*/
public function testParsingBogusDsnStringThrowsException($dsn)
{

24
test/Resque/Tests/WorkerTest.php
View file

@ -57,8 +57,8 @@ class Resque_Tests_WorkerTest extends Resque_Tests_TestCase
$worker->unregisterWorker();
$this->assertFalse(Resque_Worker::exists((string)$worker));
$this->assertEquals(array(), Resque_Worker::all());
$this->assertEquals(array(), $this->redis->smembers('resque:workers'));
$this->assertEquals([], Resque_Worker::all());
$this->assertEquals([], $this->redis->smembers('resque:workers'));
}
public function testPausedWorkerDoesNotPickUpJobs()
@ -87,10 +87,10 @@ class Resque_Tests_WorkerTest extends Resque_Tests_TestCase
public function testWorkerCanWorkOverMultipleQueues()
{
$worker = new Resque_Worker(array(
$worker = new Resque_Worker([
'queue1',
'queue2'
));
]);
$worker->setLogger(new Resque_Log());
$worker->registerWorker();
Resque::enqueue('queue1', 'Test_Job_1');
@ -105,11 +105,11 @@ class Resque_Tests_WorkerTest extends Resque_Tests_TestCase
public function testWorkerWorksQueuesInSpecifiedOrder()
{
$worker = new Resque_Worker(array(
$worker = new Resque_Worker([
'high',
'medium',
'low'
));
]);
$worker->setLogger(new Resque_Log());
$worker->registerWorker();
@ -163,7 +163,7 @@ class Resque_Tests_WorkerTest extends Resque_Tests_TestCase
$job = $worker->reserve();
$worker->workingOn($job);
$worker->doneWorking();
$this->assertEquals(array(), $worker->job());
$this->assertEquals([], $worker->job());
}
public function testWorkerRecordsWhatItIsWorkingOn()
@ -172,9 +172,9 @@ class Resque_Tests_WorkerTest extends Resque_Tests_TestCase
$worker->setLogger(new Resque_Log());
$worker->registerWorker();
$payload = array(
$payload = [
'class' => 'Test_Job'
);
];
$job = new Resque_Job('jobs', $payload);
$worker->workingOn($job);
@ -214,7 +214,7 @@ class Resque_Tests_WorkerTest extends Resque_Tests_TestCase
$worker->setId($workerId[0] . ':1:jobs');
$worker->registerWorker();
$worker = new Resque_Worker(array('high', 'low'));
$worker = new Resque_Worker(['high', 'low']);
$worker->setLogger(new Resque_Log());
$worker->setId($workerId[0] . ':2:high,low');
$worker->registerWorker();
@ -258,9 +258,9 @@ class Resque_Tests_WorkerTest extends Resque_Tests_TestCase
$worker->setLogger(new Resque_Log());
$worker->registerWorker();
$payload = array(
$payload = [
'class' => 'Test_Job'
);
];
$job = new Resque_Job('jobs', $payload);
$worker->workingOn($job);