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
|
<?php
namespace Illuminate\Tests\Integration\Queue;
use Illuminate\Bus\Dispatcher;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\Job;
use Illuminate\Queue\CallQueuedHandler;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\Middleware\Skip;
use Laravel\SerializableClosure\SerializableClosure;
use Mockery as m;
use Orchestra\Testbench\TestCase;
class SkipMiddlewareTest extends TestCase
{
public function testJobIsSkippedWhenConditionIsTrue()
{
$job = new SkipTestJob(skip: true);
$this->assertJobWasSkipped($job);
}
public function testJobIsSkippedWhenConditionIsTrueUsingClosure()
{
$job = new SkipTestJob(skip: new SerializableClosure(fn () => true));
$this->assertJobWasSkipped($job);
}
public function testJobIsNotSkippedWhenConditionIsFalse()
{
$job = new SkipTestJob(skip: false);
$this->assertJobRanSuccessfully($job);
}
public function testJobIsNotSkippedWhenConditionIsFalseUsingClosure()
{
$job = new SkipTestJob(skip: new SerializableClosure(fn () => false));
$this->assertJobRanSuccessfully($job);
}
public function testJobIsNotSkippedWhenConditionIsTrueWithUnless()
{
$job = new SkipTestJob(skip: true, useUnless: true);
$this->assertJobRanSuccessfully($job);
}
public function testJobIsNotSkippedWhenConditionIsTrueWithUnlessUsingClosure()
{
$job = new SkipTestJob(skip: new SerializableClosure(fn () => true), useUnless: true);
$this->assertJobRanSuccessfully($job);
}
public function testJobIsSkippedWhenConditionIsFalseWithUnless()
{
$job = new SkipTestJob(skip: false, useUnless: true);
$this->assertJobWasSkipped($job);
}
public function testJobIsSkippedWhenConditionIsFalseWithUnlessUsingClosure()
{
$job = new SkipTestJob(skip: new SerializableClosure(fn () => false), useUnless: true);
$this->assertJobWasSkipped($job);
}
protected function assertJobRanSuccessfully(SkipTestJob $class)
{
$this->assertJobHandled(class: $class, expectedHandledValue: true);
}
protected function assertJobWasSkipped(SkipTestJob $class)
{
$this->assertJobHandled(class: $class, expectedHandledValue: false);
}
protected function assertJobHandled(SkipTestJob $class, bool $expectedHandledValue)
{
$class::$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($class),
]);
$this->assertEquals($expectedHandledValue, $class::$handled);
}
}
class SkipTestJob
{
use InteractsWithQueue, Queueable;
public static $handled = false;
public function __construct(
protected bool|SerializableClosure $skip,
protected bool $useUnless = false,
) {
}
public function handle(): void
{
static::$handled = true;
}
public function middleware(): array
{
$skip = $this->skip instanceof SerializableClosure
? $this->skip->getClosure()
: $this->skip;
if ($this->useUnless) {
return [Skip::unless($skip)];
}
return [Skip::when($skip)];
}
}
|
