assert 2.18.3 → 2.18.4

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.
Files changed (41) hide show
  1. checksums.yaml +4 -4
  2. data/lib/assert/context.rb +5 -2
  3. data/lib/assert/context/let_dsl.rb +3 -3
  4. data/lib/assert/context/subject_dsl.rb +23 -24
  5. data/lib/assert/version.rb +1 -1
  6. data/test/system/stub_tests.rb +101 -117
  7. data/test/system/test_tests.rb +21 -33
  8. data/test/unit/assert_tests.rb +3 -1
  9. data/test/unit/assertions/assert_block_tests.rb +6 -8
  10. data/test/unit/assertions/assert_empty_tests.rb +10 -12
  11. data/test/unit/assertions/assert_equal_tests.rb +12 -18
  12. data/test/unit/assertions/assert_file_exists_tests.rb +10 -12
  13. data/test/unit/assertions/assert_includes_tests.rb +10 -12
  14. data/test/unit/assertions/assert_instance_of_tests.rb +10 -12
  15. data/test/unit/assertions/assert_kind_of_tests.rb +10 -12
  16. data/test/unit/assertions/assert_match_tests.rb +10 -12
  17. data/test/unit/assertions/assert_nil_tests.rb +10 -12
  18. data/test/unit/assertions/assert_raises_tests.rb +6 -8
  19. data/test/unit/assertions/assert_respond_to_tests.rb +10 -12
  20. data/test/unit/assertions/assert_same_tests.rb +16 -22
  21. data/test/unit/assertions/assert_true_false_tests.rb +20 -24
  22. data/test/unit/assertions_tests.rb +1 -2
  23. data/test/unit/config_helpers_tests.rb +8 -4
  24. data/test/unit/config_tests.rb +7 -2
  25. data/test/unit/context/setup_dsl_tests.rb +3 -3
  26. data/test/unit/context/subject_dsl_tests.rb +1 -2
  27. data/test/unit/context/suite_dsl_tests.rb +1 -2
  28. data/test/unit/context_info_tests.rb +9 -2
  29. data/test/unit/context_tests.rb +65 -73
  30. data/test/unit/default_suite_tests.rb +8 -2
  31. data/test/unit/factory_tests.rb +3 -1
  32. data/test/unit/file_line_tests.rb +8 -8
  33. data/test/unit/macro_tests.rb +10 -5
  34. data/test/unit/result_tests.rb +34 -45
  35. data/test/unit/runner_tests.rb +10 -10
  36. data/test/unit/suite_tests.rb +9 -9
  37. data/test/unit/test_tests.rb +32 -39
  38. data/test/unit/utils_tests.rb +3 -1
  39. data/test/unit/view_helpers_tests.rb +6 -7
  40. data/test/unit/view_tests.rb +4 -3
  41. metadata +2 -2
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: ff0d6ff9233adc09dda972e165c47c125e158e46b0329b927eb7de201ddebf65
4
- data.tar.gz: 8f77b5326cf44e2ed0c7ed72cac390a7147191634354feb2b890f73d572b366f
3
+ metadata.gz: 7ed950be1bca18deac9277678d40abc99072df13d5e23d21460c7e9b72a1c4ab
4
+ data.tar.gz: cd7c0eec0a939400f384c6e8d69b7fbb27856f3ed9fdfca25ae1ab48404c822f
5
5
  SHA512:
6
- metadata.gz: 25b58fd65c099c0c9f8ff16a652e28d5baeae76838b640872224abd7d063759d6fd40b3ec927220260d82321f78cc4b7617d50a081c7ba336b04d45acec8f618
7
- data.tar.gz: 669749ff845ae1811802042dd28e27e7a387d9d39a9504d73b8b04667c9597c4da08bd56cc26a7b34838e5afde2970215027a7d3967ad1e7f99175c62c49a08e
6
+ metadata.gz: 9a0334a2851a5b2742bab2ed51b6583e8ff47c9a89c605dfd10d84f0a20a6f17a16ba59179c53bf89b1dd0ed40673fb3909966c7476410d8ee1a52e580ec5766
7
+ data.tar.gz: a6f1f6db5d115e7e535ec0305d62970480f7b831eb8026e940011db2fcb3576244084fbf121f1ec499c61853d03dac3a76034dd7bdd3c187b778795ce0a3b5fd
@@ -165,9 +165,12 @@ module Assert
165
165
  end
166
166
 
167
167
  def subject
168
- if subj = self.class.subject
169
- instance_eval(&subj)
168
+ unless instance_variable_defined?("@__assert_subject__")
169
+ @__assert_subject__ =
170
+ instance_eval(&self.class.subject) if self.class.subject
170
171
  end
172
+
173
+ @__assert_subject__
171
174
  end
172
175
 
173
176
  def inspect
@@ -3,11 +3,11 @@ class Assert::Context; end
3
3
  module Assert::Context::LetDSL
4
4
  def let(name, &block)
5
5
  self.send(:define_method, name, &-> {
6
- if instance_variable_get("@#{name}").nil?
7
- instance_variable_set("@#{name}", instance_eval(&block))
6
+ unless instance_variable_defined?("@__assert_let_#{name}__")
7
+ instance_variable_set("@__assert_let_#{name}__", instance_eval(&block))
8
8
  end
9
9
 
10
- instance_variable_get("@#{name}")
10
+ instance_variable_get("@__assert_let_#{name}__")
11
11
  })
12
12
  end
13
13
  end
@@ -1,33 +1,32 @@
1
1
  module Assert; end
2
- class Assert::Context
3
- module SubjectDSL
4
- # Add a piece of description text or return the full description for the context
5
- def description(text = nil)
6
- if text
7
- self.descriptions << text.to_s
8
- else
9
- parent = self.superclass.desc if self.superclass.respond_to?(:desc)
10
- own = self.descriptions
11
- [parent, *own].compact.reject(&:empty?).join(" ")
12
- end
2
+ class Assert::Context; end
3
+ module Assert::Context::SubjectDSL
4
+ # Add a piece of description text or return the full description for the context
5
+ def description(text = nil)
6
+ if text
7
+ self.descriptions << text.to_s
8
+ else
9
+ parent = self.superclass.desc if self.superclass.respond_to?(:desc)
10
+ own = self.descriptions
11
+ [parent, *own].compact.reject(&:empty?).join(" ")
13
12
  end
14
- alias_method :desc, :description
15
- alias_method :describe, :description
13
+ end
14
+ alias_method :desc, :description
15
+ alias_method :describe, :description
16
16
 
17
- def subject(&block)
18
- if block_given?
19
- @subject = block
20
- else
21
- @subject || if superclass.respond_to?(:subject)
22
- superclass.subject
23
- end
17
+ def subject(&block)
18
+ if block_given?
19
+ @subject = block
20
+ else
21
+ @subject || if superclass.respond_to?(:subject)
22
+ superclass.subject
24
23
  end
25
24
  end
25
+ end
26
26
 
27
- protected
27
+ protected
28
28
 
29
- def descriptions
30
- @descriptions ||= []
31
- end
29
+ def descriptions
30
+ @descriptions ||= []
32
31
  end
33
32
  end
@@ -1,3 +1,3 @@
1
1
  module Assert
2
- VERSION = "2.18.3"
2
+ VERSION = "2.18.4"
3
3
  end
@@ -8,27 +8,25 @@ class Assert::Stub
8
8
 
9
9
  class InstanceTests < SystemTests
10
10
  desc "for instance methods"
11
- subject { instance1 }
11
+ subject { TestClass.new }
12
12
 
13
13
  setup do
14
- Assert.stub(instance1, :noargs){ "default" }
15
- Assert.stub(instance1, :noargs).with{ "none" }
14
+ Assert.stub(subject, :noargs){ "default" }
15
+ Assert.stub(subject, :noargs).with{ "none" }
16
16
 
17
- Assert.stub(instance1, :withargs){ "default" }
18
- Assert.stub(instance1, :withargs).with(1){ "one" }
17
+ Assert.stub(subject, :withargs){ "default" }
18
+ Assert.stub(subject, :withargs).with(1){ "one" }
19
19
 
20
- Assert.stub(instance1, :anyargs){ "default" }
21
- Assert.stub(instance1, :anyargs).with(1, 2){ "one-two" }
20
+ Assert.stub(subject, :anyargs){ "default" }
21
+ Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
22
22
 
23
- Assert.stub(instance1, :minargs){ "default" }
24
- Assert.stub(instance1, :minargs).with(1, 2){ "one-two" }
25
- Assert.stub(instance1, :minargs).with(1, 2, 3){ "one-two-three" }
23
+ Assert.stub(subject, :minargs){ "default" }
24
+ Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
25
+ Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
26
26
 
27
- Assert.stub(instance1, :withblock){ "default" }
27
+ Assert.stub(subject, :withblock){ "default" }
28
28
  end
29
29
 
30
- let(:instance1) { TestClass.new }
31
-
32
30
  should "allow stubbing a method that doesn't take args" do
33
31
  assert_that(subject.noargs).equals("none")
34
32
  end
@@ -82,27 +80,25 @@ class Assert::Stub
82
80
 
83
81
  class ClassTests < SystemTests
84
82
  desc "for singleton methods on a class"
85
- subject { class1 }
83
+ subject { TestClass }
86
84
 
87
85
  setup do
88
- Assert.stub(class1, :noargs){ "default" }
89
- Assert.stub(class1, :noargs).with{ "none" }
86
+ Assert.stub(subject, :noargs){ "default" }
87
+ Assert.stub(subject, :noargs).with{ "none" }
90
88
 
91
- Assert.stub(class1, :withargs){ "default" }
92
- Assert.stub(class1, :withargs).with(1){ "one" }
89
+ Assert.stub(subject, :withargs){ "default" }
90
+ Assert.stub(subject, :withargs).with(1){ "one" }
93
91
 
94
- Assert.stub(class1, :anyargs){ "default" }
95
- Assert.stub(class1, :anyargs).with(1, 2){ "one-two" }
92
+ Assert.stub(subject, :anyargs){ "default" }
93
+ Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
96
94
 
97
- Assert.stub(class1, :minargs){ "default" }
98
- Assert.stub(class1, :minargs).with(1, 2){ "one-two" }
99
- Assert.stub(class1, :minargs).with(1, 2, 3){ "one-two-three" }
95
+ Assert.stub(subject, :minargs){ "default" }
96
+ Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
97
+ Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
100
98
 
101
- Assert.stub(class1, :withblock){ "default" }
99
+ Assert.stub(subject, :withblock){ "default" }
102
100
  end
103
101
 
104
- let(:class1) { TestClass }
105
-
106
102
  should "allow stubbing a method that doesn't take args" do
107
103
  assert_that(subject.noargs).equals("none")
108
104
  end
@@ -157,27 +153,25 @@ class Assert::Stub
157
153
 
158
154
  class ModuleTests < SystemTests
159
155
  desc "for singleton methods on a module"
160
- subject { module1 }
156
+ subject { TestModule }
161
157
 
162
158
  setup do
163
- Assert.stub(module1, :noargs){ "default" }
164
- Assert.stub(module1, :noargs).with{ "none" }
159
+ Assert.stub(subject, :noargs){ "default" }
160
+ Assert.stub(subject, :noargs).with{ "none" }
165
161
 
166
- Assert.stub(module1, :withargs){ "default" }
167
- Assert.stub(module1, :withargs).with(1){ "one" }
162
+ Assert.stub(subject, :withargs){ "default" }
163
+ Assert.stub(subject, :withargs).with(1){ "one" }
168
164
 
169
- Assert.stub(module1, :anyargs){ "default" }
170
- Assert.stub(module1, :anyargs).with(1, 2){ "one-two" }
165
+ Assert.stub(subject, :anyargs){ "default" }
166
+ Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
171
167
 
172
- Assert.stub(module1, :minargs){ "default" }
173
- Assert.stub(module1, :minargs).with(1, 2){ "one-two" }
174
- Assert.stub(module1, :minargs).with(1, 2, 3){ "one-two-three" }
168
+ Assert.stub(subject, :minargs){ "default" }
169
+ Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
170
+ Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
175
171
 
176
- Assert.stub(module1, :withblock){ "default" }
172
+ Assert.stub(subject, :withblock){ "default" }
177
173
  end
178
174
 
179
- let(:module1) { TestModule }
180
-
181
175
  should "allow stubbing a method that doesn't take args" do
182
176
  assert_that(subject.noargs).equals("none")
183
177
  end
@@ -232,27 +226,25 @@ class Assert::Stub
232
226
 
233
227
  class ExtendedTests < SystemTests
234
228
  desc "for extended methods"
235
- subject { class1 }
229
+ subject { Class.new{ extend TestMixin } }
236
230
 
237
231
  setup do
238
- Assert.stub(class1, :noargs){ "default" }
239
- Assert.stub(class1, :noargs).with{ "none" }
232
+ Assert.stub(subject, :noargs){ "default" }
233
+ Assert.stub(subject, :noargs).with{ "none" }
240
234
 
241
- Assert.stub(class1, :withargs){ "default" }
242
- Assert.stub(class1, :withargs).with(1){ "one" }
235
+ Assert.stub(subject, :withargs){ "default" }
236
+ Assert.stub(subject, :withargs).with(1){ "one" }
243
237
 
244
- Assert.stub(class1, :anyargs){ "default" }
245
- Assert.stub(class1, :anyargs).with(1, 2){ "one-two" }
238
+ Assert.stub(subject, :anyargs){ "default" }
239
+ Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
246
240
 
247
- Assert.stub(class1, :minargs){ "default" }
248
- Assert.stub(class1, :minargs).with(1, 2){ "one-two" }
249
- Assert.stub(class1, :minargs).with(1, 2, 3){ "one-two-three" }
241
+ Assert.stub(subject, :minargs){ "default" }
242
+ Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
243
+ Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
250
244
 
251
- Assert.stub(class1, :withblock){ "default" }
245
+ Assert.stub(subject, :withblock){ "default" }
252
246
  end
253
247
 
254
- let(:class1) { Class.new{ extend TestMixin } }
255
-
256
248
  should "allow stubbing a method that doesn't take args" do
257
249
  assert_that(subject.noargs).equals("none")
258
250
  end
@@ -307,27 +299,27 @@ class Assert::Stub
307
299
 
308
300
  class IncludedTests < SystemTests
309
301
  desc "for an included method"
310
- subject { instance1 }
302
+ subject {
303
+ Class.new { include TestMixin }.new
304
+ }
311
305
 
312
306
  setup do
313
- Assert.stub(instance1, :noargs){ "default" }
314
- Assert.stub(instance1, :noargs).with{ "none" }
307
+ Assert.stub(subject, :noargs){ "default" }
308
+ Assert.stub(subject, :noargs).with{ "none" }
315
309
 
316
- Assert.stub(instance1, :withargs){ "default" }
317
- Assert.stub(instance1, :withargs).with(1){ "one" }
310
+ Assert.stub(subject, :withargs){ "default" }
311
+ Assert.stub(subject, :withargs).with(1){ "one" }
318
312
 
319
- Assert.stub(instance1, :anyargs){ "default" }
320
- Assert.stub(instance1, :anyargs).with(1, 2){ "one-two" }
313
+ Assert.stub(subject, :anyargs){ "default" }
314
+ Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
321
315
 
322
- Assert.stub(instance1, :minargs){ "default" }
323
- Assert.stub(instance1, :minargs).with(1, 2){ "one-two" }
324
- Assert.stub(instance1, :minargs).with(1, 2, 3){ "one-two-three" }
316
+ Assert.stub(subject, :minargs){ "default" }
317
+ Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
318
+ Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
325
319
 
326
- Assert.stub(instance1, :withblock){ "default" }
320
+ Assert.stub(subject, :withblock){ "default" }
327
321
  end
328
322
 
329
- let(:instance1) { Class.new { include TestMixin }.new }
330
-
331
323
  should "allow stubbing a method that doesn't take args" do
332
324
  assert_that(subject.noargs).equals("none")
333
325
  end
@@ -382,27 +374,25 @@ class Assert::Stub
382
374
 
383
375
  class InheritedClassTests < SystemTests
384
376
  desc "for an inherited class method"
385
- subject { class1 }
377
+ subject { Class.new(TestClass) }
386
378
 
387
379
  setup do
388
- Assert.stub(class1, :noargs){ "default" }
389
- Assert.stub(class1, :noargs).with{ "none" }
380
+ Assert.stub(subject, :noargs){ "default" }
381
+ Assert.stub(subject, :noargs).with{ "none" }
390
382
 
391
- Assert.stub(class1, :withargs){ "default" }
392
- Assert.stub(class1, :withargs).with(1){ "one" }
383
+ Assert.stub(subject, :withargs){ "default" }
384
+ Assert.stub(subject, :withargs).with(1){ "one" }
393
385
 
394
- Assert.stub(class1, :anyargs){ "default" }
395
- Assert.stub(class1, :anyargs).with(1, 2){ "one-two" }
386
+ Assert.stub(subject, :anyargs){ "default" }
387
+ Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
396
388
 
397
- Assert.stub(class1, :minargs){ "default" }
398
- Assert.stub(class1, :minargs).with(1, 2){ "one-two" }
399
- Assert.stub(class1, :minargs).with(1, 2, 3){ "one-two-three" }
389
+ Assert.stub(subject, :minargs){ "default" }
390
+ Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
391
+ Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
400
392
 
401
- Assert.stub(class1, :withblock){ "default" }
393
+ Assert.stub(subject, :withblock){ "default" }
402
394
  end
403
395
 
404
- let(:class1) { Class.new(TestClass) }
405
-
406
396
  should "allow stubbing a method that doesn't take args" do
407
397
  assert_that(subject.noargs).equals("none")
408
398
  end
@@ -457,27 +447,25 @@ class Assert::Stub
457
447
 
458
448
  class InheritedInstanceTests < SystemTests
459
449
  desc "for an inherited instance method"
460
- subject { instance1 }
450
+ subject { Class.new(TestClass).new }
461
451
 
462
452
  setup do
463
- Assert.stub(instance1, :noargs){ "default" }
464
- Assert.stub(instance1, :noargs).with{ "none" }
453
+ Assert.stub(subject, :noargs){ "default" }
454
+ Assert.stub(subject, :noargs).with{ "none" }
465
455
 
466
- Assert.stub(instance1, :withargs){ "default" }
467
- Assert.stub(instance1, :withargs).with(1){ "one" }
456
+ Assert.stub(subject, :withargs){ "default" }
457
+ Assert.stub(subject, :withargs).with(1){ "one" }
468
458
 
469
- Assert.stub(instance1, :anyargs){ "default" }
470
- Assert.stub(instance1, :anyargs).with(1, 2){ "one-two" }
459
+ Assert.stub(subject, :anyargs){ "default" }
460
+ Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
471
461
 
472
- Assert.stub(instance1, :minargs){ "default" }
473
- Assert.stub(instance1, :minargs).with(1, 2){ "one-two" }
474
- Assert.stub(instance1, :minargs).with(1, 2, 3){ "one-two-three" }
462
+ Assert.stub(subject, :minargs){ "default" }
463
+ Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
464
+ Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
475
465
 
476
- Assert.stub(instance1, :withblock){ "default" }
466
+ Assert.stub(subject, :withblock){ "default" }
477
467
  end
478
468
 
479
- let(:instance1) { Class.new(TestClass).new }
480
-
481
469
  should "allow stubbing a method that doesn't take args" do
482
470
  assert_that(subject.noargs).equals("none")
483
471
  end
@@ -532,27 +520,25 @@ class Assert::Stub
532
520
 
533
521
  class DelegateClassTests < SystemTests
534
522
  desc "a class that delegates another object"
535
- subject { class1 }
523
+ subject { DelegateClass }
536
524
 
537
525
  setup do
538
- Assert.stub(class1, :noargs){ "default" }
539
- Assert.stub(class1, :noargs).with{ "none" }
526
+ Assert.stub(subject, :noargs){ "default" }
527
+ Assert.stub(subject, :noargs).with{ "none" }
540
528
 
541
- Assert.stub(class1, :withargs){ "default" }
542
- Assert.stub(class1, :withargs).with(1){ "one" }
529
+ Assert.stub(subject, :withargs){ "default" }
530
+ Assert.stub(subject, :withargs).with(1){ "one" }
543
531
 
544
- Assert.stub(class1, :anyargs){ "default" }
545
- Assert.stub(class1, :anyargs).with(1, 2){ "one-two" }
532
+ Assert.stub(subject, :anyargs){ "default" }
533
+ Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
546
534
 
547
- Assert.stub(class1, :minargs){ "default" }
548
- Assert.stub(class1, :minargs).with(1, 2){ "one-two" }
549
- Assert.stub(class1, :minargs).with(1, 2, 3){ "one-two-three" }
535
+ Assert.stub(subject, :minargs){ "default" }
536
+ Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
537
+ Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
550
538
 
551
- Assert.stub(class1, :withblock){ "default" }
539
+ Assert.stub(subject, :withblock){ "default" }
552
540
  end
553
541
 
554
- let(:class1) { DelegateClass }
555
-
556
542
  should "allow stubbing a method that doesn't take args" do
557
543
  assert_that(subject.noargs).equals("none")
558
544
  end
@@ -607,27 +593,25 @@ class Assert::Stub
607
593
 
608
594
  class DelegateInstanceTests < SystemTests
609
595
  desc "an instance that delegates another object"
610
- subject { instance1 }
596
+ subject { DelegateClass.new }
611
597
 
612
598
  setup do
613
- Assert.stub(instance1, :noargs){ "default" }
614
- Assert.stub(instance1, :noargs).with{ "none" }
599
+ Assert.stub(subject, :noargs){ "default" }
600
+ Assert.stub(subject, :noargs).with{ "none" }
615
601
 
616
- Assert.stub(instance1, :withargs){ "default" }
617
- Assert.stub(instance1, :withargs).with(1){ "one" }
602
+ Assert.stub(subject, :withargs){ "default" }
603
+ Assert.stub(subject, :withargs).with(1){ "one" }
618
604
 
619
- Assert.stub(instance1, :anyargs){ "default" }
620
- Assert.stub(instance1, :anyargs).with(1, 2){ "one-two" }
605
+ Assert.stub(subject, :anyargs){ "default" }
606
+ Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
621
607
 
622
- Assert.stub(instance1, :minargs){ "default" }
623
- Assert.stub(instance1, :minargs).with(1, 2){ "one-two" }
624
- Assert.stub(instance1, :minargs).with(1, 2, 3){ "one-two-three" }
608
+ Assert.stub(subject, :minargs){ "default" }
609
+ Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
610
+ Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
625
611
 
626
- Assert.stub(instance1, :withblock){ "default" }
612
+ Assert.stub(subject, :withblock){ "default" }
627
613
  end
628
614
 
629
- let(:instance1) { DelegateClass.new }
630
-
631
615
  should "allow stubbing a method that doesn't take args" do
632
616
  assert_that(subject.noargs).equals("none")
633
617
  end