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 5import os 6import sys 7 8import unittest 9from unittest.test.testmock import support 10from unittest.test.testmock.support import SomeClass, is_instance 11 12from test.test_importlib.util import uncache 13from unittest.mock import ( 14 NonCallableMock, CallableMixin, sentinel, 15 MagicMock, Mock, NonCallableMagicMock, patch, _patch, 16 DEFAULT, call, _get_target 17) 18 19 20builtin_string = 'builtins' 21 22PTModule = sys.modules[__name__] 23MODNAME = '%s.PTModule' % __name__ 24 25 26def _get_proxy(obj, get_only=True): 27 class Proxy(object): 28 def __getattr__(self, name): 29 return getattr(obj, name) 30 if not get_only: 31 def __setattr__(self, name, value): 32 setattr(obj, name, value) 33 def __delattr__(self, name): 34 delattr(obj, name) 35 Proxy.__setattr__ = __setattr__ 36 Proxy.__delattr__ = __delattr__ 37 return Proxy() 38 39 40# for use in the test 41something = sentinel.Something 42something_else = sentinel.SomethingElse 43 44 45class Foo(object): 46 def __init__(self, a): pass 47 def f(self, a): pass 48 def g(self): pass 49 foo = 'bar' 50 51 @staticmethod 52 def static_method(): pass 53 54 @classmethod 55 def class_method(cls): pass 56 57 class Bar(object): 58 def a(self): pass 59 60foo_name = '%s.Foo' % __name__ 61 62 63def function(a, b=Foo): pass 64 65 66class Container(object): 67 def __init__(self): 68 self.values = {} 69 70 def __getitem__(self, name): 71 return self.values[name] 72 73 def __setitem__(self, name, value): 74 self.values[name] = value 75 76 def __delitem__(self, name): 77 del self.values[name] 78 79 def __iter__(self): 80 return iter(self.values) 81 82 83 84class PatchTest(unittest.TestCase): 85 86 def assertNotCallable(self, obj, magic=True): 87 MockClass = NonCallableMagicMock 88 if not magic: 89 MockClass = NonCallableMock 90 91 self.assertRaises(TypeError, obj) 92 self.assertTrue(is_instance(obj, MockClass)) 93 self.assertFalse(is_instance(obj, CallableMixin)) 94 95 96 def test_single_patchobject(self): 97 class Something(object): 98 attribute = sentinel.Original 99 100 @patch.object(Something, 'attribute', sentinel.Patched) 101 def test(): 102 self.assertEqual(Something.attribute, sentinel.Patched, "unpatched") 103 104 test() 105 self.assertEqual(Something.attribute, sentinel.Original, 106 "patch not restored") 107 108 def test_patchobject_with_string_as_target(self): 109 msg = "'Something' must be the actual object to be patched, not a str" 110 with self.assertRaisesRegex(TypeError, msg): 111 patch.object('Something', 'do_something') 112 113 def test_patchobject_with_none(self): 114 class Something(object): 115 attribute = sentinel.Original 116 117 @patch.object(Something, 'attribute', None) 118 def test(): 119 self.assertIsNone(Something.attribute, "unpatched") 120 121 test() 122 self.assertEqual(Something.attribute, sentinel.Original, 123 "patch not restored") 124 125 126 def test_multiple_patchobject(self): 127 class Something(object): 128 attribute = sentinel.Original 129 next_attribute = sentinel.Original2 130 131 @patch.object(Something, 'attribute', sentinel.Patched) 132 @patch.object(Something, 'next_attribute', sentinel.Patched2) 133 def test(): 134 self.assertEqual(Something.attribute, sentinel.Patched, 135 "unpatched") 136 self.assertEqual(Something.next_attribute, sentinel.Patched2, 137 "unpatched") 138 139 test() 140 self.assertEqual(Something.attribute, sentinel.Original, 141 "patch not restored") 142 self.assertEqual(Something.next_attribute, sentinel.Original2, 143 "patch not restored") 144 145 146 def test_object_lookup_is_quite_lazy(self): 147 global something 148 original = something 149 @patch('%s.something' % __name__, sentinel.Something2) 150 def test(): 151 pass 152 153 try: 154 something = sentinel.replacement_value 155 test() 156 self.assertEqual(something, sentinel.replacement_value) 157 finally: 158 something = original 159 160 161 def test_patch(self): 162 @patch('%s.something' % __name__, sentinel.Something2) 163 def test(): 164 self.assertEqual(PTModule.something, sentinel.Something2, 165 "unpatched") 166 167 test() 168 self.assertEqual(PTModule.something, sentinel.Something, 169 "patch not restored") 170 171 @patch('%s.something' % __name__, sentinel.Something2) 172 @patch('%s.something_else' % __name__, sentinel.SomethingElse) 173 def test(): 174 self.assertEqual(PTModule.something, sentinel.Something2, 175 "unpatched") 176 self.assertEqual(PTModule.something_else, sentinel.SomethingElse, 177 "unpatched") 178 179 self.assertEqual(PTModule.something, sentinel.Something, 180 "patch not restored") 181 self.assertEqual(PTModule.something_else, sentinel.SomethingElse, 182 "patch not restored") 183 184 # Test the patching and restoring works a second time 185 test() 186 187 self.assertEqual(PTModule.something, sentinel.Something, 188 "patch not restored") 189 self.assertEqual(PTModule.something_else, sentinel.SomethingElse, 190 "patch not restored") 191 192 mock = Mock() 193 mock.return_value = sentinel.Handle 194 @patch('%s.open' % builtin_string, mock) 195 def test(): 196 self.assertEqual(open('filename', 'r'), sentinel.Handle, 197 "open not patched") 198 test() 199 test() 200 201 self.assertNotEqual(open, mock, "patch not restored") 202 203 204 def test_patch_class_attribute(self): 205 @patch('%s.SomeClass.class_attribute' % __name__, 206 sentinel.ClassAttribute) 207 def test(): 208 self.assertEqual(PTModule.SomeClass.class_attribute, 209 sentinel.ClassAttribute, "unpatched") 210 test() 211 212 self.assertIsNone(PTModule.SomeClass.class_attribute, 213 "patch not restored") 214 215 216 def test_patchobject_with_default_mock(self): 217 class Test(object): 218 something = sentinel.Original 219 something2 = sentinel.Original2 220 221 @patch.object(Test, 'something') 222 def test(mock): 223 self.assertEqual(mock, Test.something, 224 "Mock not passed into test function") 225 self.assertIsInstance(mock, MagicMock, 226 "patch with two arguments did not create a mock") 227 228 test() 229 230 @patch.object(Test, 'something') 231 @patch.object(Test, 'something2') 232 def test(this1, this2, mock1, mock2): 233 self.assertEqual(this1, sentinel.this1, 234 "Patched function didn't receive initial argument") 235 self.assertEqual(this2, sentinel.this2, 236 "Patched function didn't receive second argument") 237 self.assertEqual(mock1, Test.something2, 238 "Mock not passed into test function") 239 self.assertEqual(mock2, Test.something, 240 "Second Mock not passed into test function") 241 self.assertIsInstance(mock2, MagicMock, 242 "patch with two arguments did not create a mock") 243 self.assertIsInstance(mock2, MagicMock, 244 "patch with two arguments did not create a mock") 245 246 # A hack to test that new mocks are passed the second time 247 self.assertNotEqual(outerMock1, mock1, "unexpected value for mock1") 248 self.assertNotEqual(outerMock2, mock2, "unexpected value for mock1") 249 return mock1, mock2 250 251 outerMock1 = outerMock2 = None 252 outerMock1, outerMock2 = test(sentinel.this1, sentinel.this2) 253 254 # Test that executing a second time creates new mocks 255 test(sentinel.this1, sentinel.this2) 256 257 258 def test_patch_with_spec(self): 259 @patch('%s.SomeClass' % __name__, spec=SomeClass) 260 def test(MockSomeClass): 261 self.assertEqual(SomeClass, MockSomeClass) 262 self.assertTrue(is_instance(SomeClass.wibble, MagicMock)) 263 self.assertRaises(AttributeError, lambda: SomeClass.not_wibble) 264 265 test() 266 267 268 def test_patchobject_with_spec(self): 269 @patch.object(SomeClass, 'class_attribute', spec=SomeClass) 270 def test(MockAttribute): 271 self.assertEqual(SomeClass.class_attribute, MockAttribute) 272 self.assertTrue(is_instance(SomeClass.class_attribute.wibble, 273 MagicMock)) 274 self.assertRaises(AttributeError, 275 lambda: SomeClass.class_attribute.not_wibble) 276 277 test() 278 279 280 def test_patch_with_spec_as_list(self): 281 @patch('%s.SomeClass' % __name__, spec=['wibble']) 282 def test(MockSomeClass): 283 self.assertEqual(SomeClass, MockSomeClass) 284 self.assertTrue(is_instance(SomeClass.wibble, MagicMock)) 285 self.assertRaises(AttributeError, lambda: SomeClass.not_wibble) 286 287 test() 288 289 290 def test_patchobject_with_spec_as_list(self): 291 @patch.object(SomeClass, 'class_attribute', spec=['wibble']) 292 def test(MockAttribute): 293 self.assertEqual(SomeClass.class_attribute, MockAttribute) 294 self.assertTrue(is_instance(SomeClass.class_attribute.wibble, 295 MagicMock)) 296 self.assertRaises(AttributeError, 297 lambda: SomeClass.class_attribute.not_wibble) 298 299 test() 300 301 302 def test_nested_patch_with_spec_as_list(self): 303 # regression test for nested decorators 304 @patch('%s.open' % builtin_string) 305 @patch('%s.SomeClass' % __name__, spec=['wibble']) 306 def test(MockSomeClass, MockOpen): 307 self.assertEqual(SomeClass, MockSomeClass) 308 self.assertTrue(is_instance(SomeClass.wibble, MagicMock)) 309 self.assertRaises(AttributeError, lambda: SomeClass.not_wibble) 310 test() 311 312 313 def test_patch_with_spec_as_boolean(self): 314 @patch('%s.SomeClass' % __name__, spec=True) 315 def test(MockSomeClass): 316 self.assertEqual(SomeClass, MockSomeClass) 317 # Should not raise attribute error 318 MockSomeClass.wibble 319 320 self.assertRaises(AttributeError, lambda: MockSomeClass.not_wibble) 321 322 test() 323 324 325 def test_patch_object_with_spec_as_boolean(self): 326 @patch.object(PTModule, 'SomeClass', spec=True) 327 def test(MockSomeClass): 328 self.assertEqual(SomeClass, MockSomeClass) 329 # Should not raise attribute error 330 MockSomeClass.wibble 331 332 self.assertRaises(AttributeError, lambda: MockSomeClass.not_wibble) 333 334 test() 335 336 337 def test_patch_class_acts_with_spec_is_inherited(self): 338 @patch('%s.SomeClass' % __name__, spec=True) 339 def test(MockSomeClass): 340 self.assertTrue(is_instance(MockSomeClass, MagicMock)) 341 instance = MockSomeClass() 342 self.assertNotCallable(instance) 343 # Should not raise attribute error 344 instance.wibble 345 346 self.assertRaises(AttributeError, lambda: instance.not_wibble) 347 348 test() 349 350 351 def test_patch_with_create_mocks_non_existent_attributes(self): 352 @patch('%s.frooble' % builtin_string, sentinel.Frooble, create=True) 353 def test(): 354 self.assertEqual(frooble, sentinel.Frooble) 355 356 test() 357 self.assertRaises(NameError, lambda: frooble) 358 359 360 def test_patchobject_with_create_mocks_non_existent_attributes(self): 361 @patch.object(SomeClass, 'frooble', sentinel.Frooble, create=True) 362 def test(): 363 self.assertEqual(SomeClass.frooble, sentinel.Frooble) 364 365 test() 366 self.assertFalse(hasattr(SomeClass, 'frooble')) 367 368 369 def test_patch_wont_create_by_default(self): 370 with self.assertRaises(AttributeError): 371 @patch('%s.frooble' % builtin_string, sentinel.Frooble) 372 def test(): pass 373 374 test() 375 self.assertRaises(NameError, lambda: frooble) 376 377 378 def test_patchobject_wont_create_by_default(self): 379 with self.assertRaises(AttributeError): 380 @patch.object(SomeClass, 'ord', sentinel.Frooble) 381 def test(): pass 382 test() 383 self.assertFalse(hasattr(SomeClass, 'ord')) 384 385 386 def test_patch_builtins_without_create(self): 387 @patch(__name__+'.ord') 388 def test_ord(mock_ord): 389 mock_ord.return_value = 101 390 return ord('c') 391 392 @patch(__name__+'.open') 393 def test_open(mock_open): 394 m = mock_open.return_value 395 m.read.return_value = 'abcd' 396 397 fobj = open('doesnotexists.txt') 398 data = fobj.read() 399 fobj.close() 400 return data 401 402 self.assertEqual(test_ord(), 101) 403 self.assertEqual(test_open(), 'abcd') 404 405 406 def test_patch_with_static_methods(self): 407 class Foo(object): 408 @staticmethod 409 def woot(): 410 return sentinel.Static 411 412 @patch.object(Foo, 'woot', staticmethod(lambda: sentinel.Patched)) 413 def anonymous(): 414 self.assertEqual(Foo.woot(), sentinel.Patched) 415 anonymous() 416 417 self.assertEqual(Foo.woot(), sentinel.Static) 418 419 420 def test_patch_local(self): 421 foo = sentinel.Foo 422 @patch.object(sentinel, 'Foo', 'Foo') 423 def anonymous(): 424 self.assertEqual(sentinel.Foo, 'Foo') 425 anonymous() 426 427 self.assertEqual(sentinel.Foo, foo) 428 429 430 def test_patch_slots(self): 431 class Foo(object): 432 __slots__ = ('Foo',) 433 434 foo = Foo() 435 foo.Foo = sentinel.Foo 436 437 @patch.object(foo, 'Foo', 'Foo') 438 def anonymous(): 439 self.assertEqual(foo.Foo, 'Foo') 440 anonymous() 441 442 self.assertEqual(foo.Foo, sentinel.Foo) 443 444 445 def test_patchobject_class_decorator(self): 446 class Something(object): 447 attribute = sentinel.Original 448 449 class Foo(object): 450 def test_method(other_self): 451 self.assertEqual(Something.attribute, sentinel.Patched, 452 "unpatched") 453 def not_test_method(other_self): 454 self.assertEqual(Something.attribute, sentinel.Original, 455 "non-test method patched") 456 457 Foo = patch.object(Something, 'attribute', sentinel.Patched)(Foo) 458 459 f = Foo() 460 f.test_method() 461 f.not_test_method() 462 463 self.assertEqual(Something.attribute, sentinel.Original, 464 "patch not restored") 465 466 467 def test_patch_class_decorator(self): 468 class Something(object): 469 attribute = sentinel.Original 470 471 class Foo(object): 472 473 test_class_attr = 'whatever' 474 475 def test_method(other_self, mock_something): 476 self.assertEqual(PTModule.something, mock_something, 477 "unpatched") 478 def not_test_method(other_self): 479 self.assertEqual(PTModule.something, sentinel.Something, 480 "non-test method patched") 481 Foo = patch('%s.something' % __name__)(Foo) 482 483 f = Foo() 484 f.test_method() 485 f.not_test_method() 486 487 self.assertEqual(Something.attribute, sentinel.Original, 488 "patch not restored") 489 self.assertEqual(PTModule.something, sentinel.Something, 490 "patch not restored") 491 492 493 def test_patchobject_twice(self): 494 class Something(object): 495 attribute = sentinel.Original 496 next_attribute = sentinel.Original2 497 498 @patch.object(Something, 'attribute', sentinel.Patched) 499 @patch.object(Something, 'attribute', sentinel.Patched) 500 def test(): 501 self.assertEqual(Something.attribute, sentinel.Patched, "unpatched") 502 503 test() 504 505 self.assertEqual(Something.attribute, sentinel.Original, 506 "patch not restored") 507 508 509 def test_patch_dict(self): 510 foo = {'initial': object(), 'other': 'something'} 511 original = foo.copy() 512 513 @patch.dict(foo) 514 def test(): 515 foo['a'] = 3 516 del foo['initial'] 517 foo['other'] = 'something else' 518 519 test() 520 521 self.assertEqual(foo, original) 522 523 @patch.dict(foo, {'a': 'b'}) 524 def test(): 525 self.assertEqual(len(foo), 3) 526 self.assertEqual(foo['a'], 'b') 527 528 test() 529 530 self.assertEqual(foo, original) 531 532 @patch.dict(foo, [('a', 'b')]) 533 def test(): 534 self.assertEqual(len(foo), 3) 535 self.assertEqual(foo['a'], 'b') 536 537 test() 538 539 self.assertEqual(foo, original) 540 541 542 def test_patch_dict_with_container_object(self): 543 foo = Container() 544 foo['initial'] = object() 545 foo['other'] = 'something' 546 547 original = foo.values.copy() 548 549 @patch.dict(foo) 550 def test(): 551 foo['a'] = 3 552 del foo['initial'] 553 foo['other'] = 'something else' 554 555 test() 556 557 self.assertEqual(foo.values, original) 558 559 @patch.dict(foo, {'a': 'b'}) 560 def test(): 561 self.assertEqual(len(foo.values), 3) 562 self.assertEqual(foo['a'], 'b') 563 564 test() 565 566 self.assertEqual(foo.values, original) 567 568 569 def test_patch_dict_with_clear(self): 570 foo = {'initial': object(), 'other': 'something'} 571 original = foo.copy() 572 573 @patch.dict(foo, clear=True) 574 def test(): 575 self.assertEqual(foo, {}) 576 foo['a'] = 3 577 foo['other'] = 'something else' 578 579 test() 580 581 self.assertEqual(foo, original) 582 583 @patch.dict(foo, {'a': 'b'}, clear=True) 584 def test(): 585 self.assertEqual(foo, {'a': 'b'}) 586 587 test() 588 589 self.assertEqual(foo, original) 590 591 @patch.dict(foo, [('a', 'b')], clear=True) 592 def test(): 593 self.assertEqual(foo, {'a': 'b'}) 594 595 test() 596 597 self.assertEqual(foo, original) 598 599 600 def test_patch_dict_with_container_object_and_clear(self): 601 foo = Container() 602 foo['initial'] = object() 603 foo['other'] = 'something' 604 605 original = foo.values.copy() 606 607 @patch.dict(foo, clear=True) 608 def test(): 609 self.assertEqual(foo.values, {}) 610 foo['a'] = 3 611 foo['other'] = 'something else' 612 613 test() 614 615 self.assertEqual(foo.values, original) 616 617 @patch.dict(foo, {'a': 'b'}, clear=True) 618 def test(): 619 self.assertEqual(foo.values, {'a': 'b'}) 620 621 test() 622 623 self.assertEqual(foo.values, original) 624 625 626 def test_patch_dict_as_context_manager(self): 627 foo = {'a': 'b'} 628 with patch.dict(foo, a='c') as patched: 629 self.assertEqual(patched, {'a': 'c'}) 630 self.assertEqual(foo, {'a': 'b'}) 631 632 633 def test_name_preserved(self): 634 foo = {} 635 636 @patch('%s.SomeClass' % __name__, object()) 637 @patch('%s.SomeClass' % __name__, object(), autospec=True) 638 @patch.object(SomeClass, object()) 639 @patch.dict(foo) 640 def some_name(): pass 641 642 self.assertEqual(some_name.__name__, 'some_name') 643 644 645 def test_patch_with_exception(self): 646 foo = {} 647 648 @patch.dict(foo, {'a': 'b'}) 649 def test(): 650 raise NameError('Konrad') 651 652 with self.assertRaises(NameError): 653 test() 654 655 self.assertEqual(foo, {}) 656 657 658 def test_patch_dict_with_string(self): 659 @patch.dict('os.environ', {'konrad_delong': 'some value'}) 660 def test(): 661 self.assertIn('konrad_delong', os.environ) 662 663 test() 664 665 666 def test_patch_dict_decorator_resolution(self): 667 # bpo-35512: Ensure that patch with a string target resolves to 668 # the new dictionary during function call 669 original = support.target.copy() 670 671 @patch.dict('unittest.test.testmock.support.target', {'bar': 'BAR'}) 672 def test(): 673 self.assertEqual(support.target, {'foo': 'BAZ', 'bar': 'BAR'}) 674 675 try: 676 support.target = {'foo': 'BAZ'} 677 test() 678 self.assertEqual(support.target, {'foo': 'BAZ'}) 679 finally: 680 support.target = original 681 682 683 def test_patch_spec_set(self): 684 @patch('%s.SomeClass' % __name__, spec=SomeClass, spec_set=True) 685 def test(MockClass): 686 MockClass.z = 'foo' 687 688 self.assertRaises(AttributeError, test) 689 690 @patch.object(support, 'SomeClass', spec=SomeClass, spec_set=True) 691 def test(MockClass): 692 MockClass.z = 'foo' 693 694 self.assertRaises(AttributeError, test) 695 @patch('%s.SomeClass' % __name__, spec_set=True) 696 def test(MockClass): 697 MockClass.z = 'foo' 698 699 self.assertRaises(AttributeError, test) 700 701 @patch.object(support, 'SomeClass', spec_set=True) 702 def test(MockClass): 703 MockClass.z = 'foo' 704 705 self.assertRaises(AttributeError, test) 706 707 708 def test_spec_set_inherit(self): 709 @patch('%s.SomeClass' % __name__, spec_set=True) 710 def test(MockClass): 711 instance = MockClass() 712 instance.z = 'foo' 713 714 self.assertRaises(AttributeError, test) 715 716 717 def test_patch_start_stop(self): 718 original = something 719 patcher = patch('%s.something' % __name__) 720 self.assertIs(something, original) 721 mock = patcher.start() 722 try: 723 self.assertIsNot(mock, original) 724 self.assertIs(something, mock) 725 finally: 726 patcher.stop() 727 self.assertIs(something, original) 728 729 730 def test_stop_without_start(self): 731 # bpo-36366: calling stop without start will return None. 732 patcher = patch(foo_name, 'bar', 3) 733 self.assertIsNone(patcher.stop()) 734 735 736 def test_stop_idempotent(self): 737 # bpo-36366: calling stop on an already stopped patch will return None. 738 patcher = patch(foo_name, 'bar', 3) 739 740 patcher.start() 741 patcher.stop() 742 self.assertIsNone(patcher.stop()) 743 744 745 def test_patchobject_start_stop(self): 746 original = something 747 patcher = patch.object(PTModule, 'something', 'foo') 748 self.assertIs(something, original) 749 replaced = patcher.start() 750 try: 751 self.assertEqual(replaced, 'foo') 752 self.assertIs(something, replaced) 753 finally: 754 patcher.stop() 755 self.assertIs(something, original) 756 757 758 def test_patch_dict_start_stop(self): 759 d = {'foo': 'bar'} 760 original = d.copy() 761 patcher = patch.dict(d, [('spam', 'eggs')], clear=True) 762 self.assertEqual(d, original) 763 764 patcher.start() 765 try: 766 self.assertEqual(d, {'spam': 'eggs'}) 767 finally: 768 patcher.stop() 769 self.assertEqual(d, original) 770 771 772 def test_patch_dict_class_decorator(self): 773 this = self 774 d = {'spam': 'eggs'} 775 original = d.copy() 776 777 class Test(object): 778 def test_first(self): 779 this.assertEqual(d, {'foo': 'bar'}) 780 def test_second(self): 781 this.assertEqual(d, {'foo': 'bar'}) 782 783 Test = patch.dict(d, {'foo': 'bar'}, clear=True)(Test) 784 self.assertEqual(d, original) 785 786 test = Test() 787 788 test.test_first() 789 self.assertEqual(d, original) 790 791 test.test_second() 792 self.assertEqual(d, original) 793 794 test = Test() 795 796 test.test_first() 797 self.assertEqual(d, original) 798 799 test.test_second() 800 self.assertEqual(d, original) 801 802 803 def test_get_only_proxy(self): 804 class Something(object): 805 foo = 'foo' 806 class SomethingElse: 807 foo = 'foo' 808 809 for thing in Something, SomethingElse, Something(), SomethingElse: 810 proxy = _get_proxy(thing) 811 812 @patch.object(proxy, 'foo', 'bar') 813 def test(): 814 self.assertEqual(proxy.foo, 'bar') 815 test() 816 self.assertEqual(proxy.foo, 'foo') 817 self.assertEqual(thing.foo, 'foo') 818 self.assertNotIn('foo', proxy.__dict__) 819 820 821 def test_get_set_delete_proxy(self): 822 class Something(object): 823 foo = 'foo' 824 class SomethingElse: 825 foo = 'foo' 826 827 for thing in Something, SomethingElse, Something(), SomethingElse: 828 proxy = _get_proxy(Something, get_only=False) 829 830 @patch.object(proxy, 'foo', 'bar') 831 def test(): 832 self.assertEqual(proxy.foo, 'bar') 833 test() 834 self.assertEqual(proxy.foo, 'foo') 835 self.assertEqual(thing.foo, 'foo') 836 self.assertNotIn('foo', proxy.__dict__) 837 838 839 def test_patch_keyword_args(self): 840 kwargs = {'side_effect': KeyError, 'foo.bar.return_value': 33, 841 'foo': MagicMock()} 842 843 patcher = patch(foo_name, **kwargs) 844 mock = patcher.start() 845 patcher.stop() 846 847 self.assertRaises(KeyError, mock) 848 self.assertEqual(mock.foo.bar(), 33) 849 self.assertIsInstance(mock.foo, MagicMock) 850 851 852 def test_patch_object_keyword_args(self): 853 kwargs = {'side_effect': KeyError, 'foo.bar.return_value': 33, 854 'foo': MagicMock()} 855 856 patcher = patch.object(Foo, 'f', **kwargs) 857 mock = patcher.start() 858 patcher.stop() 859 860 self.assertRaises(KeyError, mock) 861 self.assertEqual(mock.foo.bar(), 33) 862 self.assertIsInstance(mock.foo, MagicMock) 863 864 865 def test_patch_dict_keyword_args(self): 866 original = {'foo': 'bar'} 867 copy = original.copy() 868 869 patcher = patch.dict(original, foo=3, bar=4, baz=5) 870 patcher.start() 871 872 try: 873 self.assertEqual(original, dict(foo=3, bar=4, baz=5)) 874 finally: 875 patcher.stop() 876 877 self.assertEqual(original, copy) 878 879 880 def test_autospec(self): 881 class Boo(object): 882 def __init__(self, a): pass 883 def f(self, a): pass 884 def g(self): pass 885 foo = 'bar' 886 887 class Bar(object): 888 def a(self): pass 889 890 def _test(mock): 891 mock(1) 892 mock.assert_called_with(1) 893 self.assertRaises(TypeError, mock) 894 895 def _test2(mock): 896 mock.f(1) 897 mock.f.assert_called_with(1) 898 self.assertRaises(TypeError, mock.f) 899 900 mock.g() 901 mock.g.assert_called_with() 902 self.assertRaises(TypeError, mock.g, 1) 903 904 self.assertRaises(AttributeError, getattr, mock, 'h') 905 906 mock.foo.lower() 907 mock.foo.lower.assert_called_with() 908 self.assertRaises(AttributeError, getattr, mock.foo, 'bar') 909 910 mock.Bar() 911 mock.Bar.assert_called_with() 912 913 mock.Bar.a() 914 mock.Bar.a.assert_called_with() 915 self.assertRaises(TypeError, mock.Bar.a, 1) 916 917 mock.Bar().a() 918 mock.Bar().a.assert_called_with() 919 self.assertRaises(TypeError, mock.Bar().a, 1) 920 921 self.assertRaises(AttributeError, getattr, mock.Bar, 'b') 922 self.assertRaises(AttributeError, getattr, mock.Bar(), 'b') 923 924 def function(mock): 925 _test(mock) 926 _test2(mock) 927 _test2(mock(1)) 928 self.assertIs(mock, Foo) 929 return mock 930 931 test = patch(foo_name, autospec=True)(function) 932 933 mock = test() 934 self.assertIsNot(Foo, mock) 935 # test patching a second time works 936 test() 937 938 module = sys.modules[__name__] 939 test = patch.object(module, 'Foo', autospec=True)(function) 940 941 mock = test() 942 self.assertIsNot(Foo, mock) 943 # test patching a second time works 944 test() 945 946 947 def test_autospec_function(self): 948 @patch('%s.function' % __name__, autospec=True) 949 def test(mock): 950 function.assert_not_called() 951 self.assertRaises(AssertionError, function.assert_called) 952 self.assertRaises(AssertionError, function.assert_called_once) 953 function(1) 954 self.assertRaises(AssertionError, function.assert_not_called) 955 function.assert_called_with(1) 956 function.assert_called() 957 function.assert_called_once() 958 function(2, 3) 959 function.assert_called_with(2, 3) 960 961 self.assertRaises(TypeError, function) 962 self.assertRaises(AttributeError, getattr, function, 'foo') 963 964 test() 965 966 967 def test_autospec_keywords(self): 968 @patch('%s.function' % __name__, autospec=True, 969 return_value=3) 970 def test(mock_function): 971 #self.assertEqual(function.abc, 'foo') 972 return function(1, 2) 973 974 result = test() 975 self.assertEqual(result, 3) 976 977 978 def test_autospec_staticmethod(self): 979 with patch('%s.Foo.static_method' % __name__, autospec=True) as method: 980 Foo.static_method() 981 method.assert_called_once_with() 982 983 984 def test_autospec_classmethod(self): 985 with patch('%s.Foo.class_method' % __name__, autospec=True) as method: 986 Foo.class_method() 987 method.assert_called_once_with() 988 989 990 def test_autospec_with_new(self): 991 patcher = patch('%s.function' % __name__, new=3, autospec=True) 992 self.assertRaises(TypeError, patcher.start) 993 994 module = sys.modules[__name__] 995 patcher = patch.object(module, 'function', new=3, autospec=True) 996 self.assertRaises(TypeError, patcher.start) 997 998 999 def test_autospec_with_object(self): 1000 class Bar(Foo): 1001 extra = [] 1002 1003 patcher = patch(foo_name, autospec=Bar) 1004 mock = patcher.start() 1005 try: 1006 self.assertIsInstance(mock, Bar) 1007 self.assertIsInstance(mock.extra, list) 1008 finally: 1009 patcher.stop() 1010 1011 1012 def test_autospec_inherits(self): 1013 FooClass = Foo 1014 patcher = patch(foo_name, autospec=True) 1015 mock = patcher.start() 1016 try: 1017 self.assertIsInstance(mock, FooClass) 1018 self.assertIsInstance(mock(3), FooClass) 1019 finally: 1020 patcher.stop() 1021 1022 1023 def test_autospec_name(self): 1024 patcher = patch(foo_name, autospec=True) 1025 mock = patcher.start() 1026 1027 try: 1028 self.assertIn(" name='Foo'", repr(mock)) 1029 self.assertIn(" name='Foo.f'", repr(mock.f)) 1030 self.assertIn(" name='Foo()'", repr(mock(None))) 1031 self.assertIn(" name='Foo().f'", repr(mock(None).f)) 1032 finally: 1033 patcher.stop() 1034 1035 1036 def test_tracebacks(self): 1037 @patch.object(Foo, 'f', object()) 1038 def test(): 1039 raise AssertionError 1040 try: 1041 test() 1042 except: 1043 err = sys.exc_info() 1044 1045 result = unittest.TextTestResult(None, None, 0) 1046 traceback = result._exc_info_to_string(err, self) 1047 self.assertIn('raise AssertionError', traceback) 1048 1049 1050 def test_new_callable_patch(self): 1051 patcher = patch(foo_name, new_callable=NonCallableMagicMock) 1052 1053 m1 = patcher.start() 1054 patcher.stop() 1055 m2 = patcher.start() 1056 patcher.stop() 1057 1058 self.assertIsNot(m1, m2) 1059 for mock in m1, m2: 1060 self.assertNotCallable(m1) 1061 1062 1063 def test_new_callable_patch_object(self): 1064 patcher = patch.object(Foo, 'f', new_callable=NonCallableMagicMock) 1065 1066 m1 = patcher.start() 1067 patcher.stop() 1068 m2 = patcher.start() 1069 patcher.stop() 1070 1071 self.assertIsNot(m1, m2) 1072 for mock in m1, m2: 1073 self.assertNotCallable(m1) 1074 1075 1076 def test_new_callable_keyword_arguments(self): 1077 class Bar(object): 1078 kwargs = None 1079 def __init__(self, **kwargs): 1080 Bar.kwargs = kwargs 1081 1082 patcher = patch(foo_name, new_callable=Bar, arg1=1, arg2=2) 1083 m = patcher.start() 1084 try: 1085 self.assertIs(type(m), Bar) 1086 self.assertEqual(Bar.kwargs, dict(arg1=1, arg2=2)) 1087 finally: 1088 patcher.stop() 1089 1090 1091 def test_new_callable_spec(self): 1092 class Bar(object): 1093 kwargs = None 1094 def __init__(self, **kwargs): 1095 Bar.kwargs = kwargs 1096 1097 patcher = patch(foo_name, new_callable=Bar, spec=Bar) 1098 patcher.start() 1099 try: 1100 self.assertEqual(Bar.kwargs, dict(spec=Bar)) 1101 finally: 1102 patcher.stop() 1103 1104 patcher = patch(foo_name, new_callable=Bar, spec_set=Bar) 1105 patcher.start() 1106 try: 1107 self.assertEqual(Bar.kwargs, dict(spec_set=Bar)) 1108 finally: 1109 patcher.stop() 1110 1111 1112 def test_new_callable_create(self): 1113 non_existent_attr = '%s.weeeee' % foo_name 1114 p = patch(non_existent_attr, new_callable=NonCallableMock) 1115 self.assertRaises(AttributeError, p.start) 1116 1117 p = patch(non_existent_attr, new_callable=NonCallableMock, 1118 create=True) 1119 m = p.start() 1120 try: 1121 self.assertNotCallable(m, magic=False) 1122 finally: 1123 p.stop() 1124 1125 1126 def test_new_callable_incompatible_with_new(self): 1127 self.assertRaises( 1128 ValueError, patch, foo_name, new=object(), new_callable=MagicMock 1129 ) 1130 self.assertRaises( 1131 ValueError, patch.object, Foo, 'f', new=object(), 1132 new_callable=MagicMock 1133 ) 1134 1135 1136 def test_new_callable_incompatible_with_autospec(self): 1137 self.assertRaises( 1138 ValueError, patch, foo_name, new_callable=MagicMock, 1139 autospec=True 1140 ) 1141 self.assertRaises( 1142 ValueError, patch.object, Foo, 'f', new_callable=MagicMock, 1143 autospec=True 1144 ) 1145 1146 1147 def test_new_callable_inherit_for_mocks(self): 1148 class MockSub(Mock): 1149 pass 1150 1151 MockClasses = ( 1152 NonCallableMock, NonCallableMagicMock, MagicMock, Mock, MockSub 1153 ) 1154 for Klass in MockClasses: 1155 for arg in 'spec', 'spec_set': 1156 kwargs = {arg: True} 1157 p = patch(foo_name, new_callable=Klass, **kwargs) 1158 m = p.start() 1159 try: 1160 instance = m.return_value 1161 self.assertRaises(AttributeError, getattr, instance, 'x') 1162 finally: 1163 p.stop() 1164 1165 1166 def test_new_callable_inherit_non_mock(self): 1167 class NotAMock(object): 1168 def __init__(self, spec): 1169 self.spec = spec 1170 1171 p = patch(foo_name, new_callable=NotAMock, spec=True) 1172 m = p.start() 1173 try: 1174 self.assertTrue(is_instance(m, NotAMock)) 1175 self.assertRaises(AttributeError, getattr, m, 'return_value') 1176 finally: 1177 p.stop() 1178 1179 self.assertEqual(m.spec, Foo) 1180 1181 1182 def test_new_callable_class_decorating(self): 1183 test = self 1184 original = Foo 1185 class SomeTest(object): 1186 1187 def _test(self, mock_foo): 1188 test.assertIsNot(Foo, original) 1189 test.assertIs(Foo, mock_foo) 1190 test.assertIsInstance(Foo, SomeClass) 1191 1192 def test_two(self, mock_foo): 1193 self._test(mock_foo) 1194 def test_one(self, mock_foo): 1195 self._test(mock_foo) 1196 1197 SomeTest = patch(foo_name, new_callable=SomeClass)(SomeTest) 1198 SomeTest().test_one() 1199 SomeTest().test_two() 1200 self.assertIs(Foo, original) 1201 1202 1203 def test_patch_multiple(self): 1204 original_foo = Foo 1205 original_f = Foo.f 1206 original_g = Foo.g 1207 1208 patcher1 = patch.multiple(foo_name, f=1, g=2) 1209 patcher2 = patch.multiple(Foo, f=1, g=2) 1210 1211 for patcher in patcher1, patcher2: 1212 patcher.start() 1213 try: 1214 self.assertIs(Foo, original_foo) 1215 self.assertEqual(Foo.f, 1) 1216 self.assertEqual(Foo.g, 2) 1217 finally: 1218 patcher.stop() 1219 1220 self.assertIs(Foo, original_foo) 1221 self.assertEqual(Foo.f, original_f) 1222 self.assertEqual(Foo.g, original_g) 1223 1224 1225 @patch.multiple(foo_name, f=3, g=4) 1226 def test(): 1227 self.assertIs(Foo, original_foo) 1228 self.assertEqual(Foo.f, 3) 1229 self.assertEqual(Foo.g, 4) 1230 1231 test() 1232 1233 1234 def test_patch_multiple_no_kwargs(self): 1235 self.assertRaises(ValueError, patch.multiple, foo_name) 1236 self.assertRaises(ValueError, patch.multiple, Foo) 1237 1238 1239 def test_patch_multiple_create_mocks(self): 1240 original_foo = Foo 1241 original_f = Foo.f 1242 original_g = Foo.g 1243 1244 @patch.multiple(foo_name, f=DEFAULT, g=3, foo=DEFAULT) 1245 def test(f, foo): 1246 self.assertIs(Foo, original_foo) 1247 self.assertIs(Foo.f, f) 1248 self.assertEqual(Foo.g, 3) 1249 self.assertIs(Foo.foo, foo) 1250 self.assertTrue(is_instance(f, MagicMock)) 1251 self.assertTrue(is_instance(foo, MagicMock)) 1252 1253 test() 1254 self.assertEqual(Foo.f, original_f) 1255 self.assertEqual(Foo.g, original_g) 1256 1257 1258 def test_patch_multiple_create_mocks_different_order(self): 1259 original_f = Foo.f 1260 original_g = Foo.g 1261 1262 patcher = patch.object(Foo, 'f', 3) 1263 patcher.attribute_name = 'f' 1264 1265 other = patch.object(Foo, 'g', DEFAULT) 1266 other.attribute_name = 'g' 1267 patcher.additional_patchers = [other] 1268 1269 @patcher 1270 def test(g): 1271 self.assertIs(Foo.g, g) 1272 self.assertEqual(Foo.f, 3) 1273 1274 test() 1275 self.assertEqual(Foo.f, original_f) 1276 self.assertEqual(Foo.g, original_g) 1277 1278 1279 def test_patch_multiple_stacked_decorators(self): 1280 original_foo = Foo 1281 original_f = Foo.f 1282 original_g = Foo.g 1283 1284 @patch.multiple(foo_name, f=DEFAULT) 1285 @patch.multiple(foo_name, foo=DEFAULT) 1286 @patch(foo_name + '.g') 1287 def test1(g, **kwargs): 1288 _test(g, **kwargs) 1289 1290 @patch.multiple(foo_name, f=DEFAULT) 1291 @patch(foo_name + '.g') 1292 @patch.multiple(foo_name, foo=DEFAULT) 1293 def test2(g, **kwargs): 1294 _test(g, **kwargs) 1295 1296 @patch(foo_name + '.g') 1297 @patch.multiple(foo_name, f=DEFAULT) 1298 @patch.multiple(foo_name, foo=DEFAULT) 1299 def test3(g, **kwargs): 1300 _test(g, **kwargs) 1301 1302 def _test(g, **kwargs): 1303 f = kwargs.pop('f') 1304 foo = kwargs.pop('foo') 1305 self.assertFalse(kwargs) 1306 1307 self.assertIs(Foo, original_foo) 1308 self.assertIs(Foo.f, f) 1309 self.assertIs(Foo.g, g) 1310 self.assertIs(Foo.foo, foo) 1311 self.assertTrue(is_instance(f, MagicMock)) 1312 self.assertTrue(is_instance(g, MagicMock)) 1313 self.assertTrue(is_instance(foo, MagicMock)) 1314 1315 test1() 1316 test2() 1317 test3() 1318 self.assertEqual(Foo.f, original_f) 1319 self.assertEqual(Foo.g, original_g) 1320 1321 1322 def test_patch_multiple_create_mocks_patcher(self): 1323 original_foo = Foo 1324 original_f = Foo.f 1325 original_g = Foo.g 1326 1327 patcher = patch.multiple(foo_name, f=DEFAULT, g=3, foo=DEFAULT) 1328 1329 result = patcher.start() 1330 try: 1331 f = result['f'] 1332 foo = result['foo'] 1333 self.assertEqual(set(result), set(['f', 'foo'])) 1334 1335 self.assertIs(Foo, original_foo) 1336 self.assertIs(Foo.f, f) 1337 self.assertIs(Foo.foo, foo) 1338 self.assertTrue(is_instance(f, MagicMock)) 1339 self.assertTrue(is_instance(foo, MagicMock)) 1340 finally: 1341 patcher.stop() 1342 1343 self.assertEqual(Foo.f, original_f) 1344 self.assertEqual(Foo.g, original_g) 1345 1346 1347 def test_patch_multiple_decorating_class(self): 1348 test = self 1349 original_foo = Foo 1350 original_f = Foo.f 1351 original_g = Foo.g 1352 1353 class SomeTest(object): 1354 1355 def _test(self, f, foo): 1356 test.assertIs(Foo, original_foo) 1357 test.assertIs(Foo.f, f) 1358 test.assertEqual(Foo.g, 3) 1359 test.assertIs(Foo.foo, foo) 1360 test.assertTrue(is_instance(f, MagicMock)) 1361 test.assertTrue(is_instance(foo, MagicMock)) 1362 1363 def test_two(self, f, foo): 1364 self._test(f, foo) 1365 def test_one(self, f, foo): 1366 self._test(f, foo) 1367 1368 SomeTest = patch.multiple( 1369 foo_name, f=DEFAULT, g=3, foo=DEFAULT 1370 )(SomeTest) 1371 1372 thing = SomeTest() 1373 thing.test_one() 1374 thing.test_two() 1375 1376 self.assertEqual(Foo.f, original_f) 1377 self.assertEqual(Foo.g, original_g) 1378 1379 1380 def test_patch_multiple_create(self): 1381 patcher = patch.multiple(Foo, blam='blam') 1382 self.assertRaises(AttributeError, patcher.start) 1383 1384 patcher = patch.multiple(Foo, blam='blam', create=True) 1385 patcher.start() 1386 try: 1387 self.assertEqual(Foo.blam, 'blam') 1388 finally: 1389 patcher.stop() 1390 1391 self.assertFalse(hasattr(Foo, 'blam')) 1392 1393 1394 def test_patch_multiple_spec_set(self): 1395 # if spec_set works then we can assume that spec and autospec also 1396 # work as the underlying machinery is the same 1397 patcher = patch.multiple(Foo, foo=DEFAULT, spec_set=['a', 'b']) 1398 result = patcher.start() 1399 try: 1400 self.assertEqual(Foo.foo, result['foo']) 1401 Foo.foo.a(1) 1402 Foo.foo.b(2) 1403 Foo.foo.a.assert_called_with(1) 1404 Foo.foo.b.assert_called_with(2) 1405 self.assertRaises(AttributeError, setattr, Foo.foo, 'c', None) 1406 finally: 1407 patcher.stop() 1408 1409 1410 def test_patch_multiple_new_callable(self): 1411 class Thing(object): 1412 pass 1413 1414 patcher = patch.multiple( 1415 Foo, f=DEFAULT, g=DEFAULT, new_callable=Thing 1416 ) 1417 result = patcher.start() 1418 try: 1419 self.assertIs(Foo.f, result['f']) 1420 self.assertIs(Foo.g, result['g']) 1421 self.assertIsInstance(Foo.f, Thing) 1422 self.assertIsInstance(Foo.g, Thing) 1423 self.assertIsNot(Foo.f, Foo.g) 1424 finally: 1425 patcher.stop() 1426 1427 1428 def test_nested_patch_failure(self): 1429 original_f = Foo.f 1430 original_g = Foo.g 1431 1432 @patch.object(Foo, 'g', 1) 1433 @patch.object(Foo, 'missing', 1) 1434 @patch.object(Foo, 'f', 1) 1435 def thing1(): pass 1436 1437 @patch.object(Foo, 'missing', 1) 1438 @patch.object(Foo, 'g', 1) 1439 @patch.object(Foo, 'f', 1) 1440 def thing2(): pass 1441 1442 @patch.object(Foo, 'g', 1) 1443 @patch.object(Foo, 'f', 1) 1444 @patch.object(Foo, 'missing', 1) 1445 def thing3(): pass 1446 1447 for func in thing1, thing2, thing3: 1448 self.assertRaises(AttributeError, func) 1449 self.assertEqual(Foo.f, original_f) 1450 self.assertEqual(Foo.g, original_g) 1451 1452 1453 def test_new_callable_failure(self): 1454 original_f = Foo.f 1455 original_g = Foo.g 1456 original_foo = Foo.foo 1457 1458 def crasher(): 1459 raise NameError('crasher') 1460 1461 @patch.object(Foo, 'g', 1) 1462 @patch.object(Foo, 'foo', new_callable=crasher) 1463 @patch.object(Foo, 'f', 1) 1464 def thing1(): pass 1465 1466 @patch.object(Foo, 'foo', new_callable=crasher) 1467 @patch.object(Foo, 'g', 1) 1468 @patch.object(Foo, 'f', 1) 1469 def thing2(): pass 1470 1471 @patch.object(Foo, 'g', 1) 1472 @patch.object(Foo, 'f', 1) 1473 @patch.object(Foo, 'foo', new_callable=crasher) 1474 def thing3(): pass 1475 1476 for func in thing1, thing2, thing3: 1477 self.assertRaises(NameError, func) 1478 self.assertEqual(Foo.f, original_f) 1479 self.assertEqual(Foo.g, original_g) 1480 self.assertEqual(Foo.foo, original_foo) 1481 1482 1483 def test_patch_multiple_failure(self): 1484 original_f = Foo.f 1485 original_g = Foo.g 1486 1487 patcher = patch.object(Foo, 'f', 1) 1488 patcher.attribute_name = 'f' 1489 1490 good = patch.object(Foo, 'g', 1) 1491 good.attribute_name = 'g' 1492 1493 bad = patch.object(Foo, 'missing', 1) 1494 bad.attribute_name = 'missing' 1495 1496 for additionals in [good, bad], [bad, good]: 1497 patcher.additional_patchers = additionals 1498 1499 @patcher 1500 def func(): pass 1501 1502 self.assertRaises(AttributeError, func) 1503 self.assertEqual(Foo.f, original_f) 1504 self.assertEqual(Foo.g, original_g) 1505 1506 1507 def test_patch_multiple_new_callable_failure(self): 1508 original_f = Foo.f 1509 original_g = Foo.g 1510 original_foo = Foo.foo 1511 1512 def crasher(): 1513 raise NameError('crasher') 1514 1515 patcher = patch.object(Foo, 'f', 1) 1516 patcher.attribute_name = 'f' 1517 1518 good = patch.object(Foo, 'g', 1) 1519 good.attribute_name = 'g' 1520 1521 bad = patch.object(Foo, 'foo', new_callable=crasher) 1522 bad.attribute_name = 'foo' 1523 1524 for additionals in [good, bad], [bad, good]: 1525 patcher.additional_patchers = additionals 1526 1527 @patcher 1528 def func(): pass 1529 1530 self.assertRaises(NameError, func) 1531 self.assertEqual(Foo.f, original_f) 1532 self.assertEqual(Foo.g, original_g) 1533 self.assertEqual(Foo.foo, original_foo) 1534 1535 1536 def test_patch_multiple_string_subclasses(self): 1537 Foo = type('Foo', (str,), {'fish': 'tasty'}) 1538 foo = Foo() 1539 @patch.multiple(foo, fish='nearly gone') 1540 def test(): 1541 self.assertEqual(foo.fish, 'nearly gone') 1542 1543 test() 1544 self.assertEqual(foo.fish, 'tasty') 1545 1546 1547 @patch('unittest.mock.patch.TEST_PREFIX', 'foo') 1548 def test_patch_test_prefix(self): 1549 class Foo(object): 1550 thing = 'original' 1551 1552 def foo_one(self): 1553 return self.thing 1554 def foo_two(self): 1555 return self.thing 1556 def test_one(self): 1557 return self.thing 1558 def test_two(self): 1559 return self.thing 1560 1561 Foo = patch.object(Foo, 'thing', 'changed')(Foo) 1562 1563 foo = Foo() 1564 self.assertEqual(foo.foo_one(), 'changed') 1565 self.assertEqual(foo.foo_two(), 'changed') 1566 self.assertEqual(foo.test_one(), 'original') 1567 self.assertEqual(foo.test_two(), 'original') 1568 1569 1570 @patch('unittest.mock.patch.TEST_PREFIX', 'bar') 1571 def test_patch_dict_test_prefix(self): 1572 class Foo(object): 1573 def bar_one(self): 1574 return dict(the_dict) 1575 def bar_two(self): 1576 return dict(the_dict) 1577 def test_one(self): 1578 return dict(the_dict) 1579 def test_two(self): 1580 return dict(the_dict) 1581 1582 the_dict = {'key': 'original'} 1583 Foo = patch.dict(the_dict, key='changed')(Foo) 1584 1585 foo =Foo() 1586 self.assertEqual(foo.bar_one(), {'key': 'changed'}) 1587 self.assertEqual(foo.bar_two(), {'key': 'changed'}) 1588 self.assertEqual(foo.test_one(), {'key': 'original'}) 1589 self.assertEqual(foo.test_two(), {'key': 'original'}) 1590 1591 1592 def test_patch_with_spec_mock_repr(self): 1593 for arg in ('spec', 'autospec', 'spec_set'): 1594 p = patch('%s.SomeClass' % __name__, **{arg: True}) 1595 m = p.start() 1596 try: 1597 self.assertIn(" name='SomeClass'", repr(m)) 1598 self.assertIn(" name='SomeClass.class_attribute'", 1599 repr(m.class_attribute)) 1600 self.assertIn(" name='SomeClass()'", repr(m())) 1601 self.assertIn(" name='SomeClass().class_attribute'", 1602 repr(m().class_attribute)) 1603 finally: 1604 p.stop() 1605 1606 1607 def test_patch_nested_autospec_repr(self): 1608 with patch('unittest.test.testmock.support', autospec=True) as m: 1609 self.assertIn(" name='support.SomeClass.wibble()'", 1610 repr(m.SomeClass.wibble())) 1611 self.assertIn(" name='support.SomeClass().wibble()'", 1612 repr(m.SomeClass().wibble())) 1613 1614 1615 1616 def test_mock_calls_with_patch(self): 1617 for arg in ('spec', 'autospec', 'spec_set'): 1618 p = patch('%s.SomeClass' % __name__, **{arg: True}) 1619 m = p.start() 1620 try: 1621 m.wibble() 1622 1623 kalls = [call.wibble()] 1624 self.assertEqual(m.mock_calls, kalls) 1625 self.assertEqual(m.method_calls, kalls) 1626 self.assertEqual(m.wibble.mock_calls, [call()]) 1627 1628 result = m() 1629 kalls.append(call()) 1630 self.assertEqual(m.mock_calls, kalls) 1631 1632 result.wibble() 1633 kalls.append(call().wibble()) 1634 self.assertEqual(m.mock_calls, kalls) 1635 1636 self.assertEqual(result.mock_calls, [call.wibble()]) 1637 self.assertEqual(result.wibble.mock_calls, [call()]) 1638 self.assertEqual(result.method_calls, [call.wibble()]) 1639 finally: 1640 p.stop() 1641 1642 1643 def test_patch_imports_lazily(self): 1644 p1 = patch('squizz.squozz') 1645 self.assertRaises(ImportError, p1.start) 1646 1647 with uncache('squizz'): 1648 squizz = Mock() 1649 sys.modules['squizz'] = squizz 1650 1651 squizz.squozz = 6 1652 p1 = patch('squizz.squozz') 1653 squizz.squozz = 3 1654 p1.start() 1655 p1.stop() 1656 self.assertEqual(squizz.squozz, 3) 1657 1658 def test_patch_propagates_exc_on_exit(self): 1659 class holder: 1660 exc_info = None, None, None 1661 1662 class custom_patch(_patch): 1663 def __exit__(self, etype=None, val=None, tb=None): 1664 _patch.__exit__(self, etype, val, tb) 1665 holder.exc_info = etype, val, tb 1666 stop = __exit__ 1667 1668 def with_custom_patch(target): 1669 getter, attribute = _get_target(target) 1670 return custom_patch( 1671 getter, attribute, DEFAULT, None, False, None, 1672 None, None, {} 1673 ) 1674 1675 @with_custom_patch('squizz.squozz') 1676 def test(mock): 1677 raise RuntimeError 1678 1679 with uncache('squizz'): 1680 squizz = Mock() 1681 sys.modules['squizz'] = squizz 1682 1683 self.assertRaises(RuntimeError, test) 1684 1685 self.assertIs(holder.exc_info[0], RuntimeError) 1686 self.assertIsNotNone(holder.exc_info[1], 1687 'exception value not propagated') 1688 self.assertIsNotNone(holder.exc_info[2], 1689 'exception traceback not propagated') 1690 1691 1692 def test_create_and_specs(self): 1693 for kwarg in ('spec', 'spec_set', 'autospec'): 1694 p = patch('%s.doesnotexist' % __name__, create=True, 1695 **{kwarg: True}) 1696 self.assertRaises(TypeError, p.start) 1697 self.assertRaises(NameError, lambda: doesnotexist) 1698 1699 # check that spec with create is innocuous if the original exists 1700 p = patch(MODNAME, create=True, **{kwarg: True}) 1701 p.start() 1702 p.stop() 1703 1704 1705 def test_multiple_specs(self): 1706 original = PTModule 1707 for kwarg in ('spec', 'spec_set'): 1708 p = patch(MODNAME, autospec=0, **{kwarg: 0}) 1709 self.assertRaises(TypeError, p.start) 1710 self.assertIs(PTModule, original) 1711 1712 for kwarg in ('spec', 'autospec'): 1713 p = patch(MODNAME, spec_set=0, **{kwarg: 0}) 1714 self.assertRaises(TypeError, p.start) 1715 self.assertIs(PTModule, original) 1716 1717 for kwarg in ('spec_set', 'autospec'): 1718 p = patch(MODNAME, spec=0, **{kwarg: 0}) 1719 self.assertRaises(TypeError, p.start) 1720 self.assertIs(PTModule, original) 1721 1722 1723 def test_specs_false_instead_of_none(self): 1724 p = patch(MODNAME, spec=False, spec_set=False, autospec=False) 1725 mock = p.start() 1726 try: 1727 # no spec should have been set, so attribute access should not fail 1728 mock.does_not_exist 1729 mock.does_not_exist = 3 1730 finally: 1731 p.stop() 1732 1733 1734 def test_falsey_spec(self): 1735 for kwarg in ('spec', 'autospec', 'spec_set'): 1736 p = patch(MODNAME, **{kwarg: 0}) 1737 m = p.start() 1738 try: 1739 self.assertRaises(AttributeError, getattr, m, 'doesnotexit') 1740 finally: 1741 p.stop() 1742 1743 1744 def test_spec_set_true(self): 1745 for kwarg in ('spec', 'autospec'): 1746 p = patch(MODNAME, spec_set=True, **{kwarg: True}) 1747 m = p.start() 1748 try: 1749 self.assertRaises(AttributeError, setattr, m, 1750 'doesnotexist', 'something') 1751 self.assertRaises(AttributeError, getattr, m, 'doesnotexist') 1752 finally: 1753 p.stop() 1754 1755 1756 def test_callable_spec_as_list(self): 1757 spec = ('__call__',) 1758 p = patch(MODNAME, spec=spec) 1759 m = p.start() 1760 try: 1761 self.assertTrue(callable(m)) 1762 finally: 1763 p.stop() 1764 1765 1766 def test_not_callable_spec_as_list(self): 1767 spec = ('foo', 'bar') 1768 p = patch(MODNAME, spec=spec) 1769 m = p.start() 1770 try: 1771 self.assertFalse(callable(m)) 1772 finally: 1773 p.stop() 1774 1775 1776 def test_patch_stopall(self): 1777 unlink = os.unlink 1778 chdir = os.chdir 1779 path = os.path 1780 patch('os.unlink', something).start() 1781 patch('os.chdir', something_else).start() 1782 1783 @patch('os.path') 1784 def patched(mock_path): 1785 patch.stopall() 1786 self.assertIs(os.path, mock_path) 1787 self.assertIs(os.unlink, unlink) 1788 self.assertIs(os.chdir, chdir) 1789 1790 patched() 1791 self.assertIs(os.path, path) 1792 1793 def test_stopall_lifo(self): 1794 stopped = [] 1795 class thing(object): 1796 one = two = three = None 1797 1798 def get_patch(attribute): 1799 class mypatch(_patch): 1800 def stop(self): 1801 stopped.append(attribute) 1802 return super(mypatch, self).stop() 1803 return mypatch(lambda: thing, attribute, None, None, 1804 False, None, None, None, {}) 1805 [get_patch(val).start() for val in ("one", "two", "three")] 1806 patch.stopall() 1807 1808 self.assertEqual(stopped, ["three", "two", "one"]) 1809 1810 1811 def test_special_attrs(self): 1812 def foo(x=0): 1813 """TEST""" 1814 return x 1815 with patch.object(foo, '__defaults__', (1, )): 1816 self.assertEqual(foo(), 1) 1817 self.assertEqual(foo(), 0) 1818 1819 with patch.object(foo, '__doc__', "FUN"): 1820 self.assertEqual(foo.__doc__, "FUN") 1821 self.assertEqual(foo.__doc__, "TEST") 1822 1823 with patch.object(foo, '__module__', "testpatch2"): 1824 self.assertEqual(foo.__module__, "testpatch2") 1825 self.assertEqual(foo.__module__, 'unittest.test.testmock.testpatch') 1826 1827 with patch.object(foo, '__annotations__', dict([('s', 1, )])): 1828 self.assertEqual(foo.__annotations__, dict([('s', 1, )])) 1829 self.assertEqual(foo.__annotations__, dict()) 1830 1831 def foo(*a, x=0): 1832 return x 1833 with patch.object(foo, '__kwdefaults__', dict([('x', 1, )])): 1834 self.assertEqual(foo(), 1) 1835 self.assertEqual(foo(), 0) 1836 1837 def test_dotted_but_module_not_loaded(self): 1838 # This exercises the AttributeError branch of _dot_lookup. 1839 1840 # make sure it's there 1841 import unittest.test.testmock.support 1842 # now make sure it's not: 1843 with patch.dict('sys.modules'): 1844 del sys.modules['unittest.test.testmock.support'] 1845 del sys.modules['unittest.test.testmock'] 1846 del sys.modules['unittest.test'] 1847 del sys.modules['unittest'] 1848 1849 # now make sure we can patch based on a dotted path: 1850 @patch('unittest.test.testmock.support.X') 1851 def test(mock): 1852 pass 1853 test() 1854 1855 1856 def test_invalid_target(self): 1857 with self.assertRaises(TypeError): 1858 patch('') 1859 1860 1861 def test_cant_set_kwargs_when_passing_a_mock(self): 1862 @patch('unittest.test.testmock.support.X', new=object(), x=1) 1863 def test(): pass 1864 with self.assertRaises(TypeError): 1865 test() 1866 1867 1868if __name__ == '__main__': 1869 unittest.main() 1870