1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/python/mock-1.0.0/tests/testmock.py Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,1351 @@
1.4 +# Copyright (C) 2007-2012 Michael Foord & the mock team
1.5 +# E-mail: fuzzyman AT voidspace DOT org DOT uk
1.6 +# http://www.voidspace.org.uk/python/mock/
1.7 +
1.8 +from tests.support import (
1.9 + callable, unittest2, inPy3k, is_instance, next
1.10 +)
1.11 +
1.12 +import copy
1.13 +import pickle
1.14 +import sys
1.15 +
1.16 +import mock
1.17 +from mock import (
1.18 + call, DEFAULT, patch, sentinel,
1.19 + MagicMock, Mock, NonCallableMock,
1.20 + NonCallableMagicMock, _CallList,
1.21 + create_autospec
1.22 +)
1.23 +
1.24 +
1.25 +try:
1.26 + unicode
1.27 +except NameError:
1.28 + unicode = str
1.29 +
1.30 +
1.31 +class Iter(object):
1.32 + def __init__(self):
1.33 + self.thing = iter(['this', 'is', 'an', 'iter'])
1.34 +
1.35 + def __iter__(self):
1.36 + return self
1.37 +
1.38 + def next(self):
1.39 + return next(self.thing)
1.40 +
1.41 + __next__ = next
1.42 +
1.43 +
1.44 +class Subclass(MagicMock):
1.45 + pass
1.46 +
1.47 +
1.48 +class Thing(object):
1.49 + attribute = 6
1.50 + foo = 'bar'
1.51 +
1.52 +
1.53 +
1.54 +class MockTest(unittest2.TestCase):
1.55 +
1.56 + def test_all(self):
1.57 + # if __all__ is badly defined then import * will raise an error
1.58 + # We have to exec it because you can't import * inside a method
1.59 + # in Python 3
1.60 + exec("from mock import *")
1.61 +
1.62 +
1.63 + def test_constructor(self):
1.64 + mock = Mock()
1.65 +
1.66 + self.assertFalse(mock.called, "called not initialised correctly")
1.67 + self.assertEqual(mock.call_count, 0,
1.68 + "call_count not initialised correctly")
1.69 + self.assertTrue(is_instance(mock.return_value, Mock),
1.70 + "return_value not initialised correctly")
1.71 +
1.72 + self.assertEqual(mock.call_args, None,
1.73 + "call_args not initialised correctly")
1.74 + self.assertEqual(mock.call_args_list, [],
1.75 + "call_args_list not initialised correctly")
1.76 + self.assertEqual(mock.method_calls, [],
1.77 + "method_calls not initialised correctly")
1.78 +
1.79 + # Can't use hasattr for this test as it always returns True on a mock
1.80 + self.assertFalse('_items' in mock.__dict__,
1.81 + "default mock should not have '_items' attribute")
1.82 +
1.83 + self.assertIsNone(mock._mock_parent,
1.84 + "parent not initialised correctly")
1.85 + self.assertIsNone(mock._mock_methods,
1.86 + "methods not initialised correctly")
1.87 + self.assertEqual(mock._mock_children, {},
1.88 + "children not initialised incorrectly")
1.89 +
1.90 +
1.91 + def test_unicode_not_broken(self):
1.92 + # This used to raise an exception with Python 2.5 and Mock 0.4
1.93 + unicode(Mock())
1.94 +
1.95 +
1.96 + def test_return_value_in_constructor(self):
1.97 + mock = Mock(return_value=None)
1.98 + self.assertIsNone(mock.return_value,
1.99 + "return value in constructor not honoured")
1.100 +
1.101 +
1.102 + def test_repr(self):
1.103 + mock = Mock(name='foo')
1.104 + self.assertIn('foo', repr(mock))
1.105 + self.assertIn("'%s'" % id(mock), repr(mock))
1.106 +
1.107 + mocks = [(Mock(), 'mock'), (Mock(name='bar'), 'bar')]
1.108 + for mock, name in mocks:
1.109 + self.assertIn('%s.bar' % name, repr(mock.bar))
1.110 + self.assertIn('%s.foo()' % name, repr(mock.foo()))
1.111 + self.assertIn('%s.foo().bing' % name, repr(mock.foo().bing))
1.112 + self.assertIn('%s()' % name, repr(mock()))
1.113 + self.assertIn('%s()()' % name, repr(mock()()))
1.114 + self.assertIn('%s()().foo.bar.baz().bing' % name,
1.115 + repr(mock()().foo.bar.baz().bing))
1.116 +
1.117 +
1.118 + def test_repr_with_spec(self):
1.119 + class X(object):
1.120 + pass
1.121 +
1.122 + mock = Mock(spec=X)
1.123 + self.assertIn(" spec='X' ", repr(mock))
1.124 +
1.125 + mock = Mock(spec=X())
1.126 + self.assertIn(" spec='X' ", repr(mock))
1.127 +
1.128 + mock = Mock(spec_set=X)
1.129 + self.assertIn(" spec_set='X' ", repr(mock))
1.130 +
1.131 + mock = Mock(spec_set=X())
1.132 + self.assertIn(" spec_set='X' ", repr(mock))
1.133 +
1.134 + mock = Mock(spec=X, name='foo')
1.135 + self.assertIn(" spec='X' ", repr(mock))
1.136 + self.assertIn(" name='foo' ", repr(mock))
1.137 +
1.138 + mock = Mock(name='foo')
1.139 + self.assertNotIn("spec", repr(mock))
1.140 +
1.141 + mock = Mock()
1.142 + self.assertNotIn("spec", repr(mock))
1.143 +
1.144 + mock = Mock(spec=['foo'])
1.145 + self.assertNotIn("spec", repr(mock))
1.146 +
1.147 +
1.148 + def test_side_effect(self):
1.149 + mock = Mock()
1.150 +
1.151 + def effect(*args, **kwargs):
1.152 + raise SystemError('kablooie')
1.153 +
1.154 + mock.side_effect = effect
1.155 + self.assertRaises(SystemError, mock, 1, 2, fish=3)
1.156 + mock.assert_called_with(1, 2, fish=3)
1.157 +
1.158 + results = [1, 2, 3]
1.159 + def effect():
1.160 + return results.pop()
1.161 + mock.side_effect = effect
1.162 +
1.163 + self.assertEqual([mock(), mock(), mock()], [3, 2, 1],
1.164 + "side effect not used correctly")
1.165 +
1.166 + mock = Mock(side_effect=sentinel.SideEffect)
1.167 + self.assertEqual(mock.side_effect, sentinel.SideEffect,
1.168 + "side effect in constructor not used")
1.169 +
1.170 + def side_effect():
1.171 + return DEFAULT
1.172 + mock = Mock(side_effect=side_effect, return_value=sentinel.RETURN)
1.173 + self.assertEqual(mock(), sentinel.RETURN)
1.174 +
1.175 +
1.176 + @unittest2.skipUnless('java' in sys.platform,
1.177 + 'This test only applies to Jython')
1.178 + def test_java_exception_side_effect(self):
1.179 + import java
1.180 + mock = Mock(side_effect=java.lang.RuntimeException("Boom!"))
1.181 +
1.182 + # can't use assertRaises with java exceptions
1.183 + try:
1.184 + mock(1, 2, fish=3)
1.185 + except java.lang.RuntimeException:
1.186 + pass
1.187 + else:
1.188 + self.fail('java exception not raised')
1.189 + mock.assert_called_with(1,2, fish=3)
1.190 +
1.191 +
1.192 + def test_reset_mock(self):
1.193 + parent = Mock()
1.194 + spec = ["something"]
1.195 + mock = Mock(name="child", parent=parent, spec=spec)
1.196 + mock(sentinel.Something, something=sentinel.SomethingElse)
1.197 + something = mock.something
1.198 + mock.something()
1.199 + mock.side_effect = sentinel.SideEffect
1.200 + return_value = mock.return_value
1.201 + return_value()
1.202 +
1.203 + mock.reset_mock()
1.204 +
1.205 + self.assertEqual(mock._mock_name, "child",
1.206 + "name incorrectly reset")
1.207 + self.assertEqual(mock._mock_parent, parent,
1.208 + "parent incorrectly reset")
1.209 + self.assertEqual(mock._mock_methods, spec,
1.210 + "methods incorrectly reset")
1.211 +
1.212 + self.assertFalse(mock.called, "called not reset")
1.213 + self.assertEqual(mock.call_count, 0, "call_count not reset")
1.214 + self.assertEqual(mock.call_args, None, "call_args not reset")
1.215 + self.assertEqual(mock.call_args_list, [], "call_args_list not reset")
1.216 + self.assertEqual(mock.method_calls, [],
1.217 + "method_calls not initialised correctly: %r != %r" %
1.218 + (mock.method_calls, []))
1.219 + self.assertEqual(mock.mock_calls, [])
1.220 +
1.221 + self.assertEqual(mock.side_effect, sentinel.SideEffect,
1.222 + "side_effect incorrectly reset")
1.223 + self.assertEqual(mock.return_value, return_value,
1.224 + "return_value incorrectly reset")
1.225 + self.assertFalse(return_value.called, "return value mock not reset")
1.226 + self.assertEqual(mock._mock_children, {'something': something},
1.227 + "children reset incorrectly")
1.228 + self.assertEqual(mock.something, something,
1.229 + "children incorrectly cleared")
1.230 + self.assertFalse(mock.something.called, "child not reset")
1.231 +
1.232 +
1.233 + def test_reset_mock_recursion(self):
1.234 + mock = Mock()
1.235 + mock.return_value = mock
1.236 +
1.237 + # used to cause recursion
1.238 + mock.reset_mock()
1.239 +
1.240 +
1.241 + def test_call(self):
1.242 + mock = Mock()
1.243 + self.assertTrue(is_instance(mock.return_value, Mock),
1.244 + "Default return_value should be a Mock")
1.245 +
1.246 + result = mock()
1.247 + self.assertEqual(mock(), result,
1.248 + "different result from consecutive calls")
1.249 + mock.reset_mock()
1.250 +
1.251 + ret_val = mock(sentinel.Arg)
1.252 + self.assertTrue(mock.called, "called not set")
1.253 + self.assertEqual(mock.call_count, 1, "call_count incoreect")
1.254 + self.assertEqual(mock.call_args, ((sentinel.Arg,), {}),
1.255 + "call_args not set")
1.256 + self.assertEqual(mock.call_args_list, [((sentinel.Arg,), {})],
1.257 + "call_args_list not initialised correctly")
1.258 +
1.259 + mock.return_value = sentinel.ReturnValue
1.260 + ret_val = mock(sentinel.Arg, key=sentinel.KeyArg)
1.261 + self.assertEqual(ret_val, sentinel.ReturnValue,
1.262 + "incorrect return value")
1.263 +
1.264 + self.assertEqual(mock.call_count, 2, "call_count incorrect")
1.265 + self.assertEqual(mock.call_args,
1.266 + ((sentinel.Arg,), {'key': sentinel.KeyArg}),
1.267 + "call_args not set")
1.268 + self.assertEqual(mock.call_args_list, [
1.269 + ((sentinel.Arg,), {}),
1.270 + ((sentinel.Arg,), {'key': sentinel.KeyArg})
1.271 + ],
1.272 + "call_args_list not set")
1.273 +
1.274 +
1.275 + def test_call_args_comparison(self):
1.276 + mock = Mock()
1.277 + mock()
1.278 + mock(sentinel.Arg)
1.279 + mock(kw=sentinel.Kwarg)
1.280 + mock(sentinel.Arg, kw=sentinel.Kwarg)
1.281 + self.assertEqual(mock.call_args_list, [
1.282 + (),
1.283 + ((sentinel.Arg,),),
1.284 + ({"kw": sentinel.Kwarg},),
1.285 + ((sentinel.Arg,), {"kw": sentinel.Kwarg})
1.286 + ])
1.287 + self.assertEqual(mock.call_args,
1.288 + ((sentinel.Arg,), {"kw": sentinel.Kwarg}))
1.289 +
1.290 +
1.291 + def test_assert_called_with(self):
1.292 + mock = Mock()
1.293 + mock()
1.294 +
1.295 + # Will raise an exception if it fails
1.296 + mock.assert_called_with()
1.297 + self.assertRaises(AssertionError, mock.assert_called_with, 1)
1.298 +
1.299 + mock.reset_mock()
1.300 + self.assertRaises(AssertionError, mock.assert_called_with)
1.301 +
1.302 + mock(1, 2, 3, a='fish', b='nothing')
1.303 + mock.assert_called_with(1, 2, 3, a='fish', b='nothing')
1.304 +
1.305 +
1.306 + def test_assert_called_once_with(self):
1.307 + mock = Mock()
1.308 + mock()
1.309 +
1.310 + # Will raise an exception if it fails
1.311 + mock.assert_called_once_with()
1.312 +
1.313 + mock()
1.314 + self.assertRaises(AssertionError, mock.assert_called_once_with)
1.315 +
1.316 + mock.reset_mock()
1.317 + self.assertRaises(AssertionError, mock.assert_called_once_with)
1.318 +
1.319 + mock('foo', 'bar', baz=2)
1.320 + mock.assert_called_once_with('foo', 'bar', baz=2)
1.321 +
1.322 + mock.reset_mock()
1.323 + mock('foo', 'bar', baz=2)
1.324 + self.assertRaises(
1.325 + AssertionError,
1.326 + lambda: mock.assert_called_once_with('bob', 'bar', baz=2)
1.327 + )
1.328 +
1.329 +
1.330 + def test_attribute_access_returns_mocks(self):
1.331 + mock = Mock()
1.332 + something = mock.something
1.333 + self.assertTrue(is_instance(something, Mock), "attribute isn't a mock")
1.334 + self.assertEqual(mock.something, something,
1.335 + "different attributes returned for same name")
1.336 +
1.337 + # Usage example
1.338 + mock = Mock()
1.339 + mock.something.return_value = 3
1.340 +
1.341 + self.assertEqual(mock.something(), 3, "method returned wrong value")
1.342 + self.assertTrue(mock.something.called,
1.343 + "method didn't record being called")
1.344 +
1.345 +
1.346 + def test_attributes_have_name_and_parent_set(self):
1.347 + mock = Mock()
1.348 + something = mock.something
1.349 +
1.350 + self.assertEqual(something._mock_name, "something",
1.351 + "attribute name not set correctly")
1.352 + self.assertEqual(something._mock_parent, mock,
1.353 + "attribute parent not set correctly")
1.354 +
1.355 +
1.356 + def test_method_calls_recorded(self):
1.357 + mock = Mock()
1.358 + mock.something(3, fish=None)
1.359 + mock.something_else.something(6, cake=sentinel.Cake)
1.360 +
1.361 + self.assertEqual(mock.something_else.method_calls,
1.362 + [("something", (6,), {'cake': sentinel.Cake})],
1.363 + "method calls not recorded correctly")
1.364 + self.assertEqual(mock.method_calls, [
1.365 + ("something", (3,), {'fish': None}),
1.366 + ("something_else.something", (6,), {'cake': sentinel.Cake})
1.367 + ],
1.368 + "method calls not recorded correctly")
1.369 +
1.370 +
1.371 + def test_method_calls_compare_easily(self):
1.372 + mock = Mock()
1.373 + mock.something()
1.374 + self.assertEqual(mock.method_calls, [('something',)])
1.375 + self.assertEqual(mock.method_calls, [('something', (), {})])
1.376 +
1.377 + mock = Mock()
1.378 + mock.something('different')
1.379 + self.assertEqual(mock.method_calls, [('something', ('different',))])
1.380 + self.assertEqual(mock.method_calls,
1.381 + [('something', ('different',), {})])
1.382 +
1.383 + mock = Mock()
1.384 + mock.something(x=1)
1.385 + self.assertEqual(mock.method_calls, [('something', {'x': 1})])
1.386 + self.assertEqual(mock.method_calls, [('something', (), {'x': 1})])
1.387 +
1.388 + mock = Mock()
1.389 + mock.something('different', some='more')
1.390 + self.assertEqual(mock.method_calls, [
1.391 + ('something', ('different',), {'some': 'more'})
1.392 + ])
1.393 +
1.394 +
1.395 + def test_only_allowed_methods_exist(self):
1.396 + for spec in ['something'], ('something',):
1.397 + for arg in 'spec', 'spec_set':
1.398 + mock = Mock(**{arg: spec})
1.399 +
1.400 + # this should be allowed
1.401 + mock.something
1.402 + self.assertRaisesRegexp(
1.403 + AttributeError,
1.404 + "Mock object has no attribute 'something_else'",
1.405 + getattr, mock, 'something_else'
1.406 + )
1.407 +
1.408 +
1.409 + def test_from_spec(self):
1.410 + class Something(object):
1.411 + x = 3
1.412 + __something__ = None
1.413 + def y(self):
1.414 + pass
1.415 +
1.416 + def test_attributes(mock):
1.417 + # should work
1.418 + mock.x
1.419 + mock.y
1.420 + mock.__something__
1.421 + self.assertRaisesRegexp(
1.422 + AttributeError,
1.423 + "Mock object has no attribute 'z'",
1.424 + getattr, mock, 'z'
1.425 + )
1.426 + self.assertRaisesRegexp(
1.427 + AttributeError,
1.428 + "Mock object has no attribute '__foobar__'",
1.429 + getattr, mock, '__foobar__'
1.430 + )
1.431 +
1.432 + test_attributes(Mock(spec=Something))
1.433 + test_attributes(Mock(spec=Something()))
1.434 +
1.435 +
1.436 + def test_wraps_calls(self):
1.437 + real = Mock()
1.438 +
1.439 + mock = Mock(wraps=real)
1.440 + self.assertEqual(mock(), real())
1.441 +
1.442 + real.reset_mock()
1.443 +
1.444 + mock(1, 2, fish=3)
1.445 + real.assert_called_with(1, 2, fish=3)
1.446 +
1.447 +
1.448 + def test_wraps_call_with_nondefault_return_value(self):
1.449 + real = Mock()
1.450 +
1.451 + mock = Mock(wraps=real)
1.452 + mock.return_value = 3
1.453 +
1.454 + self.assertEqual(mock(), 3)
1.455 + self.assertFalse(real.called)
1.456 +
1.457 +
1.458 + def test_wraps_attributes(self):
1.459 + class Real(object):
1.460 + attribute = Mock()
1.461 +
1.462 + real = Real()
1.463 +
1.464 + mock = Mock(wraps=real)
1.465 + self.assertEqual(mock.attribute(), real.attribute())
1.466 + self.assertRaises(AttributeError, lambda: mock.fish)
1.467 +
1.468 + self.assertNotEqual(mock.attribute, real.attribute)
1.469 + result = mock.attribute.frog(1, 2, fish=3)
1.470 + Real.attribute.frog.assert_called_with(1, 2, fish=3)
1.471 + self.assertEqual(result, Real.attribute.frog())
1.472 +
1.473 +
1.474 + def test_exceptional_side_effect(self):
1.475 + mock = Mock(side_effect=AttributeError)
1.476 + self.assertRaises(AttributeError, mock)
1.477 +
1.478 + mock = Mock(side_effect=AttributeError('foo'))
1.479 + self.assertRaises(AttributeError, mock)
1.480 +
1.481 +
1.482 + def test_baseexceptional_side_effect(self):
1.483 + mock = Mock(side_effect=KeyboardInterrupt)
1.484 + self.assertRaises(KeyboardInterrupt, mock)
1.485 +
1.486 + mock = Mock(side_effect=KeyboardInterrupt('foo'))
1.487 + self.assertRaises(KeyboardInterrupt, mock)
1.488 +
1.489 +
1.490 + def test_assert_called_with_message(self):
1.491 + mock = Mock()
1.492 + self.assertRaisesRegexp(AssertionError, 'Not called',
1.493 + mock.assert_called_with)
1.494 +
1.495 +
1.496 + def test__name__(self):
1.497 + mock = Mock()
1.498 + self.assertRaises(AttributeError, lambda: mock.__name__)
1.499 +
1.500 + mock.__name__ = 'foo'
1.501 + self.assertEqual(mock.__name__, 'foo')
1.502 +
1.503 +
1.504 + def test_spec_list_subclass(self):
1.505 + class Sub(list):
1.506 + pass
1.507 + mock = Mock(spec=Sub(['foo']))
1.508 +
1.509 + mock.append(3)
1.510 + mock.append.assert_called_with(3)
1.511 + self.assertRaises(AttributeError, getattr, mock, 'foo')
1.512 +
1.513 +
1.514 + def test_spec_class(self):
1.515 + class X(object):
1.516 + pass
1.517 +
1.518 + mock = Mock(spec=X)
1.519 + self.assertTrue(isinstance(mock, X))
1.520 +
1.521 + mock = Mock(spec=X())
1.522 + self.assertTrue(isinstance(mock, X))
1.523 +
1.524 + self.assertIs(mock.__class__, X)
1.525 + self.assertEqual(Mock().__class__.__name__, 'Mock')
1.526 +
1.527 + mock = Mock(spec_set=X)
1.528 + self.assertTrue(isinstance(mock, X))
1.529 +
1.530 + mock = Mock(spec_set=X())
1.531 + self.assertTrue(isinstance(mock, X))
1.532 +
1.533 +
1.534 + def test_setting_attribute_with_spec_set(self):
1.535 + class X(object):
1.536 + y = 3
1.537 +
1.538 + mock = Mock(spec=X)
1.539 + mock.x = 'foo'
1.540 +
1.541 + mock = Mock(spec_set=X)
1.542 + def set_attr():
1.543 + mock.x = 'foo'
1.544 +
1.545 + mock.y = 'foo'
1.546 + self.assertRaises(AttributeError, set_attr)
1.547 +
1.548 +
1.549 + def test_copy(self):
1.550 + current = sys.getrecursionlimit()
1.551 + self.addCleanup(sys.setrecursionlimit, current)
1.552 +
1.553 + # can't use sys.maxint as this doesn't exist in Python 3
1.554 + sys.setrecursionlimit(int(10e8))
1.555 + # this segfaults without the fix in place
1.556 + copy.copy(Mock())
1.557 +
1.558 +
1.559 + @unittest2.skipIf(inPy3k, "no old style classes in Python 3")
1.560 + def test_spec_old_style_classes(self):
1.561 + class Foo:
1.562 + bar = 7
1.563 +
1.564 + mock = Mock(spec=Foo)
1.565 + mock.bar = 6
1.566 + self.assertRaises(AttributeError, lambda: mock.foo)
1.567 +
1.568 + mock = Mock(spec=Foo())
1.569 + mock.bar = 6
1.570 + self.assertRaises(AttributeError, lambda: mock.foo)
1.571 +
1.572 +
1.573 + @unittest2.skipIf(inPy3k, "no old style classes in Python 3")
1.574 + def test_spec_set_old_style_classes(self):
1.575 + class Foo:
1.576 + bar = 7
1.577 +
1.578 + mock = Mock(spec_set=Foo)
1.579 + mock.bar = 6
1.580 + self.assertRaises(AttributeError, lambda: mock.foo)
1.581 +
1.582 + def _set():
1.583 + mock.foo = 3
1.584 + self.assertRaises(AttributeError, _set)
1.585 +
1.586 + mock = Mock(spec_set=Foo())
1.587 + mock.bar = 6
1.588 + self.assertRaises(AttributeError, lambda: mock.foo)
1.589 +
1.590 + def _set():
1.591 + mock.foo = 3
1.592 + self.assertRaises(AttributeError, _set)
1.593 +
1.594 +
1.595 + def test_subclass_with_properties(self):
1.596 + class SubClass(Mock):
1.597 + def _get(self):
1.598 + return 3
1.599 + def _set(self, value):
1.600 + raise NameError('strange error')
1.601 + some_attribute = property(_get, _set)
1.602 +
1.603 + s = SubClass(spec_set=SubClass)
1.604 + self.assertEqual(s.some_attribute, 3)
1.605 +
1.606 + def test():
1.607 + s.some_attribute = 3
1.608 + self.assertRaises(NameError, test)
1.609 +
1.610 + def test():
1.611 + s.foo = 'bar'
1.612 + self.assertRaises(AttributeError, test)
1.613 +
1.614 +
1.615 + def test_setting_call(self):
1.616 + mock = Mock()
1.617 + def __call__(self, a):
1.618 + return self._mock_call(a)
1.619 +
1.620 + type(mock).__call__ = __call__
1.621 + mock('one')
1.622 + mock.assert_called_with('one')
1.623 +
1.624 + self.assertRaises(TypeError, mock, 'one', 'two')
1.625 +
1.626 +
1.627 + @unittest2.skipUnless(sys.version_info[:2] >= (2, 6),
1.628 + "__dir__ not available until Python 2.6 or later")
1.629 + def test_dir(self):
1.630 + mock = Mock()
1.631 + attrs = set(dir(mock))
1.632 + type_attrs = set([m for m in dir(Mock) if not m.startswith('_')])
1.633 +
1.634 + # all public attributes from the type are included
1.635 + self.assertEqual(set(), type_attrs - attrs)
1.636 +
1.637 + # creates these attributes
1.638 + mock.a, mock.b
1.639 + self.assertIn('a', dir(mock))
1.640 + self.assertIn('b', dir(mock))
1.641 +
1.642 + # instance attributes
1.643 + mock.c = mock.d = None
1.644 + self.assertIn('c', dir(mock))
1.645 + self.assertIn('d', dir(mock))
1.646 +
1.647 + # magic methods
1.648 + mock.__iter__ = lambda s: iter([])
1.649 + self.assertIn('__iter__', dir(mock))
1.650 +
1.651 +
1.652 + @unittest2.skipUnless(sys.version_info[:2] >= (2, 6),
1.653 + "__dir__ not available until Python 2.6 or later")
1.654 + def test_dir_from_spec(self):
1.655 + mock = Mock(spec=unittest2.TestCase)
1.656 + testcase_attrs = set(dir(unittest2.TestCase))
1.657 + attrs = set(dir(mock))
1.658 +
1.659 + # all attributes from the spec are included
1.660 + self.assertEqual(set(), testcase_attrs - attrs)
1.661 +
1.662 + # shadow a sys attribute
1.663 + mock.version = 3
1.664 + self.assertEqual(dir(mock).count('version'), 1)
1.665 +
1.666 +
1.667 + @unittest2.skipUnless(sys.version_info[:2] >= (2, 6),
1.668 + "__dir__ not available until Python 2.6 or later")
1.669 + def test_filter_dir(self):
1.670 + patcher = patch.object(mock, 'FILTER_DIR', False)
1.671 + patcher.start()
1.672 + try:
1.673 + attrs = set(dir(Mock()))
1.674 + type_attrs = set(dir(Mock))
1.675 +
1.676 + # ALL attributes from the type are included
1.677 + self.assertEqual(set(), type_attrs - attrs)
1.678 + finally:
1.679 + patcher.stop()
1.680 +
1.681 +
1.682 + def test_configure_mock(self):
1.683 + mock = Mock(foo='bar')
1.684 + self.assertEqual(mock.foo, 'bar')
1.685 +
1.686 + mock = MagicMock(foo='bar')
1.687 + self.assertEqual(mock.foo, 'bar')
1.688 +
1.689 + kwargs = {'side_effect': KeyError, 'foo.bar.return_value': 33,
1.690 + 'foo': MagicMock()}
1.691 + mock = Mock(**kwargs)
1.692 + self.assertRaises(KeyError, mock)
1.693 + self.assertEqual(mock.foo.bar(), 33)
1.694 + self.assertIsInstance(mock.foo, MagicMock)
1.695 +
1.696 + mock = Mock()
1.697 + mock.configure_mock(**kwargs)
1.698 + self.assertRaises(KeyError, mock)
1.699 + self.assertEqual(mock.foo.bar(), 33)
1.700 + self.assertIsInstance(mock.foo, MagicMock)
1.701 +
1.702 +
1.703 + def assertRaisesWithMsg(self, exception, message, func, *args, **kwargs):
1.704 + # needed because assertRaisesRegex doesn't work easily with newlines
1.705 + try:
1.706 + func(*args, **kwargs)
1.707 + except:
1.708 + instance = sys.exc_info()[1]
1.709 + self.assertIsInstance(instance, exception)
1.710 + else:
1.711 + self.fail('Exception %r not raised' % (exception,))
1.712 +
1.713 + msg = str(instance)
1.714 + self.assertEqual(msg, message)
1.715 +
1.716 +
1.717 + def test_assert_called_with_failure_message(self):
1.718 + mock = NonCallableMock()
1.719 +
1.720 + expected = "mock(1, '2', 3, bar='foo')"
1.721 + message = 'Expected call: %s\nNot called'
1.722 + self.assertRaisesWithMsg(
1.723 + AssertionError, message % (expected,),
1.724 + mock.assert_called_with, 1, '2', 3, bar='foo'
1.725 + )
1.726 +
1.727 + mock.foo(1, '2', 3, foo='foo')
1.728 +
1.729 +
1.730 + asserters = [
1.731 + mock.foo.assert_called_with, mock.foo.assert_called_once_with
1.732 + ]
1.733 + for meth in asserters:
1.734 + actual = "foo(1, '2', 3, foo='foo')"
1.735 + expected = "foo(1, '2', 3, bar='foo')"
1.736 + message = 'Expected call: %s\nActual call: %s'
1.737 + self.assertRaisesWithMsg(
1.738 + AssertionError, message % (expected, actual),
1.739 + meth, 1, '2', 3, bar='foo'
1.740 + )
1.741 +
1.742 + # just kwargs
1.743 + for meth in asserters:
1.744 + actual = "foo(1, '2', 3, foo='foo')"
1.745 + expected = "foo(bar='foo')"
1.746 + message = 'Expected call: %s\nActual call: %s'
1.747 + self.assertRaisesWithMsg(
1.748 + AssertionError, message % (expected, actual),
1.749 + meth, bar='foo'
1.750 + )
1.751 +
1.752 + # just args
1.753 + for meth in asserters:
1.754 + actual = "foo(1, '2', 3, foo='foo')"
1.755 + expected = "foo(1, 2, 3)"
1.756 + message = 'Expected call: %s\nActual call: %s'
1.757 + self.assertRaisesWithMsg(
1.758 + AssertionError, message % (expected, actual),
1.759 + meth, 1, 2, 3
1.760 + )
1.761 +
1.762 + # empty
1.763 + for meth in asserters:
1.764 + actual = "foo(1, '2', 3, foo='foo')"
1.765 + expected = "foo()"
1.766 + message = 'Expected call: %s\nActual call: %s'
1.767 + self.assertRaisesWithMsg(
1.768 + AssertionError, message % (expected, actual), meth
1.769 + )
1.770 +
1.771 +
1.772 + def test_mock_calls(self):
1.773 + mock = MagicMock()
1.774 +
1.775 + # need to do this because MagicMock.mock_calls used to just return
1.776 + # a MagicMock which also returned a MagicMock when __eq__ was called
1.777 + self.assertIs(mock.mock_calls == [], True)
1.778 +
1.779 + mock = MagicMock()
1.780 + mock()
1.781 + expected = [('', (), {})]
1.782 + self.assertEqual(mock.mock_calls, expected)
1.783 +
1.784 + mock.foo()
1.785 + expected.append(call.foo())
1.786 + self.assertEqual(mock.mock_calls, expected)
1.787 + # intermediate mock_calls work too
1.788 + self.assertEqual(mock.foo.mock_calls, [('', (), {})])
1.789 +
1.790 + mock = MagicMock()
1.791 + mock().foo(1, 2, 3, a=4, b=5)
1.792 + expected = [
1.793 + ('', (), {}), ('().foo', (1, 2, 3), dict(a=4, b=5))
1.794 + ]
1.795 + self.assertEqual(mock.mock_calls, expected)
1.796 + self.assertEqual(mock.return_value.foo.mock_calls,
1.797 + [('', (1, 2, 3), dict(a=4, b=5))])
1.798 + self.assertEqual(mock.return_value.mock_calls,
1.799 + [('foo', (1, 2, 3), dict(a=4, b=5))])
1.800 +
1.801 + mock = MagicMock()
1.802 + mock().foo.bar().baz()
1.803 + expected = [
1.804 + ('', (), {}), ('().foo.bar', (), {}),
1.805 + ('().foo.bar().baz', (), {})
1.806 + ]
1.807 + self.assertEqual(mock.mock_calls, expected)
1.808 + self.assertEqual(mock().mock_calls,
1.809 + call.foo.bar().baz().call_list())
1.810 +
1.811 + for kwargs in dict(), dict(name='bar'):
1.812 + mock = MagicMock(**kwargs)
1.813 + int(mock.foo)
1.814 + expected = [('foo.__int__', (), {})]
1.815 + self.assertEqual(mock.mock_calls, expected)
1.816 +
1.817 + mock = MagicMock(**kwargs)
1.818 + mock.a()()
1.819 + expected = [('a', (), {}), ('a()', (), {})]
1.820 + self.assertEqual(mock.mock_calls, expected)
1.821 + self.assertEqual(mock.a().mock_calls, [call()])
1.822 +
1.823 + mock = MagicMock(**kwargs)
1.824 + mock(1)(2)(3)
1.825 + self.assertEqual(mock.mock_calls, call(1)(2)(3).call_list())
1.826 + self.assertEqual(mock().mock_calls, call(2)(3).call_list())
1.827 + self.assertEqual(mock()().mock_calls, call(3).call_list())
1.828 +
1.829 + mock = MagicMock(**kwargs)
1.830 + mock(1)(2)(3).a.b.c(4)
1.831 + self.assertEqual(mock.mock_calls,
1.832 + call(1)(2)(3).a.b.c(4).call_list())
1.833 + self.assertEqual(mock().mock_calls,
1.834 + call(2)(3).a.b.c(4).call_list())
1.835 + self.assertEqual(mock()().mock_calls,
1.836 + call(3).a.b.c(4).call_list())
1.837 +
1.838 + mock = MagicMock(**kwargs)
1.839 + int(mock().foo.bar().baz())
1.840 + last_call = ('().foo.bar().baz().__int__', (), {})
1.841 + self.assertEqual(mock.mock_calls[-1], last_call)
1.842 + self.assertEqual(mock().mock_calls,
1.843 + call.foo.bar().baz().__int__().call_list())
1.844 + self.assertEqual(mock().foo.bar().mock_calls,
1.845 + call.baz().__int__().call_list())
1.846 + self.assertEqual(mock().foo.bar().baz.mock_calls,
1.847 + call().__int__().call_list())
1.848 +
1.849 +
1.850 + def test_subclassing(self):
1.851 + class Subclass(Mock):
1.852 + pass
1.853 +
1.854 + mock = Subclass()
1.855 + self.assertIsInstance(mock.foo, Subclass)
1.856 + self.assertIsInstance(mock(), Subclass)
1.857 +
1.858 + class Subclass(Mock):
1.859 + def _get_child_mock(self, **kwargs):
1.860 + return Mock(**kwargs)
1.861 +
1.862 + mock = Subclass()
1.863 + self.assertNotIsInstance(mock.foo, Subclass)
1.864 + self.assertNotIsInstance(mock(), Subclass)
1.865 +
1.866 +
1.867 + def test_arg_lists(self):
1.868 + mocks = [
1.869 + Mock(),
1.870 + MagicMock(),
1.871 + NonCallableMock(),
1.872 + NonCallableMagicMock()
1.873 + ]
1.874 +
1.875 + def assert_attrs(mock):
1.876 + names = 'call_args_list', 'method_calls', 'mock_calls'
1.877 + for name in names:
1.878 + attr = getattr(mock, name)
1.879 + self.assertIsInstance(attr, _CallList)
1.880 + self.assertIsInstance(attr, list)
1.881 + self.assertEqual(attr, [])
1.882 +
1.883 + for mock in mocks:
1.884 + assert_attrs(mock)
1.885 +
1.886 + if callable(mock):
1.887 + mock()
1.888 + mock(1, 2)
1.889 + mock(a=3)
1.890 +
1.891 + mock.reset_mock()
1.892 + assert_attrs(mock)
1.893 +
1.894 + mock.foo()
1.895 + mock.foo.bar(1, a=3)
1.896 + mock.foo(1).bar().baz(3)
1.897 +
1.898 + mock.reset_mock()
1.899 + assert_attrs(mock)
1.900 +
1.901 +
1.902 + def test_call_args_two_tuple(self):
1.903 + mock = Mock()
1.904 + mock(1, a=3)
1.905 + mock(2, b=4)
1.906 +
1.907 + self.assertEqual(len(mock.call_args), 2)
1.908 + args, kwargs = mock.call_args
1.909 + self.assertEqual(args, (2,))
1.910 + self.assertEqual(kwargs, dict(b=4))
1.911 +
1.912 + expected_list = [((1,), dict(a=3)), ((2,), dict(b=4))]
1.913 + for expected, call_args in zip(expected_list, mock.call_args_list):
1.914 + self.assertEqual(len(call_args), 2)
1.915 + self.assertEqual(expected[0], call_args[0])
1.916 + self.assertEqual(expected[1], call_args[1])
1.917 +
1.918 +
1.919 + def test_side_effect_iterator(self):
1.920 + mock = Mock(side_effect=iter([1, 2, 3]))
1.921 + self.assertEqual([mock(), mock(), mock()], [1, 2, 3])
1.922 + self.assertRaises(StopIteration, mock)
1.923 +
1.924 + mock = MagicMock(side_effect=['a', 'b', 'c'])
1.925 + self.assertEqual([mock(), mock(), mock()], ['a', 'b', 'c'])
1.926 + self.assertRaises(StopIteration, mock)
1.927 +
1.928 + mock = Mock(side_effect='ghi')
1.929 + self.assertEqual([mock(), mock(), mock()], ['g', 'h', 'i'])
1.930 + self.assertRaises(StopIteration, mock)
1.931 +
1.932 + class Foo(object):
1.933 + pass
1.934 + mock = MagicMock(side_effect=Foo)
1.935 + self.assertIsInstance(mock(), Foo)
1.936 +
1.937 + mock = Mock(side_effect=Iter())
1.938 + self.assertEqual([mock(), mock(), mock(), mock()],
1.939 + ['this', 'is', 'an', 'iter'])
1.940 + self.assertRaises(StopIteration, mock)
1.941 +
1.942 +
1.943 + def test_side_effect_setting_iterator(self):
1.944 + mock = Mock()
1.945 + mock.side_effect = iter([1, 2, 3])
1.946 + self.assertEqual([mock(), mock(), mock()], [1, 2, 3])
1.947 + self.assertRaises(StopIteration, mock)
1.948 + side_effect = mock.side_effect
1.949 + self.assertIsInstance(side_effect, type(iter([])))
1.950 +
1.951 + mock.side_effect = ['a', 'b', 'c']
1.952 + self.assertEqual([mock(), mock(), mock()], ['a', 'b', 'c'])
1.953 + self.assertRaises(StopIteration, mock)
1.954 + side_effect = mock.side_effect
1.955 + self.assertIsInstance(side_effect, type(iter([])))
1.956 +
1.957 + this_iter = Iter()
1.958 + mock.side_effect = this_iter
1.959 + self.assertEqual([mock(), mock(), mock(), mock()],
1.960 + ['this', 'is', 'an', 'iter'])
1.961 + self.assertRaises(StopIteration, mock)
1.962 + self.assertIs(mock.side_effect, this_iter)
1.963 +
1.964 +
1.965 + def test_side_effect_iterator_exceptions(self):
1.966 + for Klass in Mock, MagicMock:
1.967 + iterable = (ValueError, 3, KeyError, 6)
1.968 + m = Klass(side_effect=iterable)
1.969 + self.assertRaises(ValueError, m)
1.970 + self.assertEqual(m(), 3)
1.971 + self.assertRaises(KeyError, m)
1.972 + self.assertEqual(m(), 6)
1.973 +
1.974 +
1.975 + def test_assert_has_calls_any_order(self):
1.976 + mock = Mock()
1.977 + mock(1, 2)
1.978 + mock(a=3)
1.979 + mock(3, 4)
1.980 + mock(b=6)
1.981 + mock(b=6)
1.982 +
1.983 + kalls = [
1.984 + call(1, 2), ({'a': 3},),
1.985 + ((3, 4),), ((), {'a': 3}),
1.986 + ('', (1, 2)), ('', {'a': 3}),
1.987 + ('', (1, 2), {}), ('', (), {'a': 3})
1.988 + ]
1.989 + for kall in kalls:
1.990 + mock.assert_has_calls([kall], any_order=True)
1.991 +
1.992 + for kall in call(1, '2'), call(b=3), call(), 3, None, 'foo':
1.993 + self.assertRaises(
1.994 + AssertionError, mock.assert_has_calls,
1.995 + [kall], any_order=True
1.996 + )
1.997 +
1.998 + kall_lists = [
1.999 + [call(1, 2), call(b=6)],
1.1000 + [call(3, 4), call(1, 2)],
1.1001 + [call(b=6), call(b=6)],
1.1002 + ]
1.1003 +
1.1004 + for kall_list in kall_lists:
1.1005 + mock.assert_has_calls(kall_list, any_order=True)
1.1006 +
1.1007 + kall_lists = [
1.1008 + [call(b=6), call(b=6), call(b=6)],
1.1009 + [call(1, 2), call(1, 2)],
1.1010 + [call(3, 4), call(1, 2), call(5, 7)],
1.1011 + [call(b=6), call(3, 4), call(b=6), call(1, 2), call(b=6)],
1.1012 + ]
1.1013 + for kall_list in kall_lists:
1.1014 + self.assertRaises(
1.1015 + AssertionError, mock.assert_has_calls,
1.1016 + kall_list, any_order=True
1.1017 + )
1.1018 +
1.1019 + def test_assert_has_calls(self):
1.1020 + kalls1 = [
1.1021 + call(1, 2), ({'a': 3},),
1.1022 + ((3, 4),), call(b=6),
1.1023 + ('', (1,), {'b': 6}),
1.1024 + ]
1.1025 + kalls2 = [call.foo(), call.bar(1)]
1.1026 + kalls2.extend(call.spam().baz(a=3).call_list())
1.1027 + kalls2.extend(call.bam(set(), foo={}).fish([1]).call_list())
1.1028 +
1.1029 + mocks = []
1.1030 + for mock in Mock(), MagicMock():
1.1031 + mock(1, 2)
1.1032 + mock(a=3)
1.1033 + mock(3, 4)
1.1034 + mock(b=6)
1.1035 + mock(1, b=6)
1.1036 + mocks.append((mock, kalls1))
1.1037 +
1.1038 + mock = Mock()
1.1039 + mock.foo()
1.1040 + mock.bar(1)
1.1041 + mock.spam().baz(a=3)
1.1042 + mock.bam(set(), foo={}).fish([1])
1.1043 + mocks.append((mock, kalls2))
1.1044 +
1.1045 + for mock, kalls in mocks:
1.1046 + for i in range(len(kalls)):
1.1047 + for step in 1, 2, 3:
1.1048 + these = kalls[i:i+step]
1.1049 + mock.assert_has_calls(these)
1.1050 +
1.1051 + if len(these) > 1:
1.1052 + self.assertRaises(
1.1053 + AssertionError,
1.1054 + mock.assert_has_calls,
1.1055 + list(reversed(these))
1.1056 + )
1.1057 +
1.1058 +
1.1059 + def test_assert_any_call(self):
1.1060 + mock = Mock()
1.1061 + mock(1, 2)
1.1062 + mock(a=3)
1.1063 + mock(1, b=6)
1.1064 +
1.1065 + mock.assert_any_call(1, 2)
1.1066 + mock.assert_any_call(a=3)
1.1067 + mock.assert_any_call(1, b=6)
1.1068 +
1.1069 + self.assertRaises(
1.1070 + AssertionError,
1.1071 + mock.assert_any_call
1.1072 + )
1.1073 + self.assertRaises(
1.1074 + AssertionError,
1.1075 + mock.assert_any_call,
1.1076 + 1, 3
1.1077 + )
1.1078 + self.assertRaises(
1.1079 + AssertionError,
1.1080 + mock.assert_any_call,
1.1081 + a=4
1.1082 + )
1.1083 +
1.1084 +
1.1085 + def test_mock_calls_create_autospec(self):
1.1086 + def f(a, b):
1.1087 + pass
1.1088 + obj = Iter()
1.1089 + obj.f = f
1.1090 +
1.1091 + funcs = [
1.1092 + create_autospec(f),
1.1093 + create_autospec(obj).f
1.1094 + ]
1.1095 + for func in funcs:
1.1096 + func(1, 2)
1.1097 + func(3, 4)
1.1098 +
1.1099 + self.assertEqual(
1.1100 + func.mock_calls, [call(1, 2), call(3, 4)]
1.1101 + )
1.1102 +
1.1103 +
1.1104 + def test_mock_add_spec(self):
1.1105 + class _One(object):
1.1106 + one = 1
1.1107 + class _Two(object):
1.1108 + two = 2
1.1109 + class Anything(object):
1.1110 + one = two = three = 'four'
1.1111 +
1.1112 + klasses = [
1.1113 + Mock, MagicMock, NonCallableMock, NonCallableMagicMock
1.1114 + ]
1.1115 + for Klass in list(klasses):
1.1116 + klasses.append(lambda K=Klass: K(spec=Anything))
1.1117 + klasses.append(lambda K=Klass: K(spec_set=Anything))
1.1118 +
1.1119 + for Klass in klasses:
1.1120 + for kwargs in dict(), dict(spec_set=True):
1.1121 + mock = Klass()
1.1122 + #no error
1.1123 + mock.one, mock.two, mock.three
1.1124 +
1.1125 + for One, Two in [(_One, _Two), (['one'], ['two'])]:
1.1126 + for kwargs in dict(), dict(spec_set=True):
1.1127 + mock.mock_add_spec(One, **kwargs)
1.1128 +
1.1129 + mock.one
1.1130 + self.assertRaises(
1.1131 + AttributeError, getattr, mock, 'two'
1.1132 + )
1.1133 + self.assertRaises(
1.1134 + AttributeError, getattr, mock, 'three'
1.1135 + )
1.1136 + if 'spec_set' in kwargs:
1.1137 + self.assertRaises(
1.1138 + AttributeError, setattr, mock, 'three', None
1.1139 + )
1.1140 +
1.1141 + mock.mock_add_spec(Two, **kwargs)
1.1142 + self.assertRaises(
1.1143 + AttributeError, getattr, mock, 'one'
1.1144 + )
1.1145 + mock.two
1.1146 + self.assertRaises(
1.1147 + AttributeError, getattr, mock, 'three'
1.1148 + )
1.1149 + if 'spec_set' in kwargs:
1.1150 + self.assertRaises(
1.1151 + AttributeError, setattr, mock, 'three', None
1.1152 + )
1.1153 + # note that creating a mock, setting an instance attribute, and
1.1154 + # *then* setting a spec doesn't work. Not the intended use case
1.1155 +
1.1156 +
1.1157 + def test_mock_add_spec_magic_methods(self):
1.1158 + for Klass in MagicMock, NonCallableMagicMock:
1.1159 + mock = Klass()
1.1160 + int(mock)
1.1161 +
1.1162 + mock.mock_add_spec(object)
1.1163 + self.assertRaises(TypeError, int, mock)
1.1164 +
1.1165 + mock = Klass()
1.1166 + mock['foo']
1.1167 + mock.__int__.return_value =4
1.1168 +
1.1169 + mock.mock_add_spec(int)
1.1170 + self.assertEqual(int(mock), 4)
1.1171 + self.assertRaises(TypeError, lambda: mock['foo'])
1.1172 +
1.1173 +
1.1174 + def test_adding_child_mock(self):
1.1175 + for Klass in NonCallableMock, Mock, MagicMock, NonCallableMagicMock:
1.1176 + mock = Klass()
1.1177 +
1.1178 + mock.foo = Mock()
1.1179 + mock.foo()
1.1180 +
1.1181 + self.assertEqual(mock.method_calls, [call.foo()])
1.1182 + self.assertEqual(mock.mock_calls, [call.foo()])
1.1183 +
1.1184 + mock = Klass()
1.1185 + mock.bar = Mock(name='name')
1.1186 + mock.bar()
1.1187 + self.assertEqual(mock.method_calls, [])
1.1188 + self.assertEqual(mock.mock_calls, [])
1.1189 +
1.1190 + # mock with an existing _new_parent but no name
1.1191 + mock = Klass()
1.1192 + mock.baz = MagicMock()()
1.1193 + mock.baz()
1.1194 + self.assertEqual(mock.method_calls, [])
1.1195 + self.assertEqual(mock.mock_calls, [])
1.1196 +
1.1197 +
1.1198 + def test_adding_return_value_mock(self):
1.1199 + for Klass in Mock, MagicMock:
1.1200 + mock = Klass()
1.1201 + mock.return_value = MagicMock()
1.1202 +
1.1203 + mock()()
1.1204 + self.assertEqual(mock.mock_calls, [call(), call()()])
1.1205 +
1.1206 +
1.1207 + def test_manager_mock(self):
1.1208 + class Foo(object):
1.1209 + one = 'one'
1.1210 + two = 'two'
1.1211 + manager = Mock()
1.1212 + p1 = patch.object(Foo, 'one')
1.1213 + p2 = patch.object(Foo, 'two')
1.1214 +
1.1215 + mock_one = p1.start()
1.1216 + self.addCleanup(p1.stop)
1.1217 + mock_two = p2.start()
1.1218 + self.addCleanup(p2.stop)
1.1219 +
1.1220 + manager.attach_mock(mock_one, 'one')
1.1221 + manager.attach_mock(mock_two, 'two')
1.1222 +
1.1223 + Foo.two()
1.1224 + Foo.one()
1.1225 +
1.1226 + self.assertEqual(manager.mock_calls, [call.two(), call.one()])
1.1227 +
1.1228 +
1.1229 + def test_magic_methods_mock_calls(self):
1.1230 + for Klass in Mock, MagicMock:
1.1231 + m = Klass()
1.1232 + m.__int__ = Mock(return_value=3)
1.1233 + m.__float__ = MagicMock(return_value=3.0)
1.1234 + int(m)
1.1235 + float(m)
1.1236 +
1.1237 + self.assertEqual(m.mock_calls, [call.__int__(), call.__float__()])
1.1238 + self.assertEqual(m.method_calls, [])
1.1239 +
1.1240 +
1.1241 + def test_attribute_deletion(self):
1.1242 + # this behaviour isn't *useful*, but at least it's now tested...
1.1243 + for Klass in Mock, MagicMock, NonCallableMagicMock, NonCallableMock:
1.1244 + m = Klass()
1.1245 + original = m.foo
1.1246 + m.foo = 3
1.1247 + del m.foo
1.1248 + self.assertEqual(m.foo, original)
1.1249 +
1.1250 + new = m.foo = Mock()
1.1251 + del m.foo
1.1252 + self.assertEqual(m.foo, new)
1.1253 +
1.1254 +
1.1255 + def test_mock_parents(self):
1.1256 + for Klass in Mock, MagicMock:
1.1257 + m = Klass()
1.1258 + original_repr = repr(m)
1.1259 + m.return_value = m
1.1260 + self.assertIs(m(), m)
1.1261 + self.assertEqual(repr(m), original_repr)
1.1262 +
1.1263 + m.reset_mock()
1.1264 + self.assertIs(m(), m)
1.1265 + self.assertEqual(repr(m), original_repr)
1.1266 +
1.1267 + m = Klass()
1.1268 + m.b = m.a
1.1269 + self.assertIn("name='mock.a'", repr(m.b))
1.1270 + self.assertIn("name='mock.a'", repr(m.a))
1.1271 + m.reset_mock()
1.1272 + self.assertIn("name='mock.a'", repr(m.b))
1.1273 + self.assertIn("name='mock.a'", repr(m.a))
1.1274 +
1.1275 + m = Klass()
1.1276 + original_repr = repr(m)
1.1277 + m.a = m()
1.1278 + m.a.return_value = m
1.1279 +
1.1280 + self.assertEqual(repr(m), original_repr)
1.1281 + self.assertEqual(repr(m.a()), original_repr)
1.1282 +
1.1283 +
1.1284 + def test_attach_mock(self):
1.1285 + classes = Mock, MagicMock, NonCallableMagicMock, NonCallableMock
1.1286 + for Klass in classes:
1.1287 + for Klass2 in classes:
1.1288 + m = Klass()
1.1289 +
1.1290 + m2 = Klass2(name='foo')
1.1291 + m.attach_mock(m2, 'bar')
1.1292 +
1.1293 + self.assertIs(m.bar, m2)
1.1294 + self.assertIn("name='mock.bar'", repr(m2))
1.1295 +
1.1296 + m.bar.baz(1)
1.1297 + self.assertEqual(m.mock_calls, [call.bar.baz(1)])
1.1298 + self.assertEqual(m.method_calls, [call.bar.baz(1)])
1.1299 +
1.1300 +
1.1301 + def test_attach_mock_return_value(self):
1.1302 + classes = Mock, MagicMock, NonCallableMagicMock, NonCallableMock
1.1303 + for Klass in Mock, MagicMock:
1.1304 + for Klass2 in classes:
1.1305 + m = Klass()
1.1306 +
1.1307 + m2 = Klass2(name='foo')
1.1308 + m.attach_mock(m2, 'return_value')
1.1309 +
1.1310 + self.assertIs(m(), m2)
1.1311 + self.assertIn("name='mock()'", repr(m2))
1.1312 +
1.1313 + m2.foo()
1.1314 + self.assertEqual(m.mock_calls, call().foo().call_list())
1.1315 +
1.1316 +
1.1317 + def test_attribute_deletion(self):
1.1318 + for mock in Mock(), MagicMock():
1.1319 + self.assertTrue(hasattr(mock, 'm'))
1.1320 +
1.1321 + del mock.m
1.1322 + self.assertFalse(hasattr(mock, 'm'))
1.1323 +
1.1324 + del mock.f
1.1325 + self.assertFalse(hasattr(mock, 'f'))
1.1326 + self.assertRaises(AttributeError, getattr, mock, 'f')
1.1327 +
1.1328 +
1.1329 + def test_class_assignable(self):
1.1330 + for mock in Mock(), MagicMock():
1.1331 + self.assertNotIsInstance(mock, int)
1.1332 +
1.1333 + mock.__class__ = int
1.1334 + self.assertIsInstance(mock, int)
1.1335 +
1.1336 +
1.1337 + @unittest2.expectedFailure
1.1338 + def test_pickle(self):
1.1339 + for Klass in (MagicMock, Mock, Subclass, NonCallableMagicMock):
1.1340 + mock = Klass(name='foo', attribute=3)
1.1341 + mock.foo(1, 2, 3)
1.1342 + data = pickle.dumps(mock)
1.1343 + new = pickle.loads(data)
1.1344 +
1.1345 + new.foo.assert_called_once_with(1, 2, 3)
1.1346 + self.assertFalse(new.called)
1.1347 + self.assertTrue(is_instance(new, Klass))
1.1348 + self.assertIsInstance(new, Thing)
1.1349 + self.assertIn('name="foo"', repr(new))
1.1350 + self.assertEqual(new.attribute, 3)
1.1351 +
1.1352 +
1.1353 +if __name__ == '__main__':
1.1354 + unittest2.main()
