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