1# encoding: utf-8
2######################################################################
3# This file is imported from the minitest project.
4# DO NOT make modifications in this repo. They _will_ be reverted!
5# File a patch instead and assign it to Ryan Davis.
6######################################################################
7
8require 'minitest/mock'
9require 'minitest/unit'
10
11MiniTest::Unit.autorun
12
13class TestMiniTestMock < MiniTest::Unit::TestCase
14  parallelize_me! if ENV["PARALLEL"]
15
16  def setup
17    @mock = MiniTest::Mock.new.expect(:foo, nil)
18    @mock.expect(:meaning_of_life, 42)
19  end
20
21  def test_create_stub_method
22    assert_nil @mock.foo
23  end
24
25  def test_allow_return_value_specification
26    assert_equal 42, @mock.meaning_of_life
27  end
28
29  def test_blow_up_if_not_called
30    @mock.foo
31
32    util_verify_bad "expected meaning_of_life() => 42, got []"
33  end
34
35  def test_not_blow_up_if_everything_called
36    @mock.foo
37    @mock.meaning_of_life
38
39    assert @mock.verify
40  end
41
42  def test_allow_expectations_to_be_added_after_creation
43    @mock.expect(:bar, true)
44    assert @mock.bar
45  end
46
47  def test_not_verify_if_new_expected_method_is_not_called
48    @mock.foo
49    @mock.meaning_of_life
50    @mock.expect(:bar, true)
51
52    util_verify_bad "expected bar() => true, got []"
53  end
54
55  def test_blow_up_on_wrong_number_of_arguments
56    @mock.foo
57    @mock.meaning_of_life
58    @mock.expect(:sum, 3, [1, 2])
59
60    e = assert_raises ArgumentError do
61      @mock.sum
62    end
63
64    assert_equal "mocked method :sum expects 2 arguments, got 0", e.message
65  end
66
67  def test_return_mock_does_not_raise
68    retval = MiniTest::Mock.new
69    mock = MiniTest::Mock.new
70    mock.expect(:foo, retval)
71    mock.foo
72
73    assert mock.verify
74  end
75
76  def test_mock_args_does_not_raise
77    arg = MiniTest::Mock.new
78    mock = MiniTest::Mock.new
79    mock.expect(:foo, nil, [arg])
80    mock.foo(arg)
81
82    assert mock.verify
83  end
84
85  def test_blow_up_on_wrong_arguments
86    @mock.foo
87    @mock.meaning_of_life
88    @mock.expect(:sum, 3, [1, 2])
89
90    e = assert_raises MockExpectationError do
91      @mock.sum(2, 4)
92    end
93
94    exp = "mocked method :sum called with unexpected arguments [2, 4]"
95    assert_equal exp, e.message
96  end
97
98  def test_expect_with_non_array_args
99    e = assert_raises ArgumentError do
100      @mock.expect :blah, 3, false
101    end
102
103    assert_equal "args must be an array", e.message
104  end
105
106  def test_respond_appropriately
107    assert @mock.respond_to?(:foo)
108    assert @mock.respond_to?(:foo, true)
109    assert @mock.respond_to?('foo')
110    assert !@mock.respond_to?(:bar)
111  end
112
113  def test_no_method_error_on_unexpected_methods
114    e = assert_raises NoMethodError do
115      @mock.bar
116    end
117
118    expected = "unmocked method :bar, expected one of [:foo, :meaning_of_life]"
119
120    assert_equal expected, e.message
121  end
122
123  def test_assign_per_mock_return_values
124    a = MiniTest::Mock.new
125    b = MiniTest::Mock.new
126
127    a.expect(:foo, :a)
128    b.expect(:foo, :b)
129
130    assert_equal :a, a.foo
131    assert_equal :b, b.foo
132  end
133
134  def test_do_not_create_stub_method_on_new_mocks
135    a = MiniTest::Mock.new
136    a.expect(:foo, :a)
137
138    assert !MiniTest::Mock.new.respond_to?(:foo)
139  end
140
141  def test_mock_is_a_blank_slate
142    @mock.expect :kind_of?, true, [Fixnum]
143    @mock.expect :==, true, [1]
144
145    assert @mock.kind_of?(Fixnum), "didn't mock :kind_of\?"
146    assert @mock == 1, "didn't mock :=="
147  end
148
149  def test_verify_allows_called_args_to_be_loosely_specified
150    mock = MiniTest::Mock.new
151    mock.expect :loose_expectation, true, [Integer]
152    mock.loose_expectation 1
153
154    assert mock.verify
155  end
156
157  def test_verify_raises_with_strict_args
158    mock = MiniTest::Mock.new
159    mock.expect :strict_expectation, true, [2]
160
161    e = assert_raises MockExpectationError do
162      mock.strict_expectation 1
163    end
164
165    exp = "mocked method :strict_expectation called with unexpected arguments [1]"
166    assert_equal exp, e.message
167  end
168
169  def test_method_missing_empty
170    mock = MiniTest::Mock.new
171
172    mock.expect :a, nil
173
174    mock.a
175
176    e = assert_raises MockExpectationError do
177      mock.a
178    end
179
180    assert_equal "No more expects available for :a: []", e.message
181  end
182
183  def test_same_method_expects_are_verified_when_all_called
184    mock = MiniTest::Mock.new
185    mock.expect :foo, nil, [:bar]
186    mock.expect :foo, nil, [:baz]
187
188    mock.foo :bar
189    mock.foo :baz
190
191    assert mock.verify
192  end
193
194  def test_same_method_expects_blow_up_when_not_all_called
195    mock = MiniTest::Mock.new
196    mock.expect :foo, nil, [:bar]
197    mock.expect :foo, nil, [:baz]
198
199    mock.foo :bar
200
201    e = assert_raises(MockExpectationError) { mock.verify }
202
203    exp = "expected foo(:baz) => nil, got [foo(:bar) => nil]"
204
205    assert_equal exp, e.message
206  end
207
208  def test_verify_passes_when_mock_block_returns_true
209    mock = MiniTest::Mock.new
210    mock.expect :foo, nil do
211      true
212    end
213
214    mock.foo
215
216    assert mock.verify
217  end
218
219  def test_mock_block_is_passed_function_params
220    arg1, arg2, arg3 = :bar, [1,2,3], {:a => 'a'}
221    mock = MiniTest::Mock.new
222    mock.expect :foo, nil do |a1, a2, a3|
223      a1 == arg1 &&
224      a2 == arg2 &&
225      a3 == arg3
226    end
227
228    mock.foo arg1, arg2, arg3
229
230    assert mock.verify
231  end
232
233  def test_verify_fails_when_mock_block_returns_false
234    mock = MiniTest::Mock.new
235    mock.expect :foo, nil do
236      false
237    end
238
239    e = assert_raises(MockExpectationError) { mock.foo }
240    exp = "mocked method :foo failed block w/ []"
241
242    assert_equal exp, e.message
243  end
244
245  def test_mock_block_throws_if_args_passed
246    mock = MiniTest::Mock.new
247
248    e = assert_raises(ArgumentError) do
249      mock.expect :foo, nil, [:a, :b, :c] do
250        true
251      end
252    end
253
254    exp = "args ignored when block given"
255
256    assert_equal exp, e.message
257  end
258
259  def test_mock_returns_retval_when_called_with_block
260    mock = MiniTest::Mock.new
261    mock.expect(:foo, 32) do
262      true
263    end
264
265    rs = mock.foo
266
267    assert_equal rs, 32
268  end
269
270  def util_verify_bad exp
271    e = assert_raises MockExpectationError do
272      @mock.verify
273    end
274
275    assert_equal exp, e.message
276  end
277end
278
279require "minitest/metametameta"
280
281class TestMiniTestStub < MiniTest::Unit::TestCase
282  parallelize_me! if ENV["PARALLEL"]
283
284  def setup
285    super
286    MiniTest::Unit::TestCase.reset
287
288    @tc = MiniTest::Unit::TestCase.new 'fake tc'
289    @assertion_count = 1
290  end
291
292  def teardown
293    super
294    assert_equal @assertion_count, @tc._assertions
295  end
296
297  def assert_stub val_or_callable
298    @assertion_count += 1
299
300    synchronize do
301      t = Time.now.to_i
302
303      Time.stub :now, val_or_callable do
304        @tc.assert_equal 42, Time.now
305      end
306
307      @tc.assert_operator Time.now.to_i, :>=, t
308    end
309  end
310
311  def test_stub_value
312    assert_stub 42
313  end
314
315  def test_stub_block
316    assert_stub lambda { 42 }
317  end
318
319  def test_stub_block_args
320    @assertion_count += 1
321
322    synchronize do
323      t = Time.now.to_i
324
325      Time.stub :now,  lambda { |n| n * 2 } do
326        @tc.assert_equal 42, Time.now(21)
327      end
328
329      @tc.assert_operator Time.now.to_i, :>=, t
330    end
331  end
332
333  def test_stub_callable
334    obj = Object.new
335
336    def obj.call
337      42
338    end
339
340    assert_stub obj
341  end
342
343  def test_stub_yield_self
344    obj = "foo"
345
346    val = obj.stub :to_s, "bar" do |s|
347      s.to_s
348    end
349
350    @tc.assert_equal "bar", val
351  end
352
353  def test_dynamic_method
354    @assertion_count = 2
355
356    dynamic = Class.new do
357      def self.respond_to?(meth)
358        meth == :found
359      end
360
361      def self.method_missing(meth, *args, &block)
362        if meth == :found
363          false
364        else
365          super
366        end
367      end
368    end
369
370    val = dynamic.stub(:found, true) do |s|
371      s.found
372    end
373
374    @tc.assert_equal true, val
375    @tc.assert_equal false, dynamic.found
376  end
377end
378