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