-
-
Notifications
You must be signed in to change notification settings - Fork 397
/
raise_error_spec.rb
365 lines (295 loc) · 11.3 KB
/
raise_error_spec.rb
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
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
require 'spec_helper'
describe "should raise_error" do
it_behaves_like("an RSpec matcher", :valid_value => lambda { raise "boom" },
:invalid_value => lambda { }) do
let(:matcher) { raise_error(/boom/) }
end
it "passes if anything is raised" do
lambda {raise}.should raise_error
end
it "fails if nothing is raised" do
lambda {
lambda {}.should raise_error
}.should fail_with("expected Exception but nothing was raised")
end
end
describe "raise_exception aliased to raise_error" do
it "passes if anything is raised" do
lambda {raise}.should raise_exception
end
end
describe "should raise_error {|err| ... }" do
it "passes if there is an error" do
ran = false
lambda { non_existent_method }.should raise_error {|e|
ran = true
}
ran.should be_true
end
it "passes the error to the block" do
error = nil
lambda { non_existent_method }.should raise_error {|e|
error = e
}
error.should be_kind_of(NameError)
end
end
describe "should_not raise_error" do
it "passes if nothing is raised" do
lambda {}.should_not raise_error
end
it "fails if anything is raised" do
lambda {
lambda { raise RuntimeError, "example message" }.should_not raise_error
}.should fail_with(/expected no Exception, got #<RuntimeError: example message>/)
end
end
describe "should raise_error(message)" do
it "passes if RuntimeError is raised with the right message" do
lambda {raise 'blah'}.should raise_error('blah')
end
it "passes if RuntimeError is raised with a matching message" do
lambda {raise 'blah'}.should raise_error(/blah/)
end
it "passes if any other error is raised with the right message" do
lambda {raise NameError.new('blah')}.should raise_error('blah')
end
it "fails if RuntimeError error is raised with the wrong message" do
lambda do
lambda {raise 'blarg'}.should raise_error('blah')
end.should fail_with(/expected Exception with \"blah\", got #<RuntimeError: blarg>/)
end
it "fails if any other error is raised with the wrong message" do
lambda do
lambda {raise NameError.new('blarg')}.should raise_error('blah')
end.should fail_with(/expected Exception with \"blah\", got #<NameError: blarg>/)
end
end
describe "should_not raise_error(message)" do
it "passes if RuntimeError error is raised with the different message" do
lambda {raise 'blarg'}.should_not raise_error('blah')
end
it "passes if any other error is raised with the wrong message" do
lambda {raise NameError.new('blarg')}.should_not raise_error('blah')
end
it "fails if RuntimeError is raised with message" do
lambda do
lambda {raise 'blah'}.should_not raise_error('blah')
end.should fail_with(/expected no Exception with "blah", got #<RuntimeError: blah>/)
end
it "fails if any other error is raised with message" do
lambda do
lambda {raise NameError.new('blah')}.should_not raise_error('blah')
end.should fail_with(/expected no Exception with "blah", got #<NameError: blah>/)
end
end
describe "should raise_error(NamedError)" do
it "passes if named error is raised" do
lambda { non_existent_method }.should raise_error(NameError)
end
it "fails if nothing is raised" do
lambda {
lambda { }.should raise_error(NameError)
}.should fail_with(/expected NameError but nothing was raised/)
end
it "fails if another error is raised (NameError)" do
lambda {
lambda { raise RuntimeError, "example message" }.should raise_error(NameError)
}.should fail_with(/expected NameError, got #<RuntimeError: example message>/)
end
it "fails if another error is raised (NameError)" do
lambda {
lambda { load "non/existent/file" }.should raise_error(NameError)
}.should fail_with(/expected NameError, got #<LoadError/)
end
end
describe "should_not raise_error(NamedError)" do
it "passes if nothing is raised" do
lambda { }.should_not raise_error(NameError)
end
it "passes if another error is raised" do
lambda { raise }.should_not raise_error(NameError)
end
it "fails if named error is raised" do
lambda {
lambda { 1 + 'b' }.should_not raise_error(TypeError)
}.should fail_with(/expected no TypeError, got #<TypeError: String can't be/)
end
end
describe "should raise_error(NamedError, error_message) with String" do
it "passes if named error is raised with same message" do
lambda { raise "example message" }.should raise_error(RuntimeError, "example message")
end
it "fails if nothing is raised" do
lambda {
lambda {}.should raise_error(RuntimeError, "example message")
}.should fail_with(/expected RuntimeError with \"example message\" but nothing was raised/)
end
it "fails if incorrect error is raised" do
lambda {
lambda { raise RuntimeError, "example message" }.should raise_error(NameError, "example message")
}.should fail_with(/expected NameError with \"example message\", got #<RuntimeError: example message>/)
end
it "fails if correct error is raised with incorrect message" do
lambda {
lambda { raise RuntimeError.new("not the example message") }.should raise_error(RuntimeError, "example message")
}.should fail_with(/expected RuntimeError with \"example message\", got #<RuntimeError: not the example message/)
end
end
describe "should raise_error(NamedError, error_message) { |err| ... }" do
it "yields exception if named error is raised with same message" do
ran = false
lambda {
raise "example message"
}.should raise_error(RuntimeError, "example message") { |err|
ran = true
err.class.should eq RuntimeError
err.message.should eq "example message"
}
ran.should be(true)
end
it "yielded block fails on it's own right" do
ran, passed = false, false
lambda {
lambda {
raise "example message"
}.should raise_error(RuntimeError, "example message") { |err|
ran = true
5.should eq 4
passed = true
}
}.should fail_with(/expected: 4/m)
ran.should be_true
passed.should be_false
end
it "does NOT yield exception if no error was thrown" do
ran = false
lambda {
lambda {}.should raise_error(RuntimeError, "example message") { |err|
ran = true
}
}.should fail_with(/expected RuntimeError with \"example message\" but nothing was raised/)
ran.should == false
end
it "does not yield exception if error class is not matched" do
ran = false
lambda {
lambda {
raise "example message"
}.should raise_error(SyntaxError, "example message") { |err|
ran = true
}
}.should fail_with(/expected SyntaxError with \"example message\", got #<RuntimeError: example message>/)
ran.should == false
end
it "does NOT yield exception if error message is not matched" do
ran = false
lambda {
lambda {
raise "example message"
}.should raise_error(RuntimeError, "different message") { |err|
ran = true
}
}.should fail_with(/expected RuntimeError with \"different message\", got #<RuntimeError: example message>/)
ran.should == false
end
end
describe "should_not raise_error(NamedError, error_message) { |err| ... }" do
it "passes if nothing is raised" do
ran = false
lambda {}.should_not raise_error(RuntimeError, "example message") { |err|
ran = true
}
ran.should == false
end
it "passes if a different error is raised" do
ran = false
lambda { raise }.should_not raise_error(NameError, "example message") { |err|
ran = true
}
ran.should == false
end
it "passes if same error is raised with different message" do
ran = false
lambda {
raise RuntimeError.new("not the example message")
}.should_not raise_error(RuntimeError, "example message") { |err|
ran = true
}
ran.should == false
end
it "fails if named error is raised with same message" do
ran = false
lambda {
lambda {
raise "example message"
}.should_not raise_error(RuntimeError, "example message") { |err|
ran = true
}
}.should fail_with(/expected no RuntimeError with \"example message\", got #<RuntimeError: example message>/)
ran.should == false
end
it 'skips the error verification block when using the expect {...}.to syntax' do
ran = false
expect {
expect {
raise "example message"
}.not_to raise_error(RuntimeError, "example message") { |err|
ran = true
}
}.to fail_with(/expected no RuntimeError with \"example message\", got #<RuntimeError: example message>/)
ran.should == false
end
end
describe "should_not raise_error(NamedError, error_message) with String" do
it "passes if nothing is raised" do
lambda {}.should_not raise_error(RuntimeError, "example message")
end
it "passes if a different error is raised" do
lambda { raise }.should_not raise_error(NameError, "example message")
end
it "passes if same error is raised with different message" do
lambda { raise RuntimeError.new("not the example message") }.should_not raise_error(RuntimeError, "example message")
end
it "fails if named error is raised with same message" do
lambda {
lambda { raise "example message" }.should_not raise_error(RuntimeError, "example message")
}.should fail_with(/expected no RuntimeError with \"example message\", got #<RuntimeError: example message>/)
end
end
describe "should raise_error(NamedError, error_message) with Regexp" do
it "passes if named error is raised with matching message" do
lambda { raise "example message" }.should raise_error(RuntimeError, /ample mess/)
end
it "fails if nothing is raised" do
lambda {
lambda {}.should raise_error(RuntimeError, /ample mess/)
}.should fail_with(/expected RuntimeError with message matching \/ample mess\/ but nothing was raised/)
end
it "fails if incorrect error is raised" do
lambda {
lambda { raise RuntimeError, "example message" }.should raise_error(NameError, /ample mess/)
}.should fail_with(/expected NameError with message matching \/ample mess\/, got #<RuntimeError: example message>/)
end
it "fails if correct error is raised with incorrect message" do
lambda {
lambda { raise RuntimeError.new("not the example message") }.should raise_error(RuntimeError, /less than ample mess/)
}.should fail_with(/expected RuntimeError with message matching \/less than ample mess\/, got #<RuntimeError: not the example message>/)
end
end
describe "should_not raise_error(NamedError, error_message) with Regexp" do
it "passes if nothing is raised" do
lambda {}.should_not raise_error(RuntimeError, /ample mess/)
end
it "passes if a different error is raised" do
lambda { raise }.should_not raise_error(NameError, /ample mess/)
end
it "passes if same error is raised with non-matching message" do
lambda { raise RuntimeError.new("non matching message") }.should_not raise_error(RuntimeError, /ample mess/)
end
it "fails if named error is raised with matching message" do
lambda {
lambda { raise "example message" }.should_not raise_error(RuntimeError, /ample mess/)
}.should fail_with(/expected no RuntimeError with message matching \/ample mess\/, got #<RuntimeError: example message>/)
end
end