Lines Matching refs:self
29 def __getattr__(self, name):
32 def __setattr__(self, name, value):
34 def __delattr__(self, name):
47 def __init__(self, a): pass
48 def f(self, a): pass
49 def g(self): pass
59 def a(self): pass
68 def __init__(self):
69 self.values = {}
71 def __getitem__(self, name):
72 return self.values[name]
74 def __setitem__(self, name, value):
75 self.values[name] = value
77 def __delitem__(self, name):
78 del self.values[name]
80 def __iter__(self):
81 return iter(self.values)
87 def assertNotCallable(self, obj, magic=True):
92 self.assertRaises(TypeError, obj)
93 self.assertTrue(is_instance(obj, MockClass))
94 self.assertFalse(is_instance(obj, CallableMixin))
97 def test_single_patchobject(self):
103 self.assertEqual(Something.attribute, sentinel.Patched, "unpatched")
106 self.assertEqual(Something.attribute, sentinel.Original,
109 def test_patchobject_with_string_as_target(self):
111 with self.assertRaisesRegex(TypeError, msg):
114 def test_patchobject_with_none(self):
120 self.assertIsNone(Something.attribute, "unpatched")
123 self.assertEqual(Something.attribute, sentinel.Original,
127 def test_multiple_patchobject(self):
135 self.assertEqual(Something.attribute, sentinel.Patched,
137 self.assertEqual(Something.next_attribute, sentinel.Patched2,
141 self.assertEqual(Something.attribute, sentinel.Original,
143 self.assertEqual(Something.next_attribute, sentinel.Original2,
147 def test_object_lookup_is_quite_lazy(self):
157 self.assertEqual(something, sentinel.replacement_value)
162 def test_patch(self):
165 self.assertEqual(PTModule.something, sentinel.Something2,
169 self.assertEqual(PTModule.something, sentinel.Something,
175 self.assertEqual(PTModule.something, sentinel.Something2,
177 self.assertEqual(PTModule.something_else, sentinel.SomethingElse,
180 self.assertEqual(PTModule.something, sentinel.Something,
182 self.assertEqual(PTModule.something_else, sentinel.SomethingElse,
188 self.assertEqual(PTModule.something, sentinel.Something,
190 self.assertEqual(PTModule.something_else, sentinel.SomethingElse,
197 self.assertEqual(open('filename', 'r'), sentinel.Handle,
202 self.assertNotEqual(open, mock, "patch not restored")
205 def test_patch_class_attribute(self):
209 self.assertEqual(PTModule.SomeClass.class_attribute,
213 self.assertIsNone(PTModule.SomeClass.class_attribute,
217 def test_patchobject_with_default_mock(self):
224 self.assertEqual(mock, Test.something,
226 self.assertIsInstance(mock, MagicMock,
234 self.assertEqual(this1, sentinel.this1,
236 self.assertEqual(this2, sentinel.this2,
238 self.assertEqual(mock1, Test.something2,
240 self.assertEqual(mock2, Test.something,
242 self.assertIsInstance(mock2, MagicMock,
244 self.assertIsInstance(mock2, MagicMock,
248 self.assertNotEqual(outerMock1, mock1, "unexpected value for mock1")
249 self.assertNotEqual(outerMock2, mock2, "unexpected value for mock1")
259 def test_patch_with_spec(self):
262 self.assertEqual(SomeClass, MockSomeClass)
263 self.assertTrue(is_instance(SomeClass.wibble, MagicMock))
264 self.assertRaises(AttributeError, lambda: SomeClass.not_wibble)
269 def test_patchobject_with_spec(self):
272 self.assertEqual(SomeClass.class_attribute, MockAttribute)
273 self.assertTrue(is_instance(SomeClass.class_attribute.wibble,
275 self.assertRaises(AttributeError,
281 def test_patch_with_spec_as_list(self):
284 self.assertEqual(SomeClass, MockSomeClass)
285 self.assertTrue(is_instance(SomeClass.wibble, MagicMock))
286 self.assertRaises(AttributeError, lambda: SomeClass.not_wibble)
291 def test_patchobject_with_spec_as_list(self):
294 self.assertEqual(SomeClass.class_attribute, MockAttribute)
295 self.assertTrue(is_instance(SomeClass.class_attribute.wibble,
297 self.assertRaises(AttributeError,
303 def test_nested_patch_with_spec_as_list(self):
308 self.assertEqual(SomeClass, MockSomeClass)
309 self.assertTrue(is_instance(SomeClass.wibble, MagicMock))
310 self.assertRaises(AttributeError, lambda: SomeClass.not_wibble)
314 def test_patch_with_spec_as_boolean(self):
317 self.assertEqual(SomeClass, MockSomeClass)
321 self.assertRaises(AttributeError, lambda: MockSomeClass.not_wibble)
326 def test_patch_object_with_spec_as_boolean(self):
329 self.assertEqual(SomeClass, MockSomeClass)
333 self.assertRaises(AttributeError, lambda: MockSomeClass.not_wibble)
338 def test_patch_class_acts_with_spec_is_inherited(self):
341 self.assertTrue(is_instance(MockSomeClass, MagicMock))
343 self.assertNotCallable(instance)
347 self.assertRaises(AttributeError, lambda: instance.not_wibble)
352 def test_patch_with_create_mocks_non_existent_attributes(self):
355 self.assertEqual(frooble, sentinel.Frooble)
358 self.assertRaises(NameError, lambda: frooble)
361 def test_patchobject_with_create_mocks_non_existent_attributes(self):
364 self.assertEqual(SomeClass.frooble, sentinel.Frooble)
367 self.assertFalse(hasattr(SomeClass, 'frooble'))
370 def test_patch_wont_create_by_default(self):
371 with self.assertRaises(AttributeError):
376 self.assertRaises(NameError, lambda: frooble)
379 def test_patchobject_wont_create_by_default(self):
380 with self.assertRaises(AttributeError):
384 self.assertFalse(hasattr(SomeClass, 'ord'))
387 def test_patch_builtins_without_create(self):
403 self.assertEqual(test_ord(), 101)
404 self.assertEqual(test_open(), 'abcd')
407 def test_patch_with_static_methods(self):
415 self.assertEqual(Foo.woot(), sentinel.Patched)
418 self.assertEqual(Foo.woot(), sentinel.Static)
421 def test_patch_local(self):
425 self.assertEqual(sentinel.Foo, 'Foo')
428 self.assertEqual(sentinel.Foo, foo)
431 def test_patch_slots(self):
440 self.assertEqual(foo.Foo, 'Foo')
443 self.assertEqual(foo.Foo, sentinel.Foo)
446 def test_patchobject_class_decorator(self):
452 self.assertEqual(Something.attribute, sentinel.Patched,
455 self.assertEqual(Something.attribute, sentinel.Original,
464 self.assertEqual(Something.attribute, sentinel.Original,
468 def test_patch_class_decorator(self):
477 self.assertEqual(PTModule.something, mock_something,
480 self.assertEqual(PTModule.something, sentinel.Something,
488 self.assertEqual(Something.attribute, sentinel.Original,
490 self.assertEqual(PTModule.something, sentinel.Something,
494 def test_patchobject_twice(self):
502 self.assertEqual(Something.attribute, sentinel.Patched, "unpatched")
506 self.assertEqual(Something.attribute, sentinel.Original,
510 def test_patch_dict(self):
522 self.assertEqual(foo, original)
526 self.assertEqual(len(foo), 3)
527 self.assertEqual(foo['a'], 'b')
531 self.assertEqual(foo, original)
535 self.assertEqual(len(foo), 3)
536 self.assertEqual(foo['a'], 'b')
540 self.assertEqual(foo, original)
543 def test_patch_dict_with_container_object(self):
558 self.assertEqual(foo.values, original)
562 self.assertEqual(len(foo.values), 3)
563 self.assertEqual(foo['a'], 'b')
567 self.assertEqual(foo.values, original)
570 def test_patch_dict_with_clear(self):
576 self.assertEqual(foo, {})
582 self.assertEqual(foo, original)
586 self.assertEqual(foo, {'a': 'b'})
590 self.assertEqual(foo, original)
594 self.assertEqual(foo, {'a': 'b'})
598 self.assertEqual(foo, original)
601 def test_patch_dict_with_container_object_and_clear(self):
610 self.assertEqual(foo.values, {})
616 self.assertEqual(foo.values, original)
620 self.assertEqual(foo.values, {'a': 'b'})
624 self.assertEqual(foo.values, original)
627 def test_patch_dict_as_context_manager(self):
630 self.assertEqual(patched, {'a': 'c'})
631 self.assertEqual(foo, {'a': 'b'})
634 def test_name_preserved(self):
643 self.assertEqual(some_name.__name__, 'some_name')
646 def test_patch_with_exception(self):
653 with self.assertRaises(NameError):
656 self.assertEqual(foo, {})
659 def test_patch_dict_with_string(self):
662 self.assertIn('konrad_delong', os.environ)
667 def test_patch_dict_decorator_resolution(self):
674 self.assertEqual(support.target, {'foo': 'BAZ', 'bar': 'BAR'})
679 self.assertEqual(support.target, {'foo': 'BAZ'})
684 def test_patch_spec_set(self):
689 self.assertRaises(AttributeError, test)
695 self.assertRaises(AttributeError, test)
700 self.assertRaises(AttributeError, test)
706 self.assertRaises(AttributeError, test)
709 def test_spec_set_inherit(self):
715 self.assertRaises(AttributeError, test)
718 def test_patch_start_stop(self):
721 self.assertIs(something, original)
724 self.assertIsNot(mock, original)
725 self.assertIs(something, mock)
728 self.assertIs(something, original)
731 def test_stop_without_start(self):
734 self.assertIsNone(patcher.stop())
737 def test_stop_idempotent(self):
743 self.assertIsNone(patcher.stop())
746 def test_patchobject_start_stop(self):
749 self.assertIs(something, original)
752 self.assertEqual(replaced, 'foo')
753 self.assertIs(something, replaced)
756 self.assertIs(something, original)
759 def test_patch_dict_start_stop(self):
763 self.assertEqual(d, original)
767 self.assertEqual(d, {'spam': 'eggs'})
770 self.assertEqual(d, original)
773 def test_patch_dict_stop_without_start(self):
777 self.assertFalse(patcher.stop())
778 self.assertEqual(d, original)
781 def test_patch_dict_class_decorator(self):
782 this = self
787 def test_first(self):
789 def test_second(self):
793 self.assertEqual(d, original)
798 self.assertEqual(d, original)
801 self.assertEqual(d, original)
806 self.assertEqual(d, original)
809 self.assertEqual(d, original)
812 def test_get_only_proxy(self):
823 self.assertEqual(proxy.foo, 'bar')
825 self.assertEqual(proxy.foo, 'foo')
826 self.assertEqual(thing.foo, 'foo')
827 self.assertNotIn('foo', proxy.__dict__)
830 def test_get_set_delete_proxy(self):
841 self.assertEqual(proxy.foo, 'bar')
843 self.assertEqual(proxy.foo, 'foo')
844 self.assertEqual(thing.foo, 'foo')
845 self.assertNotIn('foo', proxy.__dict__)
848 def test_patch_keyword_args(self):
856 self.assertRaises(KeyError, mock)
857 self.assertEqual(mock.foo.bar(), 33)
858 self.assertIsInstance(mock.foo, MagicMock)
861 def test_patch_object_keyword_args(self):
869 self.assertRaises(KeyError, mock)
870 self.assertEqual(mock.foo.bar(), 33)
871 self.assertIsInstance(mock.foo, MagicMock)
874 def test_patch_dict_keyword_args(self):
882 self.assertEqual(original, dict(foo=3, bar=4, baz=5))
886 self.assertEqual(original, copy)
889 def test_autospec(self):
891 def __init__(self, a): pass
892 def f(self, a): pass
893 def g(self): pass
897 def a(self): pass
902 self.assertRaises(TypeError, mock)
907 self.assertRaises(TypeError, mock.f)
911 self.assertRaises(TypeError, mock.g, 1)
913 self.assertRaises(AttributeError, getattr, mock, 'h')
917 self.assertRaises(AttributeError, getattr, mock.foo, 'bar')
924 self.assertRaises(TypeError, mock.Bar.a, 1)
928 self.assertRaises(TypeError, mock.Bar().a, 1)
930 self.assertRaises(AttributeError, getattr, mock.Bar, 'b')
931 self.assertRaises(AttributeError, getattr, mock.Bar(), 'b')
937 self.assertIs(mock, Foo)
943 self.assertIsNot(Foo, mock)
951 self.assertIsNot(Foo, mock)
956 def test_autospec_function(self):
960 self.assertRaises(AssertionError, function.assert_called)
961 self.assertRaises(AssertionError, function.assert_called_once)
963 self.assertRaises(AssertionError, function.assert_not_called)
970 self.assertRaises(TypeError, function)
971 self.assertRaises(AttributeError, getattr, function, 'foo')
976 def test_autospec_keywords(self):
980 #self.assertEqual(function.abc, 'foo')
984 self.assertEqual(result, 3)
987 def test_autospec_staticmethod(self):
993 def test_autospec_classmethod(self):
999 def test_autospec_staticmethod_signature(self):
1009 self.assertRaises(TypeError, method)
1010 self.assertRaises(TypeError, method, 1)
1011 self.assertRaises(TypeError, method, 1, 2, 3, c=4)
1014 def test_autospec_classmethod_signature(self):
1024 self.assertRaises(TypeError, method)
1025 self.assertRaises(TypeError, method, 1)
1026 self.assertRaises(TypeError, method, 1, 2, 3, c=4)
1029 def test_autospec_with_new(self):
1031 self.assertRaises(TypeError, patcher.start)
1035 self.assertRaises(TypeError, patcher.start)
1038 def test_autospec_with_object(self):
1045 self.assertIsInstance(mock, Bar)
1046 self.assertIsInstance(mock.extra, list)
1051 def test_autospec_inherits(self):
1056 self.assertIsInstance(mock, FooClass)
1057 self.assertIsInstance(mock(3), FooClass)
1062 def test_autospec_name(self):
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))
1075 def test_tracebacks(self):
1085 traceback = result._exc_info_to_string(err, self)
1086 self.assertIn('raise AssertionError', traceback)
1089 def test_new_callable_patch(self):
1097 self.assertIsNot(m1, m2)
1099 self.assertNotCallable(m1)
1102 def test_new_callable_patch_object(self):
1110 self.assertIsNot(m1, m2)
1112 self.assertNotCallable(m1)
1115 def test_new_callable_keyword_arguments(self):
1118 def __init__(self, **kwargs):
1124 self.assertIs(type(m), Bar)
1125 self.assertEqual(Bar.kwargs, dict(arg1=1, arg2=2))
1130 def test_new_callable_spec(self):
1133 def __init__(self, **kwargs):
1139 self.assertEqual(Bar.kwargs, dict(spec=Bar))
1146 self.assertEqual(Bar.kwargs, dict(spec_set=Bar))
1151 def test_new_callable_create(self):
1154 self.assertRaises(AttributeError, p.start)
1160 self.assertNotCallable(m, magic=False)
1165 def test_new_callable_incompatible_with_new(self):
1166 self.assertRaises(
1169 self.assertRaises(
1175 def test_new_callable_incompatible_with_autospec(self):
1176 self.assertRaises(
1180 self.assertRaises(
1186 def test_new_callable_inherit_for_mocks(self):
1200 self.assertRaises(AttributeError, getattr, instance, 'x')
1205 def test_new_callable_inherit_non_mock(self):
1207 def __init__(self, spec):
1208 self.spec = spec
1213 self.assertTrue(is_instance(m, NotAMock))
1214 self.assertRaises(AttributeError, getattr, m, 'return_value')
1218 self.assertEqual(m.spec, Foo)
1221 def test_new_callable_class_decorating(self):
1222 test = self
1226 def _test(self, mock_foo):
1231 def test_two(self, mock_foo):
1232 self._test(mock_foo)
1233 def test_one(self, mock_foo):
1234 self._test(mock_foo)
1239 self.assertIs(Foo, original)
1242 def test_patch_multiple(self):
1253 self.assertIs(Foo, original_foo)
1254 self.assertEqual(Foo.f, 1)
1255 self.assertEqual(Foo.g, 2)
1259 self.assertIs(Foo, original_foo)
1260 self.assertEqual(Foo.f, original_f)
1261 self.assertEqual(Foo.g, original_g)
1266 self.assertIs(Foo, original_foo)
1267 self.assertEqual(Foo.f, 3)
1268 self.assertEqual(Foo.g, 4)
1273 def test_patch_multiple_no_kwargs(self):
1274 self.assertRaises(ValueError, patch.multiple, foo_name)
1275 self.assertRaises(ValueError, patch.multiple, Foo)
1278 def test_patch_multiple_create_mocks(self):
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))
1293 self.assertEqual(Foo.f, original_f)
1294 self.assertEqual(Foo.g, original_g)
1297 def test_patch_multiple_create_mocks_different_order(self):
1310 self.assertIs(Foo.g, g)
1311 self.assertEqual(Foo.f, 3)
1314 self.assertEqual(Foo.f, original_f)
1315 self.assertEqual(Foo.g, original_g)
1318 def test_patch_multiple_stacked_decorators(self):
1344 self.assertFalse(kwargs)
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))
1357 self.assertEqual(Foo.f, original_f)
1358 self.assertEqual(Foo.g, original_g)
1361 def test_patch_multiple_create_mocks_patcher(self):
1372 self.assertEqual(set(result), set(['f', 'foo']))
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))
1382 self.assertEqual(Foo.f, original_f)
1383 self.assertEqual(Foo.g, original_g)
1386 def test_patch_multiple_decorating_class(self):
1387 test = self
1394 def _test(self, f, foo):
1402 def test_two(self, f, foo):
1403 self._test(f, foo)
1404 def test_one(self, f, foo):
1405 self._test(f, foo)
1415 self.assertEqual(Foo.f, original_f)
1416 self.assertEqual(Foo.g, original_g)
1419 def test_patch_multiple_create(self):
1421 self.assertRaises(AttributeError, patcher.start)
1426 self.assertEqual(Foo.blam, 'blam')
1430 self.assertFalse(hasattr(Foo, 'blam'))
1433 def test_patch_multiple_spec_set(self):
1439 self.assertEqual(Foo.foo, result['foo'])
1444 self.assertRaises(AttributeError, setattr, Foo.foo, 'c', None)
1449 def test_patch_multiple_new_callable(self):
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)
1467 def test_nested_patch_failure(self):
1487 self.assertRaises(AttributeError, func)
1488 self.assertEqual(Foo.f, original_f)
1489 self.assertEqual(Foo.g, original_g)
1492 def test_new_callable_failure(self):
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)
1522 def test_patch_multiple_failure(self):
1541 self.assertRaises(AttributeError, func)
1542 self.assertEqual(Foo.f, original_f)
1543 self.assertEqual(Foo.g, original_g)
1546 def test_patch_multiple_new_callable_failure(self):
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)
1575 def test_patch_multiple_string_subclasses(self):
1580 self.assertEqual(foo.fish, 'nearly gone')
1583 self.assertEqual(foo.fish, 'tasty')
1587 def test_patch_test_prefix(self):
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
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')
1610 def test_patch_dict_test_prefix(self):
1612 def bar_one(self):
1614 def bar_two(self):
1616 def test_one(self):
1618 def test_two(self):
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'})
1631 def test_patch_with_spec_mock_repr(self):
1636 self.assertIn(" name='SomeClass'", repr(m))
1637 self.assertIn(" name='SomeClass.class_attribute'",
1639 self.assertIn(" name='SomeClass()'", repr(m()))
1640 self.assertIn(" name='SomeClass().class_attribute'",
1646 def test_patch_nested_autospec_repr(self):
1648 self.assertIn(" name='support.SomeClass.wibble()'",
1650 self.assertIn(" name='support.SomeClass().wibble()'",
1655 def test_mock_calls_with_patch(self):
1663 self.assertEqual(m.mock_calls, kalls)
1664 self.assertEqual(m.method_calls, kalls)
1665 self.assertEqual(m.wibble.mock_calls, [call()])
1669 self.assertEqual(m.mock_calls, kalls)
1673 self.assertEqual(m.mock_calls, kalls)
1675 self.assertEqual(result.mock_calls, [call.wibble()])
1676 self.assertEqual(result.wibble.mock_calls, [call()])
1677 self.assertEqual(result.method_calls, [call.wibble()])
1682 def test_patch_imports_lazily(self):
1684 self.assertRaises(ImportError, p1.start)
1695 self.assertEqual(squizz.squozz, 3)
1697 def test_patch_propagates_exc_on_exit(self):
1702 def __exit__(self, etype=None, val=None, tb=None):
1703 _patch.__exit__(self, etype, val, tb)
1722 self.assertRaises(RuntimeError, test)
1724 self.assertIs(holder.exc_info[0], RuntimeError)
1725 self.assertIsNotNone(holder.exc_info[1],
1727 self.assertIsNotNone(holder.exc_info[2],
1731 def test_create_and_specs(self):
1735 self.assertRaises(TypeError, p.start)
1736 self.assertRaises(NameError, lambda: doesnotexist)
1744 def test_multiple_specs(self):
1748 self.assertRaises(TypeError, p.start)
1749 self.assertIs(PTModule, original)
1753 self.assertRaises(TypeError, p.start)
1754 self.assertIs(PTModule, original)
1758 self.assertRaises(TypeError, p.start)
1759 self.assertIs(PTModule, original)
1762 def test_specs_false_instead_of_none(self):
1773 def test_falsey_spec(self):
1778 self.assertRaises(AttributeError, getattr, m, 'doesnotexit')
1783 def test_spec_set_true(self):
1788 self.assertRaises(AttributeError, setattr, m,
1790 self.assertRaises(AttributeError, getattr, m, 'doesnotexist')
1795 def test_callable_spec_as_list(self):
1800 self.assertTrue(callable(m))
1805 def test_not_callable_spec_as_list(self):
1810 self.assertFalse(callable(m))
1815 def test_patch_stopall(self):
1825 self.assertIs(os.path, mock_path)
1826 self.assertIs(os.unlink, unlink)
1827 self.assertIs(os.chdir, chdir)
1830 self.assertIs(os.path, path)
1832 def test_stopall_lifo(self):
1839 def stop(self):
1841 return super(mypatch, self).stop()
1847 self.assertEqual(stopped, ["three", "two", "one"])
1849 def test_patch_dict_stopall(self):
1864 self.assertNotEqual(dic1, origdic1)
1865 self.assertNotEqual(dic2, origdic2)
1866 self.assertEqual(dic3, origdic3)
1870 self.assertEqual(dic1, origdic1)
1871 self.assertEqual(dic2, origdic2)
1872 self.assertEqual(dic3, origdic3)
1875 def test_patch_and_patch_dict_stopall(self):
1889 self.assertIsNot(os.unlink, original_unlink)
1890 self.assertIsNot(os.chdir, original_chdir)
1891 self.assertNotEqual(dic1, origdic1)
1892 self.assertNotEqual(dic2, origdic2)
1894 self.assertIs(os.unlink, original_unlink)
1895 self.assertIs(os.chdir, original_chdir)
1896 self.assertEqual(dic1, origdic1)
1897 self.assertEqual(dic2, origdic2)
1900 def test_special_attrs(self):
1905 self.assertEqual(foo(), 1)
1906 self.assertEqual(foo(), 0)
1910 self.assertEqual(foo.__doc__, "FUN")
1911 self.assertEqual(foo.__doc__, orig_doc)
1914 self.assertEqual(foo.__module__, "testpatch2")
1915 self.assertEqual(foo.__module__, 'unittest.test.testmock.testpatch')
1918 self.assertEqual(foo.__annotations__, dict([('s', 1, )]))
1919 self.assertEqual(foo.__annotations__, dict())
1924 self.assertEqual(foo(), 1)
1925 self.assertEqual(foo(), 0)
1927 def test_patch_orderdict(self):
1937 self.assertEqual(list(foo.items()), patched_values)
1939 self.assertEqual(foo, original)
1942 self.assertEqual(list(foo.items()), patched_values)
1944 self.assertEqual(foo, original)
1946 def test_dotted_but_module_not_loaded(self):
1965 def test_invalid_target(self):
1970 with self.subTest(target=target):
1971 with self.assertRaises(TypeError):
1975 def test_cant_set_kwargs_when_passing_a_mock(self):
1978 with self.assertRaises(TypeError):