Python unittest - 与assertRaises相反？

Question

我想编写一个测试来确定在给定情况下不会引发异常。

测试是否引发异常很简单...

sInvalidPath=AlwaysSuppliesAnInvalidPath()
self.assertRaises(PathIsNotAValidOne, MyObject, sInvalidPath) 

...但是你怎么能做到相反的。

我追求的是这样的……

sValidPath=AlwaysSuppliesAValidPath()
self.assertNotRaises(PathIsNotAValidOne, MyObject, sValidPath) 

Answer 1

只需调用该函数。如果引发异常，单元测试框架会将其标记为错误。您可能想添加评论，例如：

sValidPath=AlwaysSuppliesAValidPath()
# Check PathIsNotAValidOne not thrown
MyObject(sValidPath)

已编辑以添加来自 cmets 的说明：

• 单元测试可以有 3 个结果：通过、失败、错误。 （如果算上 XPass/XFail/Skip，实际上更多...）
• 如果你在测试一个特定的异常没有被抛出，而它被抛出了，那么理论上应该是一个Fail。但是上面的代码使它成为一个错误，这在理论上是“错误的”。
• 实际上，如果出现错误，您的测试运行程序可能会打印堆栈跟踪，这可能有助于调试故障。如果出现 Fail，您可能不会看到堆栈跟踪。
• 实际上，使用 Fail 您可以将测试标记为“预期失败”。如果出现错误，您可能无法这样做，尽管您可以将测试标记为“跳过”。
• 实际上，使测试用例报告错误需要额外的代码。
• “错误”和“失败”之间的区别是否重要取决于您的流程。我的团队使用单元测试的方式，他们必须全部通过。 （敏捷编程，使用运行所有单元测试的持续集成机器）。对我的团队来说真正重要的是“所有的单元测试都通过了吗？” （即“詹金斯是绿色的吗？”）。所以对我的团队来说，“失败”和“错误”之间没有实际区别。
• 由于上述优点（更少的代码，查看堆栈跟踪），以及我的团队对 Fail/Error 的处理方式相同的事实，我使用了这种方法。
• 如果您以不同的方式使用单元测试，您可能会有不同的要求，特别是如果您的流程以不同的方式处理“失败”和“错误”，或者如果您希望能够将测试标记为“预期失败”。
• 如果您希望此测试报告错误，请使用 DGH 的答案。

Answer 2

def run_test(self):
    try:
        myFunc()
    except ExceptionType:
        self.fail("myFunc() raised ExceptionType unexpectedly!")

Answer 3

嗨 - 我想编写一个测试来确定在给定情况下不会引发异常。

这是默认假设——不会引发异常。

如果你什么都不说，这是在每一个测试中假设的。

您实际上不必为此编写任何断言。

Answer 4

我是原始发帖人，我接受了 DGH 的上述答案，而没有首先在代码中使用它。

一旦我确实使用了，我意识到它需要进行一些调整才能真正完成我需要它做的事情（为了公平对待 DGH，他/她确实说过“或类似的东西”！）。

我认为值得在此处发布调整以造福他人：

    try:
        a = Application("abcdef", "")
    except pySourceAidExceptions.PathIsNotAValidOne:
        pass
    except:
        self.assertTrue(False)

我在这里尝试做的是确保如果尝试使用空格的第二个参数实例化 Application 对象，则会引发 pySourceAidExceptions.PathIsNotAValidOne。

我相信使用上面的代码（很大程度上基于 DGH 的回答）可以做到这一点。

Answer 5

如果您将异常类传递给assertRaises()，则会提供上下文管理器。这可以提高测试的可读性：

# raise exception if Application created with bad data
with self.assertRaises(pySourceAidExceptions.PathIsNotAValidOne):
    application = Application("abcdef", "")

这允许您测试代码中的错误情况。

在这种情况下，您正在测试 PathIsNotAValidOne 在您将无效参数传递给 Application 构造函数时引发。

Answer 6

我发现猴子补丁unittest 很有用，如下所示：

def assertMayRaise(self, exception, expr):
  if exception is None:
    try:
      expr()
    except:
      info = sys.exc_info()
      self.fail('%s raised' % repr(info[0]))
  else:
    self.assertRaises(exception, expr)

unittest.TestCase.assertMayRaise = assertMayRaise

这在测试是否存在异常时阐明了意图：

self.assertMayRaise(None, does_not_raise)

这也简化了循环测试，我发现自己经常这样做：

# ValueError is raised only for op(x,x), op(y,y) and op(z,z).
for i,(a,b) in enumerate(itertools.product([x,y,z], [x,y,z])):
  self.assertMayRaise(None if i%4 else ValueError, lambda: op(a, b))

Answer 7

您可以通过在unittest 模块中重用assertRaises 的原始实现的大约90% 来定义assertNotRaises。使用这种方法，您最终会得到一个 assertNotRaises 方法，除了其反向失败条件之外，它的行为与 assertRaises 相同。

TLDR 和现场演示

事实证明，将 assertNotRaises 方法添加到 unittest.TestCase 非常容易（编写此答案的时间是编写代码的大约 4 倍）。这是a live demo of the assertNotRaises method in action。只需like assertRaises，您可以将可调用对象和参数传递给assertNotRaises，也可以在with 语句中使用它。现场演示包含一个测试用例，证明 assertNotRaises 可以按预期工作。

详情

unittest 中的assertRaises 的实现相当复杂，但是通过一些巧妙的子类化，您可以覆盖和反转它的失败条件。

assertRaises 是一个简短的方法，它基本上只是创建unittest.case._AssertRaisesContext 类的实例并返回它（参见unittest.case 模块中的定义）。您可以通过继承 _AssertRaisesContext 并覆盖其 __exit__ 方法来定义自己的 _AssertNotRaisesContext 类：

import traceback
from unittest.case import _AssertRaisesContext

class _AssertNotRaisesContext(_AssertRaisesContext):
    def __exit__(self, exc_type, exc_value, tb):
        if exc_type is not None:
            self.exception = exc_value.with_traceback(None)

            try:
                exc_name = self.expected.__name__
            except AttributeError:
                exc_name = str(self.expected)

            if self.obj_name:
                self._raiseFailure("{} raised by {}".format(exc_name,
                    self.obj_name))
            else:
                self._raiseFailure("{} raised".format(exc_name))

        else:
            traceback.clear_frames(tb)

        return True

通常，您通过让它们从TestCase 继承来定义测试用例类。如果您改为从子类MyTestCase 继承：

class MyTestCase(unittest.TestCase):
    def assertNotRaises(self, expected_exception, *args, **kwargs):
        context = _AssertNotRaisesContext(expected_exception, self)
        try:
            return context.handle('assertNotRaises', args, kwargs)
        finally:
            context = None

您的所有测试用例现在都可以使用assertNotRaises 方法。

Answer 8

你可以这样尝试。 尝试： self.assertRaises（无，函数，arg1，arg2） 除了： 经过 如果您不将代码放入 try 块中，它将通过异常“ AssertionError：None not raise ”并且测试用例将失败。如果将代码放入 try 块中，则测试用例将通过，这是预期的行为。

Answer 9

def _assertNotRaises(self, exception, obj, attr):                                                                                                                              
     try:                                                                                                                                                                       
         result = getattr(obj, attr)                                                                                                                                            
         if hasattr(result, '__call__'):                                                                                                                                        
             result()                                                                                                                                                           
     except Exception as e:                                                                                                                                                     
         if isinstance(e, exception):                                                                                                                                           
            raise AssertionError('{}.{} raises {}.'.format(obj, attr, exception)) 

如果需要接受参数，可以修改。

打个电话

self._assertNotRaises(IndexError, array, 'sort')

Answer 10

确保对象初始化没有任何错误的一种直接方法是测试对象的类型实例。

这是一个例子：

p = SomeClass(param1=_param1_value)
self.assertTrue(isinstance(p, SomeClass))