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
|
# encoding: utf-8
require_relative 'helper'
require 'sidekiq/middleware/server/retry_jobs'
class TestRetryExhausted < Sidekiq::Test
describe 'sidekiq_retries_exhausted' do
class NewWorker
include Sidekiq::Worker
class_attribute :exhausted_called, :exhausted_job, :exhausted_exception
sidekiq_retries_exhausted do |job, e|
self.exhausted_called = true
self.exhausted_job = job
self.exhausted_exception = e
end
end
class OldWorker
include Sidekiq::Worker
class_attribute :exhausted_called, :exhausted_job, :exhausted_exception
sidekiq_retries_exhausted do |job|
self.exhausted_called = true
self.exhausted_job = job
end
end
def cleanup
[NewWorker, OldWorker].each do |worker_class|
worker_class.exhausted_called = nil
worker_class.exhausted_job = nil
worker_class.exhausted_exception = nil
end
end
before do
cleanup
end
after do
cleanup
end
def new_worker
@new_worker ||= NewWorker.new
end
def old_worker
@old_worker ||= OldWorker.new
end
def handler(options={})
@handler ||= Sidekiq::Middleware::Server::RetryJobs.new(options)
end
def job(options={})
@job ||= {'class' => 'Bob', 'args' => [1, 2, 'foo']}.merge(options)
end
it 'does not run exhausted block when job successful on first run' do
handler.call(new_worker, job('retry' => 2), 'default') do
# successful
end
refute NewWorker.exhausted_called?
end
it 'does not run exhausted block when job successful on last retry' do
handler.call(new_worker, job('retry_count' => 0, 'retry' => 1), 'default') do
# successful
end
refute NewWorker.exhausted_called?
end
it 'does not run exhausted block when retries not exhausted yet' do
assert_raises RuntimeError do
handler.call(new_worker, job('retry' => 1), 'default') do
raise 'kerblammo!'
end
end
refute NewWorker.exhausted_called?
end
it 'runs exhausted block when retries exhausted' do
assert_raises RuntimeError do
handler.call(new_worker, job('retry_count' => 0, 'retry' => 1), 'default') do
raise 'kerblammo!'
end
end
assert NewWorker.exhausted_called?
end
it 'passes job and exception to retries exhausted block' do
raised_error = assert_raises RuntimeError do
handler.call(new_worker, job('retry_count' => 0, 'retry' => 1), 'default') do
raise 'kerblammo!'
end
end
assert new_worker.exhausted_called?
assert_equal raised_error.message, new_worker.exhausted_job['error_message']
assert_equal raised_error, new_worker.exhausted_exception
end
it 'passes job to retries exhausted block' do
raised_error = assert_raises RuntimeError do
handler.call(old_worker, job('retry_count' => 0, 'retry' => 1), 'default') do
raise 'kerblammo!'
end
end
assert old_worker.exhausted_called?
assert_equal raised_error.message, old_worker.exhausted_job['error_message']
assert_equal nil, new_worker.exhausted_exception
end
it 'allows a global default handler' do
begin
class Foobar
include Sidekiq::Worker
end
exhausted_job = nil
exhausted_exception = nil
Sidekiq.default_retries_exhausted = lambda do |job, ex|
exhausted_job = job
exhausted_exception = ex
end
f = Foobar.new
raised_error = assert_raises RuntimeError do
handler.call(f, job('retry_count' => 0, 'retry' => 1), 'default') do
raise 'kerblammo!'
end
end
assert exhausted_job
assert_equal raised_error, exhausted_exception
ensure
Sidekiq.default_retries_exhausted = nil
end
end
end
end
|
