def test_flattening(self):
f1 = _captured_failure('Wrap me')
f2 = _captured_failure('Wrap me, too')
f3 = _captured_failure('Woot!')
try:
raise exceptions.WrappedFailure([f1, f2])
except Exception:
fail_obj = misc.Failure()
wf = exceptions.WrappedFailure([fail_obj, f3])
self.assertEquals(list(wf), [f1, f2, f3])
def test_two_failures(self):
fls = [
_captured_failure('Woot!'),
_captured_failure('Oh, not again!')
]
wf = exceptions.WrappedFailure(fls)
self.assertEquals(len(wf), 2)
self.assertEquals(list(wf), fls)
def test_wrapped_failure_non_ascii_unicode(self):
hi_cn = u'嗨'
fail = ValueError(hi_cn)
self.assertEqual(hi_cn, encodeutils.exception_to_unicode(fail))
fail = failure.Failure.from_exception(fail)
wrapped_fail = exceptions.WrappedFailure([fail])
expected_result = (u"WrappedFailure: "
"[Failure: ValueError: %s]" % (hi_cn))
self.assertEqual(expected_result, six.text_type(wrapped_fail))
def wrap_all_failures():
"""Convert any exceptions to WrappedFailure.
When you expect several failures, it may be convenient
to wrap any exception with WrappedFailure in order to
unify error handling.
"""
try:
yield
except Exception:
raise exceptions.WrappedFailure([failure.Failure()])
def reraise_if_any(failures):
"""Re-raise exceptions if argument is not empty.
If argument is empty list, this method returns None. If
argument is list with single Failure object in it,
this failure is reraised. Else, WrappedFailure exception
is raised with failures list as causes.
"""
failures = list(failures)
if len(failures) == 1:
failures[0].reraise()
elif len(failures) > 1:
raise exceptions.WrappedFailure(failures)
def reraise_if_any(failures):
"""Re-raise exceptions if argument is not empty.
If argument is empty list, this method returns None. If
argument is a list with a single ``Failure`` object in it,
that failure is reraised. Else, a
:class:`~taskflow.exceptions.WrappedFailure` exception
is raised with a failure list as causes.
"""
failures = list(failures)
if len(failures) == 1:
failures[0].reraise()
elif len(failures) > 1:
raise exc.WrappedFailure(failures)
def test_wrapped_failure_non_ascii_unicode(self):
hi_cn = u'嗨'
fail = ValueError(hi_cn)
self.assertEqual(hi_cn, exceptions.exception_message(fail))
fail = misc.Failure.from_exception(fail)
wrapped_fail = exceptions.WrappedFailure([fail])
if six.PY2:
# Python 2.x will unicode escape it, while python 3.3+ will not,
# so we sadly have to differentiate between these two...
expected_result = (u"WrappedFailure: "
"[u'Failure: ValueError: %s']" %
(hi_cn.encode("unicode-escape")))
else:
expected_result = (u"WrappedFailure: "
"['Failure: ValueError: %s']" % (hi_cn))
self.assertEqual(expected_result, six.text_type(wrapped_fail))
def reraise_if_any(failures):
"""Re-raise exceptions if argument is not empty.
If argument is empty list/tuple/iterator, this method returns
None. If argument is coverted into a list with a
single ``Failure`` object in it, that failure is reraised. Else, a
:class:`~taskflow.exceptions.WrappedFailure` exception
is raised with the failure list as causes.
"""
if not isinstance(failures, (list, tuple)):
# Convert generators/other into a list...
failures = list(failures)
if len(failures) == 1:
failures[0].reraise()
elif len(failures) > 1:
raise exc.WrappedFailure(failures)
def test_simple_check(self):
fail_obj = _captured_failure('Woot!')
wf = exceptions.WrappedFailure([fail_obj])
self.assertEquals(wf.check(RuntimeError), RuntimeError)
self.assertEquals(wf.check(ValueError), None)
def test_simple_iter(self):
fail_obj = _captured_failure('Woot!')
wf = exceptions.WrappedFailure([fail_obj])
self.assertEquals(len(wf), 1)
self.assertEquals(list(wf), [fail_obj])
def reraise(self):
"""Re-raise captured exception."""
if self._exc_info:
six.reraise(*self._exc_info)
else:
raise exc.WrappedFailure([self])
