Python assertions.assert_raises函数代码示例

 def test_invalid_line(self):
     self.tmpfile.write('justkey\n')
     self.tmpfile.flush()
     assert_raises(
             errors.ConfigurationError,
             loader.PropertiesConfiguration,
             self.tmpfile.name)

 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_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_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_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_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_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_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_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_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_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)