def test_invalid_line(self):
self.tmpfile.write('justkey\n')
self.tmpfile.flush()
assert_raises(
errors.ConfigurationError,
loader.PropertiesConfiguration,
self.tmpfile.name)
def test_read_config_failed(self):
self.namespace.get.return_value = proxy.UndefToken
assert_raises(
errors.ConfigurationError,
readers._read_config,
'some_key',
self.namespace,
None)
def test_xml_configuration_safe_value_tag(self):
content = """
<config>
<sometag value="snazz">E</sometag>
</config>
"""
self.write_content_to_file(content)
assert_raises(errors.ConfigurationError, loader.XMLConfiguration, self.tmpfile.name, safe=True)
def test_callable_is_called_with_all_arguments(self):
class GoodArguments(Exception): pass
arg1, arg2, kwarg = object(), object(), object()
def check_arguments(*args, **kwargs):
assert_equal((arg1, arg2), args)
assert_equal({'kwarg': kwarg}, kwargs)
raise GoodArguments
assertions.assert_raises(GoodArguments, check_arguments, arg1, arg2, kwarg=kwarg)
def test_fails_when_exception_is_not_raised(self):
raises_nothing = lambda: None
try:
assertions.assert_raises(ValueError, raises_nothing)
except AssertionError:
pass
else:
assert_not_reached('AssertionError should have been raised')
def test_fails_when_exception_is_not_raised(self):
raises_nothing = lambda: None
try:
assertions.assert_raises(ValueError, raises_nothing)
except AssertionError:
pass
else:
assert_not_reached('AssertionError should have been raised')
def test_build_loader_optional(self):
err_msg = "Failed to do"
loader_func = mock.Mock()
loader_func.side_effect = ValueError(err_msg)
config_loader = loader.build_loader(loader_func)
config_loader(optional=True)
assert_raises(ValueError, config_loader)
def test_build_loader_optional(self):
err_msg = "Failed to do"
loader_func = mock.Mock()
loader_func.side_effect = ValueError(err_msg)
config_loader = loader.build_loader(loader_func)
config_loader(optional=True)
assert_raises(ValueError, config_loader)
def test_fails_when_wrong_exception_is_raised(self):
def raises_value_error():
raise ValueError
try:
assertions.assert_raises(MyException, raises_value_error)
except ValueError:
pass
else:
assert_not_reached('ValueError should have been raised')
def test_xml_configuration_safe_override(self):
content = """
<config>
<sometag foo="bar">
<foo>E</foo>
</sometag>
</config>
"""
self.write_content_to_file(content)
assert_raises(errors.ConfigurationError, loader.XMLConfiguration, self.tmpfile.name, safe=True)
def test_fails_when_wrong_exception_is_raised(self):
def raises_value_error():
raise ValueError
try:
assertions.assert_raises(MyException, raises_value_error)
except ValueError:
pass
else:
assert_not_reached('ValueError should have been raised')
def test_xml_configuration_safe_value_tag(self):
content = """
<config>
<sometag value="snazz">E</sometag>
</config>
"""
self.write_content_to_file(content)
assert_raises(errors.ConfigurationError,
loader.XMLConfiguration,
self.tmpfile.name,
safe=True)
def test_xml_configuration_safe_override(self):
content = """
<config>
<sometag foo="bar">
<foo>E</foo>
</sometag>
</config>
"""
self.write_content_to_file(content)
assert_raises(errors.ConfigurationError,
loader.XMLConfiguration,
self.tmpfile.name,
safe=True)
def test_no_vars(self):
"""
To allocate a .__dict__ attribute of this object means that we're
allocating a second, mutable dictionary as part of our frozendict.
This would be a waste of memory as well as yielding pretty nonsensical
semantics wrt immutability.
"""
fd = fdict(a=1)
with T.assert_raises(TypeError):
vars(fd)
with T.assert_raises(AttributeError):
fd.__dict__
def test_parse_test_runner_command_line_args_no_test_path(self):
"""Make sure that if no options and no arguments are passed,
parse_test_runner_command_line_args DOES complain about a missing test
path.
"""
with assert_raises(OptionParserErrorException):
test_program.parse_test_runner_command_line_args([], [])
def perform_exception_test(self, exc_class):
self.expected_reference_counts = self.get_reference_counts()
for _ in xrange(self.num_stress_test_iterations + 1):
# there's a fun wrinkle here. we have to make sure the raised exception
# is completely out of scope and destroyed before we check the reference
# counts again; otherwise it may hold incidental references to objects,
# which will appear to the reference count checks here as though it were
# a memory leak. not that this, you know, actually happened to me or anything.
assert_raises(exc_class, self.run_templating)
assert_equal(self.get_reference_counts(), self.expected_reference_counts)
try:
self.run_templating()
except exc_class, e:
# now that we're done counting references, save the exception for examination:
self.exception = e
def test_fails_when_exception_test_fails(self):
"""Tests that when an exception of the right type that fails the
passed in exception test is raised, the assertion fails."""
has_two_args = lambda e: assertions.assert_length(e.args, 2)
with assertions.assert_raises(AssertionError):
with assertions.assert_raises_such_that(Exception, has_two_args):
raise Exception("only one argument")
def test_fails_when_no_exception_is_raised(self):
"""Tests that the assertion fails when no exception is raised."""
def exists(e):
return True
with assertions.assert_raises(AssertionError):
with assertions.assert_raises_such_that(Exception, exists):
pass
def test_parse_test_runner_command_line_args_no_test_path(self):
"""Make sure that if no options and no arguments are passed,
parse_test_runner_command_line_args DOES complain about a missing test
path.
"""
with assert_raises(OptionParserErrorException):
test_program.parse_test_runner_command_line_args([], [])
def test_unexpected_exception_passes_through(self):
class DifferentException(Exception):
pass
with assertions.assert_raises(DifferentException):
with assertions.assert_raises_exactly(self.MyException, "first", "second"):
raise DifferentException("first", "second")
def test_callable_is_called_with_all_arguments(self):
class GoodArguments(Exception):
pass
arg1, arg2, kwarg = object(), object(), object()
def check_arguments(*args, **kwargs):
assert_equal((arg1, arg2), args)
assert_equal({'kwarg': kwarg}, kwargs)
raise GoodArguments
assertions.assert_raises(GoodArguments,
check_arguments,
arg1,
arg2,
kwarg=kwarg)
def test_fails_when_exception_test_fails(self):
"""Tests that when an exception of the right type that fails the
passed in exception test is raised, the assertion fails."""
has_two_args = lambda e: assertions.assert_length(e.args, 2)
with assertions.assert_raises(AssertionError):
with assertions.assert_raises_such_that(Exception, has_two_args):
raise Exception("only one argument")
def test_fails_when_incorrect_warning_with_callable(self):
"""
Test that assert_warns fails when we pass a specific warning and
a different warning class is thrown.
"""
with assertions.assert_raises(AssertionError):
assertions.assert_warns(DeprecationWarning, self._create_user_warning)
def test_fails_with_different_class(self):
class SpecialException(self.MyException):
pass
with assertions.assert_raises(AssertionError):
with assertions.assert_raises_exactly(self.MyException, "first", "second"):
raise SpecialException("first", "second")
def test_fails_when_incorrect_warning_with_callable(self):
"""
Test that assert_warns fails when we pass a specific warning and
a different warning class is thrown.
"""
with assertions.assert_raises(AssertionError):
assertions.assert_warns(DeprecationWarning,
self._create_user_warning)
def test_fails_when_warnings_test_raises_exception(self):
"""
Test that assert_warns_such_that (used as a context manager)
fails when the warnings_test method raises an exception.
"""
with assertions.assert_raises(RuntimeError):
with assertions.assert_warns_such_that(self._raise_exception):
self._create_user_warning()
def test_fails_when_warnings_test_raises_exception_with_callable(self):
"""
Test that assert_warns_such_that (when given a callable object)
fails when the warnings_test method raises an exception.
"""
with assertions.assert_raises(RuntimeError):
assertions.assert_warns_such_that(self._raise_exception,
self._create_user_warning)
def test_fails_when_warnings_test_raises_exception(self):
"""
Test that assert_warns_such_that (used as a context manager)
fails when the warnings_test method raises an exception.
"""
with assertions.assert_raises(RuntimeError):
with assertions.assert_warns_such_that(self._raise_exception):
self._create_user_warning()
def test_unexpected_exception_passes_through(self):
class DifferentException(Exception):
pass
with assertions.assert_raises(DifferentException):
with assertions.assert_raises_exactly(self.MyException, "first",
"second"):
raise DifferentException("first", "second")
def test_fails_with_different_class(self):
class SpecialException(self.MyException):
pass
with assertions.assert_raises(AssertionError):
with assertions.assert_raises_exactly(self.MyException, "first",
"second"):
raise SpecialException("first", "second")
def test_fails_when_no_warning_with_callable(self):
"""Test that assert_warns fails when there is no warning thrown."""
with assertions.assert_raises(AssertionError):
def do_nothing():
pass
assertions.assert_warns(UserWarning, do_nothing)
def test_fails_on_unyielding_generator(self):
"""Test that assert_not_empty fails on an 'empty' generator."""
def yield_nothing():
if False:
yield 0
with assertions.assert_raises(AssertionError):
assertions.assert_not_empty(yield_nothing())
def test_fails_on_infinite_generator(self):
"""Tests that assert_empty fails on an infinite generator."""
def yes():
while True:
yield 'y'
with assertions.assert_raises(AssertionError):
assertions.assert_empty(yes())
def test_fails_when_no_exception_is_raised(self):
"""Tests that the assertion fails when no exception is raised."""
def exists(e):
return True
with assertions.assert_raises(AssertionError):
with assertions.assert_raises_such_that(Exception, exists):
pass
def test_fails_on_unyielding_generator(self):
"""Test that assert_not_empty fails on an 'empty' generator."""
def yield_nothing():
if False:
yield 0
with assertions.assert_raises(AssertionError):
assertions.assert_not_empty(yield_nothing())
def test_fails_on_infinite_generator(self):
"""Tests that assert_empty fails on an infinite generator."""
def yes():
while True:
yield 'y'
with assertions.assert_raises(AssertionError):
assertions.assert_empty(yes())
def test_fails_when_warnings_test_raises_exception_with_callable(self):
"""
Test that assert_warns_such_that (when given a callable object)
fails when the warnings_test method raises an exception.
"""
with assertions.assert_raises(RuntimeError):
assertions.assert_warns_such_that(self._raise_exception,
self._create_user_warning)
def test_fails_when_wrong_exception_is_raised(self):
"""Tests that when an unexpected exception is raised, that it is
passed through and the assertion fails."""
exists = lambda e: True
# note: in assert_raises*, if the exception raised is not of the
# expected type, that exception just falls through
with assertions.assert_raises(Exception):
with assertions.assert_raises_such_that(AssertionError, exists):
raise Exception("the wrong exception")
def test_fails_when_wrong_exception_is_raised(self):
"""Tests that when an unexpected exception is raised, that it is
passed through and the assertion fails."""
exists = lambda e: True
# note: in assert_raises*, if the exception raised is not of the
# expected type, that exception just falls through
with assertions.assert_raises(Exception):
with assertions.assert_raises_such_that(AssertionError, exists):
raise Exception("the wrong exception")
def test_validate_all_fails(self):
name = 'yan'
_ = staticconf.get_string('foo', namespace=name)
assert_raises(errors.ConfigurationError,
config.validate,
all_names=True)
def test_validate_keys_unknown_raise(self):
assert_raises(errors.ConfigurationError, self.namespace.validate_keys,
self.config_data, True)
def test_validate_single_fails(self):
_ = staticconf.get_int('one.two')
assert_raises(errors.ConfigurationError, config.validate)
def test_fails_on_empty_list(self):
"""Test that assert_not_empty fails on an empty list."""
with assertions.assert_raises(AssertionError):
assertions.assert_not_empty([])
def assert_raises_an_exception_and_raise_another():
with assertions.assert_raises(MyException):
raise ValueError
def test_run_testify_with_failure(self):
assert_raises(
subprocess.CalledProcessError, test_call, ["python", "testing_suite/example_test.py", "DoesNotExist"]
)
def test(self):
assert_raises(KeyError, self.run_templating)
def test_failure_on_interrupt(self):
with assert_raises(subprocess.CalledProcessError):
test_call([
sys.executable, '-m', 'testify.test_program',
'test.failing_test_interrupt'
])
def test_has_duplicate_keys_raises(self):
config_data = dict(fear=123)
assert_raises(errors.ConfigurationError, config.has_duplicate_keys,
config_data, self.base_conf, True)
def test_passes_when_exception_is_raised(self):
def raises_value_error():
raise ValueError
assertions.assert_raises(ValueError, raises_value_error)
def test__getattr__missing_attribute(self):
assert_raises(AttributeError,
self.action_run.__getattr__, 'is_not_a_real_state')
def test_passes_when_exception_is_raised(self):
def raises_value_error():
raise ValueError
assertions.assert_raises(ValueError, raises_value_error)
def test_run_testify_with_failure(self):
assert_raises(
subprocess.CalledProcessError, test_call,
[sys.executable, 'testing_suite/example_test.py', 'DoesNotExist'])
def test_get_value_fails_validation(self):
validator = mock.Mock()
validator.side_effect = validation.ValidationError()
value_proxy = proxy.ValueProxy(validator, self.value_cache, 'something.broken')
assert_raises(errors.ConfigurationError, lambda: value_proxy + 1)
def test_fails_with_wrong_value(self):
superset = {'one': 1, 'two': 2, 'three': 3}
subset = {'one': 2}
assertions.assert_raises(AssertionError, assert_dict_subset, superset,
subset)
def test_failure_on_interrupt(self):
with assert_raises(subprocess.CalledProcessError):
test_call([sys.executable, "-m", "testify.test_program", "test.failing_test_interrupt"])
def test_get_value_unset(self):
validator = mock.Mock()
value_proxy = proxy.ValueProxy(validator, self.value_cache, 'something.missing')
assert_raises(errors.ConfigurationError, lambda: value_proxy + 1)
def exception_should_be_raised():
with assertions.assert_raises(MyException):
raise MyException
def test_run_testify_with_failure(self):
assert_raises(
subprocess.CalledProcessError,
test_call,
['python', 'testing_suite/example_test.py', 'DoesNotExist'])
def assert_raises_an_exception_and_raise_another():
with assertions.assert_raises(MyException):
raise ValueError
