[Python-modules-commits] [checkbox-support] 10/10: merge patched into master
Sylvain Pineau
spineau-guest at moszumanska.debian.org
Mon Dec 7 13:08:50 UTC 2015
This is an automated email from the git hooks/post-receive script.
spineau-guest pushed a commit to tag debian/0.22-1
in repository checkbox-support.
commit 5d049077064713fd64d281f3f74ed76701d7fc52
Merge: ae28a89 00a969c
Author: Sylvain Pineau <sylvain.pineau at canonical.com>
Date: Mon Dec 7 13:49:01 2015 +0100
merge patched into master
debian/.git-dpm | 6 +++---
debian/patches/unvendorize | 2 +-
2 files changed, 4 insertions(+), 4 deletions(-)
diff --cc debian/.git-dpm
index df2bf12,0000000..73d9349
mode 100644,000000..100644
--- a/debian/.git-dpm
+++ b/debian/.git-dpm
@@@ -1,11 -1,0 +1,11 @@@
+# see git-dpm(1) from git-dpm package
- 2d823fe260f3b0a084a12931aafdf320798f3b93
- 2d823fe260f3b0a084a12931aafdf320798f3b93
- 532f9582ad80620bc1276d6b3908dd4402563504
++00a969c85e6ed30ac296cb596248d89b11adbde4
++00a969c85e6ed30ac296cb596248d89b11adbde4
++8ddea657585c9ebb81357347c63bffbc16653c35
+8ddea657585c9ebb81357347c63bffbc16653c35
+checkbox-support_0.22.orig.tar.gz
+51bd8c66b17c6a9efb4ce7bd93b221bf60a628a8
+624352
+debianTag="debian/%e%v"
+patchedTag="patched/%e%v"
+upstreamTag="upstream/%e%u"
diff --cc debian/patches/unvendorize
index 966a3f9,0000000..e9d8ba1
mode 100644,000000..100644
--- a/debian/patches/unvendorize
+++ b/debian/patches/unvendorize
@@@ -1,2419 -1,0 +1,2419 @@@
- From 2d823fe260f3b0a084a12931aafdf320798f3b93 Mon Sep 17 00:00:00 2001
++From 00a969c85e6ed30ac296cb596248d89b11adbde4 Mon Sep 17 00:00:00 2001
+From: Zygmunt Krynicki <zygmunt.krynicki at canonical.com>
+Date: Thu, 8 Oct 2015 08:38:43 -0700
+Subject: Remove vendorized modules
+
+This patch replaces checkbox_support.vendor.mock with equivalent imports from
+the standard python3.3 library. Upstream will stop shipping those vendorized
+modules when support for python3.2 is no longer required.
+Upstream: not-needed
+Last-Update: 2014-04-07
+
+Patch-Name: unvendorize
+---
+ checkbox_support/vendor/mock.py | 2398 +--------------------------------------
+ 1 file changed, 29 insertions(+), 2369 deletions(-)
+
+diff --git a/checkbox_support/vendor/mock.py b/checkbox_support/vendor/mock.py
+index ca77df6..bd867c5 100644
+--- a/checkbox_support/vendor/mock.py
++++ b/checkbox_support/vendor/mock.py
+@@ -1,2369 +1,29 @@
+-# 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
+-# http://www.voidspace.org.uk/python/mock/
+-
+-# Released subject to the BSD License
+-# Please see http://www.voidspace.org.uk/python/license.shtml
+-
+-# Scripts maintained at http://www.voidspace.org.uk/python/index.shtml
+-# Comments, suggestions and bug reports welcome.
+-
+-
+-__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__
+- f.__wrapped__ = original
+- return f
+- return inner
+-else:
+- if sys.version_info[:2] >= (3, 3):
+- wraps = original_wraps
+- else:
+- def wraps(func):
+- def inner(f):
+- f = original_wraps(func)(f)
+- f.__wrapped__ = func
+- 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.values():
+- 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)
+- 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 __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.
+-
+- The assert passes if the mock has *ever* been called, unlike
+- `assert_called_with` and `assert_called_once_with` that only pass if
+- the call is the most recent one."""
+- kall = call(*args, **kwargs)
+- if kall not in self.call_args_list:
+- expected_string = self._format_mock_call_signature(args, kwargs)
+- raise AssertionError(
+- '%s call not found' % expected_string
+- )
+-
+-
+- def _get_child_mock(self, **kw):
+- """Create the child mocks for attributes and return value.
+- By default child mocks will be the same type as the parent.
+- Subclasses of Mock may want to override this to customize the way
+- child mocks are made.
+-
+- For non-callable mocks the callable variant will be used (rather than
+- any custom subclass)."""
+- _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]
+- return klass(**kw)
+-
+-
+-
+-def _try_iter(obj):
+- 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?
+- return obj
+-
+-
+-
+-class CallableMixin(Base):
+-
+- 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
+-
+- _super(CallableMixin, self).__init__(
+- spec, wraps, name, spec_set, parent,
... 1457 lines suppressed ...
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/python-modules/packages/checkbox-support.git
More information about the Python-modules-commits
mailing list