# mock.py

# Test tools for mocking and patching.

# Maintained by Michael Foord

# Backport for other versions of Python available from

# https://pypi.org/project/mock

__all__ = (

'Mock',

'MagicMock',

'patch',

'sentinel',

'DEFAULT',

'ANY',

'call',

'create_autospec',

'AsyncMock',

'FILTER_DIR',

'NonCallableMock',

'NonCallableMagicMock',

'mock_open',

'PropertyMock',

'seal',

)

import asyncio

import contextlib

import io

import inspect

import pprint

import sys

import builtins

import pkgutil

from asyncio import iscoroutinefunction

from types import CodeType, ModuleType, MethodType

from unittest.util import safe_repr

from functools import wraps, partial

from threading import RLock

class InvalidSpecError(Exception):

"""Indicates that an invalid value was used as a mock spec."""

_builtins = {name for name in dir(builtins) if not name.startswith('_')}

FILTER_DIR = True

# Workaround for issue #12370

# Without this, the __class__ properties wouldn't be set correctly

_safe_super = super

def _is_async_obj(obj):

if _is_instance_mock(obj) and not isinstance(obj, AsyncMock):

return False

if hasattr(obj, '__func__'):

obj = getattr(obj, '__func__')

return iscoroutinefunction(obj) or inspect.isawaitable(obj)

def _is_async_func(func):

if getattr(func, '__code__', None):

return iscoroutinefunction(func)

else:

return False

def _is_instance_mock(obj):

# can't use isinstance on Mock objects because they override __class__

# The base class for all mocks is NonCallableMock

return issubclass(type(obj), NonCallableMock)

def _is_exception(obj):

return (

isinstance(obj, BaseException) or

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

)

def _extract_mock(obj):

# Autospecced functions will return a FunctionType with "mock" attribute

# which is the actual mock object that needs to be used.

if isinstance(obj, FunctionTypes) and hasattr(obj, 'mock'):

return obj.mock

else:

return obj

def _get_signature_object(func, as_instance, eat_self):

"""

Given an arbitrary, possibly callable object, try to create a suitable

signature object.

Return a (reduced func, signature) tuple, or None.

"""

if isinstance(func, type) and not as_instance:

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

func = func.__init__

# Skip the `self` argument in __init__

eat_self = True

elif isinstance(func, (classmethod, staticmethod)):

if isinstance(func, classmethod):

# Skip the `cls` argument of a class method

eat_self = True

# Use the original decorated method to extract the correct function signature

func = func.__func__

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()

return None

def _check_signature(func, mock, skipfirst, instance=False):

sig = _get_signature_object(func, instance, skipfirst)

if sig is None:

return

func, sig = sig

def checksig(self, /, *args, **kwargs):

sig.bind(*args, **kwargs)

_copy_func_details(func, checksig)

type(mock)._mock_check_sig = checksig

type(mock).__signature__ = sig

def _copy_func_details(func, funcopy):

# 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:

pass

def _callable(obj):

if isinstance(obj, type):

return True

if isinstance(obj, (staticmethod, classmethod, MethodType)):

return _callable(obj.__func__)

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

return True

return False

def _is_list(obj):

# checks for list or tuples

# XXXX badly named!

return type(obj) in (list, tuple)

def _instance_callable(obj):

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

For classes, return True if instances would be 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

return False

def _set_signature(mock, original, instance=False):

# 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.

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):

_checksig_(*args, **kwargs)

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

exec (src, context)

funcopy = context[name]

_setup_func(funcopy, mock, sig)

return funcopy

def _setup_func(funcopy, mock, sig):

funcopy.mock = mock

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

funcopy.__signature__ = sig

mock._mock_delegate = funcopy

def _setup_async_mock(mock):

mock._is_coroutine = asyncio.coroutines._is_coroutine

mock.await_count = 0

mock.await_args = None

mock.await_args_list = _CallList()

# Mock is not configured yet so the attributes are set

# to a function and then the corresponding mock helper function

# is called when the helper is accessed similar to _setup_func.

def wrapper(attr, /, *args, **kwargs):

return getattr(mock.mock, attr)(*args, **kwargs)

for attribute in ('assert_awaited',

'assert_awaited_once',

'assert_awaited_with',

'assert_awaited_once_with',

'assert_any_await',

'assert_has_awaits',

'assert_not_awaited'):

# setattr(mock, attribute, wrapper) causes late binding

# hence attribute will always be the last value in the loop

# Use partial(wrapper, attribute) to ensure the attribute is bound

# correctly.

setattr(mock, attribute, partial(wrapper, attribute))

def _is_magic(name):

return '__%s__' % name[2:-2] == name

class _SentinelObject(object):

"A unique, named, sentinel object."

def __init__(self, name):

self.name = name

def __repr__(self):

return 'sentinel.%s' % self.name

def __reduce__(self):

return 'sentinel.%s' % self.name

class _Sentinel(object):

"""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 'sentinel'

sentinel = _Sentinel()

DEFAULT = sentinel.DEFAULT

_missing = sentinel.MISSING

_deleted = sentinel.DELETED

_allowed_names = {

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

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

'_mock_name', '_mock_new_name'

}

def _delegating_property(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)

return property(_get, _set)

class _CallList(list):

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):

return pprint.pformat(list(self))

def _check_and_set_parent(parent, value, name, new_name):

value = _extract_mock(value)

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

return True

# Internal class to identify if we wrapped an iterator object or not.

class _MockIter(object):

def __init__(self, obj):

self.obj = iter(obj)

def __next__(self):

return next(self.obj)

class Base(object):

_mock_return_value = DEFAULT

_mock_side_effect = None

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

pass

class NonCallableMock(Base):

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

# Store a mutex as a class attribute in order to protect concurrent access

# to mock attributes. Using a class attribute allows all NonCallableMock

# instances to share the mutex for simplicity.

#

# See https://github.com/python/cpython/issues/98624 for why this is

# necessary.

_lock = RLock()

def __new__(

cls, 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

):

# every instance has its own class

# so we can create magic methods on the

# class without stomping on other mocks

bases = (cls,)

if not issubclass(cls, AsyncMockMixin):

# Check if spec is an async object or function

spec_arg = spec_set or spec

if spec_arg is not None and _is_async_obj(spec_arg):

bases = (AsyncMockMixin, cls)

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

instance = _safe_super(NonCallableMock, cls).__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):

"""

Attach a mock as an attribute of this one, replacing its name and

parent. Calls to the attached mock will be recorded in the

`method_calls` and `mock_calls` attributes of this one."""

inner_mock = _extract_mock(mock)

inner_mock._mock_parent = None

inner_mock._mock_new_parent = None

inner_mock._mock_name = ''

inner_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

list of strings. Only attributes on the `spec` can be fetched as

attributes from the mock.

If `spec_set` is True then only attributes on the spec can be set."""

self._mock_add_spec(spec, spec_set)

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

_eat_self=False):

if _is_instance_mock(spec):

raise InvalidSpecError(f'Cannot spec a Mock object. [object={spec!r}]')

_spec_class = None

_spec_signature = None

_spec_asyncs = []

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

if isinstance(spec, type):

_spec_class = spec

else:

_spec_class = type(spec)

res = _get_signature_object(spec,

_spec_as_instance, _eat_self)

_spec_signature = res and res[1]

spec_list = dir(spec)

for attr in spec_list:

if iscoroutinefunction(getattr(spec, attr, None)):

_spec_asyncs.append(attr)

spec = spec_list

__dict__ = self.__dict__

__dict__['_spec_class'] = _spec_class

__dict__['_spec_set'] = spec_set

__dict__['_spec_signature'] = _spec_signature

__dict__['_mock_methods'] = spec

__dict__['_spec_asyncs'] = _spec_asyncs

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 and self._mock_wraps is None:

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) or child is _deleted:

continue

child.reset_mock(visited, return_value=return_value, side_effect=side_effect)

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.

Attributes plus return values and side effects can be set on child

mocks using standard dot notation and unpacking a dictionary in the

method call:

>>> attrs = {'method.return_value': 3, 'other.side_effect': KeyError}

>>> mock.configure_mock(**attrs)"""

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 and (not self._mock_methods or name not in self._mock_methods):

if name.startswith(('assert', 'assret', 'asert', 'aseert', 'assrt')) or name in _ATTRIB_DENY_LIST:

raise AttributeError(

f"{name!r} is not a valid assertion. Use a spec "

f"for the mock if {name!r} is meant to be an attribute.")

with NonCallableMock._lock:

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):

try:

result = create_autospec(

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

result.parent, result.name

)

except InvalidSpecError:

target_name = self.__dict__['_mock_name'] or self

raise InvalidSpecError(

f'Cannot autospec attr {name!r} from target '

f'{target_name!r} as it has already been mocked out. '

f'[target={self!r}, attr={result.spec!r}]')

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 = ''

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

_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_child_mocks = [

m_name for m_name, m_value in self._mock_children.items()

if m_value is not _deleted]

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 + from_child_mocks))

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

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

if name in self.__dict__:

_safe_super(NonCallableMock, self).__delattr__(name)

elif 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, action='call'):

message = 'expected %s not found.\nExpected: %s\n Actual: %s'

expected_string = self._format_mock_call_signature(args, kwargs)

call_args = self.call_args

actual_string = self._format_mock_call_signature(*call_args)

return message % (action, expected_string, actual_string)

def _get_call_signature_from_name(self, name):

"""

* If call objects are asserted against a method/function like obj.meth1

then there could be no name for the call object to lookup. Hence just

return the spec_signature of the method/function being asserted against.

* If the name is not empty then remove () and split by '.' to get

list of names to iterate through the children until a potential

match is found. A child mock is created only during attribute access

so if we get a _SpecState then no attributes of the spec were accessed

and can be safely exited.

"""

if not name:

return self._spec_signature

sig = None

names = name.replace('()', '').split('.')

children = self._mock_children

for name in names:

child = children.get(name)

if child is None or isinstance(child, _SpecState):

break

else:

# If an autospecced object is attached using attach_mock the

# child would be a function with mock object as attribute from

# which signature has to be derived.

child = _extract_mock(child)

children = child._mock_children

sig = child._spec_signature

return sig

def _call_matcher(self, _call):

"""

Given a call (or simply an (args, kwargs) tuple), return a

comparison key suitable for matching with other calls.

This is a best effort method which relies on the spec's signature,

if available, or falls back on the arguments themselves.

"""

if isinstance(_call, tuple) and len(_call) > 2:

sig = self._get_call_signature_from_name(_call[0])

else:

sig = self._spec_signature

if sig is not None:

if len(_call) == 2:

name = ''

args, kwargs = _call

else:

name, args, kwargs = _call

try:

bound_call = sig.bind(*args, **kwargs)

return call(name, bound_call.args, bound_call.kwargs)

except TypeError as e:

return e.with_traceback(None)

else:

return _call

def assert_not_called(self):

"""assert that the mock was never called.

"""

if self.call_count != 0:

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

% (self._mock_name or 'mock',

self.call_count,

self._calls_repr()))

raise AssertionError(msg)

def assert_called(self):

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

"""

if self.call_count == 0:

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

(self._mock_name or 'mock'))

raise AssertionError(msg)

def assert_called_once(self):

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

"""

if not self.call_count == 1:

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

% (self._mock_name or 'mock',

self.call_count,

self._calls_repr()))

raise AssertionError(msg)

def assert_called_with(self, /, *args, **kwargs):

"""assert that the last call was made with the specified arguments.

Raises an AssertionError if the args and keyword args passed in are

different to the last call to the mock."""

if self.call_args is None:

expected = self._format_mock_call_signature(args, kwargs)

actual = 'not called.'

error_message = ('expected call not found.\nExpected: %s\n Actual: %s'

% (expected, actual))

raise AssertionError(error_message)

def _error_message():

msg = self._format_mock_failure_message(args, kwargs)

return msg

expected = self._call_matcher(_Call((args, kwargs), two=True))

actual = self._call_matcher(self.call_args)

if actual != expected:

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

raise AssertionError(_error_message()) from cause

def assert_called_once_with(self, /, *args, **kwargs):

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

with the specified arguments."""

if not self.call_count == 1:

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

% (self._mock_name or 'mock',

self.call_count,

self._calls_repr()))

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.

The `mock_calls` list is checked for the calls.

If `any_order` is False (the default) then the calls must be

sequential. There can be extra calls before or after the

specified calls.

If `any_order` is True then the calls can be in any order, but

they must all appear in `mock_calls`."""

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

cause = next((e for e in expected if isinstance(e, Exception)), None)

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

if not any_order:

if expected not in all_calls:

if cause is None:

problem = 'Calls not found.'

else:

problem = ('Error processing expected calls.\n'

'Errors: {}').format(

[e if isinstance(e, Exception) else None

for e in expected])

raise AssertionError(

f'{problem}\n'

f'Expected: {_CallList(calls)}'

f'{self._calls_repr(prefix=" Actual").rstrip(".")}'

) 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)