Lines Matching refs:mock
9 from unittest import mock
10 from unittest.mock import (
56 exec("from unittest.mock import *")
60 mock = Mock()
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, [],
75 # Can't use hasattr for this test as it always returns True on a mock
76 self.assertNotIn('_items', mock.__dict__,
77 "default mock should not have '_items' attribute")
79 self.assertIsNone(mock._mock_parent,
81 self.assertIsNone(mock._mock_methods,
83 self.assertEqual(mock._mock_children, {},
88 mock = Mock(return_value=None)
89 self.assertIsNone(mock.return_value,
95 mock = create_autospec(f)
96 mock.mock.return_value = 1
97 self.assertEqual(mock(), 1)
102 mock = create_autospec(f)
103 mock.mock.side_effect = TypeError()
105 mock()
109 mock = Mock(name='foo')
110 self.assertIn('foo', repr(mock))
111 self.assertIn("'%s'" % id(mock), repr(mock))
113 mocks = [(Mock(), 'mock'), (Mock(name='bar'), 'bar')]
114 for mock, name in mocks:
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()()))
121 repr(mock()().foo.bar.baz().bing))
128 mock = Mock(spec=X)
129 self.assertIn(" spec='X' ", repr(mock))
131 mock = Mock(spec=X())
132 self.assertIn(" spec='X' ", repr(mock))
134 mock = Mock(spec_set=X)
135 self.assertIn(" spec_set='X' ", repr(mock))
137 mock = Mock(spec_set=X())
138 self.assertIn(" spec_set='X' ", repr(mock))
140 mock = Mock(spec=X, name='foo')
141 self.assertIn(" spec='X' ", repr(mock))
142 self.assertIn(" name='foo' ", repr(mock))
144 mock = Mock(name='foo')
145 self.assertNotIn("spec", repr(mock))
147 mock = Mock()
148 self.assertNotIn("spec", repr(mock))
150 mock = Mock(spec=['foo'])
151 self.assertNotIn("spec", repr(mock))
155 mock = Mock()
160 mock.side_effect = effect
161 self.assertRaises(SystemError, mock, 1, 2, fish=3)
162 mock.assert_called_with(1, 2, fish=3)
167 mock.side_effect = effect
169 self.assertEqual([mock(), mock(), mock()], [3, 2, 1],
172 mock = Mock(side_effect=sentinel.SideEffect)
173 self.assertEqual(mock.side_effect, sentinel.SideEffect,
178 mock = Mock(side_effect=side_effect, return_value=sentinel.RETURN)
179 self.assertEqual(mock(), sentinel.RETURN)
188 mock = create_autospec(f)
189 mock.side_effect = [1, 2, 3]
190 self.assertEqual([mock(), mock(), mock()], [1, 2, 3],
194 mock = create_autospec(f)
195 mock.side_effect = effect
196 self.assertEqual([mock(), mock(), mock()], [3, 2, 1],
203 mock = create_autospec(f)
204 mock.side_effect = ValueError('Bazinga!')
205 self.assertRaisesRegex(ValueError, 'Bazinga!', mock)
213 with mock.patch.object(A, 'B'):
219 mock.patch.object(A, 'B', autospec=True).start()
222 mock.patch.object(A.B, 'C', autospec=True).start()
225 mock.patch.object(A, 'B', spec=A.B).start()
228 mock.patch.object(A, 'B', spec_set=A.B).start()
231 mock.patch.object(A, 'B', spec_set=A.B).start()
233 mock.Mock(A.B)
234 with mock.patch('builtins.open', mock.mock_open()):
235 mock.mock_open() # should still be valid with open() mocked
241 mock = Mock(name="child", parent=parent, spec=spec)
242 mock(sentinel.Something, something=sentinel.SomethingElse)
243 something = mock.something
244 mock.something()
245 mock.side_effect = sentinel.SideEffect
246 return_value = mock.return_value
249 mock.reset_mock()
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, [],
264 (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")
280 mock = Mock()
281 mock.return_value = mock
284 mock.reset_mock()
287 a = mock.mock_open()
291 mock = Mock()
292 self.assertTrue(is_instance(mock.return_value, Mock),
295 result = mock()
296 self.assertEqual(mock(), result,
298 mock.reset_mock()
300 ret_val = mock(sentinel.Arg)
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,), {})],
312 mock.return_value = sentinel.ReturnValue
313 ret_val = mock(sentinel.Arg, key=sentinel.KeyArg)
317 self.assertEqual(mock.call_count, 2, "call_count incorrect")
318 self.assertEqual(mock.call_args,
321 self.assertEqual(mock.call_args_list, [
329 mock = Mock()
330 mock()
331 mock(sentinel.Arg)
332 mock(kw=sentinel.Kwarg)
333 mock(sentinel.Arg, kw=sentinel.Kwarg)
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")
352 # comparing with mock.ANY
353 mm = mock.MagicMock()
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)
365 call1 = mock.call(mock.MagicMock())
366 call2 = mock.call(mock.ANY)
379 mock = Mock()
380 mock()
383 mock.assert_called_with()
384 self.assertRaises(AssertionError, mock.assert_called_with, 1)
386 mock.reset_mock()
387 self.assertRaises(AssertionError, mock.assert_called_with)
389 mock(1, 2, 3, a='fish', b='nothing')
390 mock.assert_called_with(1, 2, 3, a='fish', b='nothing')
396 m.assert_called_with(mock.ANY)
402 mock = Mock(spec=f)
404 mock(1, b=2, c=3)
405 mock.assert_called_with(1, 2, 3)
406 mock.assert_called_with(a=1, b=2, c=3)
407 self.assertRaises(AssertionError, mock.assert_called_with,
411 mock.assert_called_with(e=8)
416 def _check(mock):
417 mock(1, b=2, c=3)
418 mock.assert_called_with(1, 2, 3)
419 mock.assert_called_with(a=1, b=2, c=3)
420 self.assertRaises(AssertionError, mock.assert_called_with,
423 mock = Mock(spec=Something().meth)
424 _check(mock)
425 mock = Mock(spec=Something.cmeth)
426 _check(mock)
427 mock = Mock(spec=Something().cmeth)
428 _check(mock)
429 mock = Mock(spec=Something.smeth)
430 _check(mock)
431 mock = Mock(spec=Something().smeth)
432 _check(mock)
437 with self.assertRaisesRegex(AssertionError, msg.format('mock')):
444 mock = Mock()
445 mock()
448 mock.assert_called_once_with()
450 mock()
451 self.assertRaises(AssertionError, mock.assert_called_once_with)
453 mock.reset_mock()
454 self.assertRaises(AssertionError, mock.assert_called_once_with)
456 mock('foo', 'bar', baz=2)
457 mock.assert_called_once_with('foo', 'bar', baz=2)
459 mock.reset_mock()
460 mock('foo', 'bar', baz=2)
463 lambda: mock.assert_called_once_with('bob', 'bar', baz=2)
478 mock = Mock(spec=f)
480 mock(1, b=2, c=3)
481 mock.assert_called_once_with(1, 2, 3)
482 mock.assert_called_once_with(a=1, b=2, c=3)
483 self.assertRaises(AssertionError, mock.assert_called_once_with,
487 mock.assert_called_once_with(e=8)
490 mock(4, 5, 6)
491 self.assertRaises(AssertionError, mock.assert_called_once_with,
493 self.assertRaises(AssertionError, mock.assert_called_once_with,
498 mock = Mock()
499 something = mock.something
500 self.assertTrue(is_instance(something, Mock), "attribute isn't a mock")
501 self.assertEqual(mock.something, something,
505 mock = Mock()
506 mock.something.return_value = 3
508 self.assertEqual(mock.something(), 3, "method returned wrong value")
509 self.assertTrue(mock.something.called,
514 mock = Mock()
515 something = mock.something
519 self.assertEqual(something._mock_parent, mock,
524 mock = Mock()
525 mock.something(3, fish=None)
526 mock.something_else.something(6, cake=sentinel.Cake)
528 self.assertEqual(mock.something_else.method_calls,
531 self.assertEqual(mock.method_calls, [
539 mock = Mock()
540 mock.something()
541 self.assertEqual(mock.method_calls, [('something',)])
542 self.assertEqual(mock.method_calls, [('something', (), {})])
544 mock = Mock()
545 mock.something('different')
546 self.assertEqual(mock.method_calls, [('something', ('different',))])
547 self.assertEqual(mock.method_calls,
550 mock = Mock()
551 mock.something(x=1)
552 self.assertEqual(mock.method_calls, [('something', {'x': 1})])
553 self.assertEqual(mock.method_calls, [('something', (), {'x': 1})])
555 mock = Mock()
556 mock.something('different', some='more')
557 self.assertEqual(mock.method_calls, [
565 mock = Mock(**{arg: spec})
568 mock.something
572 getattr, mock, 'something_else'
582 def test_attributes(mock):
584 mock.x
585 mock.y
586 mock.__something__
590 getattr, mock, 'z'
595 getattr, mock, '__foobar__'
605 mock = Mock(wraps=real)
606 self.assertEqual(mock(), real())
610 mock(1, 2, fish=3)
619 mock = Mock(wraps=real)
621 self.assertRaises(AttributeError, lambda: mock.new_attr())
627 mock = Mock(wraps=real)
628 mock.return_value = 3
630 self.assertEqual(mock(), 3)
640 mock = Mock(wraps=real)
641 self.assertEqual(mock.attribute(), real.attribute())
642 self.assertRaises(AttributeError, lambda: mock.fish)
644 self.assertNotEqual(mock.attribute, real.attribute)
645 result = mock.attribute.frog(1, 2, fish=3)
656 mock = Mock(wraps=real)
657 mock.method.side_effect = [sentinel.VALUE1, DEFAULT]
659 self.assertEqual(mock.method(), sentinel.VALUE1)
660 self.assertEqual(mock.method(), sentinel.ORIGINAL_VALUE)
661 self.assertRaises(StopIteration, mock.method)
669 mock = Mock(wraps=real)
670 mock.method.side_effect = [sentinel.VALUE1, sentinel.VALUE2]
672 self.assertEqual(mock.method(), sentinel.VALUE1)
673 self.assertEqual(mock.method(), sentinel.VALUE2)
674 self.assertRaises(StopIteration, mock.method)
682 mock = Mock(wraps=real)
683 mock.method.side_effect = RuntimeError
685 self.assertRaises(RuntimeError, mock.method)
695 mock = Mock(wraps=real)
696 mock.method.side_effect = side_effect
698 self.assertEqual(mock.method(), sentinel.VALUE)
706 mock = Mock(wraps=real)
707 mock.method.return_value = sentinel.VALUE
709 self.assertEqual(mock.method(), sentinel.VALUE)
718 mock = Mock(wraps=real)
719 mock.method.side_effect = [sentinel.VALUE1, sentinel.VALUE2]
720 mock.method.return_value = sentinel.WRONG_VALUE
722 self.assertEqual(mock.method(), sentinel.VALUE1)
723 self.assertEqual(mock.method(), sentinel.VALUE2)
724 self.assertRaises(StopIteration, mock.method)
733 mock = Mock(wraps=real)
734 mock.method.side_effect = lambda: DEFAULT
735 mock.method.return_value = sentinel.VALUE
737 self.assertEqual(mock.method(), sentinel.VALUE)
745 mock = Mock(wraps=real)
746 mock.method.side_effect = [sentinel.VALUE1, DEFAULT]
747 mock.method.return_value = sentinel.RETURN
749 self.assertEqual(mock.method(), sentinel.VALUE1)
750 self.assertEqual(mock.method(), sentinel.RETURN)
751 self.assertRaises(StopIteration, mock.method)
806 mock = Mock(side_effect=AttributeError)
807 self.assertRaises(AttributeError, mock)
809 mock = Mock(side_effect=AttributeError('foo'))
810 self.assertRaises(AttributeError, mock)
814 mock = Mock(side_effect=KeyboardInterrupt)
815 self.assertRaises(KeyboardInterrupt, mock)
817 mock = Mock(side_effect=KeyboardInterrupt('foo'))
818 self.assertRaises(KeyboardInterrupt, mock)
822 mock = Mock()
824 mock.assert_called_with)
828 mock = Mock(name='geoffrey')
831 mock.assert_called_once_with)
835 mock = Mock()
836 self.assertRaises(AttributeError, lambda: mock.__name__)
838 mock.__name__ = 'foo'
839 self.assertEqual(mock.__name__, 'foo')
845 mock = Mock(spec=Sub(['foo']))
847 mock.append(3)
848 mock.append.assert_called_with(3)
849 self.assertRaises(AttributeError, getattr, mock, 'foo')
856 mock = Mock(spec=X)
857 self.assertIsInstance(mock, X)
859 mock = Mock(spec=X())
860 self.assertIsInstance(mock, X)
862 self.assertIs(mock.__class__, X)
865 mock = Mock(spec_set=X)
866 self.assertIsInstance(mock, X)
868 mock = Mock(spec_set=X())
869 self.assertIsInstance(mock, X)
876 mock = Mock(spec=X)
877 self.assertIsInstance(mock, X)
879 mock = Mock(spec=X())
880 self.assertIsInstance(mock, X)
882 self.assertIs(mock.__class__, X)
885 mock = Mock(spec_set=X)
886 self.assertIsInstance(mock, X)
888 mock = Mock(spec_set=X())
889 self.assertIsInstance(mock, X)
896 mock = Mock(spec=X)
897 mock.x = 'foo'
899 mock = Mock(spec_set=X)
901 mock.x = 'foo'
903 mock.y = 'foo'
938 mock = Mock()
943 type(mock).__call__ = __call__
944 mock('one')
945 mock.assert_called_with('one')
947 self.assertRaises(TypeError, mock, 'one', 'two')
951 mock = Mock()
952 attrs = set(dir(mock))
959 mock.a, mock.b
960 self.assertIn('a', dir(mock))
961 self.assertIn('b', dir(mock))
964 mock.c = mock.d = None
965 self.assertIn('c', dir(mock))
966 self.assertIn('d', dir(mock))
969 mock.__iter__ = lambda s: iter([])
970 self.assertIn('__iter__', dir(mock))
974 mock = Mock(spec=unittest.TestCase)
976 attrs = set(dir(mock))
982 mock.version = 3
983 self.assertEqual(dir(mock).count('version'), 1)
987 patcher = patch.object(mock, 'FILTER_DIR', False)
1000 mock = Mock()
1001 mock.child.return_value = 1
1003 self.assertIn('child', dir(mock))
1004 del mock.child
1005 self.assertNotIn('child', dir(mock))
1009 mock = Mock(foo='bar')
1010 self.assertEqual(mock.foo, 'bar')
1012 mock = MagicMock(foo='bar')
1013 self.assertEqual(mock.foo, 'bar')
1017 mock = Mock(**kwargs)
1018 self.assertRaises(KeyError, mock)
1019 self.assertEqual(mock.foo.bar(), 33)
1020 self.assertIsInstance(mock.foo, MagicMock)
1022 mock = Mock()
1023 mock.configure_mock(**kwargs)
1024 self.assertRaises(KeyError, mock)
1025 self.assertEqual(mock.foo.bar(), 33)
1026 self.assertIsInstance(mock.foo, MagicMock)
1038 mock = NonCallableMock()
1041 expected = "mock(1, '2', 3, bar='foo')"
1045 mock.assert_called_with, 1, '2', 3, bar='foo'
1048 mock.foo(1, '2', 3, foo='foo')
1052 mock.foo.assert_called_with, mock.foo.assert_called_once_with
1094 mock = MagicMock()
1098 self.assertIs(mock.mock_calls == [], True)
1100 mock = MagicMock()
1101 mock()
1103 self.assertEqual(mock.mock_calls, expected)
1105 mock.foo()
1107 self.assertEqual(mock.mock_calls, expected)
1109 self.assertEqual(mock.foo.mock_calls, [('', (), {})])
1111 mock = MagicMock()
1112 mock().foo(1, 2, 3, a=4, b=5)
1116 self.assertEqual(mock.mock_calls, expected)
1117 self.assertEqual(mock.return_value.foo.mock_calls,
1119 self.assertEqual(mock.return_value.mock_calls,
1122 mock = MagicMock()
1123 mock().foo.bar().baz()
1128 self.assertEqual(mock.mock_calls, expected)
1129 self.assertEqual(mock().mock_calls,
1133 mock = MagicMock(**kwargs)
1134 int(mock.foo)
1136 self.assertEqual(mock.mock_calls, expected)
1138 mock = MagicMock(**kwargs)
1139 mock.a()()
1141 self.assertEqual(mock.mock_calls, expected)
1142 self.assertEqual(mock.a().mock_calls, [call()])
1144 mock = MagicMock(**kwargs)
1145 mock(1)(2)(3)
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())
1150 mock = MagicMock(**kwargs)
1151 mock(1)(2)(3).a.b.c(4)
1152 self.assertEqual(mock.mock_calls,
1154 self.assertEqual(mock().mock_calls,
1156 self.assertEqual(mock()().mock_calls,
1159 mock = MagicMock(**kwargs)
1160 int(mock().foo.bar().baz())
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,
1226 self.assertRegex(repr(m.foo()), r"<Mock name='mock\(\)' id='\d+'>")
1238 mock = Subclass()
1239 self.assertIsInstance(mock.foo, Subclass)
1240 self.assertIsInstance(mock(), Subclass)
1246 mock = Subclass()
1247 self.assertNotIsInstance(mock.foo, Subclass)
1248 self.assertNotIsInstance(mock(), Subclass)
1259 def assert_attrs(mock):
1262 attr = getattr(mock, name)
1267 for mock in mocks:
1268 assert_attrs(mock)
1270 if callable(mock):
1271 mock()
1272 mock(1, 2)
1273 mock(a=3)
1275 mock.reset_mock()
1276 assert_attrs(mock)
1278 mock.foo()
1279 mock.foo.bar(1, a=3)
1280 mock.foo(1).bar().baz(3)
1282 mock.reset_mock()
1283 assert_attrs(mock)
1287 mock = Mock()
1288 mock(1, a=3)
1289 mock(2, b=4)
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))
1296 for expected, call_args in zip(expected_list, mock.call_args_list):
1303 mock = Mock(side_effect=iter([1, 2, 3]))
1304 self.assertEqual([mock(), mock(), mock()], [1, 2, 3])
1305 self.assertRaises(StopIteration, mock)
1307 mock = MagicMock(side_effect=['a', 'b', 'c'])
1308 self.assertEqual([mock(), mock(), mock()], ['a', 'b', 'c'])
1309 self.assertRaises(StopIteration, mock)
1311 mock = Mock(side_effect='ghi')
1312 self.assertEqual([mock(), mock(), mock()], ['g', 'h', 'i'])
1313 self.assertRaises(StopIteration, mock)
1317 mock = MagicMock(side_effect=Foo)
1318 self.assertIsInstance(mock(), Foo)
1320 mock = Mock(side_effect=Iter())
1321 self.assertEqual([mock(), mock(), mock(), mock()],
1323 self.assertRaises(StopIteration, mock)
1337 mock = Mock()
1338 mock.side_effect = iter([1, 2, 3])
1339 self.assertEqual([mock(), mock(), mock()], [1, 2, 3])
1340 self.assertRaises(StopIteration, mock)
1341 side_effect = mock.side_effect
1344 mock.side_effect = ['a', 'b', 'c']
1345 self.assertEqual([mock(), mock(), mock()], ['a', 'b', 'c'])
1346 self.assertRaises(StopIteration, mock)
1347 side_effect = mock.side_effect
1351 mock.side_effect = this_iter
1352 self.assertEqual([mock(), mock(), mock(), mock()],
1354 self.assertRaises(StopIteration, mock)
1355 self.assertIs(mock.side_effect, this_iter)
1358 mock = Mock(return_value=2)
1359 mock.side_effect = iter([1, DEFAULT])
1360 self.assertEqual([mock(), mock()], [1, 2])
1363 mock = Mock()
1364 mock(1, 2)
1365 mock(a=3)
1366 mock(3, 4)
1367 mock(b=6)
1368 mock(b=6)
1377 mock.assert_has_calls([kall], any_order=True)
1381 AssertionError, mock.assert_has_calls,
1392 mock.assert_has_calls(kall_list, any_order=True)
1402 AssertionError, mock.assert_has_calls,
1417 for mock in Mock(), MagicMock():
1418 mock(1, 2)
1419 mock(a=3)
1420 mock(3, 4)
1421 mock(b=6)
1422 mock(1, b=6)
1423 mocks.append((mock, kalls1))
1425 mock = Mock()
1426 mock.foo()
1427 mock.bar(1)
1428 mock.spam().baz(a=3)
1429 mock.bam(set(), foo={}).fish([1])
1430 mocks.append((mock, kalls2))
1432 for mock, kalls in mocks:
1436 mock.assert_has_calls(these)
1441 mock.assert_has_calls,
1497 mock = Mock(spec=f)
1499 mock(1, b=2, c=3)
1500 mock(4, 5, c=6, d=7)
1501 mock(10, 11, c=12)
1507 mock.assert_has_calls(calls)
1508 mock.assert_has_calls(calls, any_order=True)
1509 mock.assert_has_calls(calls[1:])
1510 mock.assert_has_calls(calls[1:], any_order=True)
1511 mock.assert_has_calls(calls[:-1])
1512 mock.assert_has_calls(calls[:-1], any_order=True)
1516 mock.assert_has_calls(calls)
1517 mock.assert_has_calls(calls, any_order=True)
1519 mock.assert_has_calls(calls[1:])
1520 mock.assert_has_calls(calls[1:], any_order=True)
1522 mock.assert_has_calls(calls[:-1])
1523 mock.assert_has_calls(calls[:-1], any_order=True)
1528 mock = Mock(spec=f)
1529 mock(1)
1537 mock.assert_has_calls([call()])
1549 mock.assert_has_calls([call(), call(1, 2)])
1553 mock = Mock()
1554 mock(1, 2)
1555 mock(a=3)
1556 mock(1, b=6)
1558 mock.assert_any_call(1, 2)
1559 mock.assert_any_call(a=3)
1560 mock.assert_any_call(1, b=6)
1564 mock.assert_any_call
1568 mock.assert_any_call,
1573 mock.assert_any_call,
1581 mock = Mock(spec=f)
1583 mock(1, b=2, c=3)
1584 mock(4, 5, c=6, d=7)
1585 mock.assert_any_call(1, 2, 3)
1586 mock.assert_any_call(a=1, b=2, c=3)
1587 mock.assert_any_call(4, 5, 6, 7)
1588 mock.assert_any_call(a=4, b=5, c=6, d=7)
1589 self.assertRaises(AssertionError, mock.assert_any_call,
1593 mock.assert_any_call(e=8)
1616 m = mock.create_autospec(object(), name='sweet_func')
1629 mock_method = mock.create_autospec(getattr(TestClass, method))
1637 msg = "is not a valid assertion. Use a spec for the mock"
1728 #Issue21270 overrides tuple methods for mock.call objects
1785 mock = Klass()
1787 mock.one, mock.two, mock.three
1791 mock.mock_add_spec(One, **kwargs)
1793 mock.one
1795 AttributeError, getattr, mock, 'two'
1798 AttributeError, getattr, mock, 'three'
1802 AttributeError, setattr, mock, 'three', None
1805 mock.mock_add_spec(Two, **kwargs)
1807 AttributeError, getattr, mock, 'one'
1809 mock.two
1811 AttributeError, getattr, mock, 'three'
1815 AttributeError, setattr, mock, 'three', None
1817 # note that creating a mock, setting an instance attribute, and
1823 mock = Klass()
1824 int(mock)
1826 mock.mock_add_spec(object)
1827 self.assertRaises(TypeError, int, mock)
1829 mock = Klass()
1830 mock['foo']
1831 mock.__int__.return_value =4
1833 mock.mock_add_spec(int)
1834 self.assertEqual(int(mock), 4)
1835 self.assertRaises(TypeError, lambda: mock['foo'])
1841 mock = Klass()
1843 mock.foo = Mock()
1844 mock.foo()
1846 self.assertEqual(mock.method_calls, [call.foo()])
1847 self.assertEqual(mock.mock_calls, [call.foo()])
1849 mock = Klass()
1850 mock.bar = Mock(name='name')
1851 mock.bar()
1852 self.assertEqual(mock.method_calls, [])
1853 self.assertEqual(mock.mock_calls, [])
1855 # mock with an existing _new_parent but no name
1856 mock = Klass()
1857 mock.baz = MagicMock()()
1858 mock.baz()
1859 self.assertEqual(mock.method_calls, [])
1860 self.assertEqual(mock.mock_calls, [])
1865 mock = Klass()
1866 mock.return_value = MagicMock()
1868 mock()()
1869 self.assertEqual(mock.mock_calls, [call(), call()()])
1906 mocked_open = mock.mock_open(read_data='data')
1916 mocked_open = mock.mock_open(read_data='Remarkable\nNorwegian Blue')
1924 mocked_open = mock.mock_open(read_data='1st line\n2nd line\n3rd line')
1937 mopen = mock.mock_open(read_data='foo\nbarn')
1943 mock_namedtemp = mock.mock_open(mock.MagicMock(name='JLV'))
1944 with mock.patch('tempfile.NamedTemporaryFile', mock_namedtemp):
1953 mopen = mock.mock_open(read_data='foo\nbarn')
1962 _open = mock.mock_open(read_data='foo')
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))
2011 self.assertIn("name='mock.bar'", repr(m2))
2028 self.assertIn("name='mock()'", repr(m2))
2037 with mock.patch(f'{__name__}.something', autospec=True) as mock_func:
2038 self.assertEqual(mock_func.mock._extract_mock_name(), 'something')
2050 self.assertIn('mock.child', repr(parent.child.mock))
2051 self.assertEqual(mock_func.mock._extract_mock_name(), 'mock.child')
2055 with mock.patch(f'{__name__}.Something.meth', autospec=True) as mocked:
2060 manager.assert_has_calls([call.attach_meth(mock.ANY, 1, 2, 3, d=4)])
2061 obj.meth.assert_has_calls([call(mock.ANY, 1, 2, 3, d=4)])
2062 mocked.assert_has_calls([call(mock.ANY, 1, 2, 3, d=4)])
2064 with mock.patch(f'{__name__}.something', autospec=True) as mocked:
2072 with mock.patch(f'{__name__}.Something', autospec=True) as mocked:
2084 for mock in (Mock(), MagicMock(), NonCallableMagicMock(),
2086 self.assertTrue(hasattr(mock, 'm'))
2088 del mock.m
2089 self.assertFalse(hasattr(mock, 'm'))
2091 del mock.f
2092 self.assertFalse(hasattr(mock, 'f'))
2093 self.assertRaises(AttributeError, getattr, mock, 'f')
2098 for mock in (Mock(), MagicMock(), NonCallableMagicMock(),
2100 mock.foo = 3
2101 self.assertTrue(hasattr(mock, 'foo'))
2102 self.assertEqual(mock.foo, 3)
2104 del mock.foo
2105 self.assertFalse(hasattr(mock, 'foo'))
2107 mock.foo = 4
2108 self.assertTrue(hasattr(mock, 'foo'))
2109 self.assertEqual(mock.foo, 4)
2111 del mock.foo
2112 self.assertFalse(hasattr(mock, 'foo'))
2116 for mock in (Mock(), MagicMock(), NonCallableMagicMock(),
2118 del mock.foo
2120 del mock.foo
2125 # were deleted in a mock instance
2126 mock = Mock()
2127 mock.child = True
2128 del mock.child
2129 mock.reset_mock()
2130 self.assertFalse(hasattr(mock, 'child'))
2134 for mock in Mock(), MagicMock():
2135 self.assertNotIsInstance(mock, int)
2137 mock.__class__ = int
2138 self.assertIsInstance(mock, int)
2139 mock.foo
2160 mock = Mock()
2161 mock.child = create_autospec(foo)
2162 mock.child(1, 2)
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))
2178 self.assertIn('mock.child', repr(parent.child.mock))
2186 # dependent on unittest.mock.patch. In testpatch.PatchTest
2190 old_patch = unittest.mock.patch
2192 # Directly using __setattr__ on unittest.mock causes current imported
2195 self.addCleanup(lambda patch: setattr(unittest.mock, 'patch', patch),
2199 del sys.modules['unittest.mock']
2208 from unittest.mock import (
2216 for mock in mocks:
2217 obj = mock(spec=Something)
2223 self.obj_with_bool_func = unittest.mock.MagicMock()
2226 with unittest.mock.patch.object(obj, 'obj_with_bool_func', spec=object): pass