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
|
RSpec.describe RetryService do
subject { described_class.new delays: [2, 3], rescue_from: [NameError, ArgumentError] }
context 'no retry necessary' do
before do
expect( subject ).not_to receive(:sleep)
end
it 'returns an ok result' do
expect( subject.execute { 42 } ).to eq(Result.ok(42))
end
it 'does not fail on nil' do
expect( subject.execute { nil } ).to eq(Result.ok(nil))
end
it 'fails wihout retries if raising un unregistered exception' do
expect{ subject.execute{ raise KeyError } }.to raise_error(KeyError)
end
end
context 'all retries fail' do
before do
expect( subject ).to receive(:sleep).with(2)
expect( subject ).to receive(:sleep).with(3)
end
it 'fails after raising a registered exception n times' do
result = subject.execute{ raise ArgumentError }
expect( result.status ).to eq(:error)
expect( result.value ).to be_kind_of(ArgumentError)
end
it 'fails with an explicit try again (automatically registered exception)' do
result = subject.execute{ raise RetryService::Retry }
expect( result.status ).to eq(:error)
expect( result.value ).to be_kind_of(RetryService::Retry)
end
end
context "if at first you don't succeed" do
before do
@count = 0
expect( subject ).to receive(:sleep).with(2)
end
it 'succeeds the second time' do
expect( subject.execute{ succeed_later(ArgumentError){ 42 } } ).to eq(Result.ok(42))
end
it 'succeeds the second time with try again (automatically registered exception)' do
expect( subject.execute{ succeed_later(RetryService::Retry){ 42 } } ).to eq(Result.ok(42))
end
end
context 'last chance' do
before do
@count = 0
expect( subject ).to receive(:sleep).with(2)
expect( subject ).to receive(:sleep).with(3)
end
it 'succeeds the third time with try again (automatically registered exception)' do
result = subject.execute{ succeed_later(RetryService::Retry, count: 2){ 42 } }
expect( result ).to eq( Result.ok(42) )
end
end
context 'failure callback once' do
subject do
described_class.new delays: [2, 3], rescue_from: [NameError, ArgumentError] do |reason, count|
@reason=reason
@callback_count=count
@failures += 1
end
end
before do
@failures = 0
@count = 0
expect( subject ).to receive(:sleep).with(2)
end
it 'succeeds the second time and calls the failure_callback once' do
subject.execute{ succeed_later(RetryService::Retry){ 42 } }
expect( @failures ).to eq(1)
end
it '... and the failure is passed into the callback' do
subject.execute{ succeed_later(RetryService::Retry){ 42 } }
expect( @reason ).to be_a(RetryService::Retry)
expect( @callback_count ).to eq(1)
end
end
context 'failure callback twice' do
subject do
described_class.new delays: [2, 3], rescue_from: [NameError, ArgumentError] do |_reason, _count|
@failures += 1
end
end
before do
@failures = 0
@count = 0
expect( subject ).to receive(:sleep).with(2)
expect( subject ).to receive(:sleep).with(3)
end
it 'succeeds the third time and calls the failure_callback twice' do
subject.execute{ succeed_later(NameError, count: 2){ 42 } }
expect( @failures ).to eq(2)
end
end
context 'failure callback in constructor' do
subject do
described_class.new(delays: [1, 2], &method(:add2failures))
end
before do
@failures = []
@count = 0
expect( subject ).to receive(:sleep).with(1)
expect( subject ).to receive(:sleep).with(2)
end
it 'succeeds the second time and calls the failure_callback once' do
subject.execute{ succeed_later(RetryService::Retry, count: 2){ 42 } }
expect( @failures ).to eq([1,2])
end
end
def add2failures( e, c)
@failures << c
end
def succeed_later error, count: 1, &blk
return blk.() unless @count < count
@count += 1
raise error, 'error'
end
end
|
