python/mock-1.0.0/tests/testmock.py@a63d609f5ebe
python/mock-1.0.0/tests/testmock.py
Thu, 15 Jan 2015 15:55:04 +0100
- author
- Michael Schloh von Bennewitz <michael@schloh.com>
- date
- Thu, 15 Jan 2015 15:55:04 +0100
- branch
- TOR_BUG_9701
- changeset 9
- a63d609f5ebe
- permissions
- -rw-r--r--
Back out 97036ab72558 which inappropriately compared turds to third parties.
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/
5 from tests.support import (
6 callable, unittest2, inPy3k, is_instance, next
7 )
9 import copy
10 import pickle
11 import sys
13 import mock
14 from mock import (
15 call, DEFAULT, patch, sentinel,
16 MagicMock, Mock, NonCallableMock,
17 NonCallableMagicMock, _CallList,
18 create_autospec
19 )
22 try:
23 unicode
24 except NameError:
25 unicode = str
28 class Iter(object):
29 def __init__(self):
30 self.thing = iter(['this', 'is', 'an', 'iter'])
32 def __iter__(self):
33 return self
35 def next(self):
36 return next(self.thing)
38 __next__ = next
41 class Subclass(MagicMock):
42 pass
45 class Thing(object):
46 attribute = 6
47 foo = 'bar'
51 class MockTest(unittest2.TestCase):
53 def test_all(self):
54 # if __all__ is badly defined then import * will raise an error
55 # We have to exec it because you can't import * inside a method
56 # in Python 3
57 exec("from mock import *")
60 def test_constructor(self):
61 mock = Mock()
63 self.assertFalse(mock.called, "called not initialised correctly")
64 self.assertEqual(mock.call_count, 0,
65 "call_count not initialised correctly")
66 self.assertTrue(is_instance(mock.return_value, Mock),
67 "return_value not initialised correctly")
69 self.assertEqual(mock.call_args, None,
70 "call_args not initialised correctly")
71 self.assertEqual(mock.call_args_list, [],
72 "call_args_list not initialised correctly")
73 self.assertEqual(mock.method_calls, [],
74 "method_calls not initialised correctly")
76 # Can't use hasattr for this test as it always returns True on a mock
77 self.assertFalse('_items' in mock.__dict__,
78 "default mock should not have '_items' attribute")
80 self.assertIsNone(mock._mock_parent,
81 "parent not initialised correctly")
82 self.assertIsNone(mock._mock_methods,
83 "methods not initialised correctly")
84 self.assertEqual(mock._mock_children, {},
85 "children not initialised incorrectly")
88 def test_unicode_not_broken(self):
89 # This used to raise an exception with Python 2.5 and Mock 0.4
90 unicode(Mock())
93 def test_return_value_in_constructor(self):
94 mock = Mock(return_value=None)
95 self.assertIsNone(mock.return_value,
96 "return value in constructor not honoured")
99 def test_repr(self):
100 mock = Mock(name='foo')
101 self.assertIn('foo', repr(mock))
102 self.assertIn("'%s'" % id(mock), repr(mock))
104 mocks = [(Mock(), 'mock'), (Mock(name='bar'), 'bar')]
105 for mock, name in mocks:
106 self.assertIn('%s.bar' % name, repr(mock.bar))
107 self.assertIn('%s.foo()' % name, repr(mock.foo()))
108 self.assertIn('%s.foo().bing' % name, repr(mock.foo().bing))
109 self.assertIn('%s()' % name, repr(mock()))
110 self.assertIn('%s()()' % name, repr(mock()()))
111 self.assertIn('%s()().foo.bar.baz().bing' % name,
112 repr(mock()().foo.bar.baz().bing))
115 def test_repr_with_spec(self):
116 class X(object):
117 pass
119 mock = Mock(spec=X)
120 self.assertIn(" spec='X' ", repr(mock))
122 mock = Mock(spec=X())
123 self.assertIn(" spec='X' ", repr(mock))
125 mock = Mock(spec_set=X)
126 self.assertIn(" spec_set='X' ", repr(mock))
128 mock = Mock(spec_set=X())
129 self.assertIn(" spec_set='X' ", repr(mock))
131 mock = Mock(spec=X, name='foo')
132 self.assertIn(" spec='X' ", repr(mock))
133 self.assertIn(" name='foo' ", repr(mock))
135 mock = Mock(name='foo')
136 self.assertNotIn("spec", repr(mock))
138 mock = Mock()
139 self.assertNotIn("spec", repr(mock))
141 mock = Mock(spec=['foo'])
142 self.assertNotIn("spec", repr(mock))
145 def test_side_effect(self):
146 mock = Mock()
148 def effect(*args, **kwargs):
149 raise SystemError('kablooie')
151 mock.side_effect = effect
152 self.assertRaises(SystemError, mock, 1, 2, fish=3)
153 mock.assert_called_with(1, 2, fish=3)
155 results = [1, 2, 3]
156 def effect():
157 return results.pop()
158 mock.side_effect = effect
160 self.assertEqual([mock(), mock(), mock()], [3, 2, 1],
161 "side effect not used correctly")
163 mock = Mock(side_effect=sentinel.SideEffect)
164 self.assertEqual(mock.side_effect, sentinel.SideEffect,
165 "side effect in constructor not used")
167 def side_effect():
168 return DEFAULT
169 mock = Mock(side_effect=side_effect, return_value=sentinel.RETURN)
170 self.assertEqual(mock(), sentinel.RETURN)
173 @unittest2.skipUnless('java' in sys.platform,
174 'This test only applies to Jython')
175 def test_java_exception_side_effect(self):
176 import java
177 mock = Mock(side_effect=java.lang.RuntimeException("Boom!"))
179 # can't use assertRaises with java exceptions
180 try:
181 mock(1, 2, fish=3)
182 except java.lang.RuntimeException:
183 pass
184 else:
185 self.fail('java exception not raised')
186 mock.assert_called_with(1,2, fish=3)
189 def test_reset_mock(self):
190 parent = Mock()
191 spec = ["something"]
192 mock = Mock(name="child", parent=parent, spec=spec)
193 mock(sentinel.Something, something=sentinel.SomethingElse)
194 something = mock.something
195 mock.something()
196 mock.side_effect = sentinel.SideEffect
197 return_value = mock.return_value
198 return_value()
200 mock.reset_mock()
202 self.assertEqual(mock._mock_name, "child",
203 "name incorrectly reset")
204 self.assertEqual(mock._mock_parent, parent,
205 "parent incorrectly reset")
206 self.assertEqual(mock._mock_methods, spec,
207 "methods incorrectly reset")
209 self.assertFalse(mock.called, "called not reset")
210 self.assertEqual(mock.call_count, 0, "call_count not reset")
211 self.assertEqual(mock.call_args, None, "call_args not reset")
212 self.assertEqual(mock.call_args_list, [], "call_args_list not reset")
213 self.assertEqual(mock.method_calls, [],
214 "method_calls not initialised correctly: %r != %r" %
215 (mock.method_calls, []))
216 self.assertEqual(mock.mock_calls, [])
218 self.assertEqual(mock.side_effect, sentinel.SideEffect,
219 "side_effect incorrectly reset")
220 self.assertEqual(mock.return_value, return_value,
221 "return_value incorrectly reset")
222 self.assertFalse(return_value.called, "return value mock not reset")
223 self.assertEqual(mock._mock_children, {'something': something},
224 "children reset incorrectly")
225 self.assertEqual(mock.something, something,
226 "children incorrectly cleared")
227 self.assertFalse(mock.something.called, "child not reset")
230 def test_reset_mock_recursion(self):
231 mock = Mock()
232 mock.return_value = mock
234 # used to cause recursion
235 mock.reset_mock()
238 def test_call(self):
239 mock = Mock()
240 self.assertTrue(is_instance(mock.return_value, Mock),
241 "Default return_value should be a Mock")
243 result = mock()
244 self.assertEqual(mock(), result,
245 "different result from consecutive calls")
246 mock.reset_mock()
248 ret_val = mock(sentinel.Arg)
249 self.assertTrue(mock.called, "called not set")
250 self.assertEqual(mock.call_count, 1, "call_count incoreect")
251 self.assertEqual(mock.call_args, ((sentinel.Arg,), {}),
252 "call_args not set")
253 self.assertEqual(mock.call_args_list, [((sentinel.Arg,), {})],
254 "call_args_list not initialised correctly")
256 mock.return_value = sentinel.ReturnValue
257 ret_val = mock(sentinel.Arg, key=sentinel.KeyArg)
258 self.assertEqual(ret_val, sentinel.ReturnValue,
259 "incorrect return value")
261 self.assertEqual(mock.call_count, 2, "call_count incorrect")
262 self.assertEqual(mock.call_args,
263 ((sentinel.Arg,), {'key': sentinel.KeyArg}),
264 "call_args not set")
265 self.assertEqual(mock.call_args_list, [
266 ((sentinel.Arg,), {}),
267 ((sentinel.Arg,), {'key': sentinel.KeyArg})
268 ],
269 "call_args_list not set")
272 def test_call_args_comparison(self):
273 mock = Mock()
274 mock()
275 mock(sentinel.Arg)
276 mock(kw=sentinel.Kwarg)
277 mock(sentinel.Arg, kw=sentinel.Kwarg)
278 self.assertEqual(mock.call_args_list, [
279 (),
280 ((sentinel.Arg,),),
281 ({"kw": sentinel.Kwarg},),
282 ((sentinel.Arg,), {"kw": sentinel.Kwarg})
283 ])
284 self.assertEqual(mock.call_args,
285 ((sentinel.Arg,), {"kw": sentinel.Kwarg}))
288 def test_assert_called_with(self):
289 mock = Mock()
290 mock()
292 # Will raise an exception if it fails
293 mock.assert_called_with()
294 self.assertRaises(AssertionError, mock.assert_called_with, 1)
296 mock.reset_mock()
297 self.assertRaises(AssertionError, mock.assert_called_with)
299 mock(1, 2, 3, a='fish', b='nothing')
300 mock.assert_called_with(1, 2, 3, a='fish', b='nothing')
303 def test_assert_called_once_with(self):
304 mock = Mock()
305 mock()
307 # Will raise an exception if it fails
308 mock.assert_called_once_with()
310 mock()
311 self.assertRaises(AssertionError, mock.assert_called_once_with)
313 mock.reset_mock()
314 self.assertRaises(AssertionError, mock.assert_called_once_with)
316 mock('foo', 'bar', baz=2)
317 mock.assert_called_once_with('foo', 'bar', baz=2)
319 mock.reset_mock()
320 mock('foo', 'bar', baz=2)
321 self.assertRaises(
322 AssertionError,
323 lambda: mock.assert_called_once_with('bob', 'bar', baz=2)
324 )
327 def test_attribute_access_returns_mocks(self):
328 mock = Mock()
329 something = mock.something
330 self.assertTrue(is_instance(something, Mock), "attribute isn't a mock")
331 self.assertEqual(mock.something, something,
332 "different attributes returned for same name")
334 # Usage example
335 mock = Mock()
336 mock.something.return_value = 3
338 self.assertEqual(mock.something(), 3, "method returned wrong value")
339 self.assertTrue(mock.something.called,
340 "method didn't record being called")
343 def test_attributes_have_name_and_parent_set(self):
344 mock = Mock()
345 something = mock.something
347 self.assertEqual(something._mock_name, "something",
348 "attribute name not set correctly")
349 self.assertEqual(something._mock_parent, mock,
350 "attribute parent not set correctly")
353 def test_method_calls_recorded(self):
354 mock = Mock()
355 mock.something(3, fish=None)
356 mock.something_else.something(6, cake=sentinel.Cake)
358 self.assertEqual(mock.something_else.method_calls,
359 [("something", (6,), {'cake': sentinel.Cake})],
360 "method calls not recorded correctly")
361 self.assertEqual(mock.method_calls, [
362 ("something", (3,), {'fish': None}),
363 ("something_else.something", (6,), {'cake': sentinel.Cake})
364 ],
365 "method calls not recorded correctly")
368 def test_method_calls_compare_easily(self):
369 mock = Mock()
370 mock.something()
371 self.assertEqual(mock.method_calls, [('something',)])
372 self.assertEqual(mock.method_calls, [('something', (), {})])
374 mock = Mock()
375 mock.something('different')
376 self.assertEqual(mock.method_calls, [('something', ('different',))])
377 self.assertEqual(mock.method_calls,
378 [('something', ('different',), {})])
380 mock = Mock()
381 mock.something(x=1)
382 self.assertEqual(mock.method_calls, [('something', {'x': 1})])
383 self.assertEqual(mock.method_calls, [('something', (), {'x': 1})])
385 mock = Mock()
386 mock.something('different', some='more')
387 self.assertEqual(mock.method_calls, [
388 ('something', ('different',), {'some': 'more'})
389 ])
392 def test_only_allowed_methods_exist(self):
393 for spec in ['something'], ('something',):
394 for arg in 'spec', 'spec_set':
395 mock = Mock(**{arg: spec})
397 # this should be allowed
398 mock.something
399 self.assertRaisesRegexp(
400 AttributeError,
401 "Mock object has no attribute 'something_else'",
402 getattr, mock, 'something_else'
403 )
406 def test_from_spec(self):
407 class Something(object):
408 x = 3
409 __something__ = None
410 def y(self):
411 pass
413 def test_attributes(mock):
414 # should work
415 mock.x
416 mock.y
417 mock.__something__
418 self.assertRaisesRegexp(
419 AttributeError,
420 "Mock object has no attribute 'z'",
421 getattr, mock, 'z'
422 )
423 self.assertRaisesRegexp(
424 AttributeError,
425 "Mock object has no attribute '__foobar__'",
426 getattr, mock, '__foobar__'
427 )
429 test_attributes(Mock(spec=Something))
430 test_attributes(Mock(spec=Something()))
433 def test_wraps_calls(self):
434 real = Mock()
436 mock = Mock(wraps=real)
437 self.assertEqual(mock(), real())
439 real.reset_mock()
441 mock(1, 2, fish=3)
442 real.assert_called_with(1, 2, fish=3)
445 def test_wraps_call_with_nondefault_return_value(self):
446 real = Mock()
448 mock = Mock(wraps=real)
449 mock.return_value = 3
451 self.assertEqual(mock(), 3)
452 self.assertFalse(real.called)
455 def test_wraps_attributes(self):
456 class Real(object):
457 attribute = Mock()
459 real = Real()
461 mock = Mock(wraps=real)
462 self.assertEqual(mock.attribute(), real.attribute())
463 self.assertRaises(AttributeError, lambda: mock.fish)
465 self.assertNotEqual(mock.attribute, real.attribute)
466 result = mock.attribute.frog(1, 2, fish=3)
467 Real.attribute.frog.assert_called_with(1, 2, fish=3)
468 self.assertEqual(result, Real.attribute.frog())
471 def test_exceptional_side_effect(self):
472 mock = Mock(side_effect=AttributeError)
473 self.assertRaises(AttributeError, mock)
475 mock = Mock(side_effect=AttributeError('foo'))
476 self.assertRaises(AttributeError, mock)
479 def test_baseexceptional_side_effect(self):
480 mock = Mock(side_effect=KeyboardInterrupt)
481 self.assertRaises(KeyboardInterrupt, mock)
483 mock = Mock(side_effect=KeyboardInterrupt('foo'))
484 self.assertRaises(KeyboardInterrupt, mock)
487 def test_assert_called_with_message(self):
488 mock = Mock()
489 self.assertRaisesRegexp(AssertionError, 'Not called',
490 mock.assert_called_with)
493 def test__name__(self):
494 mock = Mock()
495 self.assertRaises(AttributeError, lambda: mock.__name__)
497 mock.__name__ = 'foo'
498 self.assertEqual(mock.__name__, 'foo')
501 def test_spec_list_subclass(self):
502 class Sub(list):
503 pass
504 mock = Mock(spec=Sub(['foo']))
506 mock.append(3)
507 mock.append.assert_called_with(3)
508 self.assertRaises(AttributeError, getattr, mock, 'foo')
511 def test_spec_class(self):
512 class X(object):
513 pass
515 mock = Mock(spec=X)
516 self.assertTrue(isinstance(mock, X))
518 mock = Mock(spec=X())
519 self.assertTrue(isinstance(mock, X))
521 self.assertIs(mock.__class__, X)
522 self.assertEqual(Mock().__class__.__name__, 'Mock')
524 mock = Mock(spec_set=X)
525 self.assertTrue(isinstance(mock, X))
527 mock = Mock(spec_set=X())
528 self.assertTrue(isinstance(mock, X))
531 def test_setting_attribute_with_spec_set(self):
532 class X(object):
533 y = 3
535 mock = Mock(spec=X)
536 mock.x = 'foo'
538 mock = Mock(spec_set=X)
539 def set_attr():
540 mock.x = 'foo'
542 mock.y = 'foo'
543 self.assertRaises(AttributeError, set_attr)
546 def test_copy(self):
547 current = sys.getrecursionlimit()
548 self.addCleanup(sys.setrecursionlimit, current)
550 # can't use sys.maxint as this doesn't exist in Python 3
551 sys.setrecursionlimit(int(10e8))
552 # this segfaults without the fix in place
553 copy.copy(Mock())
556 @unittest2.skipIf(inPy3k, "no old style classes in Python 3")
557 def test_spec_old_style_classes(self):
558 class Foo:
559 bar = 7
561 mock = Mock(spec=Foo)
562 mock.bar = 6
563 self.assertRaises(AttributeError, lambda: mock.foo)
565 mock = Mock(spec=Foo())
566 mock.bar = 6
567 self.assertRaises(AttributeError, lambda: mock.foo)
570 @unittest2.skipIf(inPy3k, "no old style classes in Python 3")
571 def test_spec_set_old_style_classes(self):
572 class Foo:
573 bar = 7
575 mock = Mock(spec_set=Foo)
576 mock.bar = 6
577 self.assertRaises(AttributeError, lambda: mock.foo)
579 def _set():
580 mock.foo = 3
581 self.assertRaises(AttributeError, _set)
583 mock = Mock(spec_set=Foo())
584 mock.bar = 6
585 self.assertRaises(AttributeError, lambda: mock.foo)
587 def _set():
588 mock.foo = 3
589 self.assertRaises(AttributeError, _set)
592 def test_subclass_with_properties(self):
593 class SubClass(Mock):
594 def _get(self):
595 return 3
596 def _set(self, value):
597 raise NameError('strange error')
598 some_attribute = property(_get, _set)
600 s = SubClass(spec_set=SubClass)
601 self.assertEqual(s.some_attribute, 3)
603 def test():
604 s.some_attribute = 3
605 self.assertRaises(NameError, test)
607 def test():
608 s.foo = 'bar'
609 self.assertRaises(AttributeError, test)
612 def test_setting_call(self):
613 mock = Mock()
614 def __call__(self, a):
615 return self._mock_call(a)
617 type(mock).__call__ = __call__
618 mock('one')
619 mock.assert_called_with('one')
621 self.assertRaises(TypeError, mock, 'one', 'two')
624 @unittest2.skipUnless(sys.version_info[:2] >= (2, 6),
625 "__dir__ not available until Python 2.6 or later")
626 def test_dir(self):
627 mock = Mock()
628 attrs = set(dir(mock))
629 type_attrs = set([m for m in dir(Mock) if not m.startswith('_')])
631 # all public attributes from the type are included
632 self.assertEqual(set(), type_attrs - attrs)
634 # creates these attributes
635 mock.a, mock.b
636 self.assertIn('a', dir(mock))
637 self.assertIn('b', dir(mock))
639 # instance attributes
640 mock.c = mock.d = None
641 self.assertIn('c', dir(mock))
642 self.assertIn('d', dir(mock))
644 # magic methods
645 mock.__iter__ = lambda s: iter([])
646 self.assertIn('__iter__', dir(mock))
649 @unittest2.skipUnless(sys.version_info[:2] >= (2, 6),
650 "__dir__ not available until Python 2.6 or later")
651 def test_dir_from_spec(self):
652 mock = Mock(spec=unittest2.TestCase)
653 testcase_attrs = set(dir(unittest2.TestCase))
654 attrs = set(dir(mock))
656 # all attributes from the spec are included
657 self.assertEqual(set(), testcase_attrs - attrs)
659 # shadow a sys attribute
660 mock.version = 3
661 self.assertEqual(dir(mock).count('version'), 1)
664 @unittest2.skipUnless(sys.version_info[:2] >= (2, 6),
665 "__dir__ not available until Python 2.6 or later")
666 def test_filter_dir(self):
667 patcher = patch.object(mock, 'FILTER_DIR', False)
668 patcher.start()
669 try:
670 attrs = set(dir(Mock()))
671 type_attrs = set(dir(Mock))
673 # ALL attributes from the type are included
674 self.assertEqual(set(), type_attrs - attrs)
675 finally:
676 patcher.stop()
679 def test_configure_mock(self):
680 mock = Mock(foo='bar')
681 self.assertEqual(mock.foo, 'bar')
683 mock = MagicMock(foo='bar')
684 self.assertEqual(mock.foo, 'bar')
686 kwargs = {'side_effect': KeyError, 'foo.bar.return_value': 33,
687 'foo': MagicMock()}
688 mock = Mock(**kwargs)
689 self.assertRaises(KeyError, mock)
690 self.assertEqual(mock.foo.bar(), 33)
691 self.assertIsInstance(mock.foo, MagicMock)
693 mock = Mock()
694 mock.configure_mock(**kwargs)
695 self.assertRaises(KeyError, mock)
696 self.assertEqual(mock.foo.bar(), 33)
697 self.assertIsInstance(mock.foo, MagicMock)
700 def assertRaisesWithMsg(self, exception, message, func, *args, **kwargs):
701 # needed because assertRaisesRegex doesn't work easily with newlines
702 try:
703 func(*args, **kwargs)
704 except:
705 instance = sys.exc_info()[1]
706 self.assertIsInstance(instance, exception)
707 else:
708 self.fail('Exception %r not raised' % (exception,))
710 msg = str(instance)
711 self.assertEqual(msg, message)
714 def test_assert_called_with_failure_message(self):
715 mock = NonCallableMock()
717 expected = "mock(1, '2', 3, bar='foo')"
718 message = 'Expected call: %s\nNot called'
719 self.assertRaisesWithMsg(
720 AssertionError, message % (expected,),
721 mock.assert_called_with, 1, '2', 3, bar='foo'
722 )
724 mock.foo(1, '2', 3, foo='foo')
727 asserters = [
728 mock.foo.assert_called_with, mock.foo.assert_called_once_with
729 ]
730 for meth in asserters:
731 actual = "foo(1, '2', 3, foo='foo')"
732 expected = "foo(1, '2', 3, bar='foo')"
733 message = 'Expected call: %s\nActual call: %s'
734 self.assertRaisesWithMsg(
735 AssertionError, message % (expected, actual),
736 meth, 1, '2', 3, bar='foo'
737 )
739 # just kwargs
740 for meth in asserters:
741 actual = "foo(1, '2', 3, foo='foo')"
742 expected = "foo(bar='foo')"
743 message = 'Expected call: %s\nActual call: %s'
744 self.assertRaisesWithMsg(
745 AssertionError, message % (expected, actual),
746 meth, bar='foo'
747 )
749 # just args
750 for meth in asserters:
751 actual = "foo(1, '2', 3, foo='foo')"
752 expected = "foo(1, 2, 3)"
753 message = 'Expected call: %s\nActual call: %s'
754 self.assertRaisesWithMsg(
755 AssertionError, message % (expected, actual),
756 meth, 1, 2, 3
757 )
759 # empty
760 for meth in asserters:
761 actual = "foo(1, '2', 3, foo='foo')"
762 expected = "foo()"
763 message = 'Expected call: %s\nActual call: %s'
764 self.assertRaisesWithMsg(
765 AssertionError, message % (expected, actual), meth
766 )
769 def test_mock_calls(self):
770 mock = MagicMock()
772 # need to do this because MagicMock.mock_calls used to just return
773 # a MagicMock which also returned a MagicMock when __eq__ was called
774 self.assertIs(mock.mock_calls == [], True)
776 mock = MagicMock()
777 mock()
778 expected = [('', (), {})]
779 self.assertEqual(mock.mock_calls, expected)
781 mock.foo()
782 expected.append(call.foo())
783 self.assertEqual(mock.mock_calls, expected)
784 # intermediate mock_calls work too
785 self.assertEqual(mock.foo.mock_calls, [('', (), {})])
787 mock = MagicMock()
788 mock().foo(1, 2, 3, a=4, b=5)
789 expected = [
790 ('', (), {}), ('().foo', (1, 2, 3), dict(a=4, b=5))
791 ]
792 self.assertEqual(mock.mock_calls, expected)
793 self.assertEqual(mock.return_value.foo.mock_calls,
794 [('', (1, 2, 3), dict(a=4, b=5))])
795 self.assertEqual(mock.return_value.mock_calls,
796 [('foo', (1, 2, 3), dict(a=4, b=5))])
798 mock = MagicMock()
799 mock().foo.bar().baz()
800 expected = [
801 ('', (), {}), ('().foo.bar', (), {}),
802 ('().foo.bar().baz', (), {})
803 ]
804 self.assertEqual(mock.mock_calls, expected)
805 self.assertEqual(mock().mock_calls,
806 call.foo.bar().baz().call_list())
808 for kwargs in dict(), dict(name='bar'):
809 mock = MagicMock(**kwargs)
810 int(mock.foo)
811 expected = [('foo.__int__', (), {})]
812 self.assertEqual(mock.mock_calls, expected)
814 mock = MagicMock(**kwargs)
815 mock.a()()
816 expected = [('a', (), {}), ('a()', (), {})]
817 self.assertEqual(mock.mock_calls, expected)
818 self.assertEqual(mock.a().mock_calls, [call()])
820 mock = MagicMock(**kwargs)
821 mock(1)(2)(3)
822 self.assertEqual(mock.mock_calls, call(1)(2)(3).call_list())
823 self.assertEqual(mock().mock_calls, call(2)(3).call_list())
824 self.assertEqual(mock()().mock_calls, call(3).call_list())
826 mock = MagicMock(**kwargs)
827 mock(1)(2)(3).a.b.c(4)
828 self.assertEqual(mock.mock_calls,
829 call(1)(2)(3).a.b.c(4).call_list())
830 self.assertEqual(mock().mock_calls,
831 call(2)(3).a.b.c(4).call_list())
832 self.assertEqual(mock()().mock_calls,
833 call(3).a.b.c(4).call_list())
835 mock = MagicMock(**kwargs)
836 int(mock().foo.bar().baz())
837 last_call = ('().foo.bar().baz().__int__', (), {})
838 self.assertEqual(mock.mock_calls[-1], last_call)
839 self.assertEqual(mock().mock_calls,
840 call.foo.bar().baz().__int__().call_list())
841 self.assertEqual(mock().foo.bar().mock_calls,
842 call.baz().__int__().call_list())
843 self.assertEqual(mock().foo.bar().baz.mock_calls,
844 call().__int__().call_list())
847 def test_subclassing(self):
848 class Subclass(Mock):
849 pass
851 mock = Subclass()
852 self.assertIsInstance(mock.foo, Subclass)
853 self.assertIsInstance(mock(), Subclass)
855 class Subclass(Mock):
856 def _get_child_mock(self, **kwargs):
857 return Mock(**kwargs)
859 mock = Subclass()
860 self.assertNotIsInstance(mock.foo, Subclass)
861 self.assertNotIsInstance(mock(), Subclass)
864 def test_arg_lists(self):
865 mocks = [
866 Mock(),
867 MagicMock(),
868 NonCallableMock(),
869 NonCallableMagicMock()
870 ]
872 def assert_attrs(mock):
873 names = 'call_args_list', 'method_calls', 'mock_calls'
874 for name in names:
875 attr = getattr(mock, name)
876 self.assertIsInstance(attr, _CallList)
877 self.assertIsInstance(attr, list)
878 self.assertEqual(attr, [])
880 for mock in mocks:
881 assert_attrs(mock)
883 if callable(mock):
884 mock()
885 mock(1, 2)
886 mock(a=3)
888 mock.reset_mock()
889 assert_attrs(mock)
891 mock.foo()
892 mock.foo.bar(1, a=3)
893 mock.foo(1).bar().baz(3)
895 mock.reset_mock()
896 assert_attrs(mock)
899 def test_call_args_two_tuple(self):
900 mock = Mock()
901 mock(1, a=3)
902 mock(2, b=4)
904 self.assertEqual(len(mock.call_args), 2)
905 args, kwargs = mock.call_args
906 self.assertEqual(args, (2,))
907 self.assertEqual(kwargs, dict(b=4))
909 expected_list = [((1,), dict(a=3)), ((2,), dict(b=4))]
910 for expected, call_args in zip(expected_list, mock.call_args_list):
911 self.assertEqual(len(call_args), 2)
912 self.assertEqual(expected[0], call_args[0])
913 self.assertEqual(expected[1], call_args[1])
916 def test_side_effect_iterator(self):
917 mock = Mock(side_effect=iter([1, 2, 3]))
918 self.assertEqual([mock(), mock(), mock()], [1, 2, 3])
919 self.assertRaises(StopIteration, mock)
921 mock = MagicMock(side_effect=['a', 'b', 'c'])
922 self.assertEqual([mock(), mock(), mock()], ['a', 'b', 'c'])
923 self.assertRaises(StopIteration, mock)
925 mock = Mock(side_effect='ghi')
926 self.assertEqual([mock(), mock(), mock()], ['g', 'h', 'i'])
927 self.assertRaises(StopIteration, mock)
929 class Foo(object):
930 pass
931 mock = MagicMock(side_effect=Foo)
932 self.assertIsInstance(mock(), Foo)
934 mock = Mock(side_effect=Iter())
935 self.assertEqual([mock(), mock(), mock(), mock()],
936 ['this', 'is', 'an', 'iter'])
937 self.assertRaises(StopIteration, mock)
940 def test_side_effect_setting_iterator(self):
941 mock = Mock()
942 mock.side_effect = iter([1, 2, 3])
943 self.assertEqual([mock(), mock(), mock()], [1, 2, 3])
944 self.assertRaises(StopIteration, mock)
945 side_effect = mock.side_effect
946 self.assertIsInstance(side_effect, type(iter([])))
948 mock.side_effect = ['a', 'b', 'c']
949 self.assertEqual([mock(), mock(), mock()], ['a', 'b', 'c'])
950 self.assertRaises(StopIteration, mock)
951 side_effect = mock.side_effect
952 self.assertIsInstance(side_effect, type(iter([])))
954 this_iter = Iter()
955 mock.side_effect = this_iter
956 self.assertEqual([mock(), mock(), mock(), mock()],
957 ['this', 'is', 'an', 'iter'])
958 self.assertRaises(StopIteration, mock)
959 self.assertIs(mock.side_effect, this_iter)
962 def test_side_effect_iterator_exceptions(self):
963 for Klass in Mock, MagicMock:
964 iterable = (ValueError, 3, KeyError, 6)
965 m = Klass(side_effect=iterable)
966 self.assertRaises(ValueError, m)
967 self.assertEqual(m(), 3)
968 self.assertRaises(KeyError, m)
969 self.assertEqual(m(), 6)
972 def test_assert_has_calls_any_order(self):
973 mock = Mock()
974 mock(1, 2)
975 mock(a=3)
976 mock(3, 4)
977 mock(b=6)
978 mock(b=6)
980 kalls = [
981 call(1, 2), ({'a': 3},),
982 ((3, 4),), ((), {'a': 3}),
983 ('', (1, 2)), ('', {'a': 3}),
984 ('', (1, 2), {}), ('', (), {'a': 3})
985 ]
986 for kall in kalls:
987 mock.assert_has_calls([kall], any_order=True)
989 for kall in call(1, '2'), call(b=3), call(), 3, None, 'foo':
990 self.assertRaises(
991 AssertionError, mock.assert_has_calls,
992 [kall], any_order=True
993 )
995 kall_lists = [
996 [call(1, 2), call(b=6)],
997 [call(3, 4), call(1, 2)],
998 [call(b=6), call(b=6)],
999 ]
1001 for kall_list in kall_lists:
1002 mock.assert_has_calls(kall_list, any_order=True)
1004 kall_lists = [
1005 [call(b=6), call(b=6), call(b=6)],
1006 [call(1, 2), call(1, 2)],
1007 [call(3, 4), call(1, 2), call(5, 7)],
1008 [call(b=6), call(3, 4), call(b=6), call(1, 2), call(b=6)],
1009 ]
1010 for kall_list in kall_lists:
1011 self.assertRaises(
1012 AssertionError, mock.assert_has_calls,
1013 kall_list, any_order=True
1014 )
1016 def test_assert_has_calls(self):
1017 kalls1 = [
1018 call(1, 2), ({'a': 3},),
1019 ((3, 4),), call(b=6),
1020 ('', (1,), {'b': 6}),
1021 ]
1022 kalls2 = [call.foo(), call.bar(1)]
1023 kalls2.extend(call.spam().baz(a=3).call_list())
1024 kalls2.extend(call.bam(set(), foo={}).fish([1]).call_list())
1026 mocks = []
1027 for mock in Mock(), MagicMock():
1028 mock(1, 2)
1029 mock(a=3)
1030 mock(3, 4)
1031 mock(b=6)
1032 mock(1, b=6)
1033 mocks.append((mock, kalls1))
1035 mock = Mock()
1036 mock.foo()
1037 mock.bar(1)
1038 mock.spam().baz(a=3)
1039 mock.bam(set(), foo={}).fish([1])
1040 mocks.append((mock, kalls2))
1042 for mock, kalls in mocks:
1043 for i in range(len(kalls)):
1044 for step in 1, 2, 3:
1045 these = kalls[i:i+step]
1046 mock.assert_has_calls(these)
1048 if len(these) > 1:
1049 self.assertRaises(
1050 AssertionError,
1051 mock.assert_has_calls,
1052 list(reversed(these))
1053 )
1056 def test_assert_any_call(self):
1057 mock = Mock()
1058 mock(1, 2)
1059 mock(a=3)
1060 mock(1, b=6)
1062 mock.assert_any_call(1, 2)
1063 mock.assert_any_call(a=3)
1064 mock.assert_any_call(1, b=6)
1066 self.assertRaises(
1067 AssertionError,
1068 mock.assert_any_call
1069 )
1070 self.assertRaises(
1071 AssertionError,
1072 mock.assert_any_call,
1073 1, 3
1074 )
1075 self.assertRaises(
1076 AssertionError,
1077 mock.assert_any_call,
1078 a=4
1079 )
1082 def test_mock_calls_create_autospec(self):
1083 def f(a, b):
1084 pass
1085 obj = Iter()
1086 obj.f = f
1088 funcs = [
1089 create_autospec(f),
1090 create_autospec(obj).f
1091 ]
1092 for func in funcs:
1093 func(1, 2)
1094 func(3, 4)
1096 self.assertEqual(
1097 func.mock_calls, [call(1, 2), call(3, 4)]
1098 )
1101 def test_mock_add_spec(self):
1102 class _One(object):
1103 one = 1
1104 class _Two(object):
1105 two = 2
1106 class Anything(object):
1107 one = two = three = 'four'
1109 klasses = [
1110 Mock, MagicMock, NonCallableMock, NonCallableMagicMock
1111 ]
1112 for Klass in list(klasses):
1113 klasses.append(lambda K=Klass: K(spec=Anything))
1114 klasses.append(lambda K=Klass: K(spec_set=Anything))
1116 for Klass in klasses:
1117 for kwargs in dict(), dict(spec_set=True):
1118 mock = Klass()
1119 #no error
1120 mock.one, mock.two, mock.three
1122 for One, Two in [(_One, _Two), (['one'], ['two'])]:
1123 for kwargs in dict(), dict(spec_set=True):
1124 mock.mock_add_spec(One, **kwargs)
1126 mock.one
1127 self.assertRaises(
1128 AttributeError, getattr, mock, 'two'
1129 )
1130 self.assertRaises(
1131 AttributeError, getattr, mock, 'three'
1132 )
1133 if 'spec_set' in kwargs:
1134 self.assertRaises(
1135 AttributeError, setattr, mock, 'three', None
1136 )
1138 mock.mock_add_spec(Two, **kwargs)
1139 self.assertRaises(
1140 AttributeError, getattr, mock, 'one'
1141 )
1142 mock.two
1143 self.assertRaises(
1144 AttributeError, getattr, mock, 'three'
1145 )
1146 if 'spec_set' in kwargs:
1147 self.assertRaises(
1148 AttributeError, setattr, mock, 'three', None
1149 )
1150 # note that creating a mock, setting an instance attribute, and
1151 # *then* setting a spec doesn't work. Not the intended use case
1154 def test_mock_add_spec_magic_methods(self):
1155 for Klass in MagicMock, NonCallableMagicMock:
1156 mock = Klass()
1157 int(mock)
1159 mock.mock_add_spec(object)
1160 self.assertRaises(TypeError, int, mock)
1162 mock = Klass()
1163 mock['foo']
1164 mock.__int__.return_value =4
1166 mock.mock_add_spec(int)
1167 self.assertEqual(int(mock), 4)
1168 self.assertRaises(TypeError, lambda: mock['foo'])
1171 def test_adding_child_mock(self):
1172 for Klass in NonCallableMock, Mock, MagicMock, NonCallableMagicMock:
1173 mock = Klass()
1175 mock.foo = Mock()
1176 mock.foo()
1178 self.assertEqual(mock.method_calls, [call.foo()])
1179 self.assertEqual(mock.mock_calls, [call.foo()])
1181 mock = Klass()
1182 mock.bar = Mock(name='name')
1183 mock.bar()
1184 self.assertEqual(mock.method_calls, [])
1185 self.assertEqual(mock.mock_calls, [])
1187 # mock with an existing _new_parent but no name
1188 mock = Klass()
1189 mock.baz = MagicMock()()
1190 mock.baz()
1191 self.assertEqual(mock.method_calls, [])
1192 self.assertEqual(mock.mock_calls, [])
1195 def test_adding_return_value_mock(self):
1196 for Klass in Mock, MagicMock:
1197 mock = Klass()
1198 mock.return_value = MagicMock()
1200 mock()()
1201 self.assertEqual(mock.mock_calls, [call(), call()()])
1204 def test_manager_mock(self):
1205 class Foo(object):
1206 one = 'one'
1207 two = 'two'
1208 manager = Mock()
1209 p1 = patch.object(Foo, 'one')
1210 p2 = patch.object(Foo, 'two')
1212 mock_one = p1.start()
1213 self.addCleanup(p1.stop)
1214 mock_two = p2.start()
1215 self.addCleanup(p2.stop)
1217 manager.attach_mock(mock_one, 'one')
1218 manager.attach_mock(mock_two, 'two')
1220 Foo.two()
1221 Foo.one()
1223 self.assertEqual(manager.mock_calls, [call.two(), call.one()])
1226 def test_magic_methods_mock_calls(self):
1227 for Klass in Mock, MagicMock:
1228 m = Klass()
1229 m.__int__ = Mock(return_value=3)
1230 m.__float__ = MagicMock(return_value=3.0)
1231 int(m)
1232 float(m)
1234 self.assertEqual(m.mock_calls, [call.__int__(), call.__float__()])
1235 self.assertEqual(m.method_calls, [])
1238 def test_attribute_deletion(self):
1239 # this behaviour isn't *useful*, but at least it's now tested...
1240 for Klass in Mock, MagicMock, NonCallableMagicMock, NonCallableMock:
1241 m = Klass()
1242 original = m.foo
1243 m.foo = 3
1244 del m.foo
1245 self.assertEqual(m.foo, original)
1247 new = m.foo = Mock()
1248 del m.foo
1249 self.assertEqual(m.foo, new)
1252 def test_mock_parents(self):
1253 for Klass in Mock, MagicMock:
1254 m = Klass()
1255 original_repr = repr(m)
1256 m.return_value = m
1257 self.assertIs(m(), m)
1258 self.assertEqual(repr(m), original_repr)
1260 m.reset_mock()
1261 self.assertIs(m(), m)
1262 self.assertEqual(repr(m), original_repr)
1264 m = Klass()
1265 m.b = m.a
1266 self.assertIn("name='mock.a'", repr(m.b))
1267 self.assertIn("name='mock.a'", repr(m.a))
1268 m.reset_mock()
1269 self.assertIn("name='mock.a'", repr(m.b))
1270 self.assertIn("name='mock.a'", repr(m.a))
1272 m = Klass()
1273 original_repr = repr(m)
1274 m.a = m()
1275 m.a.return_value = m
1277 self.assertEqual(repr(m), original_repr)
1278 self.assertEqual(repr(m.a()), original_repr)
1281 def test_attach_mock(self):
1282 classes = Mock, MagicMock, NonCallableMagicMock, NonCallableMock
1283 for Klass in classes:
1284 for Klass2 in classes:
1285 m = Klass()
1287 m2 = Klass2(name='foo')
1288 m.attach_mock(m2, 'bar')
1290 self.assertIs(m.bar, m2)
1291 self.assertIn("name='mock.bar'", repr(m2))
1293 m.bar.baz(1)
1294 self.assertEqual(m.mock_calls, [call.bar.baz(1)])
1295 self.assertEqual(m.method_calls, [call.bar.baz(1)])
1298 def test_attach_mock_return_value(self):
1299 classes = Mock, MagicMock, NonCallableMagicMock, NonCallableMock
1300 for Klass in Mock, MagicMock:
1301 for Klass2 in classes:
1302 m = Klass()
1304 m2 = Klass2(name='foo')
1305 m.attach_mock(m2, 'return_value')
1307 self.assertIs(m(), m2)
1308 self.assertIn("name='mock()'", repr(m2))
1310 m2.foo()
1311 self.assertEqual(m.mock_calls, call().foo().call_list())
1314 def test_attribute_deletion(self):
1315 for mock in Mock(), MagicMock():
1316 self.assertTrue(hasattr(mock, 'm'))
1318 del mock.m
1319 self.assertFalse(hasattr(mock, 'm'))
1321 del mock.f
1322 self.assertFalse(hasattr(mock, 'f'))
1323 self.assertRaises(AttributeError, getattr, mock, 'f')
1326 def test_class_assignable(self):
1327 for mock in Mock(), MagicMock():
1328 self.assertNotIsInstance(mock, int)
1330 mock.__class__ = int
1331 self.assertIsInstance(mock, int)
1334 @unittest2.expectedFailure
1335 def test_pickle(self):
1336 for Klass in (MagicMock, Mock, Subclass, NonCallableMagicMock):
1337 mock = Klass(name='foo', attribute=3)
1338 mock.foo(1, 2, 3)
1339 data = pickle.dumps(mock)
1340 new = pickle.loads(data)
1342 new.foo.assert_called_once_with(1, 2, 3)
1343 self.assertFalse(new.called)
1344 self.assertTrue(is_instance(new, Klass))
1345 self.assertIsInstance(new, Thing)
1346 self.assertIn('name="foo"', repr(new))
1347 self.assertEqual(new.attribute, 3)
1350 if __name__ == '__main__':
1351 unittest2.main()
