1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
|
######################################################################
# This file is imported from the minitest project.
# DO NOT make modifications in this repo. They _will_ be reverted!
# File a patch instead and assign it to Ryan Davis.
######################################################################
require 'minitest/autorun'
require 'stringio'
describe MiniTest::Spec do
before do
@assertion_count = 4
end
after do
self._assertions.must_equal @assertion_count
end
# TODO: figure out how the hell to write a test for this
# it "will skip if there is no block"
it "needs to have all methods named well" do
@assertion_count = 2
methods = Object.public_instance_methods.find_all { |n| n =~ /^must|^wont/ }
methods.map! { |m| m.to_s } if Symbol === methods.first
musts, wonts = methods.sort.partition { |m| m =~ /^must/ }
expected_musts = %w(must_be
must_be_close_to
must_be_empty
must_be_instance_of
must_be_kind_of
must_be_nil
must_be_same_as
must_be_silent
must_be_within_delta
must_be_within_epsilon
must_equal
must_include
must_match
must_output
must_raise
must_respond_to
must_send
must_throw)
bad = %w[not raise throw send output be_silent]
expected_wonts = expected_musts.map { |m| m.sub(/^must/, 'wont') }
expected_wonts.reject! { |m| m =~ /wont_#{Regexp.union(*bad)}/ }
musts.must_equal expected_musts
wonts.must_equal expected_wonts
end
it "needs to verify equality" do
(6 * 7).must_equal(42).must_equal true
proc { (6 * 9).must_equal(42) }.must_raise MiniTest::Assertion
end
it "needs to verify floats within a delta" do
(6.0 * 7).must_be_close_to(42.0).must_equal true
proc { 42.002.must_be_close_to 42.0 }.must_raise MiniTest::Assertion
end
it "needs to verify types of objects" do
(6 * 7).must_be_instance_of(Fixnum).must_equal true
proc { (6 * 7).must_be_instance_of String }.must_raise MiniTest::Assertion
end
it "needs to verify kinds of objects" do
@assertion_count = 6
(6 * 7).must_be_kind_of(Fixnum).must_equal true
(6 * 7).must_be_kind_of(Numeric).must_equal true
proc { (6 * 7).must_be_kind_of String }.must_raise MiniTest::Assertion
end
it "needs to verify regexp matches" do
@assertion_count = 6
"blah".must_match(/\w+/).must_equal true
proc { "blah".must_match(/\d+/) }.must_raise MiniTest::Assertion
end
it "needs to verify nil" do
nil.must_be_nil.must_equal true
proc { 42.must_be_nil }.must_raise MiniTest::Assertion
end
it "needs to verify using any operator" do
41.must_be(:<, 42).must_equal true
proc { 42.must_be(:<, 41) }.must_raise MiniTest::Assertion
end
it "needs to catch an expected exception" do
@assertion_count = 2
proc { raise "blah" }.must_raise RuntimeError
proc { raise MiniTest::Assertion }.must_raise MiniTest::Assertion
end
it "needs to catch an unexpected exception" do
@assertion_count = 2
proc {
proc { raise MiniTest::Assertion }.must_raise(RuntimeError)
}.must_raise MiniTest::Assertion
end
it "needs raise if an expected exception is not raised" do
@assertion_count = 2
proc { proc { 42 }.must_raise(RuntimeError) }.must_raise MiniTest::Assertion
end
it "needs to be able to catch a MiniTest::Assertion exception" do
@assertion_count = 2
proc { 1.wont_equal 1 }.must_raise MiniTest::Assertion
end
it "needs to verify using respond_to" do
42.must_respond_to(:+).must_equal true
proc { 42.must_respond_to(:clear) }.must_raise MiniTest::Assertion
end
it "needs to verify identity" do
1.must_be_same_as(1).must_equal true
proc { 1.must_be_same_as 2 }.must_raise MiniTest::Assertion
end
it "needs to verify throw" do
@assertion_count = 6
proc { throw :blah }.must_throw(:blah).must_equal true
proc { proc { }.must_throw(:blah) }.must_raise MiniTest::Assertion
proc { proc { throw :xxx }.must_throw(:blah) }.must_raise MiniTest::Assertion
end
it "needs to verify inequality" do
42.wont_equal(6 * 9).must_equal false
proc { 1.wont_equal 1 }.must_raise MiniTest::Assertion
end
it "needs to verify mismatch" do
@assertion_count = 6
"blah".wont_match(/\d+/).must_equal false
proc { "blah".wont_match(/\w+/) }.must_raise MiniTest::Assertion
end
it "needs to verify non-nil" do
42.wont_be_nil.must_equal false
proc { nil.wont_be_nil }.must_raise MiniTest::Assertion
end
it "needs to verify non-identity" do
1.wont_be_same_as(2).must_equal false
proc { 1.wont_be_same_as 1 }.must_raise MiniTest::Assertion
end
it "needs to verify output in stdout" do
proc { print "blah" }.must_output("blah").must_equal true
proc {
proc { print "xxx" }.must_output("blah")
}.must_raise MiniTest::Assertion
end
it "needs to verify output in stderr" do
proc { $stderr.print "blah" }.must_output(nil, "blah").must_equal true
proc {
proc { $stderr.print "xxx" }.must_output(nil, "blah")
}.must_raise MiniTest::Assertion
end
it "needs to ensure silence" do
@assertion_count = 5
proc { }.must_be_silent.must_equal true
proc {
proc { print "xxx" }.must_be_silent
}.must_raise MiniTest::Assertion
end
it "needs to be sensible about must_include order" do
@assertion_count = 6
[1, 2, 3].must_include(2).must_equal true
proc { [1, 2, 3].must_include 5 }.must_raise MiniTest::Assertion
end
it "needs to be sensible about wont_include order" do
@assertion_count = 6
[1, 2, 3].wont_include(5).must_equal false
proc { [1, 2, 3].wont_include 2 }.must_raise MiniTest::Assertion
end
end
describe MiniTest::Spec, :let do
i_suck_and_my_tests_are_order_dependent!
def _count
$let_count ||= 0
end
let :count do
$let_count += 1
$let_count
end
it "is evaluated once per example" do
_count.must_equal 0
count.must_equal 1
count.must_equal 1
_count.must_equal 1
end
it "is REALLY evaluated once per example" do
_count.must_equal 1
count.must_equal 2
count.must_equal 2
_count.must_equal 2
end
end
describe MiniTest::Spec, :subject do
attr_reader :subject_evaluation_count
subject do
@subject_evaluation_count ||= 0
@subject_evaluation_count += 1
@subject_evaluation_count
end
it "is evaluated once per example" do
subject.must_equal 1
subject.must_equal 1
subject_evaluation_count.must_equal 1
end
end
class TestMeta < MiniTest::Unit::TestCase
def test_setup
srand 42
MiniTest::Unit::TestCase.reset
end
def util_structure
x = y = z = nil
before_list = []
after_list = []
x = describe "top-level thingy" do
before { before_list << 1 }
after { after_list << 1 }
it "top-level-it" do end
y = describe "inner thingy" do
before { before_list << 2 }
after { after_list << 2 }
it "inner-it" do end
z = describe "very inner thingy" do
before { before_list << 3 }
after { after_list << 3 }
it "inner-it" do end
end
end
end
return x, y, z, before_list, after_list
end
def test_structure
x, y, z, * = util_structure
assert_equal "top-level thingy", x.to_s
assert_equal "top-level thingy::inner thingy", y.to_s
assert_equal "top-level thingy::inner thingy::very inner thingy", z.to_s
assert_equal "top-level thingy", x.desc
assert_equal "inner thingy", y.desc
assert_equal "very inner thingy", z.desc
top_methods = %w(test_0001_top_level_it)
inner_methods = %w(test_0001_inner_it)
assert_equal top_methods, x.instance_methods(false).sort.map {|o| o.to_s }
assert_equal inner_methods, y.instance_methods(false).sort.map {|o| o.to_s }
assert_equal inner_methods, z.instance_methods(false).sort.map {|o| o.to_s }
end
def test_setup_teardown_behavior
_, _, z, before_list, after_list = util_structure
tc = z.new(nil)
tc.run_setup_hooks
tc.run_teardown_hooks
assert_equal [1, 2, 3], before_list
assert_equal [3, 2, 1], after_list
end
def test_children
MiniTest::Spec.children.clear
x = y = z = nil
x = describe "top-level thingy" do
y = describe "first thingy" do end
it "top-level-it" do end
z = describe "second thingy" do end
end
assert_equal [x], MiniTest::Spec.children
assert_equal [y, z], x.children
assert_equal [], y.children
assert_equal [], z.children
end
def test_describe_first_structure
x = y = z = nil
x = describe "top-level thingy" do
y = describe "first thingy" do end
it "top-level-it" do end
z = describe "second thingy" do end
end
assert_equal ['test_0001_top_level_it'],
x.instance_methods.grep(/^test/).map {|o| o.to_s}
assert_equal [], y.instance_methods.grep(/^test/)
assert_equal [], z.instance_methods.grep(/^test/)
end
def test_structure_subclasses
z = nil
x = Class.new MiniTest::Spec do
def xyz; end
end
y = Class.new x do
z = describe("inner") {}
end
assert_respond_to x.new(nil), "xyz"
assert_respond_to y.new(nil), "xyz"
assert_respond_to z.new(nil), "xyz"
end
end
|