'Mock',

'MagicMock',

'patch',

'sentinel',

'DEFAULT',

'ANY',

'call',

'create_autospec',

'FILTER_DIR',

'NonCallableMock',

'NonCallableMagicMock',

'mock_open',

'PropertyMock',

'seal',

return (

isinstance(obj, BaseExceptions) or

isinstance(obj, type) and issubclass(obj, BaseExceptions)

"""

if isinstance(func, type) and not as_instance:

# If it's a type and should be modelled as a type, use __init__.

try:

func = func.__init__

except AttributeError:

return None

# Skip the `self` argument in __init__

eat_self = True

elif not isinstance(func, FunctionTypes):

# If we really want to model an instance of the passed type,

# __call__ should be looked up, not __init__.

try:

func = func.__call__

except AttributeError:

return None

if eat_self:

sig_func = partial(func, None)

else:

sig_func = func

try:

return func, inspect.signature(sig_func)

except ValueError:

# Certain callable types are not supported by inspect.signature()

sig = _get_signature_object(func, instance, skipfirst)

if sig is None:

return

func, sig = sig

def checksig(_mock_self, *args, **kwargs):

sig.bind(*args, **kwargs)

_copy_func_details(func, checksig)

# we explicitly don't copy func.__dict__ into this copy as it would

# expose original attributes that should be mocked

for attribute in (

'__name__', '__doc__', '__text_signature__',

'__module__', '__defaults__', '__kwdefaults__',

):

try:

setattr(funcopy, attribute, getattr(func, attribute))

except AttributeError:

if isinstance(obj, type):

return True

if getattr(obj, '__call__', None) is not None:

return True

"""Given an object, return True if the object is callable.

if not isinstance(obj, type):

# already an instance

return getattr(obj, '__call__', None) is not None

# *could* be broken by a class overriding __mro__ or __dict__ via

# a metaclass

for base in (obj,) + obj.__mro__:

if base.__dict__.get('__call__') is not None:

return True

# creates a function with signature (*args, **kwargs) that delegates to a

# mock. It still does signature checking by calling a lambda with the same

# signature as the original.

if not _callable(original):

return

skipfirst = isinstance(original, type)

result = _get_signature_object(original, instance, skipfirst)

if result is None:

return mock

func, sig = result

def checksig(*args, **kwargs):

sig.bind(*args, **kwargs)

_copy_func_details(func, checksig)

name = original.__name__

if not name.isidentifier():

name = 'funcopy'

context = {'_checksig_': checksig, 'mock': mock}

src = """def %s(*args, **kwargs):

return mock(*args, **kwargs)""" % name

exec (src, context)

funcopy = context[name]

_setup_func(funcopy, mock)

funcopy.mock = mock

# can't use isinstance with mocks

if not _is_instance_mock(mock):

return

def assert_called_with(*args, **kwargs):

return mock.assert_called_with(*args, **kwargs)

def assert_called(*args, **kwargs):

return mock.assert_called(*args, **kwargs)

def assert_not_called(*args, **kwargs):

return mock.assert_not_called(*args, **kwargs)

def assert_called_once(*args, **kwargs):

return mock.assert_called_once(*args, **kwargs)

def assert_called_once_with(*args, **kwargs):

return mock.assert_called_once_with(*args, **kwargs)

def assert_has_calls(*args, **kwargs):

return mock.assert_has_calls(*args, **kwargs)

def assert_any_call(*args, **kwargs):

return mock.assert_any_call(*args, **kwargs)

def reset_mock():

funcopy.method_calls = _CallList()

funcopy.mock_calls = _CallList()

mock.reset_mock()

ret = funcopy.return_value

if _is_instance_mock(ret) and not ret is mock:

ret.reset_mock()

funcopy.called = False

funcopy.call_count = 0

funcopy.call_args = None

funcopy.call_args_list = _CallList()

funcopy.method_calls = _CallList()

funcopy.mock_calls = _CallList()

funcopy.return_value = mock.return_value

funcopy.side_effect = mock.side_effect

funcopy._mock_children = mock._mock_children

funcopy.assert_called_with = assert_called_with

funcopy.assert_called_once_with = assert_called_once_with

funcopy.assert_has_calls = assert_has_calls

funcopy.assert_any_call = assert_any_call

funcopy.reset_mock = reset_mock

funcopy.assert_called = assert_called

funcopy.assert_not_called = assert_not_called

funcopy.assert_called_once = assert_called_once

"A unique, named, sentinel object."

def __init__(self, name):

self.name = name

def __repr__(self):

return 'sentinel.%s' % self.name

def __reduce__(self):

"""Access attributes to return a named object, usable as a sentinel."""

def __init__(self):

self._sentinels = {}

def __getattr__(self, name):

if name == '__bases__':

# Without this help(unittest.mock) raises an exception

raise AttributeError

return self._sentinels.setdefault(name, _SentinelObject(name))

def __reduce__(self):

'return_value', '_mock_return_value', 'side_effect',

'_mock_side_effect', '_mock_parent', '_mock_new_parent',

'_mock_name', '_mock_new_name'

_allowed_names.add(name)

_the_name = '_mock_' + name

def _get(self, name=name, _the_name=_the_name):

sig = self._mock_delegate

if sig is None:

return getattr(self, _the_name)

return getattr(sig, name)

def _set(self, value, name=name, _the_name=_the_name):

sig = self._mock_delegate

if sig is None:

self.__dict__[_the_name] = value

else:

setattr(sig, name, value)

def __contains__(self, value):

if not isinstance(value, list):

return list.__contains__(self, value)

len_value = len(value)

len_self = len(self)

if len_value > len_self:

return False

for i in range(0, len_self - len_value + 1):

sub_list = self[i:i+len_value]

if sub_list == value:

return True

return False

def __repr__(self):

if not _is_instance_mock(value):

return False

if ((value._mock_name or value._mock_new_name) or

(value._mock_parent is not None) or

(value._mock_new_parent is not None)):

return False

_parent = parent

while _parent is not None:

# setting a mock (value) as a child or return value of itself

# should not modify the mock

if _parent is value:

return False

_parent = _parent._mock_new_parent

if new_name:

value._mock_new_parent = parent

value._mock_new_name = new_name

if name:

value._mock_parent = parent

value._mock_name = name

def __init__(self, obj):

self.obj = iter(obj)

def __iter__(self):

return self

def __next__(self):

_mock_return_value = DEFAULT

_mock_side_effect = None

def __init__(self, *args, **kwargs):

"""A non-callable version of `Mock`"""

def __new__(cls, *args, **kw):

# every instance has its own class

# so we can create magic methods on the

# class without stomping on other mocks

new = type(cls.__name__, (cls,), {'__doc__': cls.__doc__})

instance = object.__new__(new)

return instance

def __init__(

self, spec=None, wraps=None, name=None, spec_set=None,

parent=None, _spec_state=None, _new_name='', _new_parent=None,

_spec_as_instance=False, _eat_self=None, unsafe=False, **kwargs

):

if _new_parent is None:

_new_parent = parent

__dict__ = self.__dict__

__dict__['_mock_parent'] = parent

__dict__['_mock_name'] = name

__dict__['_mock_new_name'] = _new_name

__dict__['_mock_new_parent'] = _new_parent

__dict__['_mock_sealed'] = False

if spec_set is not None:

spec = spec_set

spec_set = True

if _eat_self is None:

_eat_self = parent is not None

self._mock_add_spec(spec, spec_set, _spec_as_instance, _eat_self)

__dict__['_mock_children'] = {}

__dict__['_mock_wraps'] = wraps

__dict__['_mock_delegate'] = None

__dict__['_mock_called'] = False

__dict__['_mock_call_args'] = None

__dict__['_mock_call_count'] = 0

__dict__['_mock_call_args_list'] = _CallList()

__dict__['_mock_mock_calls'] = _CallList()

__dict__['method_calls'] = _CallList()

__dict__['_mock_unsafe'] = unsafe

if kwargs:

self.configure_mock(**kwargs)

_safe_super(NonCallableMock, self).__init__(

spec, wraps, name, spec_set, parent,

_spec_state

)

def attach_mock(self, mock, attribute):

"""

mock._mock_parent = None

mock._mock_new_parent = None

mock._mock_name = ''

mock._mock_new_name = None

setattr(self, attribute, mock)

def mock_add_spec(self, spec, spec_set=False):

"""Add a spec to a mock. `spec` can either be an object or a

self._mock_add_spec(spec, spec_set)

def _mock_add_spec(self, spec, spec_set, _spec_as_instance=False,

_eat_self=False):

_spec_class = None

_spec_signature = None

if spec is not None and not _is_list(spec):

if isinstance(spec, type):

_spec_class = spec

else:

_spec_class = _get_class(spec)

res = _get_signature_object(spec,

_spec_as_instance, _eat_self)

_spec_signature = res and res[1]

spec = dir(spec)

__dict__ = self.__dict__

__dict__['_spec_class'] = _spec_class

__dict__['_spec_set'] = spec_set

__dict__['_spec_signature'] = _spec_signature

__dict__['_mock_methods'] = spec

def __get_return_value(self):

ret = self._mock_return_value

if self._mock_delegate is not None:

ret = self._mock_delegate.return_value

if ret is DEFAULT:

ret = self._get_child_mock(

_new_parent=self, _new_name='()'

)

self.return_value = ret

return ret

def __set_return_value(self, value):

if self._mock_delegate is not None:

self._mock_delegate.return_value = value

else:

self._mock_return_value = value

_check_and_set_parent(self, value, None, '()')

__return_value_doc = "The value to be returned when the mock is called."

return_value = property(__get_return_value, __set_return_value,

__return_value_doc)

@property

def __class__(self):

if self._spec_class is None:

return type(self)

return self._spec_class

called = _delegating_property('called')

call_count = _delegating_property('call_count')

call_args = _delegating_property('call_args')

call_args_list = _delegating_property('call_args_list')

mock_calls = _delegating_property('mock_calls')

def __get_side_effect(self):

delegated = self._mock_delegate

if delegated is None:

return self._mock_side_effect

sf = delegated.side_effect

if (sf is not None and not callable(sf)

and not isinstance(sf, _MockIter) and not _is_exception(sf)):

sf = _MockIter(sf)

delegated.side_effect = sf

return sf

def __set_side_effect(self, value):

value = _try_iter(value)

delegated = self._mock_delegate

if delegated is None:

self._mock_side_effect = value

else:

delegated.side_effect = value

side_effect = property(__get_side_effect, __set_side_effect)

def reset_mock(self, visited=None,*, return_value=False, side_effect=False):

"Restore the mock object to its initial state."

if visited is None:

visited = []

if id(self) in visited:

return

visited.append(id(self))

self.called = False

self.call_args = None

self.call_count = 0

self.mock_calls = _CallList()

self.call_args_list = _CallList()

self.method_calls = _CallList()

if return_value:

self._mock_return_value = DEFAULT

if side_effect:

self._mock_side_effect = None

for child in self._mock_children.values():

if isinstance(child, _SpecState):

continue

child.reset_mock(visited)

ret = self._mock_return_value

if _is_instance_mock(ret) and ret is not self:

ret.reset_mock(visited)

def configure_mock(self, **kwargs):

"""Set attributes on the mock through keyword arguments.

for arg, val in sorted(kwargs.items(),

# we sort on the number of dots so that

# attributes are set before we set attributes on

# attributes

key=lambda entry: entry[0].count('.')):

args = arg.split('.')

final = args.pop()

obj = self

for entry in args:

obj = getattr(obj, entry)

setattr(obj, final, val)

def __getattr__(self, name):

if name in {'_mock_methods', '_mock_unsafe'}:

raise AttributeError(name)

elif self._mock_methods is not None:

if name not in self._mock_methods or name in _all_magics:

raise AttributeError("Mock object has no attribute %r" % name)

elif _is_magic(name):

raise AttributeError(name)

if not self._mock_unsafe:

if name.startswith(('assert', 'assret')):

raise AttributeError(name)

result = self._mock_children.get(name)

if result is _deleted:

raise AttributeError(name)

elif result is None:

wraps = None

if self._mock_wraps is not None:

# XXXX should we get the attribute without triggering code

# execution?

wraps = getattr(self._mock_wraps, name)

result = self._get_child_mock(

parent=self, name=name, wraps=wraps, _new_name=name,

_new_parent=self

)

self._mock_children[name] = result

elif isinstance(result, _SpecState):

result = create_autospec(

result.spec, result.spec_set, result.instance,

result.parent, result.name

)

self._mock_children[name] = result

return result

def _extract_mock_name(self):

_name_list = [self._mock_new_name]

_parent = self._mock_new_parent

last = self

dot = '.'

if _name_list == ['()']:

dot = ''

seen = set()

while _parent is not None:

last = _parent

_name_list.append(_parent._mock_new_name + dot)

dot = '.'

if _parent._mock_new_name == '()':

dot = ''

_parent = _parent._mock_new_parent

# use ids here so as not to call __hash__ on the mocks

if id(_parent) in seen:

break

seen.add(id(_parent))

_name_list = list(reversed(_name_list))

_first = last._mock_name or 'mock'

if len(_name_list) > 1:

if _name_list[1] not in ('()', '().'):

_first += '.'

_name_list[0] = _first

return ''.join(_name_list)

def __repr__(self):

name = self._extract_mock_name()

name_string = ''

if name not in ('mock', 'mock.'):

name_string = ' name=%r' % name

spec_string = ''

if self._spec_class is not None:

spec_string = ' spec=%r'

if self._spec_set:

spec_string = ' spec_set=%r'

spec_string = spec_string % self._spec_class.__name__

return "<%s%s%s id='%s'>" % (

type(self).__name__,

name_string,

spec_string,

id(self)

)

def __dir__(self):

"""Filter the output of `dir(mock)` to only useful members."""

if not FILTER_DIR:

return object.__dir__(self)

extras = self._mock_methods or []

from_type = dir(type(self))

from_dict = list(self.__dict__)

from_type = [e for e in from_type if not e.startswith('_')]

from_dict = [e for e in from_dict if not e.startswith('_') or

_is_magic(e)]

return sorted(set(extras + from_type + from_dict +

list(self._mock_children)))

def __setattr__(self, name, value):

if name in _allowed_names:

# property setters go through here

return object.__setattr__(self, name, value)

elif (self._spec_set and self._mock_methods is not None and

name not in self._mock_methods and

name not in self.__dict__):

raise AttributeError("Mock object has no attribute '%s'" % name)

elif name in _unsupported_magics:

msg = 'Attempting to set unsupported magic method %r.' % name

raise AttributeError(msg)

elif name in _all_magics:

if self._mock_methods is not None and name not in self._mock_methods:

raise AttributeError("Mock object has no attribute '%s'" % name)

if not _is_instance_mock(value):

setattr(type(self), name, _get_method(name, value))

original = value

value = lambda *args, **kw: original(self, *args, **kw)

else:

# only set _new_name and not name so that mock_calls is tracked

# but not method calls

_check_and_set_parent(self, value, None, name)

setattr(type(self), name, value)

self._mock_children[name] = value

elif name == '__class__':

self._spec_class = value

return

else:

if _check_and_set_parent(self, value, name, name):

self._mock_children[name] = value

if self._mock_sealed and not hasattr(self, name):

mock_name = f'{self._extract_mock_name()}.{name}'

raise AttributeError(f'Cannot set {mock_name}')

return object.__setattr__(self, name, value)

def __delattr__(self, name):

if name in _all_magics and name in type(self).__dict__:

delattr(type(self), name)

if name not in self.__dict__:

# for magic methods that are still MagicProxy objects and

# not set on the instance itself

return

if name in self.__dict__:

object.__delattr__(self, name)

obj = self._mock_children.get(name, _missing)

if obj is _deleted:

raise AttributeError(name)

if obj is not _missing:

del self._mock_children[name]

self._mock_children[name] = _deleted

def _format_mock_call_signature(self, args, kwargs):

name = self._mock_name or 'mock'

return _format_call_signature(name, args, kwargs)

def _format_mock_failure_message(self, args, kwargs):

message = 'Expected call: %s\nActual call: %s'

expected_string = self._format_mock_call_signature(args, kwargs)

call_args = self.call_args

if len(call_args) == 3:

call_args = call_args[1:]

actual_string = self._format_mock_call_signature(*call_args)

return message % (expected_string, actual_string)

def _call_matcher(self, _call):

"""

sig = self._spec_signature

if sig is not None:

if len(_call) == 2:

name = ''

args, kwargs = _call

else:

name, args, kwargs = _call

try:

return name, sig.bind(*args, **kwargs)

except TypeError as e:

return e.with_traceback(None)

else:

return _call

def assert_not_called(_mock_self):

"""assert that the mock was never called.

self = _mock_self

if self.call_count != 0:

msg = ("Expected '%s' to not have been called. Called %s times." %

(self._mock_name or 'mock', self.call_count))

raise AssertionError(msg)

def assert_called(_mock_self):

"""assert that the mock was called at least once

self = _mock_self

if self.call_count == 0:

msg = ("Expected '%s' to have been called." %

self._mock_name or 'mock')

raise AssertionError(msg)

def assert_called_once(_mock_self):

"""assert that the mock was called only once.

self = _mock_self

if not self.call_count == 1:

msg = ("Expected '%s' to have been called once. Called %s times." %

(self._mock_name or 'mock', self.call_count))

raise AssertionError(msg)

def assert_called_with(_mock_self, *args, **kwargs):

"""assert that the mock was called with the specified arguments.

self = _mock_self

if self.call_args is None:

expected = self._format_mock_call_signature(args, kwargs)

raise AssertionError('Expected call: %s\nNot called' % (expected,))

def _error_message():

msg = self._format_mock_failure_message(args, kwargs)

return msg

expected = self._call_matcher((args, kwargs))

actual = self._call_matcher(self.call_args)

if expected != actual:

cause = expected if isinstance(expected, Exception) else None

raise AssertionError(_error_message()) from cause

def assert_called_once_with(_mock_self, *args, **kwargs):

"""assert that the mock was called exactly once and that that call was

self = _mock_self

if not self.call_count == 1:

msg = ("Expected '%s' to be called once. Called %s times." %

(self._mock_name or 'mock', self.call_count))

raise AssertionError(msg)

return self.assert_called_with(*args, **kwargs)

def assert_has_calls(self, calls, any_order=False):

"""assert the mock has been called with the specified calls.

expected = [self._call_matcher(c) for c in calls]

cause = expected if isinstance(expected, Exception) else None

all_calls = _CallList(self._call_matcher(c) for c in self.mock_calls)

if not any_order:

if expected not in all_calls:

raise AssertionError(

'Calls not found.\nExpected: %r\n'

'Actual: %r' % (_CallList(calls), self.mock_calls)

) from cause

return

all_calls = list(all_calls)

not_found = []

for kall in expected:

try:

all_calls.remove(kall)

except ValueError:

not_found.append(kall)

if not_found:

raise AssertionError(

'%r does not contain all of %r in its call list, '

'found %r instead' % (self._mock_name or 'mock',

tuple(not_found), all_calls)

) from cause

def assert_any_call(self, *args, **kwargs):

"""assert the mock has been called with the specified arguments.

expected = self._call_matcher((args, kwargs))

actual = [self._call_matcher(c) for c in self.call_args_list]

if expected not in actual:

cause = expected if isinstance(expected, Exception) else None

expected_string = self._format_mock_call_signature(args, kwargs)

raise AssertionError(

'%s call not found' % expected_string

) from cause

def _get_child_mock(self, **kw):

"""Create the child mocks for attributes and return value.

_type = type(self)

if not issubclass(_type, CallableMixin):

if issubclass(_type, NonCallableMagicMock):

klass = MagicMock

elif issubclass(_type, NonCallableMock) :

klass = Mock

else:

klass = _type.__mro__[1]

if self._mock_sealed:

attribute = "." + kw["name"] if "name" in kw else "()"

mock_name = self._extract_mock_name() + attribute

raise AttributeError(mock_name)

if obj is None:

return obj

if _is_exception(obj):

return obj

if _callable(obj):

return obj

try:

return iter(obj)

except TypeError:

# XXXX backwards compatibility

# but this will blow up on first call - so maybe we should fail early?

def __init__(self, spec=None, side_effect=None, return_value=DEFAULT,

wraps=None, name=None, spec_set=None, parent=None,

_spec_state=None, _new_name='', _new_parent=None, **kwargs):

self.__dict__['_mock_return_value'] = return_value

_safe_super(CallableMixin, self).__init__(

spec, wraps, name, spec_set, parent,

_spec_state, _new_name, _new_parent, **kwargs

)

self.side_effect = side_effect

def _mock_check_sig(self, *args, **kwargs):

# stub method that can be replaced with one with a specific signature

pass

def __call__(_mock_self, *args, **kwargs):

# can't use self in-case a function / method we are mocking uses self

# in the signature

_mock_self._mock_check_sig(*args, **kwargs)

return _mock_self._mock_call(*args, **kwargs)

def _mock_call(_mock_self, *args, **kwargs):

self = _mock_self

self.called = True

self.call_count += 1

_new_name = self._mock_new_name

_new_parent = self._mock_new_parent

_call = _Call((args, kwargs), two=True)

self.call_args = _call

self.call_args_list.append(_call)

self.mock_calls.append(_Call(('', args, kwargs)))

seen = set()

skip_next_dot = _new_name == '()'

do_method_calls = self._mock_parent is not None

name = self._mock_name

while _new_parent is not None:

this_mock_call = _Call((_new_name, args, kwargs))

if _new_parent._mock_new_name:

dot = '.'

if skip_next_dot:

dot = ''

skip_next_dot = False

if _new_parent._mock_new_name == '()':

skip_next_dot = True

_new_name = _new_parent._mock_new_name + dot + _new_name

if do_method_calls:

if _new_name == name:

this_method_call = this_mock_call

else:

this_method_call = _Call((name, args, kwargs))

_new_parent.method_calls.append(this_method_call)

do_method_calls = _new_parent._mock_parent is not None

if do_method_calls:

name = _new_parent._mock_name + '.' + name

_new_parent.mock_calls.append(this_mock_call)

_new_parent = _new_parent._mock_new_parent

# use ids here so as not to call __hash__ on the mocks

_new_parent_id = id(_new_parent)