The Tor Browser / file comparison
comparison: python/mock-1.0.0/tests/testmock.py
python/mock-1.0.0/tests/testmock.py
- branch
- TOR_BUG_9701
- changeset 9
- a63d609f5ebe
equal
deleted
inserted
replaced
| -1:000000000000 | 0:11865205da83 |
|---|---|
| 1 # Copyright (C) 2007-2012 Michael Foord & the mock team | |
| 2 # E-mail: fuzzyman AT voidspace DOT org DOT uk | |
| 3 # http://www.voidspace.org.uk/python/mock/ | |
| 4 | |
| 5 from tests.support import ( | |
| 6 callable, unittest2, inPy3k, is_instance, next | |
| 7 ) | |
| 8 | |
| 9 import copy | |
| 10 import pickle | |
| 11 import sys | |
| 12 | |
| 13 import mock | |
| 14 from mock import ( | |
| 15 call, DEFAULT, patch, sentinel, | |
| 16 MagicMock, Mock, NonCallableMock, | |
| 17 NonCallableMagicMock, _CallList, | |
| 18 create_autospec | |
| 19 ) | |
| 20 | |
| 21 | |
| 22 try: | |
| 23 unicode | |
| 24 except NameError: | |
| 25 unicode = str | |
| 26 | |
| 27 | |
| 28 class Iter(object): | |
| 29 def __init__(self): | |
| 30 self.thing = iter(['this', 'is', 'an', 'iter']) | |
| 31 | |
| 32 def __iter__(self): | |
| 33 return self | |
| 34 | |
| 35 def next(self): | |
| 36 return next(self.thing) | |
| 37 | |
| 38 __next__ = next | |
| 39 | |
| 40 | |
| 41 class Subclass(MagicMock): | |
| 42 pass | |
| 43 | |
| 44 | |
| 45 class Thing(object): | |
| 46 attribute = 6 | |
| 47 foo = 'bar' | |
| 48 | |
| 49 | |
| 50 | |
| 51 class MockTest(unittest2.TestCase): | |
| 52 | |
| 53 def test_all(self): | |
| 54 # if __all__ is badly defined then import * will raise an error | |
| 55 # We have to exec it because you can't import * inside a method | |
| 56 # in Python 3 | |
| 57 exec("from mock import *") | |
| 58 | |
| 59 | |
| 60 def test_constructor(self): | |
| 61 mock = Mock() | |
| 62 | |
| 63 self.assertFalse(mock.called, "called not initialised correctly") | |
| 64 self.assertEqual(mock.call_count, 0, | |
| 65 "call_count not initialised correctly") | |
| 66 self.assertTrue(is_instance(mock.return_value, Mock), | |
| 67 "return_value not initialised correctly") | |
| 68 | |
| 69 self.assertEqual(mock.call_args, None, | |
| 70 "call_args not initialised correctly") | |
| 71 self.assertEqual(mock.call_args_list, [], | |
| 72 "call_args_list not initialised correctly") | |
| 73 self.assertEqual(mock.method_calls, [], | |
| 74 "method_calls not initialised correctly") | |
| 75 | |
| 76 # Can't use hasattr for this test as it always returns True on a mock | |
| 77 self.assertFalse('_items' in mock.__dict__, | |
| 78 "default mock should not have '_items' attribute") | |
| 79 | |
| 80 self.assertIsNone(mock._mock_parent, | |
| 81 "parent not initialised correctly") | |
| 82 self.assertIsNone(mock._mock_methods, | |
| 83 "methods not initialised correctly") | |
| 84 self.assertEqual(mock._mock_children, {}, | |
| 85 "children not initialised incorrectly") | |
| 86 | |
| 87 | |
| 88 def test_unicode_not_broken(self): | |
| 89 # This used to raise an exception with Python 2.5 and Mock 0.4 | |
| 90 unicode(Mock()) | |
| 91 | |
| 92 | |
| 93 def test_return_value_in_constructor(self): | |
| 94 mock = Mock(return_value=None) | |
| 95 self.assertIsNone(mock.return_value, | |
| 96 "return value in constructor not honoured") | |
| 97 | |
| 98 | |
| 99 def test_repr(self): | |
| 100 mock = Mock(name='foo') | |
| 101 self.assertIn('foo', repr(mock)) | |
| 102 self.assertIn("'%s'" % id(mock), repr(mock)) | |
| 103 | |
| 104 mocks = [(Mock(), 'mock'), (Mock(name='bar'), 'bar')] | |
| 105 for mock, name in mocks: | |
| 106 self.assertIn('%s.bar' % name, repr(mock.bar)) | |
| 107 self.assertIn('%s.foo()' % name, repr(mock.foo())) | |
| 108 self.assertIn('%s.foo().bing' % name, repr(mock.foo().bing)) | |
| 109 self.assertIn('%s()' % name, repr(mock())) | |
| 110 self.assertIn('%s()()' % name, repr(mock()())) | |
| 111 self.assertIn('%s()().foo.bar.baz().bing' % name, | |
| 112 repr(mock()().foo.bar.baz().bing)) | |
| 113 | |
| 114 | |
| 115 def test_repr_with_spec(self): | |
| 116 class X(object): | |
| 117 pass | |
| 118 | |
| 119 mock = Mock(spec=X) | |
| 120 self.assertIn(" spec='X' ", repr(mock)) | |
| 121 | |
| 122 mock = Mock(spec=X()) | |
| 123 self.assertIn(" spec='X' ", repr(mock)) | |
| 124 | |
| 125 mock = Mock(spec_set=X) | |
| 126 self.assertIn(" spec_set='X' ", repr(mock)) | |
| 127 | |
| 128 mock = Mock(spec_set=X()) | |
| 129 self.assertIn(" spec_set='X' ", repr(mock)) | |
| 130 | |
| 131 mock = Mock(spec=X, name='foo') | |
| 132 self.assertIn(" spec='X' ", repr(mock)) | |
| 133 self.assertIn(" name='foo' ", repr(mock)) | |
| 134 | |
| 135 mock = Mock(name='foo') | |
| 136 self.assertNotIn("spec", repr(mock)) | |
| 137 | |
| 138 mock = Mock() | |
| 139 self.assertNotIn("spec", repr(mock)) | |
| 140 | |
| 141 mock = Mock(spec=['foo']) | |
| 142 self.assertNotIn("spec", repr(mock)) | |
| 143 | |
| 144 | |
| 145 def test_side_effect(self): | |
| 146 mock = Mock() | |
| 147 | |
| 148 def effect(*args, **kwargs): | |
| 149 raise SystemError('kablooie') | |
| 150 | |
| 151 mock.side_effect = effect | |
| 152 self.assertRaises(SystemError, mock, 1, 2, fish=3) | |
| 153 mock.assert_called_with(1, 2, fish=3) | |
| 154 | |
| 155 results = [1, 2, 3] | |
| 156 def effect(): | |
| 157 return results.pop() | |
| 158 mock.side_effect = effect | |
| 159 | |
| 160 self.assertEqual([mock(), mock(), mock()], [3, 2, 1], | |
| 161 "side effect not used correctly") | |
| 162 | |
| 163 mock = Mock(side_effect=sentinel.SideEffect) | |
| 164 self.assertEqual(mock.side_effect, sentinel.SideEffect, | |
| 165 "side effect in constructor not used") | |
| 166 | |
| 167 def side_effect(): | |
| 168 return DEFAULT | |
| 169 mock = Mock(side_effect=side_effect, return_value=sentinel.RETURN) | |
| 170 self.assertEqual(mock(), sentinel.RETURN) | |
| 171 | |
| 172 | |
| 173 @unittest2.skipUnless('java' in sys.platform, | |
| 174 'This test only applies to Jython') | |
| 175 def test_java_exception_side_effect(self): | |
| 176 import java | |
| 177 mock = Mock(side_effect=java.lang.RuntimeException("Boom!")) | |
| 178 | |
| 179 # can't use assertRaises with java exceptions | |
| 180 try: | |
| 181 mock(1, 2, fish=3) | |
| 182 except java.lang.RuntimeException: | |
| 183 pass | |
| 184 else: | |
| 185 self.fail('java exception not raised') | |
| 186 mock.assert_called_with(1,2, fish=3) | |
| 187 | |
| 188 | |
| 189 def test_reset_mock(self): | |
| 190 parent = Mock() | |
| 191 spec = ["something"] | |
| 192 mock = Mock(name="child", parent=parent, spec=spec) | |
| 193 mock(sentinel.Something, something=sentinel.SomethingElse) | |
| 194 something = mock.something | |
| 195 mock.something() | |
| 196 mock.side_effect = sentinel.SideEffect | |
| 197 return_value = mock.return_value | |
| 198 return_value() | |
| 199 | |
| 200 mock.reset_mock() | |
| 201 | |
| 202 self.assertEqual(mock._mock_name, "child", | |
| 203 "name incorrectly reset") | |
| 204 self.assertEqual(mock._mock_parent, parent, | |
| 205 "parent incorrectly reset") | |
| 206 self.assertEqual(mock._mock_methods, spec, | |
| 207 "methods incorrectly reset") | |
| 208 | |
| 209 self.assertFalse(mock.called, "called not reset") | |
| 210 self.assertEqual(mock.call_count, 0, "call_count not reset") | |
| 211 self.assertEqual(mock.call_args, None, "call_args not reset") | |
| 212 self.assertEqual(mock.call_args_list, [], "call_args_list not reset") | |
| 213 self.assertEqual(mock.method_calls, [], | |
| 214 "method_calls not initialised correctly: %r != %r" % | |
| 215 (mock.method_calls, [])) | |
| 216 self.assertEqual(mock.mock_calls, []) | |
| 217 | |
| 218 self.assertEqual(mock.side_effect, sentinel.SideEffect, | |
| 219 "side_effect incorrectly reset") | |
| 220 self.assertEqual(mock.return_value, return_value, | |
| 221 "return_value incorrectly reset") | |
| 222 self.assertFalse(return_value.called, "return value mock not reset") | |
| 223 self.assertEqual(mock._mock_children, {'something': something}, | |
| 224 "children reset incorrectly") | |
| 225 self.assertEqual(mock.something, something, | |
| 226 "children incorrectly cleared") | |
| 227 self.assertFalse(mock.something.called, "child not reset") | |
| 228 | |
| 229 | |
| 230 def test_reset_mock_recursion(self): | |
| 231 mock = Mock() | |
| 232 mock.return_value = mock | |
| 233 | |
| 234 # used to cause recursion | |
| 235 mock.reset_mock() | |
| 236 | |
| 237 | |
| 238 def test_call(self): | |
| 239 mock = Mock() | |
| 240 self.assertTrue(is_instance(mock.return_value, Mock), | |
| 241 "Default return_value should be a Mock") | |
| 242 | |
| 243 result = mock() | |
| 244 self.assertEqual(mock(), result, | |
| 245 "different result from consecutive calls") | |
| 246 mock.reset_mock() | |
| 247 | |
| 248 ret_val = mock(sentinel.Arg) | |
| 249 self.assertTrue(mock.called, "called not set") | |
| 250 self.assertEqual(mock.call_count, 1, "call_count incoreect") | |
| 251 self.assertEqual(mock.call_args, ((sentinel.Arg,), {}), | |
| 252 "call_args not set") | |
| 253 self.assertEqual(mock.call_args_list, [((sentinel.Arg,), {})], | |
| 254 "call_args_list not initialised correctly") | |
| 255 | |
| 256 mock.return_value = sentinel.ReturnValue | |
| 257 ret_val = mock(sentinel.Arg, key=sentinel.KeyArg) | |
| 258 self.assertEqual(ret_val, sentinel.ReturnValue, | |
| 259 "incorrect return value") | |
| 260 | |
| 261 self.assertEqual(mock.call_count, 2, "call_count incorrect") | |
| 262 self.assertEqual(mock.call_args, | |
| 263 ((sentinel.Arg,), {'key': sentinel.KeyArg}), | |
| 264 "call_args not set") | |
| 265 self.assertEqual(mock.call_args_list, [ | |
| 266 ((sentinel.Arg,), {}), | |
| 267 ((sentinel.Arg,), {'key': sentinel.KeyArg}) | |
| 268 ], | |
| 269 "call_args_list not set") | |
| 270 | |
| 271 | |
| 272 def test_call_args_comparison(self): | |
| 273 mock = Mock() | |
| 274 mock() | |
| 275 mock(sentinel.Arg) | |
| 276 mock(kw=sentinel.Kwarg) | |
| 277 mock(sentinel.Arg, kw=sentinel.Kwarg) | |
| 278 self.assertEqual(mock.call_args_list, [ | |
| 279 (), | |
| 280 ((sentinel.Arg,),), | |
| 281 ({"kw": sentinel.Kwarg},), | |
| 282 ((sentinel.Arg,), {"kw": sentinel.Kwarg}) | |
| 283 ]) | |
| 284 self.assertEqual(mock.call_args, | |
| 285 ((sentinel.Arg,), {"kw": sentinel.Kwarg})) | |
| 286 | |
| 287 | |
| 288 def test_assert_called_with(self): | |
| 289 mock = Mock() | |
| 290 mock() | |
| 291 | |
| 292 # Will raise an exception if it fails | |
| 293 mock.assert_called_with() | |
| 294 self.assertRaises(AssertionError, mock.assert_called_with, 1) | |
| 295 | |
| 296 mock.reset_mock() | |
| 297 self.assertRaises(AssertionError, mock.assert_called_with) | |
| 298 | |
| 299 mock(1, 2, 3, a='fish', b='nothing') | |
| 300 mock.assert_called_with(1, 2, 3, a='fish', b='nothing') | |
| 301 | |
| 302 | |
| 303 def test_assert_called_once_with(self): | |
| 304 mock = Mock() | |
| 305 mock() | |
| 306 | |
| 307 # Will raise an exception if it fails | |
| 308 mock.assert_called_once_with() | |
| 309 | |
| 310 mock() | |
| 311 self.assertRaises(AssertionError, mock.assert_called_once_with) | |
| 312 | |
| 313 mock.reset_mock() | |
| 314 self.assertRaises(AssertionError, mock.assert_called_once_with) | |
| 315 | |
| 316 mock('foo', 'bar', baz=2) | |
| 317 mock.assert_called_once_with('foo', 'bar', baz=2) | |
| 318 | |
| 319 mock.reset_mock() | |
| 320 mock('foo', 'bar', baz=2) | |
| 321 self.assertRaises( | |
| 322 AssertionError, | |
| 323 lambda: mock.assert_called_once_with('bob', 'bar', baz=2) | |
| 324 ) | |
| 325 | |
| 326 | |
| 327 def test_attribute_access_returns_mocks(self): | |
| 328 mock = Mock() | |
| 329 something = mock.something | |
| 330 self.assertTrue(is_instance(something, Mock), "attribute isn't a mock") | |
| 331 self.assertEqual(mock.something, something, | |
| 332 "different attributes returned for same name") | |
| 333 | |
| 334 # Usage example | |
| 335 mock = Mock() | |
| 336 mock.something.return_value = 3 | |
| 337 | |
| 338 self.assertEqual(mock.something(), 3, "method returned wrong value") | |
| 339 self.assertTrue(mock.something.called, | |
| 340 "method didn't record being called") | |
| 341 | |
| 342 | |
| 343 def test_attributes_have_name_and_parent_set(self): | |
| 344 mock = Mock() | |
| 345 something = mock.something | |
| 346 | |
| 347 self.assertEqual(something._mock_name, "something", | |
| 348 "attribute name not set correctly") | |
| 349 self.assertEqual(something._mock_parent, mock, | |
| 350 "attribute parent not set correctly") | |
| 351 | |
| 352 | |
| 353 def test_method_calls_recorded(self): | |
| 354 mock = Mock() | |
| 355 mock.something(3, fish=None) | |
| 356 mock.something_else.something(6, cake=sentinel.Cake) | |
| 357 | |
| 358 self.assertEqual(mock.something_else.method_calls, | |
| 359 [("something", (6,), {'cake': sentinel.Cake})], | |
| 360 "method calls not recorded correctly") | |
| 361 self.assertEqual(mock.method_calls, [ | |
| 362 ("something", (3,), {'fish': None}), | |
| 363 ("something_else.something", (6,), {'cake': sentinel.Cake}) | |
| 364 ], | |
| 365 "method calls not recorded correctly") | |
| 366 | |
| 367 | |
| 368 def test_method_calls_compare_easily(self): | |
| 369 mock = Mock() | |
| 370 mock.something() | |
| 371 self.assertEqual(mock.method_calls, [('something',)]) | |
| 372 self.assertEqual(mock.method_calls, [('something', (), {})]) | |
| 373 | |
| 374 mock = Mock() | |
| 375 mock.something('different') | |
| 376 self.assertEqual(mock.method_calls, [('something', ('different',))]) | |
| 377 self.assertEqual(mock.method_calls, | |
| 378 [('something', ('different',), {})]) | |
| 379 | |
| 380 mock = Mock() | |
| 381 mock.something(x=1) | |
| 382 self.assertEqual(mock.method_calls, [('something', {'x': 1})]) | |
| 383 self.assertEqual(mock.method_calls, [('something', (), {'x': 1})]) | |
| 384 | |
| 385 mock = Mock() | |
| 386 mock.something('different', some='more') | |
| 387 self.assertEqual(mock.method_calls, [ | |
| 388 ('something', ('different',), {'some': 'more'}) | |
| 389 ]) | |
| 390 | |
| 391 | |
| 392 def test_only_allowed_methods_exist(self): | |
| 393 for spec in ['something'], ('something',): | |
| 394 for arg in 'spec', 'spec_set': | |
| 395 mock = Mock(**{arg: spec}) | |
| 396 | |
| 397 # this should be allowed | |
| 398 mock.something | |
| 399 self.assertRaisesRegexp( | |
| 400 AttributeError, | |
| 401 "Mock object has no attribute 'something_else'", | |
| 402 getattr, mock, 'something_else' | |
| 403 ) | |
| 404 | |
| 405 | |
| 406 def test_from_spec(self): | |
| 407 class Something(object): | |
| 408 x = 3 | |
| 409 __something__ = None | |
| 410 def y(self): | |
| 411 pass | |
| 412 | |
| 413 def test_attributes(mock): | |
| 414 # should work | |
| 415 mock.x | |
| 416 mock.y | |
| 417 mock.__something__ | |
| 418 self.assertRaisesRegexp( | |
| 419 AttributeError, | |
| 420 "Mock object has no attribute 'z'", | |
| 421 getattr, mock, 'z' | |
| 422 ) | |
| 423 self.assertRaisesRegexp( | |
| 424 AttributeError, | |
| 425 "Mock object has no attribute '__foobar__'", | |
| 426 getattr, mock, '__foobar__' | |
| 427 ) | |
| 428 | |
| 429 test_attributes(Mock(spec=Something)) | |
| 430 test_attributes(Mock(spec=Something())) | |
| 431 | |
| 432 | |
| 433 def test_wraps_calls(self): | |
| 434 real = Mock() | |
| 435 | |
| 436 mock = Mock(wraps=real) | |
| 437 self.assertEqual(mock(), real()) | |
| 438 | |
| 439 real.reset_mock() | |
| 440 | |
| 441 mock(1, 2, fish=3) | |
| 442 real.assert_called_with(1, 2, fish=3) | |
| 443 | |
| 444 | |
| 445 def test_wraps_call_with_nondefault_return_value(self): | |
| 446 real = Mock() | |
| 447 | |
| 448 mock = Mock(wraps=real) | |
| 449 mock.return_value = 3 | |
| 450 | |
| 451 self.assertEqual(mock(), 3) | |
| 452 self.assertFalse(real.called) | |
| 453 | |
| 454 | |
| 455 def test_wraps_attributes(self): | |
| 456 class Real(object): | |
| 457 attribute = Mock() | |
| 458 | |
| 459 real = Real() | |
| 460 | |
| 461 mock = Mock(wraps=real) | |
| 462 self.assertEqual(mock.attribute(), real.attribute()) | |
| 463 self.assertRaises(AttributeError, lambda: mock.fish) | |
| 464 | |
| 465 self.assertNotEqual(mock.attribute, real.attribute) | |
| 466 result = mock.attribute.frog(1, 2, fish=3) | |
| 467 Real.attribute.frog.assert_called_with(1, 2, fish=3) | |
| 468 self.assertEqual(result, Real.attribute.frog()) | |
| 469 | |
| 470 | |
| 471 def test_exceptional_side_effect(self): | |
| 472 mock = Mock(side_effect=AttributeError) | |
| 473 self.assertRaises(AttributeError, mock) | |
| 474 | |
| 475 mock = Mock(side_effect=AttributeError('foo')) | |
| 476 self.assertRaises(AttributeError, mock) | |
| 477 | |
| 478 | |
| 479 def test_baseexceptional_side_effect(self): | |
| 480 mock = Mock(side_effect=KeyboardInterrupt) | |
| 481 self.assertRaises(KeyboardInterrupt, mock) | |
| 482 | |
| 483 mock = Mock(side_effect=KeyboardInterrupt('foo')) | |
| 484 self.assertRaises(KeyboardInterrupt, mock) | |
| 485 | |
| 486 | |
| 487 def test_assert_called_with_message(self): | |
| 488 mock = Mock() | |
| 489 self.assertRaisesRegexp(AssertionError, 'Not called', | |
| 490 mock.assert_called_with) | |
| 491 | |
| 492 | |
| 493 def test__name__(self): | |
| 494 mock = Mock() | |
| 495 self.assertRaises(AttributeError, lambda: mock.__name__) | |
| 496 | |
| 497 mock.__name__ = 'foo' | |
| 498 self.assertEqual(mock.__name__, 'foo') | |
| 499 | |
| 500 | |
| 501 def test_spec_list_subclass(self): | |
| 502 class Sub(list): | |
| 503 pass | |
| 504 mock = Mock(spec=Sub(['foo'])) | |
| 505 | |
| 506 mock.append(3) | |
| 507 mock.append.assert_called_with(3) | |
| 508 self.assertRaises(AttributeError, getattr, mock, 'foo') | |
| 509 | |
| 510 | |
| 511 def test_spec_class(self): | |
| 512 class X(object): | |
| 513 pass | |
| 514 | |
| 515 mock = Mock(spec=X) | |
| 516 self.assertTrue(isinstance(mock, X)) | |
| 517 | |
| 518 mock = Mock(spec=X()) | |
| 519 self.assertTrue(isinstance(mock, X)) | |
| 520 | |
| 521 self.assertIs(mock.__class__, X) | |
| 522 self.assertEqual(Mock().__class__.__name__, 'Mock') | |
| 523 | |
| 524 mock = Mock(spec_set=X) | |
| 525 self.assertTrue(isinstance(mock, X)) | |
| 526 | |
| 527 mock = Mock(spec_set=X()) | |
| 528 self.assertTrue(isinstance(mock, X)) | |
| 529 | |
| 530 | |
| 531 def test_setting_attribute_with_spec_set(self): | |
| 532 class X(object): | |
| 533 y = 3 | |
| 534 | |
| 535 mock = Mock(spec=X) | |
| 536 mock.x = 'foo' | |
| 537 | |
| 538 mock = Mock(spec_set=X) | |
| 539 def set_attr(): | |
| 540 mock.x = 'foo' | |
| 541 | |
| 542 mock.y = 'foo' | |
| 543 self.assertRaises(AttributeError, set_attr) | |
| 544 | |
| 545 | |
| 546 def test_copy(self): | |
| 547 current = sys.getrecursionlimit() | |
| 548 self.addCleanup(sys.setrecursionlimit, current) | |
| 549 | |
| 550 # can't use sys.maxint as this doesn't exist in Python 3 | |
| 551 sys.setrecursionlimit(int(10e8)) | |
| 552 # this segfaults without the fix in place | |
| 553 copy.copy(Mock()) | |
| 554 | |
| 555 | |
| 556 @unittest2.skipIf(inPy3k, "no old style classes in Python 3") | |
| 557 def test_spec_old_style_classes(self): | |
| 558 class Foo: | |
| 559 bar = 7 | |
| 560 | |
| 561 mock = Mock(spec=Foo) | |
| 562 mock.bar = 6 | |
| 563 self.assertRaises(AttributeError, lambda: mock.foo) | |
| 564 | |
| 565 mock = Mock(spec=Foo()) | |
| 566 mock.bar = 6 | |
| 567 self.assertRaises(AttributeError, lambda: mock.foo) | |
| 568 | |
| 569 | |
| 570 @unittest2.skipIf(inPy3k, "no old style classes in Python 3") | |
| 571 def test_spec_set_old_style_classes(self): | |
| 572 class Foo: | |
| 573 bar = 7 | |
| 574 | |
| 575 mock = Mock(spec_set=Foo) | |
| 576 mock.bar = 6 | |
| 577 self.assertRaises(AttributeError, lambda: mock.foo) | |
| 578 | |
| 579 def _set(): | |
| 580 mock.foo = 3 | |
| 581 self.assertRaises(AttributeError, _set) | |
| 582 | |
| 583 mock = Mock(spec_set=Foo()) | |
| 584 mock.bar = 6 | |
| 585 self.assertRaises(AttributeError, lambda: mock.foo) | |
| 586 | |
| 587 def _set(): | |
| 588 mock.foo = 3 | |
| 589 self.assertRaises(AttributeError, _set) | |
| 590 | |
| 591 | |
| 592 def test_subclass_with_properties(self): | |
| 593 class SubClass(Mock): | |
| 594 def _get(self): | |
| 595 return 3 | |
| 596 def _set(self, value): | |
| 597 raise NameError('strange error') | |
| 598 some_attribute = property(_get, _set) | |
| 599 | |
| 600 s = SubClass(spec_set=SubClass) | |
| 601 self.assertEqual(s.some_attribute, 3) | |
| 602 | |
| 603 def test(): | |
| 604 s.some_attribute = 3 | |
| 605 self.assertRaises(NameError, test) | |
| 606 | |
| 607 def test(): | |
| 608 s.foo = 'bar' | |
| 609 self.assertRaises(AttributeError, test) | |
| 610 | |
| 611 | |
| 612 def test_setting_call(self): | |
| 613 mock = Mock() | |
| 614 def __call__(self, a): | |
| 615 return self._mock_call(a) | |
| 616 | |
| 617 type(mock).__call__ = __call__ | |
| 618 mock('one') | |
| 619 mock.assert_called_with('one') | |
| 620 | |
| 621 self.assertRaises(TypeError, mock, 'one', 'two') | |
| 622 | |
| 623 | |
| 624 @unittest2.skipUnless(sys.version_info[:2] >= (2, 6), | |
| 625 "__dir__ not available until Python 2.6 or later") | |
| 626 def test_dir(self): | |
| 627 mock = Mock() | |
| 628 attrs = set(dir(mock)) | |
| 629 type_attrs = set([m for m in dir(Mock) if not m.startswith('_')]) | |
| 630 | |
| 631 # all public attributes from the type are included | |
| 632 self.assertEqual(set(), type_attrs - attrs) | |
| 633 | |
| 634 # creates these attributes | |
| 635 mock.a, mock.b | |
| 636 self.assertIn('a', dir(mock)) | |
| 637 self.assertIn('b', dir(mock)) | |
| 638 | |
| 639 # instance attributes | |
| 640 mock.c = mock.d = None | |
| 641 self.assertIn('c', dir(mock)) | |
| 642 self.assertIn('d', dir(mock)) | |
| 643 | |
| 644 # magic methods | |
| 645 mock.__iter__ = lambda s: iter([]) | |
| 646 self.assertIn('__iter__', dir(mock)) | |
| 647 | |
| 648 | |
| 649 @unittest2.skipUnless(sys.version_info[:2] >= (2, 6), | |
| 650 "__dir__ not available until Python 2.6 or later") | |
| 651 def test_dir_from_spec(self): | |
| 652 mock = Mock(spec=unittest2.TestCase) | |
| 653 testcase_attrs = set(dir(unittest2.TestCase)) | |
| 654 attrs = set(dir(mock)) | |
| 655 | |
| 656 # all attributes from the spec are included | |
| 657 self.assertEqual(set(), testcase_attrs - attrs) | |
| 658 | |
| 659 # shadow a sys attribute | |
| 660 mock.version = 3 | |
| 661 self.assertEqual(dir(mock).count('version'), 1) | |
| 662 | |
| 663 | |
| 664 @unittest2.skipUnless(sys.version_info[:2] >= (2, 6), | |
| 665 "__dir__ not available until Python 2.6 or later") | |
| 666 def test_filter_dir(self): | |
| 667 patcher = patch.object(mock, 'FILTER_DIR', False) | |
| 668 patcher.start() | |
| 669 try: | |
| 670 attrs = set(dir(Mock())) | |
| 671 type_attrs = set(dir(Mock)) | |
| 672 | |
| 673 # ALL attributes from the type are included | |
| 674 self.assertEqual(set(), type_attrs - attrs) | |
| 675 finally: | |
| 676 patcher.stop() | |
| 677 | |
| 678 | |
| 679 def test_configure_mock(self): | |
| 680 mock = Mock(foo='bar') | |
| 681 self.assertEqual(mock.foo, 'bar') | |
| 682 | |
| 683 mock = MagicMock(foo='bar') | |
| 684 self.assertEqual(mock.foo, 'bar') | |
| 685 | |
| 686 kwargs = {'side_effect': KeyError, 'foo.bar.return_value': 33, | |
| 687 'foo': MagicMock()} | |
| 688 mock = Mock(**kwargs) | |
| 689 self.assertRaises(KeyError, mock) | |
| 690 self.assertEqual(mock.foo.bar(), 33) | |
| 691 self.assertIsInstance(mock.foo, MagicMock) | |
| 692 | |
| 693 mock = Mock() | |
| 694 mock.configure_mock(**kwargs) | |
| 695 self.assertRaises(KeyError, mock) | |
| 696 self.assertEqual(mock.foo.bar(), 33) | |
| 697 self.assertIsInstance(mock.foo, MagicMock) | |
| 698 | |
| 699 | |
| 700 def assertRaisesWithMsg(self, exception, message, func, *args, **kwargs): | |
| 701 # needed because assertRaisesRegex doesn't work easily with newlines | |
| 702 try: | |
| 703 func(*args, **kwargs) | |
| 704 except: | |
| 705 instance = sys.exc_info()[1] | |
| 706 self.assertIsInstance(instance, exception) | |
| 707 else: | |
| 708 self.fail('Exception %r not raised' % (exception,)) | |
| 709 | |
| 710 msg = str(instance) | |
| 711 self.assertEqual(msg, message) | |
| 712 | |
| 713 | |
| 714 def test_assert_called_with_failure_message(self): | |
| 715 mock = NonCallableMock() | |
| 716 | |
| 717 expected = "mock(1, '2', 3, bar='foo')" | |
| 718 message = 'Expected call: %s\nNot called' | |
| 719 self.assertRaisesWithMsg( | |
| 720 AssertionError, message % (expected,), | |
| 721 mock.assert_called_with, 1, '2', 3, bar='foo' | |
| 722 ) | |
| 723 | |
| 724 mock.foo(1, '2', 3, foo='foo') | |
| 725 | |
| 726 | |
| 727 asserters = [ | |
| 728 mock.foo.assert_called_with, mock.foo.assert_called_once_with | |
| 729 ] | |
| 730 for meth in asserters: | |
| 731 actual = "foo(1, '2', 3, foo='foo')" | |
| 732 expected = "foo(1, '2', 3, bar='foo')" | |
| 733 message = 'Expected call: %s\nActual call: %s' | |
| 734 self.assertRaisesWithMsg( | |
| 735 AssertionError, message % (expected, actual), | |
| 736 meth, 1, '2', 3, bar='foo' | |
| 737 ) | |
| 738 | |
| 739 # just kwargs | |
| 740 for meth in asserters: | |
| 741 actual = "foo(1, '2', 3, foo='foo')" | |
| 742 expected = "foo(bar='foo')" | |
| 743 message = 'Expected call: %s\nActual call: %s' | |
| 744 self.assertRaisesWithMsg( | |
| 745 AssertionError, message % (expected, actual), | |
| 746 meth, bar='foo' | |
| 747 ) | |
| 748 | |
| 749 # just args | |
| 750 for meth in asserters: | |
| 751 actual = "foo(1, '2', 3, foo='foo')" | |
| 752 expected = "foo(1, 2, 3)" | |
| 753 message = 'Expected call: %s\nActual call: %s' | |
| 754 self.assertRaisesWithMsg( | |
| 755 AssertionError, message % (expected, actual), | |
| 756 meth, 1, 2, 3 | |
| 757 ) | |
| 758 | |
| 759 # empty | |
| 760 for meth in asserters: | |
| 761 actual = "foo(1, '2', 3, foo='foo')" | |
| 762 expected = "foo()" | |
| 763 message = 'Expected call: %s\nActual call: %s' | |
| 764 self.assertRaisesWithMsg( | |
| 765 AssertionError, message % (expected, actual), meth | |
| 766 ) | |
| 767 | |
| 768 | |
| 769 def test_mock_calls(self): | |
| 770 mock = MagicMock() | |
| 771 | |
| 772 # need to do this because MagicMock.mock_calls used to just return | |
| 773 # a MagicMock which also returned a MagicMock when __eq__ was called | |
| 774 self.assertIs(mock.mock_calls == [], True) | |
| 775 | |
| 776 mock = MagicMock() | |
| 777 mock() | |
| 778 expected = [('', (), {})] | |
| 779 self.assertEqual(mock.mock_calls, expected) | |
| 780 | |
| 781 mock.foo() | |
| 782 expected.append(call.foo()) | |
| 783 self.assertEqual(mock.mock_calls, expected) | |
| 784 # intermediate mock_calls work too | |
| 785 self.assertEqual(mock.foo.mock_calls, [('', (), {})]) | |
| 786 | |
| 787 mock = MagicMock() | |
| 788 mock().foo(1, 2, 3, a=4, b=5) | |
| 789 expected = [ | |
| 790 ('', (), {}), ('().foo', (1, 2, 3), dict(a=4, b=5)) | |
| 791 ] | |
| 792 self.assertEqual(mock.mock_calls, expected) | |
| 793 self.assertEqual(mock.return_value.foo.mock_calls, | |
| 794 [('', (1, 2, 3), dict(a=4, b=5))]) | |
| 795 self.assertEqual(mock.return_value.mock_calls, | |
| 796 [('foo', (1, 2, 3), dict(a=4, b=5))]) | |
| 797 | |
| 798 mock = MagicMock() | |
| 799 mock().foo.bar().baz() | |
| 800 expected = [ | |
| 801 ('', (), {}), ('().foo.bar', (), {}), | |
| 802 ('().foo.bar().baz', (), {}) | |
| 803 ] | |
| 804 self.assertEqual(mock.mock_calls, expected) | |
| 805 self.assertEqual(mock().mock_calls, | |
| 806 call.foo.bar().baz().call_list()) | |
| 807 | |
| 808 for kwargs in dict(), dict(name='bar'): | |
| 809 mock = MagicMock(**kwargs) | |
| 810 int(mock.foo) | |
| 811 expected = [('foo.__int__', (), {})] | |
| 812 self.assertEqual(mock.mock_calls, expected) | |
| 813 | |
| 814 mock = MagicMock(**kwargs) | |
| 815 mock.a()() | |
| 816 expected = [('a', (), {}), ('a()', (), {})] | |
| 817 self.assertEqual(mock.mock_calls, expected) | |
| 818 self.assertEqual(mock.a().mock_calls, [call()]) | |
| 819 | |
| 820 mock = MagicMock(**kwargs) | |
| 821 mock(1)(2)(3) | |
| 822 self.assertEqual(mock.mock_calls, call(1)(2)(3).call_list()) | |
| 823 self.assertEqual(mock().mock_calls, call(2)(3).call_list()) | |
| 824 self.assertEqual(mock()().mock_calls, call(3).call_list()) | |
| 825 | |
| 826 mock = MagicMock(**kwargs) | |
| 827 mock(1)(2)(3).a.b.c(4) | |
| 828 self.assertEqual(mock.mock_calls, | |
| 829 call(1)(2)(3).a.b.c(4).call_list()) | |
| 830 self.assertEqual(mock().mock_calls, | |
| 831 call(2)(3).a.b.c(4).call_list()) | |
| 832 self.assertEqual(mock()().mock_calls, | |
| 833 call(3).a.b.c(4).call_list()) | |
| 834 | |
| 835 mock = MagicMock(**kwargs) | |
| 836 int(mock().foo.bar().baz()) | |
| 837 last_call = ('().foo.bar().baz().__int__', (), {}) | |
| 838 self.assertEqual(mock.mock_calls[-1], last_call) | |
| 839 self.assertEqual(mock().mock_calls, | |
| 840 call.foo.bar().baz().__int__().call_list()) | |
| 841 self.assertEqual(mock().foo.bar().mock_calls, | |
| 842 call.baz().__int__().call_list()) | |
| 843 self.assertEqual(mock().foo.bar().baz.mock_calls, | |
| 844 call().__int__().call_list()) | |
| 845 | |
| 846 | |
| 847 def test_subclassing(self): | |
| 848 class Subclass(Mock): | |
| 849 pass | |
| 850 | |
| 851 mock = Subclass() | |
| 852 self.assertIsInstance(mock.foo, Subclass) | |
| 853 self.assertIsInstance(mock(), Subclass) | |
| 854 | |
| 855 class Subclass(Mock): | |
| 856 def _get_child_mock(self, **kwargs): | |
| 857 return Mock(**kwargs) | |
| 858 | |
| 859 mock = Subclass() | |
| 860 self.assertNotIsInstance(mock.foo, Subclass) | |
| 861 self.assertNotIsInstance(mock(), Subclass) | |
| 862 | |
| 863 | |
| 864 def test_arg_lists(self): | |
| 865 mocks = [ | |
| 866 Mock(), | |
| 867 MagicMock(), | |
| 868 NonCallableMock(), | |
| 869 NonCallableMagicMock() | |
| 870 ] | |
| 871 | |
| 872 def assert_attrs(mock): | |
| 873 names = 'call_args_list', 'method_calls', 'mock_calls' | |
| 874 for name in names: | |
| 875 attr = getattr(mock, name) | |
| 876 self.assertIsInstance(attr, _CallList) | |
| 877 self.assertIsInstance(attr, list) | |
| 878 self.assertEqual(attr, []) | |
| 879 | |
| 880 for mock in mocks: | |
| 881 assert_attrs(mock) | |
| 882 | |
| 883 if callable(mock): | |
| 884 mock() | |
| 885 mock(1, 2) | |
| 886 mock(a=3) | |
| 887 | |
| 888 mock.reset_mock() | |
| 889 assert_attrs(mock) | |
| 890 | |
| 891 mock.foo() | |
| 892 mock.foo.bar(1, a=3) | |
| 893 mock.foo(1).bar().baz(3) | |
| 894 | |
| 895 mock.reset_mock() | |
| 896 assert_attrs(mock) | |
| 897 | |
| 898 | |
| 899 def test_call_args_two_tuple(self): | |
| 900 mock = Mock() | |
| 901 mock(1, a=3) | |
| 902 mock(2, b=4) | |
| 903 | |
| 904 self.assertEqual(len(mock.call_args), 2) | |
| 905 args, kwargs = mock.call_args | |
| 906 self.assertEqual(args, (2,)) | |
| 907 self.assertEqual(kwargs, dict(b=4)) | |
| 908 | |
| 909 expected_list = [((1,), dict(a=3)), ((2,), dict(b=4))] | |
| 910 for expected, call_args in zip(expected_list, mock.call_args_list): | |
| 911 self.assertEqual(len(call_args), 2) | |
| 912 self.assertEqual(expected[0], call_args[0]) | |
| 913 self.assertEqual(expected[1], call_args[1]) | |
| 914 | |
| 915 | |
| 916 def test_side_effect_iterator(self): | |
| 917 mock = Mock(side_effect=iter([1, 2, 3])) | |
| 918 self.assertEqual([mock(), mock(), mock()], [1, 2, 3]) | |
| 919 self.assertRaises(StopIteration, mock) | |
| 920 | |
| 921 mock = MagicMock(side_effect=['a', 'b', 'c']) | |
| 922 self.assertEqual([mock(), mock(), mock()], ['a', 'b', 'c']) | |
| 923 self.assertRaises(StopIteration, mock) | |
| 924 | |
| 925 mock = Mock(side_effect='ghi') | |
| 926 self.assertEqual([mock(), mock(), mock()], ['g', 'h', 'i']) | |
| 927 self.assertRaises(StopIteration, mock) | |
| 928 | |
| 929 class Foo(object): | |
| 930 pass | |
| 931 mock = MagicMock(side_effect=Foo) | |
| 932 self.assertIsInstance(mock(), Foo) | |
| 933 | |
| 934 mock = Mock(side_effect=Iter()) | |
| 935 self.assertEqual([mock(), mock(), mock(), mock()], | |
| 936 ['this', 'is', 'an', 'iter']) | |
| 937 self.assertRaises(StopIteration, mock) | |
| 938 | |
| 939 | |
| 940 def test_side_effect_setting_iterator(self): | |
| 941 mock = Mock() | |
| 942 mock.side_effect = iter([1, 2, 3]) | |
| 943 self.assertEqual([mock(), mock(), mock()], [1, 2, 3]) | |
| 944 self.assertRaises(StopIteration, mock) | |
| 945 side_effect = mock.side_effect | |
| 946 self.assertIsInstance(side_effect, type(iter([]))) | |
| 947 | |
| 948 mock.side_effect = ['a', 'b', 'c'] | |
| 949 self.assertEqual([mock(), mock(), mock()], ['a', 'b', 'c']) | |
| 950 self.assertRaises(StopIteration, mock) | |
| 951 side_effect = mock.side_effect | |
| 952 self.assertIsInstance(side_effect, type(iter([]))) | |
| 953 | |
| 954 this_iter = Iter() | |
| 955 mock.side_effect = this_iter | |
| 956 self.assertEqual([mock(), mock(), mock(), mock()], | |
| 957 ['this', 'is', 'an', 'iter']) | |
| 958 self.assertRaises(StopIteration, mock) | |
| 959 self.assertIs(mock.side_effect, this_iter) | |
| 960 | |
| 961 | |
| 962 def test_side_effect_iterator_exceptions(self): | |
| 963 for Klass in Mock, MagicMock: | |
| 964 iterable = (ValueError, 3, KeyError, 6) | |
| 965 m = Klass(side_effect=iterable) | |
| 966 self.assertRaises(ValueError, m) | |
| 967 self.assertEqual(m(), 3) | |
| 968 self.assertRaises(KeyError, m) | |
| 969 self.assertEqual(m(), 6) | |
| 970 | |
| 971 | |
| 972 def test_assert_has_calls_any_order(self): | |
| 973 mock = Mock() | |
| 974 mock(1, 2) | |
| 975 mock(a=3) | |
| 976 mock(3, 4) | |
| 977 mock(b=6) | |
| 978 mock(b=6) | |
| 979 | |
| 980 kalls = [ | |
| 981 call(1, 2), ({'a': 3},), | |
| 982 ((3, 4),), ((), {'a': 3}), | |
| 983 ('', (1, 2)), ('', {'a': 3}), | |
| 984 ('', (1, 2), {}), ('', (), {'a': 3}) | |
| 985 ] | |
| 986 for kall in kalls: | |
| 987 mock.assert_has_calls([kall], any_order=True) | |
| 988 | |
| 989 for kall in call(1, '2'), call(b=3), call(), 3, None, 'foo': | |
| 990 self.assertRaises( | |
| 991 AssertionError, mock.assert_has_calls, | |
| 992 [kall], any_order=True | |
| 993 ) | |
| 994 | |
| 995 kall_lists = [ | |
| 996 [call(1, 2), call(b=6)], | |
| 997 [call(3, 4), call(1, 2)], | |
| 998 [call(b=6), call(b=6)], | |
| 999 ] | |
| 1000 | |
| 1001 for kall_list in kall_lists: | |
| 1002 mock.assert_has_calls(kall_list, any_order=True) | |
| 1003 | |
| 1004 kall_lists = [ | |
| 1005 [call(b=6), call(b=6), call(b=6)], | |
| 1006 [call(1, 2), call(1, 2)], | |
| 1007 [call(3, 4), call(1, 2), call(5, 7)], | |
| 1008 [call(b=6), call(3, 4), call(b=6), call(1, 2), call(b=6)], | |
| 1009 ] | |
| 1010 for kall_list in kall_lists: | |
| 1011 self.assertRaises( | |
| 1012 AssertionError, mock.assert_has_calls, | |
| 1013 kall_list, any_order=True | |
| 1014 ) | |
| 1015 | |
| 1016 def test_assert_has_calls(self): | |
| 1017 kalls1 = [ | |
| 1018 call(1, 2), ({'a': 3},), | |
| 1019 ((3, 4),), call(b=6), | |
| 1020 ('', (1,), {'b': 6}), | |
| 1021 ] | |
| 1022 kalls2 = [call.foo(), call.bar(1)] | |
| 1023 kalls2.extend(call.spam().baz(a=3).call_list()) | |
| 1024 kalls2.extend(call.bam(set(), foo={}).fish([1]).call_list()) | |
| 1025 | |
| 1026 mocks = [] | |
| 1027 for mock in Mock(), MagicMock(): | |
| 1028 mock(1, 2) | |
| 1029 mock(a=3) | |
| 1030 mock(3, 4) | |
| 1031 mock(b=6) | |
| 1032 mock(1, b=6) | |
| 1033 mocks.append((mock, kalls1)) | |
| 1034 | |
| 1035 mock = Mock() | |
| 1036 mock.foo() | |
| 1037 mock.bar(1) | |
| 1038 mock.spam().baz(a=3) | |
| 1039 mock.bam(set(), foo={}).fish([1]) | |
| 1040 mocks.append((mock, kalls2)) | |
| 1041 | |
| 1042 for mock, kalls in mocks: | |
| 1043 for i in range(len(kalls)): | |
| 1044 for step in 1, 2, 3: | |
| 1045 these = kalls[i:i+step] | |
| 1046 mock.assert_has_calls(these) | |
| 1047 | |
| 1048 if len(these) > 1: | |
| 1049 self.assertRaises( | |
| 1050 AssertionError, | |
| 1051 mock.assert_has_calls, | |
| 1052 list(reversed(these)) | |
| 1053 ) | |
| 1054 | |
| 1055 | |
| 1056 def test_assert_any_call(self): | |
| 1057 mock = Mock() | |
| 1058 mock(1, 2) | |
| 1059 mock(a=3) | |
| 1060 mock(1, b=6) | |
| 1061 | |
| 1062 mock.assert_any_call(1, 2) | |
| 1063 mock.assert_any_call(a=3) | |
| 1064 mock.assert_any_call(1, b=6) | |
| 1065 | |
| 1066 self.assertRaises( | |
| 1067 AssertionError, | |
| 1068 mock.assert_any_call | |
| 1069 ) | |
| 1070 self.assertRaises( | |
| 1071 AssertionError, | |
| 1072 mock.assert_any_call, | |
| 1073 1, 3 | |
| 1074 ) | |
| 1075 self.assertRaises( | |
| 1076 AssertionError, | |
| 1077 mock.assert_any_call, | |
| 1078 a=4 | |
| 1079 ) | |
| 1080 | |
| 1081 | |
| 1082 def test_mock_calls_create_autospec(self): | |
| 1083 def f(a, b): | |
| 1084 pass | |
| 1085 obj = Iter() | |
| 1086 obj.f = f | |
| 1087 | |
| 1088 funcs = [ | |
| 1089 create_autospec(f), | |
| 1090 create_autospec(obj).f | |
| 1091 ] | |
| 1092 for func in funcs: | |
| 1093 func(1, 2) | |
| 1094 func(3, 4) | |
| 1095 | |
| 1096 self.assertEqual( | |
| 1097 func.mock_calls, [call(1, 2), call(3, 4)] | |
| 1098 ) | |
| 1099 | |
| 1100 | |
| 1101 def test_mock_add_spec(self): | |
| 1102 class _One(object): | |
| 1103 one = 1 | |
| 1104 class _Two(object): | |
| 1105 two = 2 | |
| 1106 class Anything(object): | |
| 1107 one = two = three = 'four' | |
| 1108 | |
| 1109 klasses = [ | |
| 1110 Mock, MagicMock, NonCallableMock, NonCallableMagicMock | |
| 1111 ] | |
| 1112 for Klass in list(klasses): | |
| 1113 klasses.append(lambda K=Klass: K(spec=Anything)) | |
| 1114 klasses.append(lambda K=Klass: K(spec_set=Anything)) | |
| 1115 | |
| 1116 for Klass in klasses: | |
| 1117 for kwargs in dict(), dict(spec_set=True): | |
| 1118 mock = Klass() | |
| 1119 #no error | |
| 1120 mock.one, mock.two, mock.three | |
| 1121 | |
| 1122 for One, Two in [(_One, _Two), (['one'], ['two'])]: | |
| 1123 for kwargs in dict(), dict(spec_set=True): | |
| 1124 mock.mock_add_spec(One, **kwargs) | |
| 1125 | |
| 1126 mock.one | |
| 1127 self.assertRaises( | |
| 1128 AttributeError, getattr, mock, 'two' | |
| 1129 ) | |
| 1130 self.assertRaises( | |
| 1131 AttributeError, getattr, mock, 'three' | |
| 1132 ) | |
| 1133 if 'spec_set' in kwargs: | |
| 1134 self.assertRaises( | |
| 1135 AttributeError, setattr, mock, 'three', None | |
| 1136 ) | |
| 1137 | |
| 1138 mock.mock_add_spec(Two, **kwargs) | |
| 1139 self.assertRaises( | |
| 1140 AttributeError, getattr, mock, 'one' | |
| 1141 ) | |
| 1142 mock.two | |
| 1143 self.assertRaises( | |
| 1144 AttributeError, getattr, mock, 'three' | |
| 1145 ) | |
| 1146 if 'spec_set' in kwargs: | |
| 1147 self.assertRaises( | |
| 1148 AttributeError, setattr, mock, 'three', None | |
| 1149 ) | |
| 1150 # note that creating a mock, setting an instance attribute, and | |
| 1151 # *then* setting a spec doesn't work. Not the intended use case | |
| 1152 | |
| 1153 | |
| 1154 def test_mock_add_spec_magic_methods(self): | |
| 1155 for Klass in MagicMock, NonCallableMagicMock: | |
| 1156 mock = Klass() | |
| 1157 int(mock) | |
| 1158 | |
| 1159 mock.mock_add_spec(object) | |
| 1160 self.assertRaises(TypeError, int, mock) | |
| 1161 | |
| 1162 mock = Klass() | |
| 1163 mock['foo'] | |
| 1164 mock.__int__.return_value =4 | |
| 1165 | |
| 1166 mock.mock_add_spec(int) | |
| 1167 self.assertEqual(int(mock), 4) | |
| 1168 self.assertRaises(TypeError, lambda: mock['foo']) | |
| 1169 | |
| 1170 | |
| 1171 def test_adding_child_mock(self): | |
| 1172 for Klass in NonCallableMock, Mock, MagicMock, NonCallableMagicMock: | |
| 1173 mock = Klass() | |
| 1174 | |
| 1175 mock.foo = Mock() | |
| 1176 mock.foo() | |
| 1177 | |
| 1178 self.assertEqual(mock.method_calls, [call.foo()]) | |
| 1179 self.assertEqual(mock.mock_calls, [call.foo()]) | |
| 1180 | |
| 1181 mock = Klass() | |
| 1182 mock.bar = Mock(name='name') | |
| 1183 mock.bar() | |
| 1184 self.assertEqual(mock.method_calls, []) | |
| 1185 self.assertEqual(mock.mock_calls, []) | |
| 1186 | |
| 1187 # mock with an existing _new_parent but no name | |
| 1188 mock = Klass() | |
| 1189 mock.baz = MagicMock()() | |
| 1190 mock.baz() | |
| 1191 self.assertEqual(mock.method_calls, []) | |
| 1192 self.assertEqual(mock.mock_calls, []) | |
| 1193 | |
| 1194 | |
| 1195 def test_adding_return_value_mock(self): | |
| 1196 for Klass in Mock, MagicMock: | |
| 1197 mock = Klass() | |
| 1198 mock.return_value = MagicMock() | |
| 1199 | |
| 1200 mock()() | |
| 1201 self.assertEqual(mock.mock_calls, [call(), call()()]) | |
| 1202 | |
| 1203 | |
| 1204 def test_manager_mock(self): | |
| 1205 class Foo(object): | |
| 1206 one = 'one' | |
| 1207 two = 'two' | |
| 1208 manager = Mock() | |
| 1209 p1 = patch.object(Foo, 'one') | |
| 1210 p2 = patch.object(Foo, 'two') | |
| 1211 | |
| 1212 mock_one = p1.start() | |
| 1213 self.addCleanup(p1.stop) | |
| 1214 mock_two = p2.start() | |
| 1215 self.addCleanup(p2.stop) | |
| 1216 | |
| 1217 manager.attach_mock(mock_one, 'one') | |
| 1218 manager.attach_mock(mock_two, 'two') | |
| 1219 | |
| 1220 Foo.two() | |
| 1221 Foo.one() | |
| 1222 | |
| 1223 self.assertEqual(manager.mock_calls, [call.two(), call.one()]) | |
| 1224 | |
| 1225 | |
| 1226 def test_magic_methods_mock_calls(self): | |
| 1227 for Klass in Mock, MagicMock: | |
| 1228 m = Klass() | |
| 1229 m.__int__ = Mock(return_value=3) | |
| 1230 m.__float__ = MagicMock(return_value=3.0) | |
| 1231 int(m) | |
| 1232 float(m) | |
| 1233 | |
| 1234 self.assertEqual(m.mock_calls, [call.__int__(), call.__float__()]) | |
| 1235 self.assertEqual(m.method_calls, []) | |
| 1236 | |
| 1237 | |
| 1238 def test_attribute_deletion(self): | |
| 1239 # this behaviour isn't *useful*, but at least it's now tested... | |
| 1240 for Klass in Mock, MagicMock, NonCallableMagicMock, NonCallableMock: | |
| 1241 m = Klass() | |
| 1242 original = m.foo | |
| 1243 m.foo = 3 | |
| 1244 del m.foo | |
| 1245 self.assertEqual(m.foo, original) | |
| 1246 | |
| 1247 new = m.foo = Mock() | |
| 1248 del m.foo | |
| 1249 self.assertEqual(m.foo, new) | |
| 1250 | |
| 1251 | |
| 1252 def test_mock_parents(self): | |
| 1253 for Klass in Mock, MagicMock: | |
| 1254 m = Klass() | |
| 1255 original_repr = repr(m) | |
| 1256 m.return_value = m | |
| 1257 self.assertIs(m(), m) | |
| 1258 self.assertEqual(repr(m), original_repr) | |
| 1259 | |
| 1260 m.reset_mock() | |
| 1261 self.assertIs(m(), m) | |
| 1262 self.assertEqual(repr(m), original_repr) | |
| 1263 | |
| 1264 m = Klass() | |
| 1265 m.b = m.a | |
| 1266 self.assertIn("name='mock.a'", repr(m.b)) | |
| 1267 self.assertIn("name='mock.a'", repr(m.a)) | |
| 1268 m.reset_mock() | |
| 1269 self.assertIn("name='mock.a'", repr(m.b)) | |
| 1270 self.assertIn("name='mock.a'", repr(m.a)) | |
| 1271 | |
| 1272 m = Klass() | |
| 1273 original_repr = repr(m) | |
| 1274 m.a = m() | |
| 1275 m.a.return_value = m | |
| 1276 | |
| 1277 self.assertEqual(repr(m), original_repr) | |
| 1278 self.assertEqual(repr(m.a()), original_repr) | |
| 1279 | |
| 1280 | |
| 1281 def test_attach_mock(self): | |
| 1282 classes = Mock, MagicMock, NonCallableMagicMock, NonCallableMock | |
| 1283 for Klass in classes: | |
| 1284 for Klass2 in classes: | |
| 1285 m = Klass() | |
| 1286 | |
| 1287 m2 = Klass2(name='foo') | |
| 1288 m.attach_mock(m2, 'bar') | |
| 1289 | |
| 1290 self.assertIs(m.bar, m2) | |
| 1291 self.assertIn("name='mock.bar'", repr(m2)) | |
| 1292 | |
| 1293 m.bar.baz(1) | |
| 1294 self.assertEqual(m.mock_calls, [call.bar.baz(1)]) | |
| 1295 self.assertEqual(m.method_calls, [call.bar.baz(1)]) | |
| 1296 | |
| 1297 | |
| 1298 def test_attach_mock_return_value(self): | |
| 1299 classes = Mock, MagicMock, NonCallableMagicMock, NonCallableMock | |
| 1300 for Klass in Mock, MagicMock: | |
| 1301 for Klass2 in classes: | |
| 1302 m = Klass() | |
| 1303 | |
| 1304 m2 = Klass2(name='foo') | |
| 1305 m.attach_mock(m2, 'return_value') | |
| 1306 | |
| 1307 self.assertIs(m(), m2) | |
| 1308 self.assertIn("name='mock()'", repr(m2)) | |
| 1309 | |
| 1310 m2.foo() | |
| 1311 self.assertEqual(m.mock_calls, call().foo().call_list()) | |
| 1312 | |
| 1313 | |
| 1314 def test_attribute_deletion(self): | |
| 1315 for mock in Mock(), MagicMock(): | |
| 1316 self.assertTrue(hasattr(mock, 'm')) | |
| 1317 | |
| 1318 del mock.m | |
| 1319 self.assertFalse(hasattr(mock, 'm')) | |
| 1320 | |
| 1321 del mock.f | |
| 1322 self.assertFalse(hasattr(mock, 'f')) | |
| 1323 self.assertRaises(AttributeError, getattr, mock, 'f') | |
| 1324 | |
| 1325 | |
| 1326 def test_class_assignable(self): | |
| 1327 for mock in Mock(), MagicMock(): | |
| 1328 self.assertNotIsInstance(mock, int) | |
| 1329 | |
| 1330 mock.__class__ = int | |
| 1331 self.assertIsInstance(mock, int) | |
| 1332 | |
| 1333 | |
| 1334 @unittest2.expectedFailure | |
| 1335 def test_pickle(self): | |
| 1336 for Klass in (MagicMock, Mock, Subclass, NonCallableMagicMock): | |
| 1337 mock = Klass(name='foo', attribute=3) | |
| 1338 mock.foo(1, 2, 3) | |
| 1339 data = pickle.dumps(mock) | |
| 1340 new = pickle.loads(data) | |
| 1341 | |
| 1342 new.foo.assert_called_once_with(1, 2, 3) | |
| 1343 self.assertFalse(new.called) | |
| 1344 self.assertTrue(is_instance(new, Klass)) | |
| 1345 self.assertIsInstance(new, Thing) | |
| 1346 self.assertIn('name="foo"', repr(new)) | |
| 1347 self.assertEqual(new.attribute, 3) | |
| 1348 | |
| 1349 | |
| 1350 if __name__ == '__main__': | |
| 1351 unittest2.main() |
