minitest 5.11.3 → 5.14.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -64,8 +64,6 @@ class TestMinitestMock < Minitest::Test
64
64
  end
65
65
 
66
66
  def test_mock_args_does_not_raise
67
- skip "non-opaque use of ==" if maglev?
68
-
69
67
  arg = Minitest::Mock.new
70
68
  mock = Minitest::Mock.new
71
69
  mock.expect(:foo, nil, [arg])
@@ -362,7 +360,7 @@ end
362
360
  require "minitest/metametameta"
363
361
 
364
362
  class TestMinitestStub < Minitest::Test
365
- parallelize_me!
363
+ # Do not parallelize since we're calling stub on class methods
366
364
 
367
365
  def setup
368
366
  super
@@ -374,7 +372,7 @@ class TestMinitestStub < Minitest::Test
374
372
 
375
373
  def teardown
376
374
  super
377
- assert_equal @assertion_count, @tc.assertions
375
+ assert_equal @assertion_count, @tc.assertions if self.passed?
378
376
  end
379
377
 
380
378
  class Time
@@ -1,5 +1,5 @@
1
1
  # encoding: utf-8
2
- require "minitest/autorun"
2
+ require "minitest/metametameta"
3
3
  require "stringio"
4
4
 
5
5
  class MiniSpecA < Minitest::Spec; end
@@ -26,9 +26,8 @@ describe Minitest::Spec do
26
26
 
27
27
  msg = e.message.sub(/(---Backtrace---).*/m, '\1')
28
28
  msg.gsub!(/\(oid=[-0-9]+\)/, "(oid=N)")
29
- msg.gsub!(/@.+>/, "@PATH>")
30
29
  msg.gsub!(/(\d\.\d{6})\d+/, '\1xxx') # normalize: ruby version, impl, platform
31
- msg.gsub!(/:0x[a-fA-F0-9]{4,}/m, ":0xXXXXXX")
30
+ msg.gsub!(/:0x[Xa-fA-F0-9]{4,}[ @].+?>/, ":0xXXXXXX@PATH>")
32
31
 
33
32
  if expected
34
33
  @assertion_count += 1
@@ -56,43 +55,63 @@ describe Minitest::Spec do
56
55
  @assertion_count = 1
57
56
 
58
57
  assert_triggered "Expected 1 to not be equal to 1." do
59
- 1.wont_equal 1
58
+ _(1).wont_equal 1
59
+ end
60
+ end
61
+
62
+ it "needs to check for file existence" do
63
+ @assertion_count = 3
64
+
65
+ _(_(__FILE__).path_must_exist).must_equal true
66
+
67
+ assert_triggered "Expected path 'blah' to exist." do
68
+ _("blah").path_must_exist
69
+ end
70
+ end
71
+
72
+ it "needs to check for file non-existence" do
73
+ @assertion_count = 3
74
+
75
+ _(_("blah").path_wont_exist).must_equal false
76
+
77
+ assert_triggered "Expected path '#{__FILE__}' to not exist." do
78
+ _(__FILE__).path_wont_exist
60
79
  end
61
80
  end
62
81
 
63
82
  it "needs to be sensible about must_include order" do
64
83
  @assertion_count += 3 # must_include is 2 assertions
65
84
 
66
- [1, 2, 3].must_include(2).must_equal true
85
+ _(_([1, 2, 3]).must_include(2)).must_equal true
67
86
 
68
87
  assert_triggered "Expected [1, 2, 3] to include 5." do
69
- [1, 2, 3].must_include 5
88
+ _([1, 2, 3]).must_include 5
70
89
  end
71
90
 
72
91
  assert_triggered "msg.\nExpected [1, 2, 3] to include 5." do
73
- [1, 2, 3].must_include 5, "msg"
92
+ _([1, 2, 3]).must_include 5, "msg"
74
93
  end
75
94
  end
76
95
 
77
96
  it "needs to be sensible about wont_include order" do
78
97
  @assertion_count += 3 # wont_include is 2 assertions
79
98
 
80
- [1, 2, 3].wont_include(5).must_equal false
99
+ _(_([1, 2, 3]).wont_include(5)).must_equal false
81
100
 
82
101
  assert_triggered "Expected [1, 2, 3] to not include 2." do
83
- [1, 2, 3].wont_include 2
102
+ _([1, 2, 3]).wont_include 2
84
103
  end
85
104
 
86
105
  assert_triggered "msg.\nExpected [1, 2, 3] to not include 2." do
87
- [1, 2, 3].wont_include 2, "msg"
106
+ _([1, 2, 3]).wont_include 2, "msg"
88
107
  end
89
108
  end
90
109
 
91
110
  it "needs to catch an expected exception" do
92
111
  @assertion_count = 2
93
112
 
94
- proc { raise "blah" }.must_raise RuntimeError
95
- proc { raise Minitest::Assertion }.must_raise Minitest::Assertion
113
+ expect { raise "blah" }.must_raise RuntimeError
114
+ expect { raise Minitest::Assertion }.must_raise Minitest::Assertion
96
115
  end
97
116
 
98
117
  it "needs to catch an unexpected exception" do
@@ -106,11 +125,11 @@ describe Minitest::Spec do
106
125
  EOM
107
126
 
108
127
  assert_triggered msg do
109
- proc { raise StandardError, "woot" }.must_raise RuntimeError
128
+ expect { raise StandardError, "woot" }.must_raise RuntimeError
110
129
  end
111
130
 
112
131
  assert_triggered "msg.\n#{msg}" do
113
- proc { raise StandardError, "woot" }.must_raise RuntimeError, "msg"
132
+ expect { raise StandardError, "woot" }.must_raise RuntimeError, "msg"
114
133
  end
115
134
  end
116
135
 
@@ -118,20 +137,22 @@ describe Minitest::Spec do
118
137
  @assertion_count -= 1 # no msg
119
138
  @assertion_count += 2 # assert_output is 2 assertions
120
139
 
121
- proc {}.must_be_silent.must_equal true
140
+ _(expect {}.must_be_silent).must_equal true
122
141
 
123
142
  assert_triggered "In stdout.\nExpected: \"\"\n Actual: \"xxx\"" do
124
- proc { print "xxx" }.must_be_silent
143
+ expect { print "xxx" }.must_be_silent
125
144
  end
126
145
  end
127
146
 
128
147
  it "needs to have all methods named well" do
148
+ skip "N/A" if ENV["MT_NO_EXPECTATIONS"]
149
+
129
150
  @assertion_count = 2
130
151
 
131
- methods = Object.public_instance_methods.find_all { |n| n =~ /^must|^wont/ }
152
+ methods = Minitest::Expectations.public_instance_methods.grep(/must|wont/)
132
153
  methods.map!(&:to_s) if Symbol === methods.first
133
154
 
134
- musts, wonts = methods.sort.partition { |m| m =~ /^must/ }
155
+ musts, wonts = methods.sort.partition { |m| m =~ /must/ }
135
156
 
136
157
  expected_musts = %w[must_be
137
158
  must_be_close_to
@@ -149,70 +170,71 @@ describe Minitest::Spec do
149
170
  must_output
150
171
  must_raise
151
172
  must_respond_to
152
- must_throw]
173
+ must_throw
174
+ path_must_exist]
153
175
 
154
176
  bad = %w[not raise throw send output be_silent]
155
177
 
156
- expected_wonts = expected_musts.map { |m| m.sub(/^must/, "wont") }
178
+ expected_wonts = expected_musts.map { |m| m.sub(/must/, "wont") }.sort
157
179
  expected_wonts.reject! { |m| m =~ /wont_#{Regexp.union(*bad)}/ }
158
180
 
159
- musts.must_equal expected_musts
160
- wonts.must_equal expected_wonts
181
+ _(musts).must_equal expected_musts
182
+ _(wonts).must_equal expected_wonts
161
183
  end
162
184
 
163
185
  it "needs to raise if an expected exception is not raised" do
164
186
  @assertion_count -= 2 # no positive test
165
187
 
166
188
  assert_triggered "RuntimeError expected but nothing was raised." do
167
- proc { 42 }.must_raise RuntimeError
189
+ expect { 42 }.must_raise RuntimeError
168
190
  end
169
191
 
170
192
  assert_triggered "msg.\nRuntimeError expected but nothing was raised." do
171
- proc { 42 }.must_raise RuntimeError, "msg"
193
+ expect { 42 }.must_raise RuntimeError, "msg"
172
194
  end
173
195
  end
174
196
 
175
197
  it "needs to verify binary messages" do
176
- 42.wont_be(:<, 24).must_equal false
198
+ _(_(42).wont_be(:<, 24)).must_equal false
177
199
 
178
200
  assert_triggered "Expected 24 to not be < 42." do
179
- 24.wont_be :<, 42
201
+ _(24).wont_be :<, 42
180
202
  end
181
203
 
182
204
  assert_triggered "msg.\nExpected 24 to not be < 42." do
183
- 24.wont_be :<, 42, "msg"
205
+ _(24).wont_be :<, 42, "msg"
184
206
  end
185
207
  end
186
208
 
187
209
  it "needs to verify emptyness" do
188
210
  @assertion_count += 3 # empty is 2 assertions
189
211
 
190
- [].must_be_empty.must_equal true
212
+ _(_([]).must_be_empty).must_equal true
191
213
 
192
214
  assert_triggered "Expected [42] to be empty." do
193
- [42].must_be_empty
215
+ _([42]).must_be_empty
194
216
  end
195
217
 
196
218
  assert_triggered "msg.\nExpected [42] to be empty." do
197
- [42].must_be_empty "msg"
219
+ _([42]).must_be_empty "msg"
198
220
  end
199
221
  end
200
222
 
201
223
  it "needs to verify equality" do
202
224
  @assertion_count += 1
203
225
 
204
- (6 * 7).must_equal(42).must_equal true
226
+ _(_(6 * 7).must_equal(42)).must_equal true
205
227
 
206
228
  assert_triggered "Expected: 42\n Actual: 54" do
207
- (6 * 9).must_equal 42
229
+ _(6 * 9).must_equal 42
208
230
  end
209
231
 
210
232
  assert_triggered "msg.\nExpected: 42\n Actual: 54" do
211
- (6 * 9).must_equal 42, "msg"
233
+ _(6 * 9).must_equal 42, "msg"
212
234
  end
213
235
 
214
- assert_triggered(/^-42\n\+#<Proc:0xXXXXXX@PATH>\n/) do
215
- proc { 42 }.must_equal 42 # proc isn't called, so expectation fails
236
+ assert_triggered(/^-42\n\+#<Proc:0xXXXXXX[ @]PATH>\n/) do
237
+ _(proc { 42 }).must_equal 42 # proc isn't called, so expectation fails
216
238
  end
217
239
  end
218
240
 
@@ -220,7 +242,7 @@ describe Minitest::Spec do
220
242
  @assertion_count += 1 # extra test
221
243
 
222
244
  out, err = capture_io do
223
- nil.must_equal(nil).must_equal true
245
+ _(_(nil).must_equal(nil)).must_equal true
224
246
  end
225
247
 
226
248
  exp = "DEPRECATED: Use assert_nil if expecting nil from #{__FILE__}:#{__LINE__-3}. " \
@@ -234,259 +256,259 @@ describe Minitest::Spec do
234
256
  it "needs to verify floats outside a delta" do
235
257
  @assertion_count += 1 # extra test
236
258
 
237
- 24.wont_be_close_to(42).must_equal false
259
+ _(_(24).wont_be_close_to(42)).must_equal false
238
260
 
239
261
  assert_triggered "Expected |42 - 42.0| (0.0) to not be <= 0.001." do
240
- (6 * 7.0).wont_be_close_to 42
262
+ _(6 * 7.0).wont_be_close_to 42
241
263
  end
242
264
 
243
- x = maglev? ? "1.0000000000000001e-05" : "1.0e-05"
265
+ x = "1.0e-05"
244
266
  assert_triggered "Expected |42 - 42.0| (0.0) to not be <= #{x}." do
245
- (6 * 7.0).wont_be_close_to 42, 0.00001
267
+ _(6 * 7.0).wont_be_close_to 42, 0.00001
246
268
  end
247
269
 
248
270
  assert_triggered "msg.\nExpected |42 - 42.0| (0.0) to not be <= #{x}." do
249
- (6 * 7.0).wont_be_close_to 42, 0.00001, "msg"
271
+ _(6 * 7.0).wont_be_close_to 42, 0.00001, "msg"
250
272
  end
251
273
  end
252
274
 
253
275
  it "needs to verify floats outside an epsilon" do
254
276
  @assertion_count += 1 # extra test
255
277
 
256
- 24.wont_be_within_epsilon(42).must_equal false
278
+ _(_(24).wont_be_within_epsilon(42)).must_equal false
257
279
 
258
- x = maglev? ? "0.042000000000000003" : "0.042"
280
+ x = "0.042"
259
281
  assert_triggered "Expected |42 - 42.0| (0.0) to not be <= #{x}." do
260
- (6 * 7.0).wont_be_within_epsilon 42
282
+ _(6 * 7.0).wont_be_within_epsilon 42
261
283
  end
262
284
 
263
- x = maglev? ? "0.00042000000000000002" : "0.00042"
285
+ x = "0.00042"
264
286
  assert_triggered "Expected |42 - 42.0| (0.0) to not be <= #{x}." do
265
- (6 * 7.0).wont_be_within_epsilon 42, 0.00001
287
+ _(6 * 7.0).wont_be_within_epsilon 42, 0.00001
266
288
  end
267
289
 
268
290
  assert_triggered "msg.\nExpected |42 - 42.0| (0.0) to not be <= #{x}." do
269
- (6 * 7.0).wont_be_within_epsilon 42, 0.00001, "msg"
291
+ _(6 * 7.0).wont_be_within_epsilon 42, 0.00001, "msg"
270
292
  end
271
293
  end
272
294
 
273
295
  it "needs to verify floats within a delta" do
274
296
  @assertion_count += 1 # extra test
275
297
 
276
- (6.0 * 7).must_be_close_to(42.0).must_equal true
298
+ _(_(6.0 * 7).must_be_close_to(42.0)).must_equal true
277
299
 
278
300
  assert_triggered "Expected |0.0 - 0.01| (0.01) to be <= 0.001." do
279
- (1.0 / 100).must_be_close_to 0.0
301
+ _(1.0 / 100).must_be_close_to 0.0
280
302
  end
281
303
 
282
- x = maglev? ? "9.9999999999999995e-07" : "1.0e-06"
304
+ x = "1.0e-06"
283
305
  assert_triggered "Expected |0.0 - 0.001| (0.001) to be <= #{x}." do
284
- (1.0 / 1000).must_be_close_to 0.0, 0.000001
306
+ _(1.0 / 1000).must_be_close_to 0.0, 0.000001
285
307
  end
286
308
 
287
309
  assert_triggered "msg.\nExpected |0.0 - 0.001| (0.001) to be <= #{x}." do
288
- (1.0 / 1000).must_be_close_to 0.0, 0.000001, "msg"
310
+ _(1.0 / 1000).must_be_close_to 0.0, 0.000001, "msg"
289
311
  end
290
312
  end
291
313
 
292
314
  it "needs to verify floats within an epsilon" do
293
315
  @assertion_count += 1 # extra test
294
316
 
295
- (6.0 * 7).must_be_within_epsilon(42.0).must_equal true
317
+ _(_(6.0 * 7).must_be_within_epsilon(42.0)).must_equal true
296
318
 
297
319
  assert_triggered "Expected |0.0 - 0.01| (0.01) to be <= 0.0." do
298
- (1.0 / 100).must_be_within_epsilon 0.0
320
+ _(1.0 / 100).must_be_within_epsilon 0.0
299
321
  end
300
322
 
301
323
  assert_triggered "Expected |0.0 - 0.001| (0.001) to be <= 0.0." do
302
- (1.0 / 1000).must_be_within_epsilon 0.0, 0.000001
324
+ _(1.0 / 1000).must_be_within_epsilon 0.0, 0.000001
303
325
  end
304
326
 
305
327
  assert_triggered "msg.\nExpected |0.0 - 0.001| (0.001) to be <= 0.0." do
306
- (1.0 / 1000).must_be_within_epsilon 0.0, 0.000001, "msg"
328
+ _(1.0 / 1000).must_be_within_epsilon 0.0, 0.000001, "msg"
307
329
  end
308
330
  end
309
331
 
310
332
  it "needs to verify identity" do
311
- 1.must_be_same_as(1).must_equal true
333
+ _(_(1).must_be_same_as(1)).must_equal true
312
334
 
313
335
  assert_triggered "Expected 1 (oid=N) to be the same as 2 (oid=N)." do
314
- 1.must_be_same_as 2
336
+ _(1).must_be_same_as 2
315
337
  end
316
338
 
317
339
  assert_triggered "msg.\nExpected 1 (oid=N) to be the same as 2 (oid=N)." do
318
- 1.must_be_same_as 2, "msg"
340
+ _(1).must_be_same_as 2, "msg"
319
341
  end
320
342
  end
321
343
 
322
344
  it "needs to verify inequality" do
323
345
  @assertion_count += 2
324
- 42.wont_equal(6 * 9).must_equal false
325
- proc {}.wont_equal(42).must_equal false
346
+ _(_(42).wont_equal(6 * 9)).must_equal false
347
+ _(_(proc {}).wont_equal(42)).must_equal false
326
348
 
327
349
  assert_triggered "Expected 1 to not be equal to 1." do
328
- 1.wont_equal 1
350
+ _(1).wont_equal 1
329
351
  end
330
352
 
331
353
  assert_triggered "msg.\nExpected 1 to not be equal to 1." do
332
- 1.wont_equal 1, "msg"
354
+ _(1).wont_equal 1, "msg"
333
355
  end
334
356
  end
335
357
 
336
358
  it "needs to verify instances of a class" do
337
- 42.wont_be_instance_of(String).must_equal false
359
+ _(_(42).wont_be_instance_of(String)).must_equal false
338
360
 
339
361
  assert_triggered "Expected 42 to not be a kind of #{Int.name}." do
340
- 42.wont_be_kind_of Int
362
+ _(42).wont_be_kind_of Int
341
363
  end
342
364
 
343
365
  assert_triggered "msg.\nExpected 42 to not be an instance of #{Int.name}." do
344
- 42.wont_be_instance_of Int, "msg"
366
+ _(42).wont_be_instance_of Int, "msg"
345
367
  end
346
368
  end
347
369
 
348
370
  it "needs to verify kinds of a class" do
349
371
  @assertion_count += 2
350
372
 
351
- 42.wont_be_kind_of(String).must_equal false
352
- proc {}.wont_be_kind_of(String).must_equal false
373
+ _(_(42).wont_be_kind_of(String)).must_equal false
374
+ _(_(proc {}).wont_be_kind_of(String)).must_equal false
353
375
 
354
376
  assert_triggered "Expected 42 to not be a kind of #{Int.name}." do
355
- 42.wont_be_kind_of Int
377
+ _(42).wont_be_kind_of Int
356
378
  end
357
379
 
358
380
  assert_triggered "msg.\nExpected 42 to not be a kind of #{Int.name}." do
359
- 42.wont_be_kind_of Int, "msg"
381
+ _(42).wont_be_kind_of Int, "msg"
360
382
  end
361
383
  end
362
384
 
363
385
  it "needs to verify kinds of objects" do
364
386
  @assertion_count += 3 # extra test
365
387
 
366
- (6 * 7).must_be_kind_of(Int).must_equal true
367
- (6 * 7).must_be_kind_of(Numeric).must_equal true
388
+ _(_(6 * 7).must_be_kind_of(Int)).must_equal true
389
+ _(_(6 * 7).must_be_kind_of(Numeric)).must_equal true
368
390
 
369
391
  assert_triggered "Expected 42 to be a kind of String, not #{Int.name}." do
370
- (6 * 7).must_be_kind_of String
392
+ _(6 * 7).must_be_kind_of String
371
393
  end
372
394
 
373
395
  assert_triggered "msg.\nExpected 42 to be a kind of String, not #{Int.name}." do
374
- (6 * 7).must_be_kind_of String, "msg"
396
+ _(6 * 7).must_be_kind_of String, "msg"
375
397
  end
376
398
 
377
399
  exp = "Expected #<Proc:0xXXXXXX@PATH> to be a kind of String, not Proc."
378
400
  assert_triggered exp do
379
- proc {}.must_be_kind_of String
401
+ _(proc {}).must_be_kind_of String
380
402
  end
381
403
  end
382
404
 
383
405
  it "needs to verify mismatch" do
384
406
  @assertion_count += 3 # match is 2
385
407
 
386
- "blah".wont_match(/\d+/).must_equal false
408
+ _(_("blah").wont_match(/\d+/)).must_equal false
387
409
 
388
410
  assert_triggered "Expected /\\w+/ to not match \"blah\"." do
389
- "blah".wont_match(/\w+/)
411
+ _("blah").wont_match(/\w+/)
390
412
  end
391
413
 
392
414
  assert_triggered "msg.\nExpected /\\w+/ to not match \"blah\"." do
393
- "blah".wont_match(/\w+/, "msg")
415
+ _("blah").wont_match(/\w+/, "msg")
394
416
  end
395
417
  end
396
418
 
397
419
  it "needs to verify nil" do
398
- nil.must_be_nil.must_equal true
420
+ _(_(nil).must_be_nil).must_equal true
399
421
 
400
422
  assert_triggered "Expected 42 to be nil." do
401
- 42.must_be_nil
423
+ _(42).must_be_nil
402
424
  end
403
425
 
404
426
  assert_triggered "msg.\nExpected 42 to be nil." do
405
- 42.must_be_nil "msg"
427
+ _(42).must_be_nil "msg"
406
428
  end
407
429
  end
408
430
 
409
431
  it "needs to verify non-emptyness" do
410
432
  @assertion_count += 3 # empty is 2 assertions
411
433
 
412
- ["some item"].wont_be_empty.must_equal false
434
+ _(_(["some item"]).wont_be_empty).must_equal false
413
435
 
414
436
  assert_triggered "Expected [] to not be empty." do
415
- [].wont_be_empty
437
+ _([]).wont_be_empty
416
438
  end
417
439
 
418
440
  assert_triggered "msg.\nExpected [] to not be empty." do
419
- [].wont_be_empty "msg"
441
+ _([]).wont_be_empty "msg"
420
442
  end
421
443
  end
422
444
 
423
445
  it "needs to verify non-identity" do
424
- 1.wont_be_same_as(2).must_equal false
446
+ _(_(1).wont_be_same_as(2)).must_equal false
425
447
 
426
448
  assert_triggered "Expected 1 (oid=N) to not be the same as 1 (oid=N)." do
427
- 1.wont_be_same_as 1
449
+ _(1).wont_be_same_as 1
428
450
  end
429
451
 
430
452
  assert_triggered "msg.\nExpected 1 (oid=N) to not be the same as 1 (oid=N)." do
431
- 1.wont_be_same_as 1, "msg"
453
+ _(1).wont_be_same_as 1, "msg"
432
454
  end
433
455
  end
434
456
 
435
457
  it "needs to verify non-nil" do
436
- 42.wont_be_nil.must_equal false
458
+ _(_(42).wont_be_nil).must_equal false
437
459
 
438
460
  assert_triggered "Expected nil to not be nil." do
439
- nil.wont_be_nil
461
+ _(nil).wont_be_nil
440
462
  end
441
463
 
442
464
  assert_triggered "msg.\nExpected nil to not be nil." do
443
- nil.wont_be_nil "msg"
465
+ _(nil).wont_be_nil "msg"
444
466
  end
445
467
  end
446
468
 
447
469
  it "needs to verify objects not responding to a message" do
448
- "".wont_respond_to(:woot!).must_equal false
470
+ _(_("").wont_respond_to(:woot!)).must_equal false
449
471
 
450
472
  assert_triggered "Expected \"\" to not respond to to_s." do
451
- "".wont_respond_to :to_s
473
+ _("").wont_respond_to :to_s
452
474
  end
453
475
 
454
476
  assert_triggered "msg.\nExpected \"\" to not respond to to_s." do
455
- "".wont_respond_to :to_s, "msg"
477
+ _("").wont_respond_to :to_s, "msg"
456
478
  end
457
479
  end
458
480
 
459
481
  it "needs to verify output in stderr" do
460
482
  @assertion_count -= 1 # no msg
461
483
 
462
- proc { $stderr.print "blah" }.must_output(nil, "blah").must_equal true
484
+ _(expect { $stderr.print "blah" }.must_output(nil, "blah")).must_equal true
463
485
 
464
486
  assert_triggered "In stderr.\nExpected: \"blah\"\n Actual: \"xxx\"" do
465
- proc { $stderr.print "xxx" }.must_output(nil, "blah")
487
+ expect { $stderr.print "xxx" }.must_output(nil, "blah")
466
488
  end
467
489
  end
468
490
 
469
491
  it "needs to verify output in stdout" do
470
492
  @assertion_count -= 1 # no msg
471
493
 
472
- proc { print "blah" }.must_output("blah").must_equal true
494
+ _(expect { print "blah" }.must_output("blah")).must_equal true
473
495
 
474
496
  assert_triggered "In stdout.\nExpected: \"blah\"\n Actual: \"xxx\"" do
475
- proc { print "xxx" }.must_output("blah")
497
+ expect { print "xxx" }.must_output("blah")
476
498
  end
477
499
  end
478
500
 
479
501
  it "needs to verify regexp matches" do
480
502
  @assertion_count += 3 # must_match is 2 assertions
481
503
 
482
- "blah".must_match(/\w+/).must_equal true
504
+ _(_("blah").must_match(/\w+/)).must_equal true
483
505
 
484
506
  assert_triggered "Expected /\\d+/ to match \"blah\"." do
485
- "blah".must_match(/\d+/)
507
+ _("blah").must_match(/\d+/)
486
508
  end
487
509
 
488
510
  assert_triggered "msg.\nExpected /\\d+/ to match \"blah\"." do
489
- "blah".must_match(/\d+/, "msg")
511
+ _("blah").must_match(/\d+/, "msg")
490
512
  end
491
513
  end
492
514
 
@@ -508,89 +530,120 @@ describe Minitest::Spec do
508
530
  end
509
531
 
510
532
  it "can NOT use must_equal in a thread. It must use expect in a thread" do
511
- assert_raises NoMethodError do
533
+ skip "N/A" if ENV["MT_NO_EXPECTATIONS"]
534
+ assert_raises RuntimeError do
512
535
  capture_io do
513
536
  Thread.new { (1 + 1).must_equal 2 }.join
514
537
  end
515
538
  end
516
539
  end
540
+
541
+ it "fails gracefully when expectation used outside of `it`" do
542
+ skip "N/A" if ENV["MT_NO_EXPECTATIONS"]
543
+
544
+ @assertion_count += 1
545
+
546
+ e = assert_raises RuntimeError do
547
+ capture_io do
548
+ Thread.new { # forces ctx to be nil
549
+ describe("woot") do
550
+ (1 + 1).must_equal 2
551
+ end
552
+ }.join
553
+ end
554
+ end
555
+
556
+ assert_equal "Calling #must_equal outside of test.", e.message
557
+ end
558
+
559
+ it "deprecates expectation used without _" do
560
+ skip "N/A" if ENV["MT_NO_EXPECTATIONS"]
561
+
562
+ @assertion_count += 3
563
+
564
+ exp = /DEPRECATED: global use of must_equal from/
565
+
566
+ assert_output "", exp do
567
+ (1 + 1).must_equal 2
568
+ end
569
+ end
517
570
  end
518
571
 
519
572
  it "needs to verify throw" do
520
573
  @assertion_count += 2 # 2 extra tests
521
574
 
522
- proc { throw :blah }.must_throw(:blah).must_equal true
575
+ _(expect { throw :blah }.must_throw(:blah)).must_equal true
523
576
 
524
577
  assert_triggered "Expected :blah to have been thrown." do
525
- proc {}.must_throw :blah
578
+ expect {}.must_throw :blah
526
579
  end
527
580
 
528
581
  assert_triggered "Expected :blah to have been thrown, not :xxx." do
529
- proc { throw :xxx }.must_throw :blah
582
+ expect { throw :xxx }.must_throw :blah
530
583
  end
531
584
 
532
585
  assert_triggered "msg.\nExpected :blah to have been thrown." do
533
- proc {}.must_throw :blah, "msg"
586
+ expect {}.must_throw :blah, "msg"
534
587
  end
535
588
 
536
589
  assert_triggered "msg.\nExpected :blah to have been thrown, not :xxx." do
537
- proc { throw :xxx }.must_throw :blah, "msg"
590
+ expect { throw :xxx }.must_throw :blah, "msg"
538
591
  end
539
592
  end
540
593
 
541
594
  it "needs to verify types of objects" do
542
- (6 * 7).must_be_instance_of(Int).must_equal true
595
+ _(_(6 * 7).must_be_instance_of(Int)).must_equal true
543
596
 
544
597
  exp = "Expected 42 to be an instance of String, not #{Int.name}."
545
598
 
546
599
  assert_triggered exp do
547
- (6 * 7).must_be_instance_of String
600
+ _(6 * 7).must_be_instance_of String
548
601
  end
549
602
 
550
603
  assert_triggered "msg.\n#{exp}" do
551
- (6 * 7).must_be_instance_of String, "msg"
604
+ _(6 * 7).must_be_instance_of String, "msg"
552
605
  end
553
606
  end
554
607
 
555
608
  it "needs to verify using any (negative) predicate" do
556
609
  @assertion_count -= 1 # doesn"t take a message
557
610
 
558
- "blah".wont_be(:empty?).must_equal false
611
+ _(_("blah").wont_be(:empty?)).must_equal false
559
612
 
560
613
  assert_triggered "Expected \"\" to not be empty?." do
561
- "".wont_be :empty?
614
+ _("").wont_be :empty?
562
615
  end
563
616
  end
564
617
 
565
618
  it "needs to verify using any binary operator" do
566
619
  @assertion_count -= 1 # no msg
567
620
 
568
- 41.must_be(:<, 42).must_equal true
621
+ _(_(41).must_be(:<, 42)).must_equal true
569
622
 
570
623
  assert_triggered "Expected 42 to be < 41." do
571
- 42.must_be(:<, 41)
624
+ _(42).must_be(:<, 41)
572
625
  end
573
626
  end
574
627
 
575
628
  it "needs to verify using any predicate" do
576
629
  @assertion_count -= 1 # no msg
577
630
 
578
- "".must_be(:empty?).must_equal true
631
+ _(_("").must_be(:empty?)).must_equal true
579
632
 
580
633
  assert_triggered "Expected \"blah\" to be empty?." do
581
- "blah".must_be :empty?
634
+ _("blah").must_be :empty?
582
635
  end
583
636
  end
584
637
 
585
638
  it "needs to verify using respond_to" do
586
- 42.must_respond_to(:+).must_equal true
639
+ _(_(42).must_respond_to(:+)).must_equal true
587
640
 
588
641
  assert_triggered "Expected 42 (#{Int.name}) to respond to #clear." do
589
- 42.must_respond_to :clear
642
+ _(42).must_respond_to :clear
590
643
  end
591
644
 
592
645
  assert_triggered "msg.\nExpected 42 (#{Int.name}) to respond to #clear." do
593
- 42.must_respond_to :clear, "msg"
646
+ _(42).must_respond_to :clear, "msg"
594
647
  end
595
648
  end
596
649
  end
@@ -608,33 +661,33 @@ describe Minitest::Spec, :let do
608
661
  end
609
662
 
610
663
  it "is evaluated once per example" do
611
- _count.must_equal 0
664
+ _(_count).must_equal 0
612
665
 
613
- count.must_equal 1
614
- count.must_equal 1
666
+ _(count).must_equal 1
667
+ _(count).must_equal 1
615
668
 
616
- _count.must_equal 1
669
+ _(_count).must_equal 1
617
670
  end
618
671
 
619
672
  it "is REALLY evaluated once per example" do
620
- _count.must_equal 1
673
+ _(_count).must_equal 1
621
674
 
622
- count.must_equal 2
623
- count.must_equal 2
675
+ _(count).must_equal 2
676
+ _(count).must_equal 2
624
677
 
625
- _count.must_equal 2
678
+ _(_count).must_equal 2
626
679
  end
627
680
 
628
681
  it 'raises an error if the name begins with "test"' do
629
- proc { self.class.let(:test_value) { true } }.must_raise ArgumentError
682
+ expect { self.class.let(:test_value) { true } }.must_raise ArgumentError
630
683
  end
631
684
 
632
685
  it "raises an error if the name shadows a normal instance method" do
633
- proc { self.class.let(:message) { true } }.must_raise ArgumentError
686
+ expect { self.class.let(:message) { true } }.must_raise ArgumentError
634
687
  end
635
688
 
636
689
  it "doesn't raise an error if it is just another let" do
637
- proc do
690
+ v = proc do
638
691
  describe :outer do
639
692
  let(:bar)
640
693
  describe :inner do
@@ -642,13 +695,14 @@ describe Minitest::Spec, :let do
642
695
  end
643
696
  end
644
697
  :good
645
- end.call.must_equal :good
698
+ end.call
699
+ _(v).must_equal :good
646
700
  end
647
701
 
648
702
  it "procs come after dont_flip" do
649
703
  p = proc {}
650
704
  assert_respond_to p, :call
651
- p.must_respond_to :call
705
+ _(p).must_respond_to :call
652
706
  end
653
707
  end
654
708
 
@@ -662,9 +716,9 @@ describe Minitest::Spec, :subject do
662
716
  end
663
717
 
664
718
  it "is evaluated once per example" do
665
- subject.must_equal 1
666
- subject.must_equal 1
667
- subject_evaluation_count.must_equal 1
719
+ _(subject).must_equal 1
720
+ _(subject).must_equal 1
721
+ _(subject_evaluation_count).must_equal 1
668
722
  end
669
723
  end
670
724
 
@@ -722,10 +776,8 @@ class TestMetaStatic < Minitest::Test
722
776
  end
723
777
  end
724
778
 
725
- require "minitest/metametameta"
726
-
727
779
  class TestMeta < MetaMetaMetaTestCase
728
- parallelize_me!
780
+ # do not call parallelize_me! here because specs use register_spec_type globally
729
781
 
730
782
  def util_structure
731
783
  y = z = nil
@@ -795,7 +847,7 @@ class TestMeta < MetaMetaMetaTestCase
795
847
  def test_bug_dsl_expectations
796
848
  spec_class = Class.new MiniSpecB do
797
849
  it "should work" do
798
- 0.must_equal 0
850
+ _(0).must_equal 0
799
851
  end
800
852
  end
801
853
 
@@ -947,18 +999,20 @@ class TestSpecInTestCase < MetaMetaMetaTestCase
947
999
  end
948
1000
 
949
1001
  def test_expectation
950
- @tc.assert_equal true, 1.must_equal(1)
1002
+ @tc.assert_equal true, _(1).must_equal(1)
951
1003
  end
952
1004
 
953
1005
  def test_expectation_triggered
954
1006
  assert_triggered "Expected: 2\n Actual: 1" do
955
- 1.must_equal 2
1007
+ _(1).must_equal 2
956
1008
  end
957
1009
  end
958
1010
 
1011
+ include Minitest::Spec::DSL::InstanceMethods
1012
+
959
1013
  def test_expectation_with_a_message
960
1014
  assert_triggered "woot.\nExpected: 2\n Actual: 1" do
961
- 1.must_equal 2, "woot"
1015
+ _(1).must_equal 2, "woot"
962
1016
  end
963
1017
  end
964
1018
  end