/usr/share/pyshared/hamcrest/core/core/raises.py is in python-hamcrest 1.8.0-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 | from weakref import ref
import re
import sys
from hamcrest.core.base_matcher import BaseMatcher
from hamcrest.core.helpers.wrap_matcher import wrap_matcher
from hamcrest.core.compat import is_callable
__author__ = "Per Fagrell"
__copyright__ = "Copyright 2013 hamcrest.org"
__license__ = "BSD, see License.txt"
class Raises(BaseMatcher):
def __init__(self, expected, pattern=None):
self.pattern = pattern
self.expected = expected
self.actual = None
self.function = None
def _matches(self, function):
if not is_callable(function):
return False
self.function = ref(function)
return self._call_function(function)
def _call_function(self, function):
self.actual = None
try:
function()
except Exception:
self.actual = sys.exc_info()[1]
if isinstance(self.actual, self.expected):
if self.pattern is not None:
return re.search(self.pattern, str(self.actual)) is not None
return True
return False
def describe_to(self, description):
description.append_text('Expected a callable raising %s' % self.expected)
def describe_mismatch(self, item, description):
if not is_callable(item):
description.append_text('%s is not callable' % item)
return
function = None if self.function is None else self.function()
if function is None or function is not item:
self.function = ref(item)
if not self._call_function(item):
return
if self.actual is None:
description.append_text('No exception raised.')
elif isinstance(self.actual, self.expected) and self.pattern is not None:
description.append_text('Correct assertion type raised, but the expected pattern ("%s") not found.' % self.pattern)
description.append_text('\n message was: "%s"' % str(self.actual))
else:
description.append_text('%s was raised instead' % type(self.actual))
def raises(exception, pattern=None):
"""Matches if the called function raised the expected exception.
:param exception: The class of the expected exception
:param pattern: Optional regular expression to match exception message.
Expects the actual to be wrapped by using :py:func:`~hamcrest.core.core.raises.calling`,
or a callable taking no arguments.
Optional argument pattern should be a string containing a regular expression. If provided,
the string representation of the actual exception - e.g. `str(actual)` - must match pattern.
Examples::
assert_that(calling(int).with_args('q'), raises(TypeError))
assert_that(calling(parse, broken_input), raises(ValueError))
"""
return Raises(exception, pattern)
class DeferredCallable(object):
def __init__(self, func):
self.func = func
self.args = tuple()
self.kwargs = {}
def __call__(self):
self.func(*self.args, **self.kwargs)
def with_args(self, *args, **kwargs):
self.args = args
self.kwargs = kwargs
return self
def calling(func):
"""Wrapper for function call that delays the actual execution so that
:py:func:`~hamcrest.core.core.raises.raises` matcher can catch any thrown exception.
:param func: The function or method to be called
The arguments can be provided with a call to the `with_args` function on the returned
object::
calling(my_method).with_args(arguments, and_='keywords')
"""
return DeferredCallable(func)
|