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