assert 2.19.1 → 2.19.6

Sign up to get free protection for your applications and to get access to all the features.
Files changed (72) hide show
  1. checksums.yaml +4 -4
  2. data/assert.gemspec +10 -7
  3. data/lib/assert.rb +18 -6
  4. data/lib/assert/actual_value.rb +8 -6
  5. data/lib/assert/assert_runner.rb +36 -17
  6. data/lib/assert/assertions.rb +83 -50
  7. data/lib/assert/cli.rb +30 -70
  8. data/lib/assert/clirb.rb +55 -0
  9. data/lib/assert/config.rb +20 -8
  10. data/lib/assert/config_helpers.rb +55 -22
  11. data/lib/assert/context.rb +14 -18
  12. data/lib/assert/context/let_dsl.rb +5 -2
  13. data/lib/assert/context/setup_dsl.rb +21 -16
  14. data/lib/assert/context/subject_dsl.rb +6 -7
  15. data/lib/assert/context/suite_dsl.rb +2 -1
  16. data/lib/assert/context/test_dsl.rb +55 -19
  17. data/lib/assert/default_suite.rb +25 -15
  18. data/lib/assert/default_view.rb +47 -30
  19. data/lib/assert/file_line.rb +6 -6
  20. data/lib/assert/macro.rb +1 -1
  21. data/lib/assert/macros/methods.rb +71 -45
  22. data/lib/assert/result.rb +111 -62
  23. data/lib/assert/runner.rb +68 -51
  24. data/lib/assert/stub.rb +42 -3
  25. data/lib/assert/suite.rb +67 -28
  26. data/lib/assert/test.rb +40 -35
  27. data/lib/assert/utils.rb +19 -10
  28. data/lib/assert/version.rb +1 -1
  29. data/lib/assert/view.rb +44 -18
  30. data/lib/assert/view_helpers.rb +100 -92
  31. data/test/helper.rb +3 -1
  32. data/test/support/factory.rb +38 -21
  33. data/test/system/stub_tests.rb +180 -144
  34. data/test/system/test_tests.rb +86 -60
  35. data/test/unit/actual_value_tests.rb +69 -50
  36. data/test/unit/assert_tests.rb +39 -22
  37. data/test/unit/assertions/assert_block_tests.rb +10 -10
  38. data/test/unit/assertions/assert_changes_tests.rb +25 -21
  39. data/test/unit/assertions/assert_empty_tests.rb +14 -12
  40. data/test/unit/assertions/assert_equal_tests.rb +26 -26
  41. data/test/unit/assertions/assert_file_exists_tests.rb +15 -13
  42. data/test/unit/assertions/assert_includes_tests.rb +10 -10
  43. data/test/unit/assertions/assert_instance_of_tests.rb +14 -14
  44. data/test/unit/assertions/assert_is_a_tests.rb +128 -0
  45. data/test/unit/assertions/assert_match_tests.rb +10 -10
  46. data/test/unit/assertions/assert_nil_tests.rb +16 -12
  47. data/test/unit/assertions/assert_raises_tests.rb +27 -20
  48. data/test/unit/assertions/assert_respond_to_tests.rb +10 -10
  49. data/test/unit/assertions/assert_same_tests.rb +24 -24
  50. data/test/unit/assertions/assert_true_false_tests.rb +32 -24
  51. data/test/unit/assertions_tests.rb +14 -9
  52. data/test/unit/config_helpers_tests.rb +15 -10
  53. data/test/unit/config_tests.rb +34 -9
  54. data/test/unit/context/setup_dsl_tests.rb +24 -14
  55. data/test/unit/context/subject_dsl_tests.rb +3 -3
  56. data/test/unit/context/suite_dsl_tests.rb +4 -4
  57. data/test/unit/context/test_dsl_tests.rb +37 -17
  58. data/test/unit/context_info_tests.rb +4 -4
  59. data/test/unit/context_tests.rb +110 -54
  60. data/test/unit/default_suite_tests.rb +10 -6
  61. data/test/unit/factory_tests.rb +2 -2
  62. data/test/unit/file_line_tests.rb +7 -7
  63. data/test/unit/macro_tests.rb +11 -11
  64. data/test/unit/result_tests.rb +47 -41
  65. data/test/unit/runner_tests.rb +29 -16
  66. data/test/unit/suite_tests.rb +37 -15
  67. data/test/unit/test_tests.rb +63 -50
  68. data/test/unit/utils_tests.rb +48 -35
  69. data/test/unit/view_helpers_tests.rb +21 -14
  70. data/test/unit/view_tests.rb +5 -5
  71. metadata +26 -11
  72. data/test/unit/assertions/assert_kind_of_tests.rb +0 -68
data/test/system/stub_tests.rb CHANGED
@@ -10,7 +10,7 @@ class Assert::Stub
10
10
 
11
11
  class InstanceTests < SystemTests
12
12
  desc "for instance methods"
13
- subject { TestClass.new }
13
+ subject{ TestClass.new }
14
14
 
15
15
  setup do
16
16
  Assert.stub(subject, :noargs){ "default" }
@@ -56,33 +56,33 @@ class Assert::Stub
56
56
  end
57
57
 
58
58
  should "not allow stubbing methods with invalid arity" do
59
- assert_that { Assert.stub(subject, :noargs).with(1){ } }.raises
59
+ assert_that{ Assert.stub(subject, :noargs).with(1){} }.raises
60
60
 
61
- assert_that { Assert.stub(subject, :withargs).with{ } }.raises
62
- assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.raises
61
+ assert_that{ Assert.stub(subject, :withargs).with{} }.raises
62
+ assert_that{ Assert.stub(subject, :withargs).with(1, 2){} }.raises
63
63
 
64
- assert_that { Assert.stub(subject, :minargs).with{ } }.raises
65
- assert_that { Assert.stub(subject, :minargs).with(1){ } }.raises
64
+ assert_that{ Assert.stub(subject, :minargs).with{} }.raises
65
+ assert_that{ Assert.stub(subject, :minargs).with(1){} }.raises
66
66
 
67
- assert_that { Assert.stub(subject, :withblock).with(1){ } }.raises
67
+ assert_that{ Assert.stub(subject, :withblock).with(1){} }.raises
68
68
  end
69
69
 
70
70
  should "not allow calling methods with invalid arity" do
71
- assert_that { subject.noargs(1) }.raises
71
+ assert_that{ subject.noargs(1) }.raises
72
72
 
73
- assert_that { subject.withargs }.raises
74
- assert_that { subject.withargs(1, 2) }.raises
73
+ assert_that{ subject.withargs }.raises
74
+ assert_that{ subject.withargs(1, 2) }.raises
75
75
 
76
- assert_that { subject.minargs }.raises
77
- assert_that { subject.minargs(1) }.raises
76
+ assert_that{ subject.minargs }.raises
77
+ assert_that{ subject.minargs(1) }.raises
78
78
 
79
- assert_that { subject.withblock(1) }.raises
79
+ assert_that{ subject.withblock(1) }.raises
80
80
  end
81
81
  end
82
82
 
83
83
  class ClassTests < SystemTests
84
84
  desc "for singleton methods on a class"
85
- subject { TestClass }
85
+ subject{ TestClass }
86
86
 
87
87
  setup do
88
88
  Assert.stub(subject, :noargs){ "default" }
@@ -129,33 +129,33 @@ class Assert::Stub
129
129
  end
130
130
 
131
131
  should "not allow stubbing methods with invalid arity" do
132
- assert_that { Assert.stub(subject, :noargs).with(1){ } }.raises
132
+ assert_that{ Assert.stub(subject, :noargs).with(1){} }.raises
133
133
 
134
- assert_that { Assert.stub(subject, :withargs).with{ } }.raises
135
- assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.raises
134
+ assert_that{ Assert.stub(subject, :withargs).with{} }.raises
135
+ assert_that{ Assert.stub(subject, :withargs).with(1, 2){} }.raises
136
136
 
137
- assert_that { Assert.stub(subject, :minargs).with{ } }.raises
138
- assert_that { Assert.stub(subject, :minargs).with(1){ } }.raises
137
+ assert_that{ Assert.stub(subject, :minargs).with{} }.raises
138
+ assert_that{ Assert.stub(subject, :minargs).with(1){} }.raises
139
139
 
140
- assert_that { Assert.stub(subject, :withblock).with(1){ } }.raises
140
+ assert_that{ Assert.stub(subject, :withblock).with(1){} }.raises
141
141
  end
142
142
 
143
143
  should "not allow calling methods with invalid arity" do
144
- assert_that { subject.noargs(1) }.raises
144
+ assert_that{ subject.noargs(1) }.raises
145
145
 
146
- assert_that { subject.withargs }.raises
147
- assert_that { subject.withargs(1, 2) }.raises
146
+ assert_that{ subject.withargs }.raises
147
+ assert_that{ subject.withargs(1, 2) }.raises
148
148
 
149
- assert_that { subject.minargs }.raises
150
- assert_that { subject.minargs(1) }.raises
149
+ assert_that{ subject.minargs }.raises
150
+ assert_that{ subject.minargs(1) }.raises
151
151
 
152
- assert_that { subject.withblock(1) }.raises
152
+ assert_that{ subject.withblock(1) }.raises
153
153
  end
154
154
  end
155
155
 
156
156
  class ModuleTests < SystemTests
157
157
  desc "for singleton methods on a module"
158
- subject { TestModule }
158
+ subject{ TestModule }
159
159
 
160
160
  setup do
161
161
  Assert.stub(subject, :noargs){ "default" }
@@ -202,33 +202,33 @@ class Assert::Stub
202
202
  end
203
203
 
204
204
  should "not allow stubbing methods with invalid arity" do
205
- assert_that { Assert.stub(subject, :noargs).with(1){ } }.raises
205
+ assert_that{ Assert.stub(subject, :noargs).with(1){} }.raises
206
206
 
207
- assert_that { Assert.stub(subject, :withargs).with{ } }.raises
208
- assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.raises
207
+ assert_that{ Assert.stub(subject, :withargs).with{} }.raises
208
+ assert_that{ Assert.stub(subject, :withargs).with(1, 2){} }.raises
209
209
 
210
- assert_that { Assert.stub(subject, :minargs).with{ } }.raises
211
- assert_that { Assert.stub(subject, :minargs).with(1){ } }.raises
210
+ assert_that{ Assert.stub(subject, :minargs).with{} }.raises
211
+ assert_that{ Assert.stub(subject, :minargs).with(1){} }.raises
212
212
 
213
- assert_that { Assert.stub(subject, :withblock).with(1){ } }.raises
213
+ assert_that{ Assert.stub(subject, :withblock).with(1){} }.raises
214
214
  end
215
215
 
216
216
  should "not allow calling methods with invalid arity" do
217
- assert_that { subject.noargs(1) }.raises
217
+ assert_that{ subject.noargs(1) }.raises
218
218
 
219
- assert_that { subject.withargs }.raises
220
- assert_that { subject.withargs(1, 2) }.raises
219
+ assert_that{ subject.withargs }.raises
220
+ assert_that{ subject.withargs(1, 2) }.raises
221
221
 
222
- assert_that { subject.minargs }.raises
223
- assert_that { subject.minargs(1) }.raises
222
+ assert_that{ subject.minargs }.raises
223
+ assert_that{ subject.minargs(1) }.raises
224
224
 
225
- assert_that { subject.withblock(1) }.raises
225
+ assert_that{ subject.withblock(1) }.raises
226
226
  end
227
227
  end
228
228
 
229
229
  class ExtendedTests < SystemTests
230
230
  desc "for extended methods"
231
- subject { Class.new{ extend TestMixin } }
231
+ subject{ Class.new{ extend TestMixin } }
232
232
 
233
233
  setup do
234
234
  Assert.stub(subject, :noargs){ "default" }
@@ -275,35 +275,35 @@ class Assert::Stub
275
275
  end
276
276
 
277
277
  should "not allow stubbing methods with invalid arity" do
278
- assert_that { Assert.stub(subject, :noargs).with(1){ } }.raises
278
+ assert_that{ Assert.stub(subject, :noargs).with(1){} }.raises
279
279
 
280
- assert_that { Assert.stub(subject, :withargs).with{ } }.raises
281
- assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.raises
280
+ assert_that{ Assert.stub(subject, :withargs).with{} }.raises
281
+ assert_that{ Assert.stub(subject, :withargs).with(1, 2){} }.raises
282
282
 
283
- assert_that { Assert.stub(subject, :minargs).with{ } }.raises
284
- assert_that { Assert.stub(subject, :minargs).with(1){ } }.raises
283
+ assert_that{ Assert.stub(subject, :minargs).with{} }.raises
284
+ assert_that{ Assert.stub(subject, :minargs).with(1){} }.raises
285
285
 
286
- assert_that { Assert.stub(subject, :withblock).with(1){ } }.raises
286
+ assert_that{ Assert.stub(subject, :withblock).with(1){} }.raises
287
287
  end
288
288
 
289
289
  should "not allow calling methods with invalid arity" do
290
- assert_that { subject.noargs(1) }.raises
290
+ assert_that{ subject.noargs(1) }.raises
291
291
 
292
- assert_that { subject.withargs }.raises
293
- assert_that { subject.withargs(1, 2) }.raises
292
+ assert_that{ subject.withargs }.raises
293
+ assert_that{ subject.withargs(1, 2) }.raises
294
294
 
295
- assert_that { subject.minargs }.raises
296
- assert_that { subject.minargs(1) }.raises
295
+ assert_that{ subject.minargs }.raises
296
+ assert_that{ subject.minargs(1) }.raises
297
297
 
298
- assert_that { subject.withblock(1) }.raises
298
+ assert_that{ subject.withblock(1) }.raises
299
299
  end
300
300
  end
301
301
 
302
302
  class IncludedTests < SystemTests
303
303
  desc "for an included method"
304
- subject {
305
- Class.new { include TestMixin }.new
306
- }
304
+ subject do
305
+ Class.new{ include TestMixin }.new
306
+ end
307
307
 
308
308
  setup do
309
309
  Assert.stub(subject, :noargs){ "default" }
@@ -350,33 +350,33 @@ class Assert::Stub
350
350
  end
351
351
 
352
352
  should "not allow stubbing methods with invalid arity" do
353
- assert_that { Assert.stub(subject, :noargs).with(1){ } }.raises
353
+ assert_that{ Assert.stub(subject, :noargs).with(1){} }.raises
354
354
 
355
- assert_that { Assert.stub(subject, :withargs).with{ } }.raises
356
- assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.raises
355
+ assert_that{ Assert.stub(subject, :withargs).with{} }.raises
356
+ assert_that{ Assert.stub(subject, :withargs).with(1, 2){} }.raises
357
357
 
358
- assert_that { Assert.stub(subject, :minargs).with{ } }.raises
359
- assert_that { Assert.stub(subject, :minargs).with(1){ } }.raises
358
+ assert_that{ Assert.stub(subject, :minargs).with{} }.raises
359
+ assert_that{ Assert.stub(subject, :minargs).with(1){} }.raises
360
360
 
361
- assert_that { Assert.stub(subject, :withblock).with(1){ } }.raises
361
+ assert_that{ Assert.stub(subject, :withblock).with(1){} }.raises
362
362
  end
363
363
 
364
364
  should "not allow calling methods with invalid arity" do
365
- assert_that { subject.noargs(1) }.raises
365
+ assert_that{ subject.noargs(1) }.raises
366
366
 
367
- assert_that { subject.withargs }.raises
368
- assert_that { subject.withargs(1, 2) }.raises
367
+ assert_that{ subject.withargs }.raises
368
+ assert_that{ subject.withargs(1, 2) }.raises
369
369
 
370
- assert_that { subject.minargs }.raises
371
- assert_that { subject.minargs(1) }.raises
370
+ assert_that{ subject.minargs }.raises
371
+ assert_that{ subject.minargs(1) }.raises
372
372
 
373
- assert_that { subject.withblock(1) }.raises
373
+ assert_that{ subject.withblock(1) }.raises
374
374
  end
375
375
  end
376
376
 
377
377
  class InheritedClassTests < SystemTests
378
378
  desc "for an inherited class method"
379
- subject { Class.new(TestClass) }
379
+ subject{ Class.new(TestClass) }
380
380
 
381
381
  setup do
382
382
  Assert.stub(subject, :noargs){ "default" }
@@ -423,33 +423,33 @@ class Assert::Stub
423
423
  end
424
424
 
425
425
  should "not allow stubbing methods with invalid arity" do
426
- assert_that { Assert.stub(subject, :noargs).with(1){ } }.raises
426
+ assert_that{ Assert.stub(subject, :noargs).with(1){} }.raises
427
427
 
428
- assert_that { Assert.stub(subject, :withargs).with{ } }.raises
429
- assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.raises
428
+ assert_that{ Assert.stub(subject, :withargs).with{} }.raises
429
+ assert_that{ Assert.stub(subject, :withargs).with(1, 2){} }.raises
430
430
 
431
- assert_that { Assert.stub(subject, :minargs).with{ } }.raises
432
- assert_that { Assert.stub(subject, :minargs).with(1){ } }.raises
431
+ assert_that{ Assert.stub(subject, :minargs).with{} }.raises
432
+ assert_that{ Assert.stub(subject, :minargs).with(1){} }.raises
433
433
 
434
- assert_that { Assert.stub(subject, :withblock).with(1){ } }.raises
434
+ assert_that{ Assert.stub(subject, :withblock).with(1){} }.raises
435
435
  end
436
436
 
437
437
  should "not allow calling methods with invalid arity" do
438
- assert_that { subject.noargs(1) }.raises
438
+ assert_that{ subject.noargs(1) }.raises
439
439
 
440
- assert_that { subject.withargs }.raises
441
- assert_that { subject.withargs(1, 2) }.raises
440
+ assert_that{ subject.withargs }.raises
441
+ assert_that{ subject.withargs(1, 2) }.raises
442
442
 
443
- assert_that { subject.minargs }.raises
444
- assert_that { subject.minargs(1) }.raises
443
+ assert_that{ subject.minargs }.raises
444
+ assert_that{ subject.minargs(1) }.raises
445
445
 
446
- assert_that { subject.withblock(1) }.raises
446
+ assert_that{ subject.withblock(1) }.raises
447
447
  end
448
448
  end
449
449
 
450
450
  class InheritedInstanceTests < SystemTests
451
451
  desc "for an inherited instance method"
452
- subject { Class.new(TestClass).new }
452
+ subject{ Class.new(TestClass).new }
453
453
 
454
454
  setup do
455
455
  Assert.stub(subject, :noargs){ "default" }
@@ -496,33 +496,33 @@ class Assert::Stub
496
496
  end
497
497
 
498
498
  should "not allow stubbing methods with invalid arity" do
499
- assert_that { Assert.stub(subject, :noargs).with(1){ } }.raises
499
+ assert_that{ Assert.stub(subject, :noargs).with(1){} }.raises
500
500
 
501
- assert_that { Assert.stub(subject, :withargs).with{ } }.raises
502
- assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.raises
501
+ assert_that{ Assert.stub(subject, :withargs).with{} }.raises
502
+ assert_that{ Assert.stub(subject, :withargs).with(1, 2){} }.raises
503
503
 
504
- assert_that { Assert.stub(subject, :minargs).with{ } }.raises
505
- assert_that { Assert.stub(subject, :minargs).with(1){ } }.raises
504
+ assert_that{ Assert.stub(subject, :minargs).with{} }.raises
505
+ assert_that{ Assert.stub(subject, :minargs).with(1){} }.raises
506
506
 
507
- assert_that { Assert.stub(subject, :withblock).with(1){ } }.raises
507
+ assert_that{ Assert.stub(subject, :withblock).with(1){} }.raises
508
508
  end
509
509
 
510
510
  should "not allow calling methods with invalid arity" do
511
- assert_that { subject.noargs(1) }.raises
511
+ assert_that{ subject.noargs(1) }.raises
512
512
 
513
- assert_that { subject.withargs }.raises
514
- assert_that { subject.withargs(1, 2) }.raises
513
+ assert_that{ subject.withargs }.raises
514
+ assert_that{ subject.withargs(1, 2) }.raises
515
515
 
516
- assert_that { subject.minargs }.raises
517
- assert_that { subject.minargs(1) }.raises
516
+ assert_that{ subject.minargs }.raises
517
+ assert_that{ subject.minargs(1) }.raises
518
518
 
519
- assert_that { subject.withblock(1) }.raises
519
+ assert_that{ subject.withblock(1) }.raises
520
520
  end
521
521
  end
522
522
 
523
523
  class DelegateClassTests < SystemTests
524
524
  desc "a class that delegates another object"
525
- subject { DelegateClass }
525
+ subject{ DelegateClass }
526
526
 
527
527
  setup do
528
528
  Assert.stub(subject, :noargs){ "default" }
@@ -569,33 +569,33 @@ class Assert::Stub
569
569
  end
570
570
 
571
571
  should "allow stubbing methods with invalid arity" do
572
- assert_that { Assert.stub(subject, :noargs).with(1){ } }.does_not_raise
572
+ assert_that{ Assert.stub(subject, :noargs).with(1){} }.does_not_raise
573
573
 
574
- assert_that { Assert.stub(subject, :withargs).with{ } }.does_not_raise
575
- assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.does_not_raise
574
+ assert_that{ Assert.stub(subject, :withargs).with{} }.does_not_raise
575
+ assert_that{ Assert.stub(subject, :withargs).with(1, 2){} }.does_not_raise
576
576
 
577
- assert_that { Assert.stub(subject, :minargs).with{ } }.does_not_raise
578
- assert_that { Assert.stub(subject, :minargs).with(1){ } }.does_not_raise
577
+ assert_that{ Assert.stub(subject, :minargs).with{} }.does_not_raise
578
+ assert_that{ Assert.stub(subject, :minargs).with(1){} }.does_not_raise
579
579
 
580
- assert_that { Assert.stub(subject, :withblock).with(1){ } }.does_not_raise
580
+ assert_that{ Assert.stub(subject, :withblock).with(1){} }.does_not_raise
581
581
  end
582
582
 
583
583
  should "allow calling methods with invalid arity" do
584
- assert_that { subject.noargs(1) }.does_not_raise
584
+ assert_that{ subject.noargs(1) }.does_not_raise
585
585
 
586
- assert_that { subject.withargs }.does_not_raise
587
- assert_that { subject.withargs(1, 2) }.does_not_raise
586
+ assert_that{ subject.withargs }.does_not_raise
587
+ assert_that{ subject.withargs(1, 2) }.does_not_raise
588
588
 
589
- assert_that { subject.minargs }.does_not_raise
590
- assert_that { subject.minargs(1) }.does_not_raise
589
+ assert_that{ subject.minargs }.does_not_raise
590
+ assert_that{ subject.minargs(1) }.does_not_raise
591
591
 
592
- assert_that { subject.withblock(1) }.does_not_raise
592
+ assert_that{ subject.withblock(1) }.does_not_raise
593
593
  end
594
594
  end
595
595
 
596
596
  class DelegateInstanceTests < SystemTests
597
597
  desc "an instance that delegates another object"
598
- subject { DelegateClass.new }
598
+ subject{ DelegateClass.new }
599
599
 
600
600
  setup do
601
601
  Assert.stub(subject, :noargs){ "default" }
@@ -642,27 +642,27 @@ class Assert::Stub
642
642
  end
643
643
 
644
644
  should "allow stubbing methods with invalid arity" do
645
- assert_that { Assert.stub(subject, :noargs).with(1){ } }.does_not_raise
645
+ assert_that{ Assert.stub(subject, :noargs).with(1){} }.does_not_raise
646
646
 
647
- assert_that { Assert.stub(subject, :withargs).with{ } }.does_not_raise
648
- assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.does_not_raise
647
+ assert_that{ Assert.stub(subject, :withargs).with{} }.does_not_raise
648
+ assert_that{ Assert.stub(subject, :withargs).with(1, 2){} }.does_not_raise
649
649
 
650
- assert_that { Assert.stub(subject, :minargs).with{ } }.does_not_raise
651
- assert_that { Assert.stub(subject, :minargs).with(1){ } }.does_not_raise
650
+ assert_that{ Assert.stub(subject, :minargs).with{} }.does_not_raise
651
+ assert_that{ Assert.stub(subject, :minargs).with(1){} }.does_not_raise
652
652
 
653
- assert_that { Assert.stub(subject, :withblock).with(1){ } }.does_not_raise
653
+ assert_that{ Assert.stub(subject, :withblock).with(1){} }.does_not_raise
654
654
  end
655
655
 
656
656
  should "allow calling methods with invalid arity" do
657
- assert_that { subject.noargs(1) }.does_not_raise
657
+ assert_that{ subject.noargs(1) }.does_not_raise
658
658
 
659
- assert_that { subject.withargs }.does_not_raise
660
- assert_that { subject.withargs(1, 2) }.does_not_raise
659
+ assert_that{ subject.withargs }.does_not_raise
660
+ assert_that{ subject.withargs(1, 2) }.does_not_raise
661
661
 
662
- assert_that { subject.minargs }.does_not_raise
663
- assert_that { subject.minargs(1) }.does_not_raise
662
+ assert_that{ subject.minargs }.does_not_raise
663
+ assert_that{ subject.minargs(1) }.does_not_raise
664
664
 
665
- assert_that { subject.withblock(1) }.does_not_raise
665
+ assert_that{ subject.withblock(1) }.does_not_raise
666
666
  end
667
667
  end
668
668
 
@@ -673,8 +673,8 @@ class Assert::Stub
673
673
  Assert.stub(child_class, :new){ "child" }
674
674
  end
675
675
 
676
- let(:parent_class) { Class.new }
677
- let(:child_class) { Class.new(parent_class) }
676
+ let(:parent_class){ Class.new }
677
+ let(:child_class){ Class.new(parent_class) }
678
678
 
679
679
  should "allow stubbing the methods individually" do
680
680
  assert_that(parent_class.new).equals("parent")
@@ -683,37 +683,73 @@ class Assert::Stub
683
683
  end
684
684
 
685
685
  class TestClass
686
- def self.noargs; end
687
- def self.withargs(a); end
688
- def self.anyargs(*args); end
689
- def self.minargs(a, b, *args); end
690
- def self.withblock(&block); end
691
-
692
- def noargs; end
693
- def withargs(a); end
694
- def anyargs(*args); end
695
- def minargs(a, b, *args); end
696
- def withblock(&block); end
686
+ def self.noargs
687
+ end
688
+
689
+ def self.withargs(a)
690
+ end
691
+
692
+ def self.anyargs(*args)
693
+ end
694
+
695
+ def self.minargs(a, b, *args)
696
+ end
697
+
698
+ def self.withblock(&block)
699
+ end
700
+
701
+ def noargs
702
+ end
703
+
704
+ def withargs(a)
705
+ end
706
+
707
+ def anyargs(*args)
708
+ end
709
+
710
+ def minargs(a, b, *args)
711
+ end
712
+
713
+ def withblock(&block)
714
+ end
697
715
  end
698
716
 
699
717
  module TestModule
700
- def self.noargs; end
701
- def self.withargs(a); end
702
- def self.anyargs(*args); end
703
- def self.minargs(a, b, *args); end
704
- def self.withblock(&block); end
718
+ def self.noargs
719
+ end
720
+
721
+ def self.withargs(a)
722
+ end
723
+
724
+ def self.anyargs(*args)
725
+ end
726
+
727
+ def self.minargs(a, b, *args)
728
+ end
729
+
730
+ def self.withblock(&block)
731
+ end
705
732
  end
706
733
 
707
734
  module TestMixin
708
- def noargs; end
709
- def withargs(a); end
710
- def anyargs(*args); end
711
- def minargs(a, b, *args); end
712
- def withblock(&block); end
735
+ def noargs
736
+ end
737
+
738
+ def withargs(a)
739
+ end
740
+
741
+ def anyargs(*args)
742
+ end
743
+
744
+ def minargs(a, b, *args)
745
+ end
746
+
747
+ def withblock(&block)
748
+ end
713
749
  end
714
750
 
715
751
  class DelegateClass
716
- def self.respond_to?(*args)
752
+ def self.respond_to_missing?(*args)
717
753
  TestClass.respond_to?(*args) || super
718
754
  end
719
755
 
@@ -725,7 +761,7 @@ class Assert::Stub
725
761
  @delegate = TestClass.new
726
762
  end
727
763
 
728
- def respond_to?(*args)
764
+ def respond_to_missing?(*args)
729
765
  @delegate.respond_to?(*args) || super
730
766
  end
731
767