assert 2.18.2 → 2.19.2

Sign up to get free protection for your applications and to get access to all the features.
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