assert 2.18.2 → 2.19.2

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 (80) hide show
  1. checksums.yaml +4 -4
  2. data/Gemfile +4 -2
  3. data/README.md +7 -6
  4. data/assert.gemspec +5 -2
  5. data/bin/assert +1 -0
  6. data/lib/assert.rb +2 -0
  7. data/lib/assert/actual_value.rb +143 -0
  8. data/lib/assert/assert_runner.rb +2 -0
  9. data/lib/assert/assertions.rb +82 -20
  10. data/lib/assert/cli.rb +2 -0
  11. data/lib/assert/config.rb +2 -0
  12. data/lib/assert/config_helpers.rb +2 -0
  13. data/lib/assert/context.rb +33 -37
  14. data/lib/assert/context/let_dsl.rb +16 -0
  15. data/lib/assert/context/method_missing.rb +22 -0
  16. data/lib/assert/context/setup_dsl.rb +3 -0
  17. data/lib/assert/context/subject_dsl.rb +26 -24
  18. data/lib/assert/context/suite_dsl.rb +3 -0
  19. data/lib/assert/context/test_dsl.rb +3 -0
  20. data/lib/assert/context_info.rb +2 -0
  21. data/lib/assert/default_runner.rb +2 -0
  22. data/lib/assert/default_suite.rb +2 -0
  23. data/lib/assert/default_view.rb +2 -0
  24. data/lib/assert/factory.rb +2 -0
  25. data/lib/assert/file_line.rb +2 -0
  26. data/lib/assert/macro.rb +2 -0
  27. data/lib/assert/macros/methods.rb +6 -4
  28. data/lib/assert/result.rb +8 -1
  29. data/lib/assert/runner.rb +2 -0
  30. data/lib/assert/stub.rb +45 -0
  31. data/lib/assert/suite.rb +9 -10
  32. data/lib/assert/test.rb +3 -9
  33. data/lib/assert/utils.rb +3 -1
  34. data/lib/assert/version.rb +3 -1
  35. data/lib/assert/view.rb +2 -0
  36. data/lib/assert/view_helpers.rb +2 -0
  37. data/test/helper.rb +28 -28
  38. data/test/support/factory.rb +17 -0
  39. data/test/support/inherited_stuff.rb +2 -0
  40. data/test/system/stub_tests.rb +334 -333
  41. data/test/system/test_tests.rb +101 -109
  42. data/test/unit/actual_value_tests.rb +373 -0
  43. data/test/unit/assert_tests.rb +79 -61
  44. data/test/unit/assertions/assert_block_tests.rb +32 -31
  45. data/test/unit/assertions/assert_changes_tests.rb +99 -0
  46. data/test/unit/assertions/assert_empty_tests.rb +35 -32
  47. data/test/unit/assertions/assert_equal_tests.rb +96 -74
  48. data/test/unit/assertions/assert_file_exists_tests.rb +34 -33
  49. data/test/unit/assertions/assert_includes_tests.rb +40 -37
  50. data/test/unit/assertions/assert_instance_of_tests.rb +36 -33
  51. data/test/unit/assertions/assert_kind_of_tests.rb +36 -33
  52. data/test/unit/assertions/assert_match_tests.rb +36 -33
  53. data/test/unit/assertions/assert_nil_tests.rb +32 -31
  54. data/test/unit/assertions/assert_raises_tests.rb +57 -55
  55. data/test/unit/assertions/assert_respond_to_tests.rb +38 -35
  56. data/test/unit/assertions/assert_same_tests.rb +88 -81
  57. data/test/unit/assertions/assert_true_false_tests.rb +62 -60
  58. data/test/unit/assertions_tests.rb +28 -24
  59. data/test/unit/config_helpers_tests.rb +45 -38
  60. data/test/unit/config_tests.rb +40 -34
  61. data/test/unit/context/let_dsl_tests.rb +12 -0
  62. data/test/unit/context/setup_dsl_tests.rb +72 -81
  63. data/test/unit/context/subject_dsl_tests.rb +17 -43
  64. data/test/unit/context/suite_dsl_tests.rb +17 -16
  65. data/test/unit/context/test_dsl_tests.rb +52 -52
  66. data/test/unit/context_info_tests.rb +25 -15
  67. data/test/unit/context_tests.rb +186 -179
  68. data/test/unit/default_runner_tests.rb +4 -5
  69. data/test/unit/default_suite_tests.rb +59 -53
  70. data/test/unit/factory_tests.rb +7 -3
  71. data/test/unit/file_line_tests.rb +35 -35
  72. data/test/unit/macro_tests.rb +16 -10
  73. data/test/unit/result_tests.rb +161 -183
  74. data/test/unit/runner_tests.rb +67 -65
  75. data/test/unit/suite_tests.rb +58 -59
  76. data/test/unit/test_tests.rb +120 -139
  77. data/test/unit/utils_tests.rb +45 -45
  78. data/test/unit/view_helpers_tests.rb +56 -52
  79. data/test/unit/view_tests.rb +24 -23
  80. metadata +29 -6
data/test/support/factory.rb CHANGED
@@ -1,3 +1,5 @@
1
+ # frozen_string_literal: true
2
+
1
3
  require "assert/config"
2
4
  require "assert/default_suite"
3
5
  require "assert/factory"
@@ -85,4 +87,19 @@ module Factory
85
87
  instance_eval(&block) if !block.nil?
86
88
  end
87
89
  end
90
+
91
+ def self.modes_off_context(&result_block)
92
+ test = Factory.test
93
+ Factory.modes_off_context_class.new(
94
+ test,
95
+ test.config,
96
+ result_block || proc { |r| }
97
+ )
98
+ end
99
+
100
+ def self.backtrace
101
+ assert_lib_path =
102
+ File.join(ROOT_PATH, "lib/#{Factory.string}:#{Factory.integer}")
103
+ (Factory.integer(3).times.map{ Factory.string } + [assert_lib_path]).shuffle
104
+ end
88
105
  end
data/test/support/inherited_stuff.rb CHANGED
@@ -1,3 +1,5 @@
1
+ # frozen_string_literal: true
2
+
1
3
  module MixinStuff
2
4
  def test_mixin_stuff
3
5
  "from mixin"
data/test/system/stub_tests.rb CHANGED
@@ -1,3 +1,5 @@
1
+ # frozen_string_literal: true
2
+
1
3
  require "assert"
2
4
  require "assert/stub"
3
5
 
@@ -8,676 +10,675 @@ class Assert::Stub
8
10
 
9
11
  class InstanceTests < SystemTests
10
12
  desc "for instance methods"
13
+ subject { TestClass.new }
14
+
11
15
  setup do
12
- @instance = TestClass.new
13
- Assert.stub(@instance, :noargs){ "default" }
14
- Assert.stub(@instance, :noargs).with{ "none" }
16
+ Assert.stub(subject, :noargs){ "default" }
17
+ Assert.stub(subject, :noargs).with{ "none" }
15
18
 
16
- Assert.stub(@instance, :withargs){ "default" }
17
- Assert.stub(@instance, :withargs).with(1){ "one" }
19
+ Assert.stub(subject, :withargs){ "default" }
20
+ Assert.stub(subject, :withargs).with(1){ "one" }
18
21
 
19
- Assert.stub(@instance, :anyargs){ "default" }
20
- Assert.stub(@instance, :anyargs).with(1, 2){ "one-two" }
22
+ Assert.stub(subject, :anyargs){ "default" }
23
+ Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
21
24
 
22
- Assert.stub(@instance, :minargs){ "default" }
23
- Assert.stub(@instance, :minargs).with(1, 2){ "one-two" }
24
- Assert.stub(@instance, :minargs).with(1, 2, 3){ "one-two-three" }
25
+ Assert.stub(subject, :minargs){ "default" }
26
+ Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
27
+ Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
25
28
 
26
- Assert.stub(@instance, :withblock){ "default" }
29
+ Assert.stub(subject, :withblock){ "default" }
27
30
  end
28
- subject{ @instance }
29
31
 
30
32
  should "allow stubbing a method that doesn't take args" do
31
- assert_equal "none", subject.noargs
33
+ assert_that(subject.noargs).equals("none")
32
34
  end
33
35
 
34
36
  should "allow stubbing a method that takes args" do
35
- assert_equal "one", subject.withargs(1)
36
- assert_equal "default", subject.withargs(2)
37
+ assert_that(subject.withargs(2)).equals("default")
37
38
  end
38
39
 
39
40
  should "allow stubbing a method that takes any args" do
40
- assert_equal "default", subject.anyargs
41
- assert_equal "default", subject.anyargs(1)
42
- assert_equal "one-two", subject.anyargs(1, 2)
41
+ assert_that(subject.anyargs).equals("default")
42
+ assert_that(subject.anyargs(1)).equals("default")
43
+ assert_that(subject.anyargs(1, 2)).equals("one-two")
43
44
  end
44
45
 
45
46
  should "allow stubbing a method that takes a minimum number of args" do
46
- assert_equal "one-two", subject.minargs(1, 2)
47
- assert_equal "one-two-three", subject.minargs(1, 2, 3)
48
- assert_equal "default", subject.minargs(1, 2, 4)
49
- assert_equal "default", subject.minargs(1, 2, 3, 4)
47
+ assert_that(subject.minargs(1, 2)).equals("one-two")
48
+ assert_that(subject.minargs(1, 2, 3)).equals("one-two-three")
49
+ assert_that(subject.minargs(1, 2, 4)).equals("default")
50
+ assert_that(subject.minargs(1, 2, 3, 4)).equals("default")
50
51
  end
51
52
 
52
53
  should "allow stubbing a method that takes a block" do
53
- assert_equal "default", subject.withblock
54
- assert_equal "default", subject.withblock{ "my-block" }
54
+ assert_that(subject.withblock).equals("default")
55
+ assert_that(subject.withblock{ "my-block" }).equals("default")
55
56
  end
56
57
 
57
58
  should "not allow stubbing methods with invalid arity" do
58
- assert_raises{ Assert.stub(subject, :noargs).with(1){ } }
59
+ assert_that { Assert.stub(subject, :noargs).with(1){ } }.raises
59
60
 
60
- assert_raises{ Assert.stub(subject, :withargs).with{ } }
61
- assert_raises{ Assert.stub(subject, :withargs).with(1, 2){ } }
61
+ assert_that { Assert.stub(subject, :withargs).with{ } }.raises
62
+ assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.raises
62
63
 
63
- assert_raises{ Assert.stub(subject, :minargs).with{ } }
64
- assert_raises{ Assert.stub(subject, :minargs).with(1){ } }
64
+ assert_that { Assert.stub(subject, :minargs).with{ } }.raises
65
+ assert_that { Assert.stub(subject, :minargs).with(1){ } }.raises
65
66
 
66
- assert_raises{ Assert.stub(subject, :withblock).with(1){ } }
67
+ assert_that { Assert.stub(subject, :withblock).with(1){ } }.raises
67
68
  end
68
69
 
69
70
  should "not allow calling methods with invalid arity" do
70
- assert_raises{ subject.noargs(1) }
71
+ assert_that { subject.noargs(1) }.raises
71
72
 
72
- assert_raises{ subject.withargs }
73
- assert_raises{ subject.withargs(1, 2) }
73
+ assert_that { subject.withargs }.raises
74
+ assert_that { subject.withargs(1, 2) }.raises
74
75
 
75
- assert_raises{ subject.minargs }
76
- assert_raises{ subject.minargs(1) }
76
+ assert_that { subject.minargs }.raises
77
+ assert_that { subject.minargs(1) }.raises
77
78
 
78
- assert_raises{ subject.withblock(1) }
79
+ assert_that { subject.withblock(1) }.raises
79
80
  end
80
81
  end
81
82
 
82
83
  class ClassTests < SystemTests
83
84
  desc "for singleton methods on a class"
85
+ subject { TestClass }
86
+
84
87
  setup do
85
- @class = TestClass
86
- Assert.stub(@class, :noargs){ "default" }
87
- Assert.stub(@class, :noargs).with{ "none" }
88
+ Assert.stub(subject, :noargs){ "default" }
89
+ Assert.stub(subject, :noargs).with{ "none" }
88
90
 
89
- Assert.stub(@class, :withargs){ "default" }
90
- Assert.stub(@class, :withargs).with(1){ "one" }
91
+ Assert.stub(subject, :withargs){ "default" }
92
+ Assert.stub(subject, :withargs).with(1){ "one" }
91
93
 
92
- Assert.stub(@class, :anyargs){ "default" }
93
- Assert.stub(@class, :anyargs).with(1, 2){ "one-two" }
94
+ Assert.stub(subject, :anyargs){ "default" }
95
+ Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
94
96
 
95
- Assert.stub(@class, :minargs){ "default" }
96
- Assert.stub(@class, :minargs).with(1, 2){ "one-two" }
97
- Assert.stub(@class, :minargs).with(1, 2, 3){ "one-two-three" }
97
+ Assert.stub(subject, :minargs){ "default" }
98
+ Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
99
+ Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
98
100
 
99
- Assert.stub(@class, :withblock){ "default" }
101
+ Assert.stub(subject, :withblock){ "default" }
100
102
  end
101
- subject{ @class }
102
103
 
103
104
  should "allow stubbing a method that doesn't take args" do
104
- assert_equal "none", subject.noargs
105
+ assert_that(subject.noargs).equals("none")
105
106
  end
106
107
 
107
108
  should "allow stubbing a method that takes args" do
108
- assert_equal "one", subject.withargs(1)
109
- assert_equal "default", subject.withargs(2)
109
+ assert_that(subject.withargs(1)).equals("one")
110
+ assert_that(subject.withargs(2)).equals("default")
110
111
  end
111
112
 
112
113
  should "allow stubbing a method that takes any args" do
113
- assert_equal "default", subject.anyargs
114
- assert_equal "default", subject.anyargs(1)
115
- assert_equal "one-two", subject.anyargs(1, 2)
114
+ assert_that(subject.anyargs).equals("default")
115
+ assert_that(subject.anyargs(1)).equals("default")
116
+ assert_that(subject.anyargs(1, 2)).equals("one-two")
116
117
  end
117
118
 
118
119
  should "allow stubbing a method that takes a minimum number of args" do
119
- assert_equal "one-two", subject.minargs(1, 2)
120
- assert_equal "one-two-three", subject.minargs(1, 2, 3)
121
- assert_equal "default", subject.minargs(1, 2, 4)
122
- assert_equal "default", subject.minargs(1, 2, 3, 4)
120
+ assert_that(subject.minargs(1, 2)).equals("one-two")
121
+ assert_that(subject.minargs(1, 2, 3)).equals("one-two-three")
122
+ assert_that(subject.minargs(1, 2, 4)).equals("default")
123
+ assert_that(subject.minargs(1, 2, 3, 4)).equals("default")
123
124
  end
124
125
 
125
126
  should "allow stubbing a method that takes a block" do
126
- assert_equal "default", subject.withblock
127
- assert_equal "default", subject.withblock{ "my-block" }
127
+ assert_that(subject.withblock).equals("default")
128
+ assert_that(subject.withblock{ "my-block" }).equals("default")
128
129
  end
129
130
 
130
131
  should "not allow stubbing methods with invalid arity" do
131
- assert_raises{ Assert.stub(subject, :noargs).with(1){ } }
132
+ assert_that { Assert.stub(subject, :noargs).with(1){ } }.raises
132
133
 
133
- assert_raises{ Assert.stub(subject, :withargs).with{ } }
134
- assert_raises{ Assert.stub(subject, :withargs).with(1, 2){ } }
134
+ assert_that { Assert.stub(subject, :withargs).with{ } }.raises
135
+ assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.raises
135
136
 
136
- assert_raises{ Assert.stub(subject, :minargs).with{ } }
137
- assert_raises{ Assert.stub(subject, :minargs).with(1){ } }
137
+ assert_that { Assert.stub(subject, :minargs).with{ } }.raises
138
+ assert_that { Assert.stub(subject, :minargs).with(1){ } }.raises
138
139
 
139
- assert_raises{ Assert.stub(subject, :withblock).with(1){ } }
140
+ assert_that { Assert.stub(subject, :withblock).with(1){ } }.raises
140
141
  end
141
142
 
142
143
  should "not allow calling methods with invalid arity" do
143
- assert_raises{ subject.noargs(1) }
144
+ assert_that { subject.noargs(1) }.raises
144
145
 
145
- assert_raises{ subject.withargs }
146
- assert_raises{ subject.withargs(1, 2) }
146
+ assert_that { subject.withargs }.raises
147
+ assert_that { subject.withargs(1, 2) }.raises
147
148
 
148
- assert_raises{ subject.minargs }
149
- assert_raises{ subject.minargs(1) }
149
+ assert_that { subject.minargs }.raises
150
+ assert_that { subject.minargs(1) }.raises
150
151
 
151
- assert_raises{ subject.withblock(1) }
152
+ assert_that { subject.withblock(1) }.raises
152
153
  end
153
154
  end
154
155
 
155
156
  class ModuleTests < SystemTests
156
157
  desc "for singleton methods on a module"
158
+ subject { TestModule }
159
+
157
160
  setup do
158
- @module = TestModule
159
- Assert.stub(@module, :noargs){ "default" }
160
- Assert.stub(@module, :noargs).with{ "none" }
161
+ Assert.stub(subject, :noargs){ "default" }
162
+ Assert.stub(subject, :noargs).with{ "none" }
161
163
 
162
- Assert.stub(@module, :withargs){ "default" }
163
- Assert.stub(@module, :withargs).with(1){ "one" }
164
+ Assert.stub(subject, :withargs){ "default" }
165
+ Assert.stub(subject, :withargs).with(1){ "one" }
164
166
 
165
- Assert.stub(@module, :anyargs){ "default" }
166
- Assert.stub(@module, :anyargs).with(1, 2){ "one-two" }
167
+ Assert.stub(subject, :anyargs){ "default" }
168
+ Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
167
169
 
168
- Assert.stub(@module, :minargs){ "default" }
169
- Assert.stub(@module, :minargs).with(1, 2){ "one-two" }
170
- Assert.stub(@module, :minargs).with(1, 2, 3){ "one-two-three" }
170
+ Assert.stub(subject, :minargs){ "default" }
171
+ Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
172
+ Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
171
173
 
172
- Assert.stub(@module, :withblock){ "default" }
174
+ Assert.stub(subject, :withblock){ "default" }
173
175
  end
174
- subject{ @module }
175
176
 
176
177
  should "allow stubbing a method that doesn't take args" do
177
- assert_equal "none", subject.noargs
178
+ assert_that(subject.noargs).equals("none")
178
179
  end
179
180
 
180
181
  should "allow stubbing a method that takes args" do
181
- assert_equal "one", subject.withargs(1)
182
- assert_equal "default", subject.withargs(2)
182
+ assert_that(subject.withargs(1)).equals("one")
183
+ assert_that(subject.withargs(2)).equals("default")
183
184
  end
184
185
 
185
186
  should "allow stubbing a method that takes any args" do
186
- assert_equal "default", subject.anyargs
187
- assert_equal "default", subject.anyargs(1)
188
- assert_equal "one-two", subject.anyargs(1, 2)
187
+ assert_that(subject.anyargs).equals("default")
188
+ assert_that(subject.anyargs(1)).equals("default")
189
+ assert_that(subject.anyargs(1, 2)).equals("one-two")
189
190
  end
190
191
 
191
192
  should "allow stubbing a method that takes a minimum number of args" do
192
- assert_equal "one-two", subject.minargs(1, 2)
193
- assert_equal "one-two-three", subject.minargs(1, 2, 3)
194
- assert_equal "default", subject.minargs(1, 2, 4)
195
- assert_equal "default", subject.minargs(1, 2, 3, 4)
193
+ assert_that(subject.minargs(1, 2)).equals("one-two")
194
+ assert_that(subject.minargs(1, 2, 3)).equals("one-two-three")
195
+ assert_that(subject.minargs(1, 2, 4)).equals("default")
196
+ assert_that(subject.minargs(1, 2, 3, 4)).equals("default")
196
197
  end
197
198
 
198
199
  should "allow stubbing a method that takes a block" do
199
- assert_equal "default", subject.withblock
200
- assert_equal "default", subject.withblock{ "my-block" }
200
+ assert_that(subject.withblock).equals("default")
201
+ assert_that(subject.withblock{ "my-block" }).equals("default")
201
202
  end
202
203
 
203
204
  should "not allow stubbing methods with invalid arity" do
204
- assert_raises{ Assert.stub(subject, :noargs).with(1){ } }
205
+ assert_that { Assert.stub(subject, :noargs).with(1){ } }.raises
205
206
 
206
- assert_raises{ Assert.stub(subject, :withargs).with{ } }
207
- assert_raises{ Assert.stub(subject, :withargs).with(1, 2){ } }
207
+ assert_that { Assert.stub(subject, :withargs).with{ } }.raises
208
+ assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.raises
208
209
 
209
- assert_raises{ Assert.stub(subject, :minargs).with{ } }
210
- assert_raises{ Assert.stub(subject, :minargs).with(1){ } }
210
+ assert_that { Assert.stub(subject, :minargs).with{ } }.raises
211
+ assert_that { Assert.stub(subject, :minargs).with(1){ } }.raises
211
212
 
212
- assert_raises{ Assert.stub(subject, :withblock).with(1){ } }
213
+ assert_that { Assert.stub(subject, :withblock).with(1){ } }.raises
213
214
  end
214
215
 
215
216
  should "not allow calling methods with invalid arity" do
216
- assert_raises{ subject.noargs(1) }
217
+ assert_that { subject.noargs(1) }.raises
217
218
 
218
- assert_raises{ subject.withargs }
219
- assert_raises{ subject.withargs(1, 2) }
219
+ assert_that { subject.withargs }.raises
220
+ assert_that { subject.withargs(1, 2) }.raises
220
221
 
221
- assert_raises{ subject.minargs }
222
- assert_raises{ subject.minargs(1) }
222
+ assert_that { subject.minargs }.raises
223
+ assert_that { subject.minargs(1) }.raises
223
224
 
224
- assert_raises{ subject.withblock(1) }
225
+ assert_that { subject.withblock(1) }.raises
225
226
  end
226
227
  end
227
228
 
228
229
  class ExtendedTests < SystemTests
229
230
  desc "for extended methods"
231
+ subject { Class.new{ extend TestMixin } }
232
+
230
233
  setup do
231
- @class = Class.new{ extend TestMixin }
232
- Assert.stub(@class, :noargs){ "default" }
233
- Assert.stub(@class, :noargs).with{ "none" }
234
+ Assert.stub(subject, :noargs){ "default" }
235
+ Assert.stub(subject, :noargs).with{ "none" }
234
236
 
235
- Assert.stub(@class, :withargs){ "default" }
236
- Assert.stub(@class, :withargs).with(1){ "one" }
237
+ Assert.stub(subject, :withargs){ "default" }
238
+ Assert.stub(subject, :withargs).with(1){ "one" }
237
239
 
238
- Assert.stub(@class, :anyargs){ "default" }
239
- Assert.stub(@class, :anyargs).with(1, 2){ "one-two" }
240
+ Assert.stub(subject, :anyargs){ "default" }
241
+ Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
240
242
 
241
- Assert.stub(@class, :minargs){ "default" }
242
- Assert.stub(@class, :minargs).with(1, 2){ "one-two" }
243
- Assert.stub(@class, :minargs).with(1, 2, 3){ "one-two-three" }
243
+ Assert.stub(subject, :minargs){ "default" }
244
+ Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
245
+ Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
244
246
 
245
- Assert.stub(@class, :withblock){ "default" }
247
+ Assert.stub(subject, :withblock){ "default" }
246
248
  end
247
- subject{ @class }
248
249
 
249
250
  should "allow stubbing a method that doesn't take args" do
250
- assert_equal "none", subject.noargs
251
+ assert_that(subject.noargs).equals("none")
251
252
  end
252
253
 
253
254
  should "allow stubbing a method that takes args" do
254
- assert_equal "one", subject.withargs(1)
255
- assert_equal "default", subject.withargs(2)
255
+ assert_that(subject.withargs(1)).equals("one")
256
+ assert_that(subject.withargs(2)).equals("default")
256
257
  end
257
258
 
258
259
  should "allow stubbing a method that takes any args" do
259
- assert_equal "default", subject.anyargs
260
- assert_equal "default", subject.anyargs(1)
261
- assert_equal "one-two", subject.anyargs(1, 2)
260
+ assert_that(subject.anyargs).equals("default")
261
+ assert_that(subject.anyargs(1)).equals("default")
262
+ assert_that(subject.anyargs(1, 2)).equals("one-two")
262
263
  end
263
264
 
264
265
  should "allow stubbing a method that takes a minimum number of args" do
265
- assert_equal "one-two", subject.minargs(1, 2)
266
- assert_equal "one-two-three", subject.minargs(1, 2, 3)
267
- assert_equal "default", subject.minargs(1, 2, 4)
268
- assert_equal "default", subject.minargs(1, 2, 3, 4)
266
+ assert_that(subject.minargs(1, 2)).equals("one-two")
267
+ assert_that(subject.minargs(1, 2, 3)).equals("one-two-three")
268
+ assert_that(subject.minargs(1, 2, 4)).equals("default")
269
+ assert_that(subject.minargs(1, 2, 3, 4)).equals("default")
269
270
  end
270
271
 
271
272
  should "allow stubbing a method that takes a block" do
272
- assert_equal "default", subject.withblock
273
- assert_equal "default", subject.withblock{ "my-block" }
273
+ assert_that(subject.withblock).equals("default")
274
+ assert_that(subject.withblock{ "my-block" }).equals("default")
274
275
  end
275
276
 
276
277
  should "not allow stubbing methods with invalid arity" do
277
- assert_raises{ Assert.stub(subject, :noargs).with(1){ } }
278
+ assert_that { Assert.stub(subject, :noargs).with(1){ } }.raises
278
279
 
279
- assert_raises{ Assert.stub(subject, :withargs).with{ } }
280
- assert_raises{ Assert.stub(subject, :withargs).with(1, 2){ } }
280
+ assert_that { Assert.stub(subject, :withargs).with{ } }.raises
281
+ assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.raises
281
282
 
282
- assert_raises{ Assert.stub(subject, :minargs).with{ } }
283
- assert_raises{ Assert.stub(subject, :minargs).with(1){ } }
283
+ assert_that { Assert.stub(subject, :minargs).with{ } }.raises
284
+ assert_that { Assert.stub(subject, :minargs).with(1){ } }.raises
284
285
 
285
- assert_raises{ Assert.stub(subject, :withblock).with(1){ } }
286
+ assert_that { Assert.stub(subject, :withblock).with(1){ } }.raises
286
287
  end
287
288
 
288
289
  should "not allow calling methods with invalid arity" do
289
- assert_raises{ subject.noargs(1) }
290
+ assert_that { subject.noargs(1) }.raises
290
291
 
291
- assert_raises{ subject.withargs }
292
- assert_raises{ subject.withargs(1, 2) }
292
+ assert_that { subject.withargs }.raises
293
+ assert_that { subject.withargs(1, 2) }.raises
293
294
 
294
- assert_raises{ subject.minargs }
295
- assert_raises{ subject.minargs(1) }
295
+ assert_that { subject.minargs }.raises
296
+ assert_that { subject.minargs(1) }.raises
296
297
 
297
- assert_raises{ subject.withblock(1) }
298
+ assert_that { subject.withblock(1) }.raises
298
299
  end
299
300
  end
300
301
 
301
302
  class IncludedTests < SystemTests
302
303
  desc "for an included method"
304
+ subject {
305
+ Class.new { include TestMixin }.new
306
+ }
307
+
303
308
  setup do
304
- @class = Class.new{ include TestMixin }
305
- @instance = @class.new
306
- Assert.stub(@instance, :noargs){ "default" }
307
- Assert.stub(@instance, :noargs).with{ "none" }
309
+ Assert.stub(subject, :noargs){ "default" }
310
+ Assert.stub(subject, :noargs).with{ "none" }
308
311
 
309
- Assert.stub(@instance, :withargs){ "default" }
310
- Assert.stub(@instance, :withargs).with(1){ "one" }
312
+ Assert.stub(subject, :withargs){ "default" }
313
+ Assert.stub(subject, :withargs).with(1){ "one" }
311
314
 
312
- Assert.stub(@instance, :anyargs){ "default" }
313
- Assert.stub(@instance, :anyargs).with(1, 2){ "one-two" }
315
+ Assert.stub(subject, :anyargs){ "default" }
316
+ Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
314
317
 
315
- Assert.stub(@instance, :minargs){ "default" }
316
- Assert.stub(@instance, :minargs).with(1, 2){ "one-two" }
317
- Assert.stub(@instance, :minargs).with(1, 2, 3){ "one-two-three" }
318
+ Assert.stub(subject, :minargs){ "default" }
319
+ Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
320
+ Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
318
321
 
319
- Assert.stub(@instance, :withblock){ "default" }
322
+ Assert.stub(subject, :withblock){ "default" }
320
323
  end
321
- subject{ @instance }
322
324
 
323
325
  should "allow stubbing a method that doesn't take args" do
324
- assert_equal "none", subject.noargs
326
+ assert_that(subject.noargs).equals("none")
325
327
  end
326
328
 
327
329
  should "allow stubbing a method that takes args" do
328
- assert_equal "one", subject.withargs(1)
329
- assert_equal "default", subject.withargs(2)
330
+ assert_that(subject.withargs(1)).equals("one")
331
+ assert_that(subject.withargs(2)).equals("default")
330
332
  end
331
333
 
332
334
  should "allow stubbing a method that takes any args" do
333
- assert_equal "default", subject.anyargs
334
- assert_equal "default", subject.anyargs(1)
335
- assert_equal "one-two", subject.anyargs(1, 2)
335
+ assert_that(subject.anyargs).equals("default")
336
+ assert_that(subject.anyargs(1)).equals("default")
337
+ assert_that(subject.anyargs(1, 2)).equals("one-two")
336
338
  end
337
339
 
338
340
  should "allow stubbing a method that takes a minimum number of args" do
339
- assert_equal "one-two", subject.minargs(1, 2)
340
- assert_equal "one-two-three", subject.minargs(1, 2, 3)
341
- assert_equal "default", subject.minargs(1, 2, 4)
342
- assert_equal "default", subject.minargs(1, 2, 3, 4)
341
+ assert_that(subject.minargs(1, 2)).equals("one-two")
342
+ assert_that(subject.minargs(1, 2, 3)).equals("one-two-three")
343
+ assert_that(subject.minargs(1, 2, 4)).equals("default")
344
+ assert_that(subject.minargs(1, 2, 3, 4)).equals("default")
343
345
  end
344
346
 
345
347
  should "allow stubbing a method that takes a block" do
346
- assert_equal "default", subject.withblock
347
- assert_equal "default", subject.withblock{ "my-block" }
348
+ assert_that(subject.withblock).equals("default")
349
+ assert_that(subject.withblock{ "my-block" }).equals("default")
348
350
  end
349
351
 
350
352
  should "not allow stubbing methods with invalid arity" do
351
- assert_raises{ Assert.stub(subject, :noargs).with(1){ } }
353
+ assert_that { Assert.stub(subject, :noargs).with(1){ } }.raises
352
354
 
353
- assert_raises{ Assert.stub(subject, :withargs).with{ } }
354
- assert_raises{ Assert.stub(subject, :withargs).with(1, 2){ } }
355
+ assert_that { Assert.stub(subject, :withargs).with{ } }.raises
356
+ assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.raises
355
357
 
356
- assert_raises{ Assert.stub(subject, :minargs).with{ } }
357
- assert_raises{ Assert.stub(subject, :minargs).with(1){ } }
358
+ assert_that { Assert.stub(subject, :minargs).with{ } }.raises
359
+ assert_that { Assert.stub(subject, :minargs).with(1){ } }.raises
358
360
 
359
- assert_raises{ Assert.stub(subject, :withblock).with(1){ } }
361
+ assert_that { Assert.stub(subject, :withblock).with(1){ } }.raises
360
362
  end
361
363
 
362
364
  should "not allow calling methods with invalid arity" do
363
- assert_raises{ subject.noargs(1) }
365
+ assert_that { subject.noargs(1) }.raises
364
366
 
365
- assert_raises{ subject.withargs }
366
- assert_raises{ subject.withargs(1, 2) }
367
+ assert_that { subject.withargs }.raises
368
+ assert_that { subject.withargs(1, 2) }.raises
367
369
 
368
- assert_raises{ subject.minargs }
369
- assert_raises{ subject.minargs(1) }
370
+ assert_that { subject.minargs }.raises
371
+ assert_that { subject.minargs(1) }.raises
370
372
 
371
- assert_raises{ subject.withblock(1) }
373
+ assert_that { subject.withblock(1) }.raises
372
374
  end
373
375
  end
374
376
 
375
377
  class InheritedClassTests < SystemTests
376
378
  desc "for an inherited class method"
379
+ subject { Class.new(TestClass) }
380
+
377
381
  setup do
378
- @class = Class.new(TestClass)
379
- Assert.stub(@class, :noargs){ "default" }
380
- Assert.stub(@class, :noargs).with{ "none" }
382
+ Assert.stub(subject, :noargs){ "default" }
383
+ Assert.stub(subject, :noargs).with{ "none" }
381
384
 
382
- Assert.stub(@class, :withargs){ "default" }
383
- Assert.stub(@class, :withargs).with(1){ "one" }
385
+ Assert.stub(subject, :withargs){ "default" }
386
+ Assert.stub(subject, :withargs).with(1){ "one" }
384
387
 
385
- Assert.stub(@class, :anyargs){ "default" }
386
- Assert.stub(@class, :anyargs).with(1, 2){ "one-two" }
388
+ Assert.stub(subject, :anyargs){ "default" }
389
+ Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
387
390
 
388
- Assert.stub(@class, :minargs){ "default" }
389
- Assert.stub(@class, :minargs).with(1, 2){ "one-two" }
390
- Assert.stub(@class, :minargs).with(1, 2, 3){ "one-two-three" }
391
+ Assert.stub(subject, :minargs){ "default" }
392
+ Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
393
+ Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
391
394
 
392
- Assert.stub(@class, :withblock){ "default" }
395
+ Assert.stub(subject, :withblock){ "default" }
393
396
  end
394
- subject{ @class }
395
397
 
396
398
  should "allow stubbing a method that doesn't take args" do
397
- assert_equal "none", subject.noargs
399
+ assert_that(subject.noargs).equals("none")
398
400
  end
399
401
 
400
402
  should "allow stubbing a method that takes args" do
401
- assert_equal "one", subject.withargs(1)
402
- assert_equal "default", subject.withargs(2)
403
+ assert_that(subject.withargs(1)).equals("one")
404
+ assert_that(subject.withargs(2)).equals("default")
403
405
  end
404
406
 
405
407
  should "allow stubbing a method that takes any args" do
406
- assert_equal "default", subject.anyargs
407
- assert_equal "default", subject.anyargs(1)
408
- assert_equal "one-two", subject.anyargs(1, 2)
408
+ assert_that(subject.anyargs).equals("default")
409
+ assert_that(subject.anyargs(1)).equals("default")
410
+ assert_that(subject.anyargs(1, 2)).equals("one-two")
409
411
  end
410
412
 
411
413
  should "allow stubbing a method that takes a minimum number of args" do
412
- assert_equal "one-two", subject.minargs(1, 2)
413
- assert_equal "one-two-three", subject.minargs(1, 2, 3)
414
- assert_equal "default", subject.minargs(1, 2, 4)
415
- assert_equal "default", subject.minargs(1, 2, 3, 4)
414
+ assert_that(subject.minargs(1, 2)).equals("one-two")
415
+ assert_that(subject.minargs(1, 2, 3)).equals("one-two-three")
416
+ assert_that(subject.minargs(1, 2, 4)).equals("default")
417
+ assert_that(subject.minargs(1, 2, 3, 4)).equals("default")
416
418
  end
417
419
 
418
420
  should "allow stubbing a method that takes a block" do
419
- assert_equal "default", subject.withblock
420
- assert_equal "default", subject.withblock{ "my-block" }
421
+ assert_that(subject.withblock).equals("default")
422
+ assert_that(subject.withblock{ "my-block" }).equals("default")
421
423
  end
422
424
 
423
425
  should "not allow stubbing methods with invalid arity" do
424
- assert_raises{ Assert.stub(subject, :noargs).with(1){ } }
426
+ assert_that { Assert.stub(subject, :noargs).with(1){ } }.raises
425
427
 
426
- assert_raises{ Assert.stub(subject, :withargs).with{ } }
427
- assert_raises{ Assert.stub(subject, :withargs).with(1, 2){ } }
428
+ assert_that { Assert.stub(subject, :withargs).with{ } }.raises
429
+ assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.raises
428
430
 
429
- assert_raises{ Assert.stub(subject, :minargs).with{ } }
430
- assert_raises{ Assert.stub(subject, :minargs).with(1){ } }
431
+ assert_that { Assert.stub(subject, :minargs).with{ } }.raises
432
+ assert_that { Assert.stub(subject, :minargs).with(1){ } }.raises
431
433
 
432
- assert_raises{ Assert.stub(subject, :withblock).with(1){ } }
434
+ assert_that { Assert.stub(subject, :withblock).with(1){ } }.raises
433
435
  end
434
436
 
435
437
  should "not allow calling methods with invalid arity" do
436
- assert_raises{ subject.noargs(1) }
438
+ assert_that { subject.noargs(1) }.raises
437
439
 
438
- assert_raises{ subject.withargs }
439
- assert_raises{ subject.withargs(1, 2) }
440
+ assert_that { subject.withargs }.raises
441
+ assert_that { subject.withargs(1, 2) }.raises
440
442
 
441
- assert_raises{ subject.minargs }
442
- assert_raises{ subject.minargs(1) }
443
+ assert_that { subject.minargs }.raises
444
+ assert_that { subject.minargs(1) }.raises
443
445
 
444
- assert_raises{ subject.withblock(1) }
446
+ assert_that { subject.withblock(1) }.raises
445
447
  end
446
448
  end
447
449
 
448
450
  class InheritedInstanceTests < SystemTests
449
451
  desc "for an inherited instance method"
452
+ subject { Class.new(TestClass).new }
453
+
450
454
  setup do
451
- @class = Class.new(TestClass)
452
- @instance = @class.new
453
- Assert.stub(@instance, :noargs){ "default" }
454
- Assert.stub(@instance, :noargs).with{ "none" }
455
+ Assert.stub(subject, :noargs){ "default" }
456
+ Assert.stub(subject, :noargs).with{ "none" }
455
457
 
456
- Assert.stub(@instance, :withargs){ "default" }
457
- Assert.stub(@instance, :withargs).with(1){ "one" }
458
+ Assert.stub(subject, :withargs){ "default" }
459
+ Assert.stub(subject, :withargs).with(1){ "one" }
458
460
 
459
- Assert.stub(@instance, :anyargs){ "default" }
460
- Assert.stub(@instance, :anyargs).with(1, 2){ "one-two" }
461
+ Assert.stub(subject, :anyargs){ "default" }
462
+ Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
461
463
 
462
- Assert.stub(@instance, :minargs){ "default" }
463
- Assert.stub(@instance, :minargs).with(1, 2){ "one-two" }
464
- Assert.stub(@instance, :minargs).with(1, 2, 3){ "one-two-three" }
464
+ Assert.stub(subject, :minargs){ "default" }
465
+ Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
466
+ Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
465
467
 
466
- Assert.stub(@instance, :withblock){ "default" }
468
+ Assert.stub(subject, :withblock){ "default" }
467
469
  end
468
- subject{ @instance }
469
470
 
470
471
  should "allow stubbing a method that doesn't take args" do
471
- assert_equal "none", subject.noargs
472
+ assert_that(subject.noargs).equals("none")
472
473
  end
473
474
 
474
475
  should "allow stubbing a method that takes args" do
475
- assert_equal "one", subject.withargs(1)
476
- assert_equal "default", subject.withargs(2)
476
+ assert_that(subject.withargs(1)).equals("one")
477
+ assert_that(subject.withargs(2)).equals("default")
477
478
  end
478
479
 
479
480
  should "allow stubbing a method that takes any args" do
480
- assert_equal "default", subject.anyargs
481
- assert_equal "default", subject.anyargs(1)
482
- assert_equal "one-two", subject.anyargs(1, 2)
481
+ assert_that(subject.anyargs).equals("default")
482
+ assert_that(subject.anyargs(1)).equals("default")
483
+ assert_that(subject.anyargs(1, 2)).equals("one-two")
483
484
  end
484
485
 
485
486
  should "allow stubbing a method that takes a minimum number of args" do
486
- assert_equal "one-two", subject.minargs(1, 2)
487
- assert_equal "one-two-three", subject.minargs(1, 2, 3)
488
- assert_equal "default", subject.minargs(1, 2, 4)
489
- assert_equal "default", subject.minargs(1, 2, 3, 4)
487
+ assert_that(subject.minargs(1, 2)).equals("one-two")
488
+ assert_that(subject.minargs(1, 2, 3)).equals("one-two-three")
489
+ assert_that(subject.minargs(1, 2, 4)).equals("default")
490
+ assert_that(subject.minargs(1, 2, 3, 4)).equals("default")
490
491
  end
491
492
 
492
493
  should "allow stubbing a method that takes a block" do
493
- assert_equal "default", subject.withblock
494
- assert_equal "default", subject.withblock{ "my-block" }
494
+ assert_that(subject.withblock).equals("default")
495
+ assert_that(subject.withblock{ "my-block" }).equals("default")
495
496
  end
496
497
 
497
498
  should "not allow stubbing methods with invalid arity" do
498
- assert_raises{ Assert.stub(subject, :noargs).with(1){ } }
499
+ assert_that { Assert.stub(subject, :noargs).with(1){ } }.raises
499
500
 
500
- assert_raises{ Assert.stub(subject, :withargs).with{ } }
501
- assert_raises{ Assert.stub(subject, :withargs).with(1, 2){ } }
501
+ assert_that { Assert.stub(subject, :withargs).with{ } }.raises
502
+ assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.raises
502
503
 
503
- assert_raises{ Assert.stub(subject, :minargs).with{ } }
504
- assert_raises{ Assert.stub(subject, :minargs).with(1){ } }
504
+ assert_that { Assert.stub(subject, :minargs).with{ } }.raises
505
+ assert_that { Assert.stub(subject, :minargs).with(1){ } }.raises
505
506
 
506
- assert_raises{ Assert.stub(subject, :withblock).with(1){ } }
507
+ assert_that { Assert.stub(subject, :withblock).with(1){ } }.raises
507
508
  end
508
509
 
509
510
  should "not allow calling methods with invalid arity" do
510
- assert_raises{ subject.noargs(1) }
511
+ assert_that { subject.noargs(1) }.raises
511
512
 
512
- assert_raises{ subject.withargs }
513
- assert_raises{ subject.withargs(1, 2) }
513
+ assert_that { subject.withargs }.raises
514
+ assert_that { subject.withargs(1, 2) }.raises
514
515
 
515
- assert_raises{ subject.minargs }
516
- assert_raises{ subject.minargs(1) }
516
+ assert_that { subject.minargs }.raises
517
+ assert_that { subject.minargs(1) }.raises
517
518
 
518
- assert_raises{ subject.withblock(1) }
519
+ assert_that { subject.withblock(1) }.raises
519
520
  end
520
521
  end
521
522
 
522
523
  class DelegateClassTests < SystemTests
523
524
  desc "a class that delegates another object"
525
+ subject { DelegateClass }
526
+
524
527
  setup do
525
- @class = DelegateClass
526
- Assert.stub(@class, :noargs){ "default" }
527
- Assert.stub(@class, :noargs).with{ "none" }
528
+ Assert.stub(subject, :noargs){ "default" }
529
+ Assert.stub(subject, :noargs).with{ "none" }
528
530
 
529
- Assert.stub(@class, :withargs){ "default" }
530
- Assert.stub(@class, :withargs).with(1){ "one" }
531
+ Assert.stub(subject, :withargs){ "default" }
532
+ Assert.stub(subject, :withargs).with(1){ "one" }
531
533
 
532
- Assert.stub(@class, :anyargs){ "default" }
533
- Assert.stub(@class, :anyargs).with(1, 2){ "one-two" }
534
+ Assert.stub(subject, :anyargs){ "default" }
535
+ Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
534
536
 
535
- Assert.stub(@class, :minargs){ "default" }
536
- Assert.stub(@class, :minargs).with(1, 2){ "one-two" }
537
- Assert.stub(@class, :minargs).with(1, 2, 3){ "one-two-three" }
537
+ Assert.stub(subject, :minargs){ "default" }
538
+ Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
539
+ Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
538
540
 
539
- Assert.stub(@class, :withblock){ "default" }
541
+ Assert.stub(subject, :withblock){ "default" }
540
542
  end
541
- subject{ @class }
542
543
 
543
544
  should "allow stubbing a method that doesn't take args" do
544
- assert_equal "none", subject.noargs
545
+ assert_that(subject.noargs).equals("none")
545
546
  end
546
547
 
547
548
  should "allow stubbing a method that takes args" do
548
- assert_equal "one", subject.withargs(1)
549
- assert_equal "default", subject.withargs(2)
549
+ assert_that(subject.withargs(1)).equals("one")
550
+ assert_that(subject.withargs(2)).equals("default")
550
551
  end
551
552
 
552
553
  should "allow stubbing a method that takes any args" do
553
- assert_equal "default", subject.anyargs
554
- assert_equal "default", subject.anyargs(1)
555
- assert_equal "one-two", subject.anyargs(1, 2)
554
+ assert_that(subject.anyargs).equals("default")
555
+ assert_that(subject.anyargs(1)).equals("default")
556
+ assert_that(subject.anyargs(1, 2)).equals("one-two")
556
557
  end
557
558
 
558
559
  should "allow stubbing a method that takes a minimum number of args" do
559
- assert_equal "one-two", subject.minargs(1, 2)
560
- assert_equal "one-two-three", subject.minargs(1, 2, 3)
561
- assert_equal "default", subject.minargs(1, 2, 4)
562
- assert_equal "default", subject.minargs(1, 2, 3, 4)
560
+ assert_that(subject.minargs(1, 2)).equals("one-two")
561
+ assert_that(subject.minargs(1, 2, 3)).equals("one-two-three")
562
+ assert_that(subject.minargs(1, 2, 4)).equals("default")
563
+ assert_that(subject.minargs(1, 2, 3, 4)).equals("default")
563
564
  end
564
565
 
565
566
  should "allow stubbing a method that takes a block" do
566
- assert_equal "default", subject.withblock
567
- assert_equal "default", subject.withblock{ "my-block" }
567
+ assert_that(subject.withblock).equals("default")
568
+ assert_that(subject.withblock{ "my-block" }).equals("default")
568
569
  end
569
570
 
570
571
  should "allow stubbing methods with invalid arity" do
571
- assert_nothing_raised{ Assert.stub(subject, :noargs).with(1){ } }
572
+ assert_that { Assert.stub(subject, :noargs).with(1){ } }.does_not_raise
572
573
 
573
- assert_nothing_raised{ Assert.stub(subject, :withargs).with{ } }
574
- assert_nothing_raised{ Assert.stub(subject, :withargs).with(1, 2){ } }
574
+ assert_that { Assert.stub(subject, :withargs).with{ } }.does_not_raise
575
+ assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.does_not_raise
575
576
 
576
- assert_nothing_raised{ Assert.stub(subject, :minargs).with{ } }
577
- assert_nothing_raised{ Assert.stub(subject, :minargs).with(1){ } }
577
+ assert_that { Assert.stub(subject, :minargs).with{ } }.does_not_raise
578
+ assert_that { Assert.stub(subject, :minargs).with(1){ } }.does_not_raise
578
579
 
579
- assert_nothing_raised{ Assert.stub(subject, :withblock).with(1){ } }
580
+ assert_that { Assert.stub(subject, :withblock).with(1){ } }.does_not_raise
580
581
  end
581
582
 
582
583
  should "allow calling methods with invalid arity" do
583
- assert_nothing_raised{ subject.noargs(1) }
584
+ assert_that { subject.noargs(1) }.does_not_raise
584
585
 
585
- assert_nothing_raised{ subject.withargs }
586
- assert_nothing_raised{ subject.withargs(1, 2) }
586
+ assert_that { subject.withargs }.does_not_raise
587
+ assert_that { subject.withargs(1, 2) }.does_not_raise
587
588
 
588
- assert_nothing_raised{ subject.minargs }
589
- assert_nothing_raised{ subject.minargs(1) }
589
+ assert_that { subject.minargs }.does_not_raise
590
+ assert_that { subject.minargs(1) }.does_not_raise
590
591
 
591
- assert_nothing_raised{ subject.withblock(1) }
592
+ assert_that { subject.withblock(1) }.does_not_raise
592
593
  end
593
594
  end
594
595
 
595
596
  class DelegateInstanceTests < SystemTests
596
597
  desc "an instance that delegates another object"
598
+ subject { DelegateClass.new }
599
+
597
600
  setup do
598
- @instance = DelegateClass.new
599
- Assert.stub(@instance, :noargs){ "default" }
600
- Assert.stub(@instance, :noargs).with{ "none" }
601
+ Assert.stub(subject, :noargs){ "default" }
602
+ Assert.stub(subject, :noargs).with{ "none" }
601
603
 
602
- Assert.stub(@instance, :withargs){ "default" }
603
- Assert.stub(@instance, :withargs).with(1){ "one" }
604
+ Assert.stub(subject, :withargs){ "default" }
605
+ Assert.stub(subject, :withargs).with(1){ "one" }
604
606
 
605
- Assert.stub(@instance, :anyargs){ "default" }
606
- Assert.stub(@instance, :anyargs).with(1, 2){ "one-two" }
607
+ Assert.stub(subject, :anyargs){ "default" }
608
+ Assert.stub(subject, :anyargs).with(1, 2){ "one-two" }
607
609
 
608
- Assert.stub(@instance, :minargs){ "default" }
609
- Assert.stub(@instance, :minargs).with(1, 2){ "one-two" }
610
- Assert.stub(@instance, :minargs).with(1, 2, 3){ "one-two-three" }
610
+ Assert.stub(subject, :minargs){ "default" }
611
+ Assert.stub(subject, :minargs).with(1, 2){ "one-two" }
612
+ Assert.stub(subject, :minargs).with(1, 2, 3){ "one-two-three" }
611
613
 
612
- Assert.stub(@instance, :withblock){ "default" }
614
+ Assert.stub(subject, :withblock){ "default" }
613
615
  end
614
- subject{ @instance }
615
616
 
616
617
  should "allow stubbing a method that doesn't take args" do
617
- assert_equal "none", subject.noargs
618
+ assert_that(subject.noargs).equals("none")
618
619
  end
619
620
 
620
621
  should "allow stubbing a method that takes args" do
621
- assert_equal "one", subject.withargs(1)
622
- assert_equal "default", subject.withargs(2)
622
+ assert_that(subject.withargs(1)).equals("one")
623
+ assert_that(subject.withargs(2)).equals("default")
623
624
  end
624
625
 
625
626
  should "allow stubbing a method that takes any args" do
626
- assert_equal "default", subject.anyargs
627
- assert_equal "default", subject.anyargs(1)
628
- assert_equal "one-two", subject.anyargs(1, 2)
627
+ assert_that(subject.anyargs).equals("default")
628
+ assert_that(subject.anyargs(1)).equals("default")
629
+ assert_that(subject.anyargs(1, 2)).equals("one-two")
629
630
  end
630
631
 
631
632
  should "allow stubbing a method that takes a minimum number of args" do
632
- assert_equal "one-two", subject.minargs(1, 2)
633
- assert_equal "one-two-three", subject.minargs(1, 2, 3)
634
- assert_equal "default", subject.minargs(1, 2, 4)
635
- assert_equal "default", subject.minargs(1, 2, 3, 4)
633
+ assert_that(subject.minargs(1, 2)).equals("one-two")
634
+ assert_that(subject.minargs(1, 2, 3)).equals("one-two-three")
635
+ assert_that(subject.minargs(1, 2, 4)).equals("default")
636
+ assert_that(subject.minargs(1, 2, 3, 4)).equals("default")
636
637
  end
637
638
 
638
639
  should "allow stubbing a method that takes a block" do
639
- assert_equal "default", subject.withblock
640
- assert_equal "default", subject.withblock{ "my-block" }
640
+ assert_that(subject.withblock).equals("default")
641
+ assert_that(subject.withblock{ "my-block" }).equals("default")
641
642
  end
642
643
 
643
644
  should "allow stubbing methods with invalid arity" do
644
- assert_nothing_raised{ Assert.stub(subject, :noargs).with(1){ } }
645
+ assert_that { Assert.stub(subject, :noargs).with(1){ } }.does_not_raise
645
646
 
646
- assert_nothing_raised{ Assert.stub(subject, :withargs).with{ } }
647
- assert_nothing_raised{ Assert.stub(subject, :withargs).with(1, 2){ } }
647
+ assert_that { Assert.stub(subject, :withargs).with{ } }.does_not_raise
648
+ assert_that { Assert.stub(subject, :withargs).with(1, 2){ } }.does_not_raise
648
649
 
649
- assert_nothing_raised{ Assert.stub(subject, :minargs).with{ } }
650
- assert_nothing_raised{ Assert.stub(subject, :minargs).with(1){ } }
650
+ assert_that { Assert.stub(subject, :minargs).with{ } }.does_not_raise
651
+ assert_that { Assert.stub(subject, :minargs).with(1){ } }.does_not_raise
651
652
 
652
- assert_nothing_raised{ Assert.stub(subject, :withblock).with(1){ } }
653
+ assert_that { Assert.stub(subject, :withblock).with(1){ } }.does_not_raise
653
654
  end
654
655
 
655
656
  should "allow calling methods with invalid arity" do
656
- assert_nothing_raised{ subject.noargs(1) }
657
+ assert_that { subject.noargs(1) }.does_not_raise
657
658
 
658
- assert_nothing_raised{ subject.withargs }
659
- assert_nothing_raised{ subject.withargs(1, 2) }
659
+ assert_that { subject.withargs }.does_not_raise
660
+ assert_that { subject.withargs(1, 2) }.does_not_raise
660
661
 
661
- assert_nothing_raised{ subject.minargs }
662
- assert_nothing_raised{ subject.minargs(1) }
662
+ assert_that { subject.minargs }.does_not_raise
663
+ assert_that { subject.minargs(1) }.does_not_raise
663
664
 
664
- assert_nothing_raised{ subject.withblock(1) }
665
+ assert_that { subject.withblock(1) }.does_not_raise
665
666
  end
666
667
  end
667
668
 
668
669
  class ParentAndChildClassTests < SystemTests
669
670
  desc "for a parent method stubbed on both the parent and child"
670
671
  setup do
671
- @parent_class = Class.new
672
- @child_class = Class.new(@parent_class)
673
-
674
- Assert.stub(@parent_class, :new){ "parent" }
675
- Assert.stub(@child_class, :new){ "child" }
672
+ Assert.stub(parent_class, :new){ "parent" }
673
+ Assert.stub(child_class, :new){ "child" }
676
674
  end
677
675
 
676
+ let(:parent_class) { Class.new }
677
+ let(:child_class) { Class.new(parent_class) }
678
+
678
679
  should "allow stubbing the methods individually" do
679
- assert_equal "parent", @parent_class.new
680
- assert_equal "child", @child_class.new
680
+ assert_that(parent_class.new).equals("parent")
681
+ assert_that(child_class.new).equals("child")
681
682
  end
682
683
  end
683
684