Viewing file:  test_should_raise.py (9.73 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
from textwrap import dedent
from testfixtures import Comparison as C, ShouldRaise, should_raise
from unittest import TestCase
from ..compat import PY_37_PLUS
from ..shouldraise import ShouldAssert
class TestShouldAssert(object):
def test_no_exception(self):
try:
with ShouldAssert('foo'):
pass
except AssertionError as e:
assert str(e) == "Expected AssertionError('foo'), None raised!"
def test_wrong_exception(self):
try:
with ShouldAssert('foo'):
raise KeyError()
except KeyError:
pass
def test_wrong_text(self):
try:
with ShouldAssert('foo'):
assert False, 'bar'
except AssertionError as e:
assert str(e) == dedent("""\
--- expected
+++ actual
@@ -1 +1,2 @@
-foo
+bar
+assert False""")
class TestShouldRaise(TestCase):
def test_no_params(self):
def to_test():
raise ValueError('wrong value supplied')
should_raise(ValueError('wrong value supplied'))(to_test)()
def test_no_exception(self):
def to_test():
pass
with ShouldAssert('ValueError() (expected) != None (raised)'):
should_raise(ValueError())(to_test)()
def test_wrong_exception(self):
def to_test():
raise ValueError('bar')
if PY_37_PLUS:
expected = "ValueError('foo') (expected) != ValueError('bar') (raised)"
else:
expected = "ValueError('foo',) (expected) != ValueError('bar',) (raised)"
with ShouldAssert(expected):
should_raise(ValueError('foo'))(to_test)()
def test_only_exception_class(self):
def to_test():
raise ValueError('bar')
should_raise(ValueError)(to_test)()
def test_wrong_exception_class(self):
expected_exception = ValueError('bar')
def to_test():
raise expected_exception
try:
should_raise(KeyError)(to_test)()
except ValueError as actual_exception:
assert actual_exception is expected_exception
else: # pragma: no cover
self.fail(('Wrong exception raised'))
def test_wrong_exception_type(self):
expected_exception = ValueError('bar')
def to_test():
raise expected_exception
try:
should_raise(KeyError('foo'))(to_test)()
except ValueError as actual_exception:
assert actual_exception is expected_exception
else: # pragma: no cover
self.fail(('Wrong exception raised'))
def test_no_supplied_or_raised(self):
# effectvely we're saying "something should be raised!"
# but we want to inspect s.raised rather than making
# an up-front assertion
def to_test():
pass
with ShouldAssert("No exception raised!"):
should_raise()(to_test)()
def test_args(self):
def to_test(*args):
raise ValueError('%s' % repr(args))
should_raise(ValueError('(1,)'))(to_test)(1)
def test_kw_to_args(self):
def to_test(x):
raise ValueError('%s' % x)
should_raise(ValueError('1'))(to_test)(x=1)
def test_kw(self):
def to_test(**kw):
raise ValueError('%r' % kw)
should_raise(ValueError("{'x': 1}"))(to_test)(x=1)
def test_both(self):
def to_test(*args, **kw):
raise ValueError('%r %r' % (args, kw))
should_raise(ValueError("(1,) {'x': 2}"))(to_test)(1, x=2)
def test_method_args(self):
class X:
def to_test(self, *args):
self.args = args
raise ValueError()
x = X()
should_raise(ValueError)(x.to_test)(1, 2, 3)
self.assertEqual(x.args, (1, 2, 3))
def test_method_kw(self):
class X:
def to_test(self, **kw):
self.kw = kw
raise ValueError()
x = X()
should_raise(ValueError)(x.to_test)(x=1, y=2)
self.assertEqual(x.kw, {'x': 1, 'y': 2})
def test_method_both(self):
class X:
def to_test(self, *args, **kw):
self.args = args
self.kw = kw
raise ValueError()
x = X()
should_raise(ValueError)(x.to_test)(1, y=2)
self.assertEqual(x.args, (1, ))
self.assertEqual(x.kw, {'y': 2})
def test_class_class(self):
class Test:
def __init__(self, x):
# The TypeError is raised due to the mis-matched parameters
# so the pass never gets executed
pass # pragma: no cover
should_raise(TypeError)(Test)()
def test_raised(self):
with ShouldRaise() as s:
raise ValueError('wrong value supplied')
self.assertEqual(s.raised, C(ValueError('wrong value supplied')))
def test_catch_baseexception_1(self):
with ShouldRaise(SystemExit):
raise SystemExit()
def test_catch_baseexception_2(self):
with ShouldRaise(KeyboardInterrupt):
raise KeyboardInterrupt()
def test_with_exception_class_supplied(self):
with ShouldRaise(ValueError):
raise ValueError('foo bar')
def test_with_exception_supplied(self):
with ShouldRaise(ValueError('foo bar')):
raise ValueError('foo bar')
def test_with_exception_supplied_wrong_args(self):
if PY_37_PLUS:
expected = "ValueError('foo') (expected) != ValueError('bar') (raised)"
else:
expected = "ValueError('foo',) (expected) != ValueError('bar',) (raised)"
with ShouldAssert(expected):
with ShouldRaise(ValueError('foo')):
raise ValueError('bar')
def test_neither_supplied(self):
with ShouldRaise():
raise ValueError('foo bar')
def test_with_no_exception_when_expected(self):
if PY_37_PLUS:
expected = "ValueError('foo') (expected) != None (raised)"
else:
expected = "ValueError('foo',) (expected) != None (raised)"
with ShouldAssert(expected):
with ShouldRaise(ValueError('foo')):
pass
def test_with_no_exception_when_expected_by_type(self):
with ShouldAssert("<class 'ValueError'> (expected) != None (raised)"):
with ShouldRaise(ValueError):
pass
def test_with_no_exception_when_neither_expected(self):
with ShouldAssert("No exception raised!"):
with ShouldRaise():
pass
def test_with_getting_raised_exception(self):
e = ValueError('foo bar')
with ShouldRaise() as s:
raise e
assert e is s.raised
def test_import_errors_1(self):
with ShouldRaise(ModuleNotFoundError("No module named 'textfixtures'")):
import textfixtures.foo.bar
def test_import_errors_2(self):
with ShouldRaise(ImportError('X')):
raise ImportError('X')
def test_custom_exception(self):
class FileTypeError(Exception):
def __init__(self, value):
self.value = value
with ShouldRaise(FileTypeError('X')):
raise FileTypeError('X')
def test_decorator_usage(self):
@should_raise(ValueError('bad'))
def to_test():
raise ValueError('bad')
to_test()
def test_unless_false_okay(self):
with ShouldRaise(unless=False):
raise AttributeError()
def test_unless_false_bad(self):
with ShouldAssert("No exception raised!"):
with ShouldRaise(unless=False):
pass
def test_unless_true_okay(self):
with ShouldRaise(unless=True):
pass
def test_unless_true_not_okay(self):
expected_exception = AttributeError('foo')
try:
with ShouldRaise(unless=True):
raise expected_exception
except AttributeError as actual_exception:
assert actual_exception is expected_exception
else: # pragma: no cover
self.fail(('Wrong exception raised'))
def test_unless_decorator_usage(self):
@should_raise(unless=True)
def to_test():
pass
to_test()
def test_identical_reprs(self):
class AnnoyingException(Exception):
def __init__(self, **kw):
self.other = kw.get('other')
with ShouldAssert(
"AnnoyingException not as expected:\n\n"
'attributes same:\n'
"['args']\n\n"
"attributes differ:\n"
"'other': 'bar' (expected) != 'baz' (raised)\n\n"
"While comparing .other: 'bar' (expected) != 'baz' (raised)"
):
with ShouldRaise(AnnoyingException(other='bar')):
raise AnnoyingException(other='baz')
def test_identical_reprs_but_args_different(self):
class MessageError(Exception):
def __init__(self, message, type=None):
self.message = message
self.type = type
def __repr__(self):
return 'MessageError({!r}, {!r})'.format(self.message, self.type)
with ShouldAssert(
"MessageError not as expected:\n\n"
'attributes same:\n'
"['message', 'type']\n\n"
"attributes differ:\n"
"'args': ('foo',) (expected) != ('foo', None) (raised)\n\n"
"While comparing .args: sequence not as expected:\n\n"
"same:\n"
"('foo',)\n\n"
"expected:\n"
"()\n\n"
"raised:\n"
"(None,)"
):
with ShouldRaise(MessageError('foo')):
raise MessageError('foo', None)
|