# mock.py

# Test tools for mocking and patching.

# Copyright (C) 2007-2012 Michael Foord & the mock team

# E-mail: fuzzyman AT voidspace DOT org DOT uk

# mock 1.0.1

# http://www.voidspace.org.uk/python/mock/

# Released subject to the BSD License

# Please see http://www.voidspace.org.uk/python/license.shtml

__all__ = (

    'Mock',

    'MagicMock',

    'patch',

    'sentinel',

    'DEFAULT',

    'ANY',

    'call',

    'create_autospec',

    'FILTER_DIR',

    'NonCallableMock',

    'NonCallableMagicMock',

    'mock_open',

    'PropertyMock',

)

__version__ = '1.0.1'

import pprint

import sys

try:

    import inspect

except ImportError:

    # for alternative platforms that

    # may not have inspect

    inspect = None

try:

    from functools import wraps as original_wraps

except ImportError:

    # Python 2.4 compatibility

    def wraps(original):

        def inner(f):

            f.__name__ = original.__name__

            f.__doc__ = original.__doc__

            f.__module__ = original.__module__

            wrapped = getattr(original, '__wrapped__', original)

            f.__wrapped__ = wrapped

            return f

        return inner

else:

    if sys.version_info[:2] >= (3, 2):

        wraps = original_wraps

    else:

        def wraps(func):

            def inner(f):

                f = original_wraps(func)(f)

                wrapped = getattr(func, '__wrapped__', func)

                f.__wrapped__ = wrapped

                return f

            return inner

try:

    unicode

except NameError:

    # Python 3

    basestring = unicode = str

try:

    long

except NameError:

    # Python 3

    long = int

try:

    BaseException

except NameError:

    # Python 2.4 compatibility

    BaseException = Exception

try:

    next

except NameError:

    def next(obj):

        return obj.next()

BaseExceptions = (BaseException,)

if 'java' in sys.platform:

    # jython

    import java

    BaseExceptions = (BaseException, java.lang.Throwable)

try:

    _isidentifier = str.isidentifier

except AttributeError:

    # Python 2.X

    import keyword

    import re

    regex = re.compile(r'^[a-z_][a-z0-9_]*$', re.I)

    def _isidentifier(string):

        if string in keyword.kwlist:

            return False

        return regex.match(string)

inPy3k = sys.version_info[0] == 3

# Needed to work around Python 3 bug where use of "super" interferes with

# defining __class__ as a descriptor

_super = super

self = 'im_self'

builtin = '__builtin__'

if inPy3k:

    self = '__self__'

    builtin = 'builtins'

FILTER_DIR = True

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, BaseExceptions) or

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

    )

class _slotted(object):

    __slots__ = ['a']

DescriptorTypes = (

    type(_slotted.a),

    property,

)

def _getsignature(func, skipfirst, instance=False):

    if inspect is None:

        raise ImportError('inspect module not available')

    if isinstance(func, ClassTypes) and not instance:

        try:

            func = func.__init__

        except AttributeError:

            return

        skipfirst = True

    elif not isinstance(func, FunctionTypes):

        # for classes where instance is True we end up here too

        try:

            func = func.__call__

        except AttributeError:

            return

    if inPy3k:

        try:

            argspec = inspect.getfullargspec(func)

        except TypeError:

            # C function / method, possibly inherited object().__init__

            return

        regargs, varargs, varkw, defaults, kwonly, kwonlydef, ann = argspec

    else:

        try:

            regargs, varargs, varkwargs, defaults = inspect.getargspec(func)

        except TypeError:

            # C function / method, possibly inherited object().__init__

            return

    # instance methods and classmethods need to lose the self argument

    if getattr(func, self, None) is not None:

        regargs = regargs[1:]

    if skipfirst:

        # this condition and the above one are never both True - why?

        regargs = regargs[1:]

    if inPy3k:

        signature = inspect.formatargspec(

            regargs, varargs, varkw, defaults,

            kwonly, kwonlydef, ann, formatvalue=lambda value: "")

    else:

        signature = inspect.formatargspec(

            regargs, varargs, varkwargs, defaults,

            formatvalue=lambda value: "")

    return signature[1:-1], func

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

    if not _callable(func):

        return

    result = _getsignature(func, skipfirst, instance)

    if result is None:

        return

    signature, func = result

    # can't use self because "self" is common as an argument name

    # unfortunately even not in the first place

    src = "lambda _mock_self, %s: None" % signature

    checksig = eval(src, {})

    _copy_func_details(func, checksig)

    type(mock)._mock_check_sig = checksig

def _copy_func_details(func, funcopy):

    funcopy.__name__ = func.__name__

    funcopy.__doc__ = func.__doc__

    #funcopy.__dict__.update(func.__dict__)

    funcopy.__module__ = func.__module__

    if not inPy3k:

        funcopy.func_defaults = func.func_defaults

        return

    funcopy.__defaults__ = func.__defaults__

    funcopy.__kwdefaults__ = func.__kwdefaults__

def _callable(obj):

    if isinstance(obj, ClassTypes):

        return True

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

        # already an instance

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

    klass = obj

    # uses __bases__ instead of __mro__ so that we work with old style classes

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

        return True

    for base in klass.__bases__:

        if _instance_callable(base):

            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.

    if not _callable(original):

        return

    skipfirst = isinstance(original, ClassTypes)

    result = _getsignature(original, skipfirst, instance)

    if result is None:

        # was a C function (e.g. object().__init__ ) that can't be mocked

        return

    signature, func = result

    src = "lambda %s: None" % signature

    checksig = eval(src, {})

    _copy_func_details(func, checksig)

    name = original.__name__

    if not _isidentifier(name):

        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)

    return funcopy

def _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_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

    mock._mock_delegate = funcopy

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

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(mock) raises an exception

            raise AttributeError

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

sentinel = _Sentinel()

DEFAULT = sentinel.DEFAULT

_missing = sentinel.MISSING

_deleted = sentinel.DELETED

class OldStyleClass:

    pass

ClassType = type(OldStyleClass)

def _copy(value):

    if type(value) in (dict, list, tuple, set):

        return type(value)(value)

    return value

ClassTypes = (type,)

if not inPy3k:

    ClassTypes = (type, ClassType)

_allowed_names = set(

    [

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

    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

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`"""

    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,

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

        if spec_set is not None:

            spec = spec_set

            spec_set = True

        self._mock_add_spec(spec, spec_set)

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

        if kwargs:

            self.configure_mock(**kwargs)

        _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."""

        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

        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_class = None

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

            if isinstance(spec, ClassTypes):

                _spec_class = spec

            else:

                _spec_class = _get_class(spec)

            spec = dir(spec)

        __dict__ = self.__dict__

        __dict__['_spec_class'] = _spec_class

        __dict__['_spec_set'] = spec_set

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

        sig = self._mock_delegate

        if sig is None:

            return self._mock_side_effect

        return sig.side_effect

    def __set_side_effect(self, value):

        value = _try_iter(value)

        sig = self._mock_delegate

        if sig is None:

            self._mock_side_effect = value

        else:

            sig.side_effect = value

    side_effect = property(__get_side_effect, __set_side_effect)

    def reset_mock(self):

        "Restore the mock object to its initial state."

        self.called = False

        self.call_args = None

        self.call_count = 0

        self.mock_calls = _CallList()

        self.call_args_list = _CallList()

        self.method_calls = _CallList()

        for child in self._mock_children.itervalues():

            if isinstance(child, _SpecState):

                continue

            child.reset_mock()

        ret = self._mock_return_value

        if _is_instance_mock(ret) and ret is not self:

            ret.reset_mock()

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

            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)

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

        name = ''.join(_name_list)

        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.

        XXXX

        """

        extras = self._mock_methods or []

        from_type = dir(type(self))

        from_dict = list(self.__dict__)

        if FILTER_DIR:

            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

        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 assert_called_with(_mock_self, *args, **kwargs):

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

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

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

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

        if self.call_args != (args, kwargs):

            msg = self._format_mock_failure_message(args, kwargs)

            raise AssertionError(msg)

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

        """assert that the mock was called exactly once and with the specified

        arguments."""

        self = _mock_self

        if not self.call_count == 1:

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

                   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.

        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`."""

        if not any_order:

            if calls not in self.mock_calls:

                raise AssertionError(

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

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

                )

            return

        all_calls = list(self.mock_calls)

        not_found = []

        for kall in calls:

            try:

                all_calls.remove(kall)

            except ValueError:

                not_found.append(kall)

        if not_found:

            raise AssertionError(

                '%r not all found in call list' % (tuple(not_found),)

            )

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

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