1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
<?php
namespace Illuminate\Tests\Integration\Queue;
use Exception;
use Illuminate\Bus\Dispatcher;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Cache\Repository as Cache;
use Illuminate\Contracts\Queue\Job;
use Illuminate\Queue\CallQueuedHandler;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\Middleware\WithoutOverlapping;
use Mockery as m;
use Orchestra\Testbench\TestCase;
class WithoutOverlappingJobsTest extends TestCase
{
protected function tearDown(): void
{
parent::tearDown();
m::close();
}
public function testNonOverlappingJobsAreExecuted()
{
OverlappingTestJob::$handled = false;
$instance = new CallQueuedHandler(new Dispatcher($this->app), $this->app);
$job = m::mock(Job::class);
$job->shouldReceive('hasFailed')->andReturn(false);
$job->shouldReceive('isReleased')->andReturn(false);
$job->shouldReceive('isDeletedOrReleased')->andReturn(false);
$job->shouldReceive('delete')->once();
$instance->call($job, [
'command' => serialize($command = new OverlappingTestJob),
]);
$lockKey = (new WithoutOverlapping)->getLockKey($command);
$this->assertTrue(OverlappingTestJob::$handled);
$this->assertTrue($this->app->get(Cache::class)->lock($lockKey, 10)->acquire());
}
public function testLockIsReleasedOnJobExceptions()
{
FailedOverlappingTestJob::$handled = false;
$instance = new CallQueuedHandler(new Dispatcher($this->app), $this->app);
$job = m::mock(Job::class);
$job->shouldReceive('hasFailed')->andReturn(false);
$job->shouldReceive('isReleased')->andReturn(false);
$job->shouldReceive('isDeletedOrReleased')->andReturn(false);
$this->expectException(Exception::class);
try {
$instance->call($job, [
'command' => serialize($command = new FailedOverlappingTestJob),
]);
} finally {
$lockKey = (new WithoutOverlapping)->getLockKey($command);
$this->assertTrue(FailedOverlappingTestJob::$handled);
$this->assertTrue($this->app->get(Cache::class)->lock($lockKey, 10)->acquire());
}
}
public function testOverlappingJobsAreReleased()
{
OverlappingTestJob::$handled = false;
$instance = new CallQueuedHandler(new Dispatcher($this->app), $this->app);
$lockKey = (new WithoutOverlapping)->getLockKey($command = new OverlappingTestJob);
$this->app->get(Cache::class)->lock($lockKey, 10)->acquire();
$job = m::mock(Job::class);
$job->shouldReceive('release')->once();
$job->shouldReceive('hasFailed')->andReturn(false);
$job->shouldReceive('isReleased')->andReturn(true);
$job->shouldReceive('isDeletedOrReleased')->andReturn(true);
$instance->call($job, [
'command' => serialize($command),
]);
$this->assertFalse(OverlappingTestJob::$handled);
}
public function testOverlappingJobsCanBeSkipped()
{
SkipOverlappingTestJob::$handled = false;
$instance = new CallQueuedHandler(new Dispatcher($this->app), $this->app);
$lockKey = (new WithoutOverlapping)->getLockKey($command = new SkipOverlappingTestJob);
$this->app->get(Cache::class)->lock($lockKey, 10)->acquire();
$job = m::mock(Job::class);
$job->shouldReceive('hasFailed')->andReturn(false);
$job->shouldReceive('isReleased')->andReturn(false);
$job->shouldReceive('isDeletedOrReleased')->andReturn(false);
$job->shouldReceive('delete')->once();
$instance->call($job, [
'command' => serialize($command),
]);
$this->assertFalse(SkipOverlappingTestJob::$handled);
}
}
class OverlappingTestJob
{
use InteractsWithQueue, Queueable;
public static $handled = false;
public function handle()
{
static::$handled = true;
}
public function middleware()
{
return [new WithoutOverlapping];
}
}
class SkipOverlappingTestJob extends OverlappingTestJob
{
public function middleware()
{
return [(new WithoutOverlapping)->dontRelease()];
}
}
class FailedOverlappingTestJob extends OverlappingTestJob
{
public function handle()
{
static::$handled = true;
throw new Exception;
}
}
|
