Lines Matching refs:self
19 def __init__(self):
20 self.thing = iter(['this', 'is', 'an', 'iter'])
22 def __iter__(self):
23 return self
25 def next(self):
26 return next(self.thing)
32 def meth(self, a, b, c, d=None): pass
52 def test_all(self):
59 def test_constructor(self):
62 self.assertFalse(mock.called, "called not initialised correctly")
63 self.assertEqual(mock.call_count, 0,
65 self.assertTrue(is_instance(mock.return_value, Mock),
68 self.assertEqual(mock.call_args, None,
70 self.assertEqual(mock.call_args_list, [],
72 self.assertEqual(mock.method_calls, [],
76 self.assertNotIn('_items', mock.__dict__,
79 self.assertIsNone(mock._mock_parent,
81 self.assertIsNone(mock._mock_methods,
83 self.assertEqual(mock._mock_children, {},
87 def test_return_value_in_constructor(self):
89 self.assertIsNone(mock.return_value,
93 def test_change_return_value_via_delegate(self):
97 self.assertEqual(mock(), 1)
100 def test_change_side_effect_via_delegate(self):
104 with self.assertRaises(TypeError):
108 def test_repr(self):
110 self.assertIn('foo', repr(mock))
111 self.assertIn("'%s'" % id(mock), repr(mock))
115 self.assertIn('%s.bar' % name, repr(mock.bar))
116 self.assertIn('%s.foo()' % name, repr(mock.foo()))
117 self.assertIn('%s.foo().bing' % name, repr(mock.foo().bing))
118 self.assertIn('%s()' % name, repr(mock()))
119 self.assertIn('%s()()' % name, repr(mock()()))
120 self.assertIn('%s()().foo.bar.baz().bing' % name,
124 def test_repr_with_spec(self):
129 self.assertIn(" spec='X' ", repr(mock))
132 self.assertIn(" spec='X' ", repr(mock))
135 self.assertIn(" spec_set='X' ", repr(mock))
138 self.assertIn(" spec_set='X' ", repr(mock))
141 self.assertIn(" spec='X' ", repr(mock))
142 self.assertIn(" name='foo' ", repr(mock))
145 self.assertNotIn("spec", repr(mock))
148 self.assertNotIn("spec", repr(mock))
151 self.assertNotIn("spec", repr(mock))
154 def test_side_effect(self):
161 self.assertRaises(SystemError, mock, 1, 2, fish=3)
169 self.assertEqual([mock(), mock(), mock()], [3, 2, 1],
173 self.assertEqual(mock.side_effect, sentinel.SideEffect,
179 self.assertEqual(mock(), sentinel.RETURN)
181 def test_autospec_side_effect(self):
190 self.assertEqual([mock(), mock(), mock()], [1, 2, 3],
196 self.assertEqual([mock(), mock(), mock()], [3, 2, 1],
199 def test_autospec_side_effect_exception(self):
205 self.assertRaisesRegex(ValueError, 'Bazinga!', mock)
208 def test_autospec_mock(self):
214 with self.assertRaisesRegex(InvalidSpecError,
217 with self.assertRaisesRegex(InvalidSpecError,
220 with self.assertRaisesRegex(InvalidSpecError,
223 with self.assertRaisesRegex(InvalidSpecError,
226 with self.assertRaisesRegex(InvalidSpecError,
229 with self.assertRaisesRegex(InvalidSpecError,
232 with self.assertRaisesRegex(InvalidSpecError, "Cannot spec a Mock object."):
238 def test_reset_mock(self):
251 self.assertEqual(mock._mock_name, "child",
253 self.assertEqual(mock._mock_parent, parent,
255 self.assertEqual(mock._mock_methods, spec,
258 self.assertFalse(mock.called, "called not reset")
259 self.assertEqual(mock.call_count, 0, "call_count not reset")
260 self.assertEqual(mock.call_args, None, "call_args not reset")
261 self.assertEqual(mock.call_args_list, [], "call_args_list not reset")
262 self.assertEqual(mock.method_calls, [],
265 self.assertEqual(mock.mock_calls, [])
267 self.assertEqual(mock.side_effect, sentinel.SideEffect,
269 self.assertEqual(mock.return_value, return_value,
271 self.assertFalse(return_value.called, "return value mock not reset")
272 self.assertEqual(mock._mock_children, {'something': something},
274 self.assertEqual(mock.something, something,
276 self.assertFalse(mock.something.called, "child not reset")
279 def test_reset_mock_recursion(self):
286 def test_reset_mock_on_mock_open_issue_18622(self):
290 def test_call(self):
292 self.assertTrue(is_instance(mock.return_value, Mock),
296 self.assertEqual(mock(), result,
301 self.assertTrue(mock.called, "called not set")
302 self.assertEqual(mock.call_count, 1, "call_count incorrect")
303 self.assertEqual(mock.call_args, ((sentinel.Arg,), {}),
305 self.assertEqual(mock.call_args.args, (sentinel.Arg,),
307 self.assertEqual(mock.call_args.kwargs, {},
309 self.assertEqual(mock.call_args_list, [((sentinel.Arg,), {})],
314 self.assertEqual(ret_val, sentinel.ReturnValue,
317 self.assertEqual(mock.call_count, 2, "call_count incorrect")
318 self.assertEqual(mock.call_args,
321 self.assertEqual(mock.call_args_list, [
328 def test_call_args_comparison(self):
334 self.assertEqual(mock.call_args_list, [
340 self.assertEqual(mock.call_args,
342 self.assertEqual(mock.call_args.args, (sentinel.Arg,))
343 self.assertEqual(mock.call_args.kwargs, {"kw": sentinel.Kwarg})
347 self.assertFalse(mock.call_args == "a long sequence")
350 def test_calls_equal_with_any(self):
354 self.assertTrue(mm == mm)
355 self.assertFalse(mm != mm)
356 self.assertFalse(mm == mock.MagicMock())
357 self.assertTrue(mm != mock.MagicMock())
358 self.assertTrue(mm == mock.ANY)
359 self.assertFalse(mm != mock.ANY)
360 self.assertTrue(mock.ANY == mm)
361 self.assertFalse(mock.ANY != mm)
362 self.assertTrue(mm == ALWAYS_EQ)
363 self.assertFalse(mm != ALWAYS_EQ)
367 self.assertTrue(call1 == call2)
368 self.assertFalse(call1 != call2)
369 self.assertTrue(call2 == call1)
370 self.assertFalse(call2 != call1)
372 self.assertTrue(call1 == ALWAYS_EQ)
373 self.assertFalse(call1 != ALWAYS_EQ)
374 self.assertFalse(call1 == 1)
375 self.assertTrue(call1 != 1)
378 def test_assert_called_with(self):
384 self.assertRaises(AssertionError, mock.assert_called_with, 1)
387 self.assertRaises(AssertionError, mock.assert_called_with)
393 def test_assert_called_with_any(self):
399 def test_assert_called_with_function_spec(self):
407 self.assertRaises(AssertionError, mock.assert_called_with,
410 with self.assertRaises(AssertionError) as cm:
412 self.assertIsInstance(cm.exception.__cause__, TypeError)
415 def test_assert_called_with_method_spec(self):
420 self.assertRaises(AssertionError, mock.assert_called_with,
435 def test_assert_called_exception_message(self):
437 with self.assertRaisesRegex(AssertionError, msg.format('mock')):
439 with self.assertRaisesRegex(AssertionError, msg.format('test_name')):
443 def test_assert_called_once_with(self):
451 self.assertRaises(AssertionError, mock.assert_called_once_with)
454 self.assertRaises(AssertionError, mock.assert_called_once_with)
461 self.assertRaises(
466 def test_assert_called_once_with_call_list(self):
470 self.assertRaisesRegex(AssertionError,
475 def test_assert_called_once_with_function_spec(self):
483 self.assertRaises(AssertionError, mock.assert_called_once_with,
486 with self.assertRaises(AssertionError) as cm:
488 self.assertIsInstance(cm.exception.__cause__, TypeError)
491 self.assertRaises(AssertionError, mock.assert_called_once_with,
493 self.assertRaises(AssertionError, mock.assert_called_once_with,
497 def test_attribute_access_returns_mocks(self):
500 self.assertTrue(is_instance(something, Mock), "attribute isn't a mock")
501 self.assertEqual(mock.something, something,
508 self.assertEqual(mock.something(), 3, "method returned wrong value")
509 self.assertTrue(mock.something.called,
513 def test_attributes_have_name_and_parent_set(self):
517 self.assertEqual(something._mock_name, "something",
519 self.assertEqual(something._mock_parent, mock,
523 def test_method_calls_recorded(self):
528 self.assertEqual(mock.something_else.method_calls,
531 self.assertEqual(mock.method_calls, [
538 def test_method_calls_compare_easily(self):
541 self.assertEqual(mock.method_calls, [('something',)])
542 self.assertEqual(mock.method_calls, [('something', (), {})])
546 self.assertEqual(mock.method_calls, [('something', ('different',))])
547 self.assertEqual(mock.method_calls,
552 self.assertEqual(mock.method_calls, [('something', {'x': 1})])
553 self.assertEqual(mock.method_calls, [('something', (), {'x': 1})])
557 self.assertEqual(mock.method_calls, [
562 def test_only_allowed_methods_exist(self):
569 self.assertRaisesRegex(
576 def test_from_spec(self):
580 def y(self): pass
587 self.assertRaisesRegex(
592 self.assertRaisesRegex(
602 def test_wraps_calls(self):
606 self.assertEqual(mock(), real())
614 def test_wraps_prevents_automatic_creation_of_mocks(self):
621 self.assertRaises(AttributeError, lambda: mock.new_attr())
624 def test_wraps_call_with_nondefault_return_value(self):
630 self.assertEqual(mock(), 3)
631 self.assertFalse(real.called)
634 def test_wraps_attributes(self):
641 self.assertEqual(mock.attribute(), real.attribute())
642 self.assertRaises(AttributeError, lambda: mock.fish)
644 self.assertNotEqual(mock.attribute, real.attribute)
647 self.assertEqual(result, Real.attribute.frog())
650 def test_customize_wrapped_object_with_side_effect_iterable_with_default(self):
652 def method(self):
659 self.assertEqual(mock.method(), sentinel.VALUE1)
660 self.assertEqual(mock.method(), sentinel.ORIGINAL_VALUE)
661 self.assertRaises(StopIteration, mock.method)
664 def test_customize_wrapped_object_with_side_effect_iterable(self):
666 def method(self): pass
672 self.assertEqual(mock.method(), sentinel.VALUE1)
673 self.assertEqual(mock.method(), sentinel.VALUE2)
674 self.assertRaises(StopIteration, mock.method)
677 def test_customize_wrapped_object_with_side_effect_exception(self):
679 def method(self): pass
685 self.assertRaises(RuntimeError, mock.method)
688 def test_customize_wrapped_object_with_side_effect_function(self):
690 def method(self): pass
698 self.assertEqual(mock.method(), sentinel.VALUE)
701 def test_customize_wrapped_object_with_return_value(self):
703 def method(self): pass
709 self.assertEqual(mock.method(), sentinel.VALUE)
712 def test_customize_wrapped_object_with_return_value_and_side_effect(self):
715 def method(self): pass
722 self.assertEqual(mock.method(), sentinel.VALUE1)
723 self.assertEqual(mock.method(), sentinel.VALUE2)
724 self.assertRaises(StopIteration, mock.method)
727 def test_customize_wrapped_object_with_return_value_and_side_effect2(self):
730 def method(self): pass
737 self.assertEqual(mock.method(), sentinel.VALUE)
740 def test_customize_wrapped_object_with_return_value_and_side_effect_default(self):
742 def method(self): pass
749 self.assertEqual(mock.method(), sentinel.VALUE1)
750 self.assertEqual(mock.method(), sentinel.RETURN)
751 self.assertRaises(StopIteration, mock.method)
754 def test_magic_method_wraps_dict(self):
760 self.assertEqual(wrapped_dict.get('foo'), 'bar')
762 self.assertIsInstance(wrapped_dict['foo'], MagicMock)
764 self.assertFalse('foo' in wrapped_dict)
768 self.assertEqual(wrapped_dict.get('foo'), 'return_value')
772 self.assertEqual(wrapped_dict.get('foo'), 'bar')
774 self.assertEqual(wrapped_dict.get('baz'), None)
775 self.assertIsInstance(wrapped_dict['baz'], MagicMock)
776 self.assertFalse('bar' in wrapped_dict)
779 self.assertEqual(wrapped_dict.get('baz'), 'spam')
780 self.assertIsInstance(wrapped_dict['baz'], MagicMock)
781 self.assertFalse('bar' in wrapped_dict)
784 self.assertEqual(wrapped_dict.get('baz'), None)
787 def test_magic_method_wraps_class(self):
791 def __getitem__(self, index):
794 def __custom_method__(self):
800 self.assertEqual(obj.__getitem__(2), 2)
801 self.assertEqual(obj[2], 2)
802 self.assertEqual(obj.__custom_method__(), "foo")
805 def test_exceptional_side_effect(self):
807 self.assertRaises(AttributeError, mock)
810 self.assertRaises(AttributeError, mock)
813 def test_baseexceptional_side_effect(self):
815 self.assertRaises(KeyboardInterrupt, mock)
818 self.assertRaises(KeyboardInterrupt, mock)
821 def test_assert_called_with_message(self):
823 self.assertRaisesRegex(AssertionError, 'not called',
827 def test_assert_called_once_with_message(self):
829 self.assertRaisesRegex(AssertionError,
834 def test__name__(self):
836 self.assertRaises(AttributeError, lambda: mock.__name__)
839 self.assertEqual(mock.__name__, 'foo')
842 def test_spec_list_subclass(self):
849 self.assertRaises(AttributeError, getattr, mock, 'foo')
852 def test_spec_class(self):
857 self.assertIsInstance(mock, X)
860 self.assertIsInstance(mock, X)
862 self.assertIs(mock.__class__, X)
863 self.assertEqual(Mock().__class__.__name__, 'Mock')
866 self.assertIsInstance(mock, X)
869 self.assertIsInstance(mock, X)
872 def test_spec_class_no_object_base(self):
877 self.assertIsInstance(mock, X)
880 self.assertIsInstance(mock, X)
882 self.assertIs(mock.__class__, X)
883 self.assertEqual(Mock().__class__.__name__, 'Mock')
886 self.assertIsInstance(mock, X)
889 self.assertIsInstance(mock, X)
892 def test_setting_attribute_with_spec_set(self):
904 self.assertRaises(AttributeError, set_attr)
907 def test_copy(self):
909 self.addCleanup(sys.setrecursionlimit, current)
917 def test_subclass_with_properties(self):
919 def _get(self):
921 def _set(self, value):
926 self.assertEqual(s.some_attribute, 3)
930 self.assertRaises(NameError, test)
934 self.assertRaises(AttributeError, test)
937 def test_setting_call(self):
939 def __call__(self, a):
940 self._increment_mock_call(a)
941 return self._mock_call(a)
947 self.assertRaises(TypeError, mock, 'one', 'two')
950 def test_dir(self):
956 self.assertEqual(set(), type_attrs - attrs)
960 self.assertIn('a', dir(mock))
961 self.assertIn('b', dir(mock))
965 self.assertIn('c', dir(mock))
966 self.assertIn('d', dir(mock))
970 self.assertIn('__iter__', dir(mock))
973 def test_dir_from_spec(self):
979 self.assertEqual(set(), testcase_attrs - attrs)
983 self.assertEqual(dir(mock).count('version'), 1)
986 def test_filter_dir(self):
994 self.assertEqual(set(), type_attrs - attrs)
999 def test_dir_does_not_include_deleted_attributes(self):
1003 self.assertIn('child', dir(mock))
1005 self.assertNotIn('child', dir(mock))
1008 def test_configure_mock(self):
1010 self.assertEqual(mock.foo, 'bar')
1013 self.assertEqual(mock.foo, 'bar')
1018 self.assertRaises(KeyError, mock)
1019 self.assertEqual(mock.foo.bar(), 33)
1020 self.assertIsInstance(mock.foo, MagicMock)
1024 self.assertRaises(KeyError, mock)
1025 self.assertEqual(mock.foo.bar(), 33)
1026 self.assertIsInstance(mock.foo, MagicMock)
1029 def assertRaisesWithMsg(self, exception, message, func, *args, **kwargs):
1031 with self.assertRaises(exception) as context:
1034 self.assertEqual(msg, message)
1037 def test_assert_called_with_failure_message(self):
1043 self.assertRaisesWithMsg(
1058 self.assertRaisesWithMsg(
1068 self.assertRaisesWithMsg(
1078 self.assertRaisesWithMsg(
1088 self.assertRaisesWithMsg(
1093 def test_mock_calls(self):
1098 self.assertIs(mock.mock_calls == [], True)
1103 self.assertEqual(mock.mock_calls, expected)
1107 self.assertEqual(mock.mock_calls, expected)
1109 self.assertEqual(mock.foo.mock_calls, [('', (), {})])
1116 self.assertEqual(mock.mock_calls, expected)
1117 self.assertEqual(mock.return_value.foo.mock_calls,
1119 self.assertEqual(mock.return_value.mock_calls,
1128 self.assertEqual(mock.mock_calls, expected)
1129 self.assertEqual(mock().mock_calls,
1136 self.assertEqual(mock.mock_calls, expected)
1141 self.assertEqual(mock.mock_calls, expected)
1142 self.assertEqual(mock.a().mock_calls, [call()])
1146 self.assertEqual(mock.mock_calls, call(1)(2)(3).call_list())
1147 self.assertEqual(mock().mock_calls, call(2)(3).call_list())
1148 self.assertEqual(mock()().mock_calls, call(3).call_list())
1152 self.assertEqual(mock.mock_calls,
1154 self.assertEqual(mock().mock_calls,
1156 self.assertEqual(mock()().mock_calls,
1162 self.assertEqual(mock.mock_calls[-1], last_call)
1163 self.assertEqual(mock().mock_calls,
1165 self.assertEqual(mock().foo.bar().mock_calls,
1167 self.assertEqual(mock().foo.bar().baz.mock_calls,
1171 def test_child_mock_call_equal(self):
1176 self.assertEqual(m.mock_calls, [call(), call().wibble()])
1178 self.assertEqual(result.mock_calls, [call.wibble()])
1181 def test_mock_call_not_equal_leaf(self):
1184 self.assertNotEqual(m.mock_calls[1], call.foo().different())
1185 self.assertEqual(m.mock_calls[0], call.foo())
1188 def test_mock_call_not_equal_non_leaf(self):
1191 self.assertNotEqual(m.mock_calls[1], call.baz().bar())
1192 self.assertNotEqual(m.mock_calls[0], call.baz())
1195 def test_mock_call_not_equal_non_leaf_params_different(self):
1199 self.assertEqual(m.mock_calls[1], call.foo(x=2).bar())
1202 def test_mock_call_not_equal_non_leaf_attr(self):
1205 self.assertNotEqual(m.mock_calls[0], call.baz.bar())
1208 def test_mock_call_not_equal_non_leaf_call_versus_attr(self):
1211 self.assertNotEqual(m.mock_calls[0], call.foo().bar())
1214 def test_mock_call_repr(self):
1217 self.assertEqual(repr(m.mock_calls[0]), 'call.foo()')
1218 self.assertEqual(repr(m.mock_calls[1]), 'call.foo().bar()')
1219 self.assertEqual(repr(m.mock_calls[2]), 'call.foo().bar().baz.bob()')
1222 def test_mock_call_repr_loop(self):
1226 self.assertRegex(repr(m.foo()), r"<Mock name='mock\(\)' id='\d+'>")
1229 def test_mock_calls_contains(self):
1231 self.assertFalse([call()] in m.mock_calls)
1234 def test_subclassing(self):
1239 self.assertIsInstance(mock.foo, Subclass)
1240 self.assertIsInstance(mock(), Subclass)
1243 def _get_child_mock(self, **kwargs):
1247 self.assertNotIsInstance(mock.foo, Subclass)
1248 self.assertNotIsInstance(mock(), Subclass)
1251 def test_arg_lists(self):
1263 self.assertIsInstance(attr, _CallList)
1264 self.assertIsInstance(attr, list)
1265 self.assertEqual(attr, [])
1286 def test_call_args_two_tuple(self):
1291 self.assertEqual(len(mock.call_args), 2)
1292 self.assertEqual(mock.call_args.args, (2,))
1293 self.assertEqual(mock.call_args.kwargs, dict(b=4))
1297 self.assertEqual(len(call_args), 2)
1298 self.assertEqual(expected[0], call_args[0])
1299 self.assertEqual(expected[1], call_args[1])
1302 def test_side_effect_iterator(self):
1304 self.assertEqual([mock(), mock(), mock()], [1, 2, 3])
1305 self.assertRaises(StopIteration, mock)
1308 self.assertEqual([mock(), mock(), mock()], ['a', 'b', 'c'])
1309 self.assertRaises(StopIteration, mock)
1312 self.assertEqual([mock(), mock(), mock()], ['g', 'h', 'i'])
1313 self.assertRaises(StopIteration, mock)
1318 self.assertIsInstance(mock(), Foo)
1321 self.assertEqual([mock(), mock(), mock(), mock()],
1323 self.assertRaises(StopIteration, mock)
1326 def test_side_effect_iterator_exceptions(self):
1330 self.assertRaises(ValueError, m)
1331 self.assertEqual(m(), 3)
1332 self.assertRaises(KeyError, m)
1333 self.assertEqual(m(), 6)
1336 def test_side_effect_setting_iterator(self):
1339 self.assertEqual([mock(), mock(), mock()], [1, 2, 3])
1340 self.assertRaises(StopIteration, mock)
1342 self.assertIsInstance(side_effect, type(iter([])))
1345 self.assertEqual([mock(), mock(), mock()], ['a', 'b', 'c'])
1346 self.assertRaises(StopIteration, mock)
1348 self.assertIsInstance(side_effect, type(iter([])))
1352 self.assertEqual([mock(), mock(), mock(), mock()],
1354 self.assertRaises(StopIteration, mock)
1355 self.assertIs(mock.side_effect, this_iter)
1357 def test_side_effect_iterator_default(self):
1360 self.assertEqual([mock(), mock()], [1, 2])
1362 def test_assert_has_calls_any_order(self):
1380 self.assertRaises(
1401 self.assertRaises(
1406 def test_assert_has_calls(self):
1439 self.assertRaises(
1446 def test_assert_has_calls_nested_spec(self):
1449 def __init__(self): pass
1450 def meth(self, a, b, c, d=None): pass
1454 def __init__(self, a): pass
1455 def meth1(self, a, b): pass
1467 self.assertRaises(AssertionError, m.assert_has_calls, [call.Foo()])
1480 self.assertRaises(AssertionError,
1486 def test_assert_has_calls_nested_without_spec(self):
1494 def test_assert_has_calls_with_function_spec(self):
1515 with self.assertRaises(AssertionError):
1518 with self.assertRaises(AssertionError):
1521 with self.assertRaises(AssertionError):
1525 def test_assert_has_calls_not_matching_spec_error(self):
1531 with self.assertRaisesRegex(
1538 self.assertIsNone(cm.exception.__cause__)
1541 with self.assertRaisesRegex(
1550 self.assertIsInstance(cm.exception.__cause__, TypeError)
1552 def test_assert_any_call(self):
1562 self.assertRaises(
1566 self.assertRaises(
1571 self.assertRaises(
1578 def test_assert_any_call_with_function_spec(self):
1589 self.assertRaises(AssertionError, mock.assert_any_call,
1592 with self.assertRaises(AssertionError) as cm:
1594 self.assertIsInstance(cm.exception.__cause__, TypeError)
1597 def test_mock_calls_create_autospec(self):
1610 self.assertEqual(
1615 def test_create_autospec_with_name(self):
1617 self.assertIn('sweet_func', repr(m))
1620 def test_create_autospec_classmethod_and_staticmethod(self):
1628 with self.subTest(method=method):
1632 self.assertRaises(TypeError, mock_method, 'extra_arg')
1635 def test_mock_unsafe(self):
1638 with self.assertRaisesRegex(AttributeError, msg):
1640 with self.assertRaisesRegex(AttributeError, msg):
1642 with self.assertRaisesRegex(AttributeError, msg):
1644 with self.assertRaisesRegex(AttributeError, msg):
1646 with self.assertRaisesRegex(AttributeError, msg):
1656 def test_mock_safe_with_spec(self):
1658 def assert_bar(self):
1661 def assertSome(self):
1672 def test_assert_not_called(self):
1676 with self.assertRaises(AssertionError):
1679 def test_assert_not_called_message(self):
1682 self.assertRaisesRegex(AssertionError,
1686 def test_assert_called(self):
1688 with self.assertRaises(AssertionError):
1696 def test_assert_called_once(self):
1698 with self.assertRaises(AssertionError):
1704 with self.assertRaises(AssertionError):
1707 def test_assert_called_once_message(self):
1711 self.assertRaisesRegex(AssertionError,
1715 def test_assert_called_once_message_not_called(self):
1717 with self.assertRaises(AssertionError) as e:
1719 self.assertNotIn("Calls:", str(e.exception))
1722 def test_ordered_call_signature(self):
1726 self.assertEqual(repr(m.hello.call_args), text)
1729 def test_override_tuple_methods(self):
1735 self.assertEqual(m.method_calls[0], c)
1736 self.assertEqual(m.method_calls[1], i)
1738 def test_reset_return_sideeffect(self):
1741 self.assertIsInstance(m.return_value, Mock)
1742 self.assertEqual(m.side_effect, None)
1744 def test_reset_return(self):
1747 self.assertIsInstance(m.return_value, Mock)
1748 self.assertNotEqual(m.side_effect, None)
1750 def test_reset_sideeffect(self):
1753 self.assertEqual(m.return_value, 10)
1754 self.assertEqual(m.side_effect, None)
1756 def test_reset_return_with_children(self):
1758 self.assertEqual(m.f(), 1)
1760 self.assertNotEqual(m.f(), 1)
1762 def test_reset_return_with_children_side_effect(self):
1764 self.assertNotEqual(m.f.side_effect, None)
1766 self.assertEqual(m.f.side_effect, None)
1768 def test_mock_add_spec(self):
1794 self.assertRaises(
1797 self.assertRaises(
1801 self.assertRaises(
1806 self.assertRaises(
1810 self.assertRaises(
1814 self.assertRaises(
1821 def test_mock_add_spec_magic_methods(self):
1827 self.assertRaises(TypeError, int, mock)
1834 self.assertEqual(int(mock), 4)
1835 self.assertRaises(TypeError, lambda: mock['foo'])
1838 def test_adding_child_mock(self):
1846 self.assertEqual(mock.method_calls, [call.foo()])
1847 self.assertEqual(mock.mock_calls, [call.foo()])
1852 self.assertEqual(mock.method_calls, [])
1853 self.assertEqual(mock.mock_calls, [])
1859 self.assertEqual(mock.method_calls, [])
1860 self.assertEqual(mock.mock_calls, [])
1863 def test_adding_return_value_mock(self):
1869 self.assertEqual(mock.mock_calls, [call(), call()()])
1872 def test_manager_mock(self):
1881 self.addCleanup(p1.stop)
1883 self.addCleanup(p2.stop)
1891 self.assertEqual(manager.mock_calls, [call.two(), call.one()])
1894 def test_magic_methods_mock_calls(self):
1902 self.assertEqual(m.mock_calls, [call.__int__(), call.__float__()])
1903 self.assertEqual(m.method_calls, [])
1905 def test_mock_open_reuse_issue_21750(self):
1911 self.assertEqual(f1_data, f2_data)
1913 def test_mock_open_dunder_iter_issue(self):
1919 self.assertEqual(lines[0], 'Remarkable\n')
1920 self.assertEqual(lines[1], 'Norwegian Blue')
1921 self.assertEqual(list(f1), [])
1923 def test_mock_open_using_next(self):
1929 self.assertEqual(line1, '1st line\n')
1930 self.assertEqual(line2, '2nd line\n')
1931 self.assertEqual(lines[0], '3rd line')
1932 self.assertEqual(list(f1), [])
1933 with self.assertRaises(StopIteration):
1936 def test_mock_open_next_with_readline_with_return_value(self):
1939 self.assertEqual('abc', next(mopen()))
1941 def test_mock_open_write(self):
1950 self.assertRaises(OSError, attempt)
1952 def test_mock_open_alter_readline(self):
1957 self.assertEqual('abc', first)
1958 self.assertEqual('abc', second)
1960 def test_mock_open_after_eof(self):
1965 self.assertEqual('', h.read())
1966 self.assertEqual('', h.read())
1967 self.assertEqual('', h.readline())
1968 self.assertEqual('', h.readline())
1969 self.assertEqual([], h.readlines())
1970 self.assertEqual([], h.readlines())
1972 def test_mock_parents(self):
1977 self.assertIs(m(), m)
1978 self.assertEqual(repr(m), original_repr)
1981 self.assertIs(m(), m)
1982 self.assertEqual(repr(m), original_repr)
1986 self.assertIn("name='mock.a'", repr(m.b))
1987 self.assertIn("name='mock.a'", repr(m.a))
1989 self.assertIn("name='mock.a'", repr(m.b))
1990 self.assertIn("name='mock.a'", repr(m.a))
1997 self.assertEqual(repr(m), original_repr)
1998 self.assertEqual(repr(m.a()), original_repr)
2001 def test_attach_mock(self):
2010 self.assertIs(m.bar, m2)
2011 self.assertIn("name='mock.bar'", repr(m2))
2014 self.assertEqual(m.mock_calls, [call.bar.baz(1)])
2015 self.assertEqual(m.method_calls, [call.bar.baz(1)])
2018 def test_attach_mock_return_value(self):
2027 self.assertIs(m(), m2)
2028 self.assertIn("name='mock()'", repr(m2))
2031 self.assertEqual(m.mock_calls, call().foo().call_list())
2034 def test_attach_mock_patch_autospec(self):
2038 self.assertEqual(mock_func.mock._extract_mock_name(), 'something')
2046 self.assertEqual(parent.mock_calls, parent_calls)
2047 self.assertEqual(parent.child.mock_calls, child_calls)
2048 self.assertEqual(something.mock_calls, child_calls)
2049 self.assertEqual(mock_func.mock_calls, child_calls)
2050 self.assertIn('mock.child', repr(parent.child.mock))
2051 self.assertEqual(mock_func.mock._extract_mock_name(), 'mock.child')
2054 def test_attach_mock_patch_autospec_signature(self):
2083 def test_attribute_deletion(self):
2086 self.assertTrue(hasattr(mock, 'm'))
2089 self.assertFalse(hasattr(mock, 'm'))
2092 self.assertFalse(hasattr(mock, 'f'))
2093 self.assertRaises(AttributeError, getattr, mock, 'f')
2096 def test_mock_does_not_raise_on_repeated_attribute_deletion(self):
2101 self.assertTrue(hasattr(mock, 'foo'))
2102 self.assertEqual(mock.foo, 3)
2105 self.assertFalse(hasattr(mock, 'foo'))
2108 self.assertTrue(hasattr(mock, 'foo'))
2109 self.assertEqual(mock.foo, 4)
2112 self.assertFalse(hasattr(mock, 'foo'))
2115 def test_mock_raises_when_deleting_nonexistent_attribute(self):
2119 with self.assertRaises(AttributeError):
2123 def test_reset_mock_does_not_raise_on_attr_deletion(self):
2130 self.assertFalse(hasattr(mock, 'child'))
2133 def test_class_assignable(self):
2135 self.assertNotIsInstance(mock, int)
2138 self.assertIsInstance(mock, int)
2141 def test_name_attribute_of_call(self):
2144 self.assertIsNotNone(call.name)
2145 self.assertEqual(type(call.name), _Call)
2146 self.assertEqual(type(call.name().name), _Call)
2148 def test_parent_attribute_of_call(self):
2151 self.assertIsNotNone(call.parent)
2152 self.assertEqual(type(call.parent), _Call)
2153 self.assertEqual(type(call.parent().parent), _Call)
2156 def test_parent_propagation_with_create_autospec(self):
2164 self.assertRaises(TypeError, mock.child, 1)
2165 self.assertEqual(mock.mock_calls, [call.child(1, 2)])
2166 self.assertIn('mock.child', repr(mock.child.mock))
2168 def test_parent_propagation_with_autospec_attach_mock(self):
2176 self.assertRaises(TypeError, parent.child, 1)
2177 self.assertEqual(parent.child.mock_calls, [call.child(1, 2)])
2178 self.assertIn('mock.child', repr(parent.child.mock))
2181 def test_isinstance_under_settrace(self):
2195 self.addCleanup(lambda patch: setattr(unittest.mock, 'patch', patch),
2205 self.addCleanup(sys.settrace, sys.gettrace())
2218 self.assertIsInstance(obj, Something)
2220 def test_bool_not_called_when_passing_spec_arg(self):
2222 def __init__(self):
2223 self.obj_with_bool_func = unittest.mock.MagicMock()
2228 self.assertEqual(obj.obj_with_bool_func.__bool__.call_count, 0)
2230 def test_misspelled_arguments(self):
2235 with self.assertRaises(RuntimeError):
2237 with self.assertRaises(RuntimeError):
2239 with self.assertRaises(RuntimeError):
2241 with self.assertRaises(RuntimeError):
2243 with self.assertRaises(RuntimeError):
2245 with self.assertRaises(RuntimeError):
2247 with self.assertRaises(RuntimeError):
2252 with self.assertRaises(AttributeError):
2255 with self.assertRaises(AttributeError):
2258 with self.assertRaises(AttributeError):