python (3.12.0)
1 # Copyright (C) 2007-2012 Michael Foord & the mock team
2 # E-mail: fuzzyman AT voidspace DOT org DOT uk
3 # http://www.voidspace.org.uk/python/mock/
4
5 import os
6 import sys
7 from collections import OrderedDict
8
9 import unittest
10 from test.test_unittest.testmock import support
11 from test.test_unittest.testmock.support import SomeClass, is_instance
12
13 from test.test_importlib.util import uncache
14 from unittest.mock import (
15 NonCallableMock, CallableMixin, sentinel,
16 MagicMock, Mock, NonCallableMagicMock, patch, _patch,
17 DEFAULT, call, _get_target
18 )
19
20
21 builtin_string = 'builtins'
22
23 PTModule = sys.modules[__name__]
24 MODNAME = '%s.PTModule' % __name__
25
26
27 def _get_proxy(obj, get_only=True):
28 class ESC[4;38;5;81mProxy(ESC[4;38;5;149mobject):
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
42 something = sentinel.Something
43 something_else = sentinel.SomethingElse
44
45
46 class ESC[4;38;5;81mFoo(ESC[4;38;5;149mobject):
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 ESC[4;38;5;81mBar(ESC[4;38;5;149mobject):
59 def a(self): pass
60
61 foo_name = '%s.Foo' % __name__
62
63
64 def function(a, b=Foo): pass
65
66
67 class ESC[4;38;5;81mContainer(ESC[4;38;5;149mobject):
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
85 class ESC[4;38;5;81mPatchTest(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
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 ESC[4;38;5;81mSomething(ESC[4;38;5;149mobject):
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 ESC[4;38;5;81mSomething(ESC[4;38;5;149mobject):
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 ESC[4;38;5;81mSomething(ESC[4;38;5;149mobject):
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 ESC[4;38;5;81mTest(ESC[4;38;5;149mobject):
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 ESC[4;38;5;81mFoo(ESC[4;38;5;149mobject):
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 ESC[4;38;5;81mFoo(ESC[4;38;5;149mobject):
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 ESC[4;38;5;81mSomething(ESC[4;38;5;149mobject):
448 attribute = sentinel.Original
449
450 class ESC[4;38;5;81mFoo(ESC[4;38;5;149mobject):
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 ESC[4;38;5;81mSomething(ESC[4;38;5;149mobject):
470 attribute = sentinel.Original
471
472 class ESC[4;38;5;81mFoo(ESC[4;38;5;149mobject):
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 ESC[4;38;5;81mSomething(ESC[4;38;5;149mobject):
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('test.test_unittest.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 ESC[4;38;5;81mTest(ESC[4;38;5;149mobject):
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 ESC[4;38;5;81mSomething(ESC[4;38;5;149mobject):
814 foo = 'foo'
815 class ESC[4;38;5;81mSomethingElse:
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 ESC[4;38;5;81mSomething(ESC[4;38;5;149mobject):
832 foo = 'foo'
833 class ESC[4;38;5;81mSomethingElse:
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 ESC[4;38;5;81mBoo(ESC[4;38;5;149mobject):
891 def __init__(self, a): pass
892 def f(self, a): pass
893 def g(self): pass
894 foo = 'bar'
895
896 class ESC[4;38;5;81mBar(ESC[4;38;5;149mobject):
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 ESC[4;38;5;81mFoo:
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 ESC[4;38;5;81mFoo:
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 ESC[4;38;5;81mBar(ESC[4;38;5;149mFoo):
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 ESC[4;38;5;81mBar(ESC[4;38;5;149mobject):
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 ESC[4;38;5;81mBar(ESC[4;38;5;149mobject):
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 ESC[4;38;5;81mMockSub(ESC[4;38;5;149mMock):
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 ESC[4;38;5;81mNotAMock(ESC[4;38;5;149mobject):
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 ESC[4;38;5;81mSomeTest(ESC[4;38;5;149mobject):
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 ESC[4;38;5;81mSomeTest(ESC[4;38;5;149mobject):
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 ESC[4;38;5;81mThing(ESC[4;38;5;149mobject):
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 ESC[4;38;5;81mFoo(ESC[4;38;5;149mobject):
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 ESC[4;38;5;81mFoo(ESC[4;38;5;149mobject):
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('test.test_unittest.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 ESC[4;38;5;81mholder:
1699 exc_info = None, None, None
1700
1701 class ESC[4;38;5;81mcustom_patch(ESC[4;38;5;149m_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 ESC[4;38;5;81mthing(ESC[4;38;5;149mobject):
1835 one = two = three = None
1836
1837 def get_patch(attribute):
1838 class ESC[4;38;5;81mmypatch(ESC[4;38;5;149m_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__, 'test.test_unittest.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 test.test_unittest.testmock.support
1951 # now make sure it's not:
1952 with patch.dict('sys.modules'):
1953 del sys.modules['test.test_unittest.testmock.support']
1954 del sys.modules['test.test_unittest.testmock']
1955 del sys.modules['test.test_unittest']
1956 del sys.modules['test']
1957
1958 # now make sure we can patch based on a dotted path:
1959 @patch('test.test_unittest.testmock.support.X')
1960 def test(mock):
1961 pass
1962 test()
1963
1964
1965 def test_invalid_target(self):
1966 class ESC[4;38;5;81mFoo:
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('test.test_unittest.testmock.support.X', new=object(), x=1)
1977 def test(): pass
1978 with self.assertRaises(TypeError):
1979 test()
1980
1981
1982 if __name__ == '__main__':
1983 unittest.main()
Browse
Usage
Versions