import copy

import re

import sys

import tempfile

from test.support import ALWAYS_EQ

import unittest

from test.test_unittest.testmock.support import is_instance

from unittest import mock

from unittest.mock import (

call, DEFAULT, patch, sentinel,

MagicMock, Mock, NonCallableMock,

NonCallableMagicMock, AsyncMock, _Call, _CallList,

create_autospec, InvalidSpecError

)

class Iter(object):

def __init__(self):

self.thing = iter(['this', 'is', 'an', 'iter'])

def __iter__(self):

return self

def next(self):

return next(self.thing)

__next__ = next

class Something(object):

def meth(self, a, b, c, d=None): pass

@classmethod

def cmeth(cls, a, b, c, d=None): pass

@staticmethod

def smeth(a, b, c, d=None): pass

class SomethingElse(object):

def __init__(self):

self._instance = None

@property

def instance(self):

if not self._instance:

self._instance = 'object'

return self._instance

class Typos():

autospect = None

auto_spec = None

set_spec = None

def something(a): pass

class MockTest(unittest.TestCase):

def test_all(self):

# if __all__ is badly defined then import * will raise an error

# We have to exec it because you can't import * inside a method

# in Python 3

exec("from unittest.mock import *")

def test_constructor(self):

mock = Mock()

self.assertFalse(mock.called, "called not initialised correctly")

self.assertEqual(mock.call_count, 0,

"call_count not initialised correctly")

self.assertTrue(is_instance(mock.return_value, Mock),

"return_value not initialised correctly")

self.assertEqual(mock.call_args, None,

"call_args not initialised correctly")

self.assertEqual(mock.call_args_list, [],

"call_args_list not initialised correctly")

self.assertEqual(mock.method_calls, [],

"method_calls not initialised correctly")

# Can't use hasattr for this test as it always returns True on a mock

self.assertNotIn('_items', mock.__dict__,

"default mock should not have '_items' attribute")

self.assertIsNone(mock._mock_parent,

"parent not initialised correctly")

self.assertIsNone(mock._mock_methods,

"methods not initialised correctly")

self.assertEqual(mock._mock_children, {},

"children not initialised incorrectly")

def test_return_value_in_constructor(self):

mock = Mock(return_value=None)

self.assertIsNone(mock.return_value,

"return value in constructor not honoured")

def test_change_return_value_via_delegate(self):

def f(): pass

mock = create_autospec(f)

mock.mock.return_value = 1

self.assertEqual(mock(), 1)

def test_change_side_effect_via_delegate(self):

def f(): pass

mock = create_autospec(f)

mock.mock.side_effect = TypeError()

with self.assertRaises(TypeError):

mock()

def test_create_autospec_should_be_configurable_by_kwargs(self):

"""If kwargs are given to configure mock, the function must configure

the parent mock during initialization."""

mocked_result = 'mocked value'

class_mock = create_autospec(spec=Something, **{

'return_value.meth.side_effect': [ValueError, DEFAULT],

'return_value.meth.return_value': mocked_result})

with self.assertRaises(ValueError):

class_mock().meth(a=None, b=None, c=None)

self.assertEqual(class_mock().meth(a=None, b=None, c=None), mocked_result)

# Only the parent mock should be configurable because the user will

# pass kwargs with respect to the parent mock.

self.assertEqual(class_mock().return_value.meth.side_effect, None)

def test_create_autospec_correctly_handles_name(self):

class X: ...

mock = create_autospec(X, spec_set=True, name="Y")

self.assertEqual(mock._mock_name, "Y")

def test_repr(self):

mock = Mock(name='foo')

self.assertIn('foo', repr(mock))

self.assertIn("'%s'" % id(mock), repr(mock))

mocks = [(Mock(), 'mock'), (Mock(name='bar'), 'bar')]

for mock, name in mocks:

self.assertIn('%s.bar' % name, repr(mock.bar))

self.assertIn('%s.foo()' % name, repr(mock.foo()))

self.assertIn('%s.foo().bing' % name, repr(mock.foo().bing))

self.assertIn('%s()' % name, repr(mock()))

self.assertIn('%s()()' % name, repr(mock()()))

self.assertIn('%s()().foo.bar.baz().bing' % name,

repr(mock()().foo.bar.baz().bing))

def test_repr_with_spec(self):

class X(object):

pass

mock = Mock(spec=X)

self.assertIn(" spec='X' ", repr(mock))

mock = Mock(spec=X())

self.assertIn(" spec='X' ", repr(mock))

mock = Mock(spec_set=X)

self.assertIn(" spec_set='X' ", repr(mock))

mock = Mock(spec_set=X())

self.assertIn(" spec_set='X' ", repr(mock))

mock = Mock(spec=X, name='foo')

self.assertIn(" spec='X' ", repr(mock))

self.assertIn(" name='foo' ", repr(mock))

mock = Mock(name='foo')

self.assertNotIn("spec", repr(mock))

mock = Mock()

self.assertNotIn("spec", repr(mock))

mock = Mock(spec=['foo'])

self.assertNotIn("spec", repr(mock))

def test_side_effect(self):

mock = Mock()

def effect(*args, **kwargs):

raise SystemError('kablooie')

mock.side_effect = effect

self.assertRaises(SystemError, mock, 1, 2, fish=3)

mock.assert_called_with(1, 2, fish=3)

results = [1, 2, 3]

def effect():

return results.pop()

mock.side_effect = effect

self.assertEqual([mock(), mock(), mock()], [3, 2, 1],

"side effect not used correctly")

mock = Mock(side_effect=sentinel.SideEffect)

self.assertEqual(mock.side_effect, sentinel.SideEffect,

"side effect in constructor not used")

def side_effect():

return DEFAULT

mock = Mock(side_effect=side_effect, return_value=sentinel.RETURN)

self.assertEqual(mock(), sentinel.RETURN)

def test_autospec_side_effect(self):

# Test for issue17826

results = [1, 2, 3]

def effect():

return results.pop()

def f(): pass

mock = create_autospec(f)

mock.side_effect = [1, 2, 3]

self.assertEqual([mock(), mock(), mock()], [1, 2, 3],

"side effect not used correctly in create_autospec")

# Test where side effect is a callable

results = [1, 2, 3]

mock = create_autospec(f)

mock.side_effect = effect

self.assertEqual([mock(), mock(), mock()], [3, 2, 1],

"callable side effect not used correctly")

def test_autospec_side_effect_exception(self):

# Test for issue 23661

def f(): pass

mock = create_autospec(f)

mock.side_effect = ValueError('Bazinga!')

self.assertRaisesRegex(ValueError, 'Bazinga!', mock)

def test_autospec_mock(self):

class A(object):

class B(object):

C = None

with mock.patch.object(A, 'B'):

with self.assertRaisesRegex(InvalidSpecError,

"Cannot autospec attr 'B' from target <MagicMock spec='A'"):

create_autospec(A).B

with self.assertRaisesRegex(InvalidSpecError,

"Cannot autospec attr 'B' from target 'A'"):

mock.patch.object(A, 'B', autospec=True).start()

with self.assertRaisesRegex(InvalidSpecError,

"Cannot autospec attr 'C' as the patch target "):

mock.patch.object(A.B, 'C', autospec=True).start()

with self.assertRaisesRegex(InvalidSpecError,

"Cannot spec attr 'B' as the spec "):

mock.patch.object(A, 'B', spec=A.B).start()

with self.assertRaisesRegex(InvalidSpecError,

"Cannot spec attr 'B' as the spec_set "):

mock.patch.object(A, 'B', spec_set=A.B).start()

with self.assertRaisesRegex(InvalidSpecError,

"Cannot spec attr 'B' as the spec_set "):

mock.patch.object(A, 'B', spec_set=A.B).start()

with self.assertRaisesRegex(InvalidSpecError, "Cannot spec a Mock object."):

mock.Mock(A.B)

with mock.patch('builtins.open', mock.mock_open()):

mock.mock_open() # should still be valid with open() mocked

def test_create_autospec_wraps_class(self):

"""Autospec a class with wraps & test if the call is passed to the

wrapped object."""

result = "real result"

class Result:

def get_result(self):

return result

class_mock = create_autospec(spec=Result, wraps=Result)

# Have to reassign the return_value to DEFAULT to return the real

# result (actual instance of "Result") when the mock is called.

class_mock.return_value = mock.DEFAULT

self.assertEqual(class_mock().get_result(), result)

# Autospec should also wrap child attributes of parent.

self.assertEqual(class_mock.get_result._mock_wraps, Result.get_result)

def test_create_autospec_instance_wraps_class(self):

"""Autospec a class instance with wraps & test if the call is passed

to the wrapped object."""

result = "real result"

class Result:

@staticmethod

def get_result():

"""This is a static method because when the mocked instance of

'Result' will call this method, it won't be able to consume

'self' argument."""

return result

instance_mock = create_autospec(spec=Result, instance=True, wraps=Result)

# Have to reassign the return_value to DEFAULT to return the real

# result from "Result.get_result" when the mocked instance of "Result"

# calls "get_result".

instance_mock.get_result.return_value = mock.DEFAULT

self.assertEqual(instance_mock.get_result(), result)

# Autospec should also wrap child attributes of the instance.

self.assertEqual(instance_mock.get_result._mock_wraps, Result.get_result)

def test_create_autospec_wraps_function_type(self):

"""Autospec a function or a method with wraps & test if the call is

passed to the wrapped object."""

result = "real result"

class Result:

def get_result(self):

return result

func_mock = create_autospec(spec=Result.get_result, wraps=Result.get_result)

self.assertEqual(func_mock(Result()), result)

def test_explicit_return_value_even_if_mock_wraps_object(self):

"""If the mock has an explicit return_value set then calls are not

passed to the wrapped object and the return_value is returned instead.

"""

def my_func():

return None # pragma: no cover

func_mock = create_autospec(spec=my_func, wraps=my_func)

return_value = "explicit return value"

func_mock.return_value = return_value

self.assertEqual(func_mock(), return_value)

def test_explicit_parent(self):

parent = Mock()

mock1 = Mock(parent=parent, return_value=None)

mock1(1, 2, 3)

mock2 = Mock(parent=parent, return_value=None)

mock2(4, 5, 6)

self.assertEqual(parent.mock_calls, [call(1, 2, 3), call(4, 5, 6)])

def test_reset_mock(self):

parent = Mock()

spec = ["something"]

mock = Mock(name="child", parent=parent, spec=spec)

mock(sentinel.Something, something=sentinel.SomethingElse)

something = mock.something

mock.something()

mock.side_effect = sentinel.SideEffect

return_value = mock.return_value

return_value()

mock.reset_mock()

self.assertEqual(mock._mock_name, "child",

"name incorrectly reset")

self.assertEqual(mock._mock_parent, parent,

"parent incorrectly reset")

self.assertEqual(mock._mock_methods, spec,

"methods incorrectly reset")

self.assertFalse(mock.called, "called not reset")

self.assertEqual(mock.call_count, 0, "call_count not reset")

self.assertEqual(mock.call_args, None, "call_args not reset")

self.assertEqual(mock.call_args_list, [], "call_args_list not reset")

self.assertEqual(mock.method_calls, [],

"method_calls not initialised correctly: %r != %r" %

(mock.method_calls, []))

self.assertEqual(mock.mock_calls, [])

self.assertEqual(mock.side_effect, sentinel.SideEffect,

"side_effect incorrectly reset")

self.assertEqual(mock.return_value, return_value,

"return_value incorrectly reset")

self.assertFalse(return_value.called, "return value mock not reset")

self.assertEqual(mock._mock_children, {'something': something},

"children reset incorrectly")

self.assertEqual(mock.something, something,

"children incorrectly cleared")

self.assertFalse(mock.something.called, "child not reset")

def test_reset_mock_recursion(self):

mock = Mock()

mock.return_value = mock

# used to cause recursion

mock.reset_mock()

def test_reset_mock_on_mock_open_issue_18622(self):

a = mock.mock_open()

a.reset_mock()

def test_call(self):

mock = Mock()

self.assertTrue(is_instance(mock.return_value, Mock),

"Default return_value should be a Mock")

result = mock()

self.assertEqual(mock(), result,

"different result from consecutive calls")

mock.reset_mock()

ret_val = mock(sentinel.Arg)

self.assertTrue(mock.called, "called not set")

self.assertEqual(mock.call_count, 1, "call_count incorrect")

self.assertEqual(mock.call_args, ((sentinel.Arg,), {}),

"call_args not set")

self.assertEqual(mock.call_args.args, (sentinel.Arg,),

"call_args not set")

self.assertEqual(mock.call_args.kwargs, {},

"call_args not set")

self.assertEqual(mock.call_args_list, [((sentinel.Arg,), {})],

"call_args_list not initialised correctly")

mock.return_value = sentinel.ReturnValue

ret_val = mock(sentinel.Arg, key=sentinel.KeyArg)

self.assertEqual(ret_val, sentinel.ReturnValue,

"incorrect return value")

self.assertEqual(mock.call_count, 2, "call_count incorrect")

self.assertEqual(mock.call_args,

((sentinel.Arg,), {'key': sentinel.KeyArg}),

"call_args not set")

self.assertEqual(mock.call_args_list, [

((sentinel.Arg,), {}),

((sentinel.Arg,), {'key': sentinel.KeyArg})

],

"call_args_list not set")

def test_call_args_comparison(self):

mock = Mock()

mock()

mock(sentinel.Arg)

mock(kw=sentinel.Kwarg)

mock(sentinel.Arg, kw=sentinel.Kwarg)

self.assertEqual(mock.call_args_list, [

(),

((sentinel.Arg,),),

({"kw": sentinel.Kwarg},),

((sentinel.Arg,), {"kw": sentinel.Kwarg})

])

self.assertEqual(mock.call_args,

((sentinel.Arg,), {"kw": sentinel.Kwarg}))

self.assertEqual(mock.call_args.args, (sentinel.Arg,))

self.assertEqual(mock.call_args.kwargs, {"kw": sentinel.Kwarg})

# Comparing call_args to a long sequence should not raise

# an exception. See issue 24857.

self.assertFalse(mock.call_args == "a long sequence")

def test_calls_equal_with_any(self):

# Check that equality and non-equality is consistent even when

# comparing with mock.ANY

mm = mock.MagicMock()

self.assertTrue(mm == mm)

self.assertFalse(mm != mm)

self.assertFalse(mm == mock.MagicMock())

self.assertTrue(mm != mock.MagicMock())

self.assertTrue(mm == mock.ANY)

self.assertFalse(mm != mock.ANY)

self.assertTrue(mock.ANY == mm)

self.assertFalse(mock.ANY != mm)

self.assertTrue(mm == ALWAYS_EQ)

self.assertFalse(mm != ALWAYS_EQ)

call1 = mock.call(mock.MagicMock())

call2 = mock.call(mock.ANY)

self.assertTrue(call1 == call2)

self.assertFalse(call1 != call2)

self.assertTrue(call2 == call1)

self.assertFalse(call2 != call1)

self.assertTrue(call1 == ALWAYS_EQ)

self.assertFalse(call1 != ALWAYS_EQ)

self.assertFalse(call1 == 1)

self.assertTrue(call1 != 1)

def test_assert_called_with(self):

mock = Mock()

mock()

# Will raise an exception if it fails

mock.assert_called_with()

self.assertRaises(AssertionError, mock.assert_called_with, 1)

mock.reset_mock()

self.assertRaises(AssertionError, mock.assert_called_with)

mock(1, 2, 3, a='fish', b='nothing')

mock.assert_called_with(1, 2, 3, a='fish', b='nothing')

def test_assert_called_with_any(self):

m = MagicMock()

m(MagicMock())

m.assert_called_with(mock.ANY)

def test_assert_called_with_function_spec(self):

def f(a, b, c, d=None): pass

mock = Mock(spec=f)

mock(1, b=2, c=3)

mock.assert_called_with(1, 2, 3)

mock.assert_called_with(a=1, b=2, c=3)

self.assertRaises(AssertionError, mock.assert_called_with,

1, b=3, c=2)

# Expected call doesn't match the spec's signature

with self.assertRaises(AssertionError) as cm:

mock.assert_called_with(e=8)

self.assertIsInstance(cm.exception.__cause__, TypeError)

def test_assert_called_with_method_spec(self):

def _check(mock):

mock(1, b=2, c=3)

mock.assert_called_with(1, 2, 3)

mock.assert_called_with(a=1, b=2, c=3)

self.assertRaises(AssertionError, mock.assert_called_with,

1, b=3, c=2)

mock = Mock(spec=Something().meth)

_check(mock)

mock = Mock(spec=Something.cmeth)

_check(mock)

mock = Mock(spec=Something().cmeth)

_check(mock)

mock = Mock(spec=Something.smeth)

_check(mock)

mock = Mock(spec=Something().smeth)

_check(mock)

def test_assert_called_exception_message(self):

msg = "Expected '{0}' to have been called"

with self.assertRaisesRegex(AssertionError, msg.format('mock')):

Mock().assert_called()

with self.assertRaisesRegex(AssertionError, msg.format('test_name')):

Mock(name="test_name").assert_called()

def test_assert_called_once_with(self):

mock = Mock()

mock()

# Will raise an exception if it fails

mock.assert_called_once_with()

mock()

self.assertRaises(AssertionError, mock.assert_called_once_with)

mock.reset_mock()

self.assertRaises(AssertionError, mock.assert_called_once_with)

mock('foo', 'bar', baz=2)

mock.assert_called_once_with('foo', 'bar', baz=2)

mock.reset_mock()

mock('foo', 'bar', baz=2)

self.assertRaises(

AssertionError,

lambda: mock.assert_called_once_with('bob', 'bar', baz=2)

)

def test_assert_called_once_with_call_list(self):

m = Mock()

m(1)

m(2)

self.assertRaisesRegex(AssertionError,

re.escape("Calls: [call(1), call(2)]"),

lambda: m.assert_called_once_with(2))

def test_assert_called_once_with_function_spec(self):

def f(a, b, c, d=None): pass

mock = Mock(spec=f)

mock(1, b=2, c=3)

mock.assert_called_once_with(1, 2, 3)

mock.assert_called_once_with(a=1, b=2, c=3)

self.assertRaises(AssertionError, mock.assert_called_once_with,

1, b=3, c=2)

# Expected call doesn't match the spec's signature

with self.assertRaises(AssertionError) as cm:

mock.assert_called_once_with(e=8)

self.assertIsInstance(cm.exception.__cause__, TypeError)

# Mock called more than once => always fails

mock(4, 5, 6)

self.assertRaises(AssertionError, mock.assert_called_once_with,

1, 2, 3)

self.assertRaises(AssertionError, mock.assert_called_once_with,

4, 5, 6)

def test_attribute_access_returns_mocks(self):

mock = Mock()

something = mock.something

self.assertTrue(is_instance(something, Mock), "attribute isn't a mock")

self.assertEqual(mock.something, something,

"different attributes returned for same name")

# Usage example

mock = Mock()

mock.something.return_value = 3

self.assertEqual(mock.something(), 3, "method returned wrong value")

self.assertTrue(mock.something.called,

"method didn't record being called")

def test_attributes_have_name_and_parent_set(self):

mock = Mock()

something = mock.something

self.assertEqual(something._mock_name, "something",

"attribute name not set correctly")

self.assertEqual(something._mock_parent, mock,

"attribute parent not set correctly")

def test_method_calls_recorded(self):

mock = Mock()

mock.something(3, fish=None)

mock.something_else.something(6, cake=sentinel.Cake)

self.assertEqual(mock.something_else.method_calls,

[("something", (6,), {'cake': sentinel.Cake})],

"method calls not recorded correctly")

self.assertEqual(mock.method_calls, [

("something", (3,), {'fish': None}),

("something_else.something", (6,), {'cake': sentinel.Cake})

],

"method calls not recorded correctly")

def test_method_calls_compare_easily(self):

mock = Mock()

mock.something()

self.assertEqual(mock.method_calls, [('something',)])

self.assertEqual(mock.method_calls, [('something', (), {})])

mock = Mock()

mock.something('different')

self.assertEqual(mock.method_calls, [('something', ('different',))])

self.assertEqual(mock.method_calls,

[('something', ('different',), {})])

mock = Mock()

mock.something(x=1)

self.assertEqual(mock.method_calls, [('something', {'x': 1})])

self.assertEqual(mock.method_calls, [('something', (), {'x': 1})])

mock = Mock()

mock.something('different', some='more')

self.assertEqual(mock.method_calls, [

('something', ('different',), {'some': 'more'})

])

def test_only_allowed_methods_exist(self):

for spec in ['something'], ('something',):

for arg in 'spec', 'spec_set':

mock = Mock(**{arg: spec})

# this should be allowed

mock.something

self.assertRaisesRegex(

AttributeError,

"Mock object has no attribute 'something_else'",

getattr, mock, 'something_else'

)

def test_from_spec(self):

class Something(object):

x = 3

__something__ = None

def y(self): pass

def test_attributes(mock):

# should work

mock.x

mock.y

mock.__something__

self.assertRaisesRegex(

AttributeError,

"Mock object has no attribute 'z'",

getattr, mock, 'z'

)

self.assertRaisesRegex(

AttributeError,

"Mock object has no attribute '__foobar__'",

getattr, mock, '__foobar__'

)

test_attributes(Mock(spec=Something))

test_attributes(Mock(spec=Something()))

def test_wraps_calls(self):

real = Mock()

mock = Mock(wraps=real)

# If "Mock" wraps an object, just accessing its

# "return_value" ("NonCallableMock.__get_return_value") should not

# trigger its descriptor ("NonCallableMock.__set_return_value") so

# the default "return_value" should always be "sentinel.DEFAULT".

self.assertEqual(mock.return_value, DEFAULT)

# It will not be "sentinel.DEFAULT" if the mock is not wrapping any

# object.

self.assertNotEqual(real.return_value, DEFAULT)

self.assertEqual(mock(), real())

real.reset_mock()

mock(1, 2, fish=3)

real.assert_called_with(1, 2, fish=3)

def test_wraps_prevents_automatic_creation_of_mocks(self):

class Real(object):

pass

real = Real()

mock = Mock(wraps=real)

self.assertRaises(AttributeError, lambda: mock.new_attr())

def test_wraps_call_with_nondefault_return_value(self):

real = Mock()

mock = Mock(wraps=real)

mock.return_value = 3

self.assertEqual(mock(), 3)

self.assertFalse(real.called)

def test_wraps_attributes(self):

class Real(object):

attribute = Mock()

real = Real()

mock = Mock(wraps=real)

self.assertEqual(mock.attribute(), real.attribute())

self.assertRaises(AttributeError, lambda: mock.fish)

self.assertNotEqual(mock.attribute, real.attribute)

result = mock.attribute.frog(1, 2, fish=3)

Real.attribute.frog.assert_called_with(1, 2, fish=3)

self.assertEqual(result, Real.attribute.frog())

def test_customize_wrapped_object_with_side_effect_iterable_with_default(self):

class Real(object):

def method(self):

return sentinel.ORIGINAL_VALUE

real = Real()

mock = Mock(wraps=real)

mock.method.side_effect = [sentinel.VALUE1, DEFAULT]

self.assertEqual(mock.method(), sentinel.VALUE1)

self.assertEqual(mock.method(), sentinel.ORIGINAL_VALUE)

self.assertRaises(StopIteration, mock.method)

def test_customize_wrapped_object_with_side_effect_iterable(self):

class Real(object):

def method(self): pass

real = Real()

mock = Mock(wraps=real)

mock.method.side_effect = [sentinel.VALUE1, sentinel.VALUE2]

self.assertEqual(mock.method(), sentinel.VALUE1)

self.assertEqual(mock.method(), sentinel.VALUE2)

self.assertRaises(StopIteration, mock.method)

def test_customize_wrapped_object_with_side_effect_exception(self):

class Real(object):

def method(self): pass

real = Real()

mock = Mock(wraps=real)

mock.method.side_effect = RuntimeError

self.assertRaises(RuntimeError, mock.method)

def test_customize_wrapped_object_with_side_effect_function(self):

class Real(object):

def method(self): pass

def side_effect():

return sentinel.VALUE

real = Real()

mock = Mock(wraps=real)

mock.method.side_effect = side_effect

self.assertEqual(mock.method(), sentinel.VALUE)

def test_customize_wrapped_object_with_return_value(self):

class Real(object):

def method(self): pass

real = Real()

mock = Mock(wraps=real)

mock.method.return_value = sentinel.VALUE

self.assertEqual(mock.method(), sentinel.VALUE)

def test_customize_wrapped_object_with_return_value_and_side_effect(self):

# side_effect should always take precedence over return_value.

class Real(object):

def method(self): pass

real = Real()

mock = Mock(wraps=real)

mock.method.side_effect = [sentinel.VALUE1, sentinel.VALUE2]

mock.method.return_value = sentinel.WRONG_VALUE

self.assertEqual(mock.method(), sentinel.VALUE1)

self.assertEqual(mock.method(), sentinel.VALUE2)

self.assertRaises(StopIteration, mock.method)

def test_customize_wrapped_object_with_return_value_and_side_effect2(self):

# side_effect can return DEFAULT to default to return_value

class Real(object):

def method(self): pass

real = Real()

mock = Mock(wraps=real)

mock.method.side_effect = lambda: DEFAULT

mock.method.return_value = sentinel.VALUE

self.assertEqual(mock.method(), sentinel.VALUE)

def test_customize_wrapped_object_with_return_value_and_side_effect_default(self):

class Real(object):

def method(self): pass

real = Real()

mock = Mock(wraps=real)

mock.method.side_effect = [sentinel.VALUE1, DEFAULT]

mock.method.return_value = sentinel.RETURN

self.assertEqual(mock.method(), sentinel.VALUE1)

self.assertEqual(mock.method(), sentinel.RETURN)

self.assertRaises(StopIteration, mock.method)

def test_magic_method_wraps_dict(self):

# bpo-25597: MagicMock with wrap doesn't call wrapped object's

# method for magic methods with default values.

data = {'foo': 'bar'}

wrapped_dict = MagicMock(wraps=data)

self.assertEqual(wrapped_dict.get('foo'), 'bar')

# Accessing key gives a MagicMock

self.assertIsInstance(wrapped_dict['foo'], MagicMock)

# __contains__ method has a default value of False

self.assertFalse('foo' in wrapped_dict)

# return_value is non-sentinel and takes precedence over wrapped value.

wrapped_dict.get.return_value = 'return_value'

self.assertEqual(wrapped_dict.get('foo'), 'return_value')

# return_value is sentinel and hence wrapped value is returned.

wrapped_dict.get.return_value = sentinel.DEFAULT

self.assertEqual(wrapped_dict.get('foo'), 'bar')

self.assertEqual(wrapped_dict.get('baz'), None)

self.assertIsInstance(wrapped_dict['baz'], MagicMock)

self.assertFalse('bar' in wrapped_dict)

data['baz'] = 'spam'

self.assertEqual(wrapped_dict.get('baz'), 'spam')

self.assertIsInstance(wrapped_dict['baz'], MagicMock)

self.assertFalse('bar' in wrapped_dict)

del data['baz']

self.assertEqual(wrapped_dict.get('baz'), None)

def test_magic_method_wraps_class(self):

class Foo:

def __getitem__(self, index):

return index

def __custom_method__(self):

return "foo"

klass = MagicMock(wraps=Foo)

obj = klass()

self.assertEqual(obj.__getitem__(2), 2)

self.assertEqual(obj[2], 2)

self.assertEqual(obj.__custom_method__(), "foo")

def test_exceptional_side_effect(self):

mock = Mock(side_effect=AttributeError)

self.assertRaises(AttributeError, mock)

mock = Mock(side_effect=AttributeError('foo'))

self.assertRaises(AttributeError, mock)

def test_baseexceptional_side_effect(self):

mock = Mock(side_effect=KeyboardInterrupt)

self.assertRaises(KeyboardInterrupt, mock)

mock = Mock(side_effect=KeyboardInterrupt('foo'))

self.assertRaises(KeyboardInterrupt, mock)

def test_assert_called_with_message(self):

mock = Mock()

self.assertRaisesRegex(AssertionError, 'not called',

mock.assert_called_with)

def test_assert_called_once_with_message(self):

mock = Mock(name='geoffrey')

self.assertRaisesRegex(AssertionError,

r"Expected 'geoffrey' to be called once\.",

mock.assert_called_once_with)

def test__name__(self):

mock = Mock()

self.assertRaises(AttributeError, lambda: mock.__name__)

mock.__name__ = 'foo'

self.assertEqual(mock.__name__, 'foo')

def test_spec_list_subclass(self):

class Sub(list):

pass

mock = Mock(spec=Sub(['foo']))

mock.append(3)

mock.append.assert_called_with(3)

self.assertRaises(AttributeError, getattr, mock, 'foo')

def test_spec_class(self):

class X(object):

pass

mock = Mock(spec=X)

self.assertIsInstance(mock, X)

mock = Mock(spec=X())

self.assertIsInstance(mock, X)

self.assertIs(mock.__class__, X)

self.assertEqual(Mock().__class__.__name__, 'Mock')

mock = Mock(spec_set=X)

self.assertIsInstance(mock, X)

mock = Mock(spec_set=X())

self.assertIsInstance(mock, X)

def test_spec_class_no_object_base(self):

class X:

pass

mock = Mock(spec=X)

self.assertIsInstance(mock, X)

mock = Mock(spec=X())

self.assertIsInstance(mock, X)

self.assertIs(mock.__class__, X)

self.assertEqual(Mock().__class__.__name__, 'Mock')

mock = Mock(spec_set=X)

self.assertIsInstance(mock, X)

mock = Mock(spec_set=X())

self.assertIsInstance(mock, X)

def test_setting_attribute_with_spec_set(self):

class X(object):

y = 3

mock = Mock(spec=X)