深入探索Unittest中的断言类型：全面覆盖与专业应用

于 2025-01-10 13:40:09 发布
阅读量867 收藏 13
点赞数 22
分类专栏： # Unittest&&pytest 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/python_jeff/article/details/145056450
版权

深入探索Unittest中的断言类型：全面覆盖与专业应用

在现代软件开发中，单元测试是确保代码质量和功能正确性的重要手段。Python的unittest模块提供了丰富的断言方法，用于验证代码的行为是否符合预期。本文将详细介绍unittest中的所有断言类型，并通过示例展示其专业应用。

什么是断言？

断言（Assertion）是一种用于验证程序状态或行为的机制。在单元测试中，断言用于检查代码是否按预期运行。如果断言失败，测试框架会报告错误，从而帮助开发者快速定位和修复问题。

unittest中的断言类型

unittest模块提供了多种断言方法，每种方法适用于不同的测试场景。以下是所有主要的断言类型及其详细解释和示例：

1. assertEqual(a, b)

用于检查两个值是否相等。如果不相等，则测试失败。

import unittest

class TestEqualAssertion(unittest.TestCase):
    def test_equal(self):
        self.assertEqual(5, 5, "两个值应该相等")
        self.assertEqual("hello", "hello", "字符串应该相等")

if __name__ == '__main__':
    unittest.main()

2. assertNotEqual(a, b)

用于检查两个值是否不相等。如果相等，则测试失败。

class TestNotEqualAssertion(unittest.TestCase):
    def test_not_equal(self):
        self.assertNotEqual(5, 6, "两个值不应该相等")
        self.assertNotEqual("hello", "world", "字符串不应该相等")

if __name__ == '__main__':
    unittest.main()

3. assertTrue(x)

用于检查表达式是否为真。如果表达式为假，则测试失败。

class TestTrueAssertion(unittest.TestCase):
    def test_true(self):
        self.assertTrue(5 > 3, "表达式应该为真")
        self.assertTrue(bool("non-empty string"), "非空字符串应该为真")

if __name__ == '__main__':
    unittest.main()

4. assertFalse(x)

用于检查表达式是否为假。如果表达式为真，则测试失败。

class TestFalseAssertion(unittest.TestCase):
    def test_false(self):
        self.assertFalse(5 < 3, "表达式应该为假")
        self.assertFalse(bool(""), "空字符串应该为假")

if __name__ == '__main__':
    unittest.main()

5. assertIs(a, b)

用于检查两个对象是否是同一个对象。如果不是同一个对象，则测试失败。

class TestIsAssertion(unittest.TestCase):
    def test_is(self):
        a = [1, 2, 3]
        b = a
        c = [1, 2, 3]
        self.assertIs(a, b, "a和b应该是同一个对象")
        self.assertIsNot(a, c, "a和c不应该是同一个对象")

if __name__ == '__main__':
    unittest.main()

6. assertIsNot(a, b)

用于检查两个对象是否不是同一个对象。如果是同一个对象，则测试失败。

class TestIsNotAssertion(unittest.TestCase):
    def test_is_not(self):
        a = [1, 2, 3]
        b = [1, 2, 3]
        self.assertIsNot(a, b, "a和b不应该是同一个对象")

if __name__ == '__main__':
    unittest.main()

7. assertIsNone(x)

用于检查对象是否为None。如果对象不为None，则测试失败。

class TestIsNoneAssertion(unittest.TestCase):
    def test_is_none(self):
        self.assertIsNone(None, "对象应该为None")
        self.assertIsNotNone(5, "对象不应该为None")

if __name__ == '__main__':
    unittest.main()

8. assertIsNotNone(x)

用于检查对象是否不为None。如果对象为None，则测试失败。

class TestIsNotNoneAssertion(unittest.TestCase):
    def test_is_not_none(self):
        self.assertIsNotNone(5, "对象不应该为None")
        self.assertIsNone(None, "对象应该为None")

if __name__ == '__main__':
    unittest.main()

9. assertIn(a, b)

用于检查元素a是否在容器b中。如果不在，则测试失败。

class TestInAssertion(unittest.TestCase):
    def test_in(self):
        self.assertIn(3, [1, 2, 3], "元素应该在列表中")
        self.assertIn("hello", "hello world", "子字符串应该在字符串中")

if __name__ == '__main__':
    unittest.main()

10. assertNotIn(a, b)

用于检查元素a是否不在容器b中。如果在，则测试失败。

class TestNotInAssertion(unittest.TestCase):
    def test_not_in(self):
        self.assertNotIn(4, [1, 2, 3], "元素不应该在列表中")
        self.assertNotIn("bye", "hello world", "子字符串不应该在字符串中")

if __name__ == '__main__':
    unittest.main()

11. assertIsInstance(a, b)

用于检查对象a是否是类b的实例。如果不是，则测试失败。

class TestIsInstanceAssertion(unittest.TestCase):
    def test_is_instance(self):
        self.assertIsInstance(5, int, "对象应该是int类型")
        self.assertIsInstance("hello", str, "对象应该是str类型")

if __name__ == '__main__':
    unittest.main()

12. assertNotIsInstance(a, b)

用于检查对象a是否不是类b的实例。如果是，则测试失败。

class TestNotIsInstanceAssertion(unittest.TestCase):
    def test_not_is_instance(self):
        self.assertNotIsInstance(5, str, "对象不应该是str类型")
        self.assertNotIsInstance("hello", list, "对象不应该是list类型")

if __name__ == '__main__':
    unittest.main()

13. assertAlmostEqual(a, b, places=7)

用于检查两个浮点数是否近似相等。如果不相等，则测试失败。places参数指定小数点后的精度。

class TestAlmostEqualAssertion(unittest.TestCase):
    def test_almost_equal(self):
        self.assertAlmostEqual(0.1 + 0.2, 0.3, places=7, msg="两个浮点数应该近似相等")
        self.assertAlmostEqual(1.0000001, 1.0000002, places=7, msg="两个浮点数应该近似相等")

if __name__ == '__main__':
    unittest.main()

14. assertNotAlmostEqual(a, b, places=7)

用于检查两个浮点数是否不近似相等。如果相等，则测试失败。places参数指定小数点后的精度。

class TestNotAlmostEqualAssertion(unittest.TestCase):
    def test_not_almost_equal(self):
        self.assertNotAlmostEqual(0.1 + 0.2, 0.4, places=7, msg="两个浮点数不应该近似相等")
        self.assertNotAlmostEqual(1.0000001, 1.0000001, places=7, msg="两个浮点数不应该近似相等")

if __name__ == '__main__':
    unittest.main()

15. assertGreater(a, b)

用于检查a是否大于b。如果不大于，则测试失败。

class TestGreaterAssertion(unittest.TestCase):
    def test_greater(self):
        self.assertGreater(5, 3, "5应该大于3")
        self.assertGreater(10.5, 10.0, "10.5应该大于10.0")

if __name__ == '__main__':
    unittest.main()

16. assertGreaterEqual(a, b)

用于检查a是否大于或等于b。如果不大于或等于，则测试失败。

class TestGreaterEqualAssertion(unittest.TestCase):
    def test_greater_equal(self):
        self.assertGreaterEqual(5, 5, "5应该大于或等于5")
        self.assertGreaterEqual(10.5, 10.0, "10.5应该大于或等于10.0")

if __name__ == '__main__':
    unittest.main()

17. assertLess(a, b)

用于检查a是否小于b。如果不小于，则测试失败。

class TestLessAssertion(unittest.TestCase):
    def test_less(self):
        self.assertLess(3, 5, "3应该小于5")
        self.assertLess(10.0, 10.5, "10.0应该小于10.5")

if __name__ == '__main__':
    unittest.main()

18. assertLessEqual(a, b)

用于检查a是否小于或等于b。如果不小于或等于，则测试失败。

class TestLessEqualAssertion(unittest.TestCase):
    def test_less_equal(self):
        self.assertLessEqual(5, 5, "5应该小于或等于5")
        self.assertLessEqual(10.0, 10.5, "10.0应该小于或等于10.5")

if __name__ == '__main__':
    unittest.main()

好的，让我们继续深入探讨unittest模块中的高级断言类型。这些断言类型包括上下文管理器断言、自定义断言、多线程断言和异步断言等。

19. assertRaises(exception)

用于检查是否抛出了指定的异常。如果没有抛出异常或抛出了不同的异常，则测试失败。

import unittest

class TestAssertRaises(unittest.TestCase):
    def test_raises(self):
        with self.assertRaises(ValueError) as cm:
            raise ValueError("An error occurred")
        self.assertEqual(str(cm.exception), "An error occurred", "应该捕获到指定的异常")

if __name__ == '__main__':
    unittest.main()

20. assertRegex(text, pattern, msg=None)

用于检查字符串text是否与正则表达式pattern匹配。如果不匹配，则测试失败。

import unittest
import re

class TestAssertRegex(unittest.TestCase):
    def test_regex(self):
        self.assertRegex("hello world", r"\bworld\b", "字符串应该匹配正则表达式")
        self.assertNotRegex("hello world", r"\d", "字符串不应该匹配正则表达式")

if __name__ == '__main__':
    unittest.main()

21. assertNoRegex(text, pattern, msg=None)

用于检查字符串text是否不与正则表达式pattern匹配。如果匹配，则测试失败。

import unittest
import re

class TestAssertNoRegex(unittest.TestCase):
    def test_no_regex(self):
        self.assertNoRegex("hello world", r"\d", "字符串不应该匹配正则表达式")
        self.assertRegex("hello world", r"\bworld\b", "字符串应该匹配正则表达式")

if __name__ == '__main__':
    unittest.main()

22. assertIsNone(x, msg=None)

用于检查对象x是否为None。如果不是，则测试失败。

import unittest

class TestIsNoneAssertion(unittest.TestCase):
    def test_is_none(self):
        self.assertIsNone(None, "对象应该为None")
        self.assertIsNotNone(5, "对象不应该为None")

if __name__ == '__main__':
    unittest.main()

23. assertIsNotNone(x, msg=None)

用于检查对象x是否不为None。如果是，则测试失败。

import unittest

class TestIsNotNoneAssertion(unittest.TestCase):
    def test_is_not_none(self):
        self.assertIsNotNone(5, "对象不应该为None")
        self.assertIsNone(None, "对象应该为None")

if __name__ == '__main__':
    unittest.main()

24. assertWarns(expected_warning, func, *args, **kwds)

用于检查函数func在执行时是否发出警告expected_warning。如果没有发出警告或发出的警告不是期望的，则测试失败。

import unittest
import warnings

class TestAssertWarns(unittest.TestCase):
    def test_warns(self):
        with self.assertWarns(UserWarning):
            warnings.warn("This is a warning", UserWarning)
        self.assertNoWarns(UserWarning, self.test_no_warn)

    def test_no_warn(self):
        pass

if __name__ == '__main__':
    unittest.main()

25. assertNoWarns(expected_warning, func, *args, **kwds)

用于检查函数func在执行时是否没有发出警告expected_warning。如果发出了警告，则测试失败。

import unittest
import warnings

class TestAssertNoWarns(unittest.TestCase):
    def test_no_warns(self):
        self.assertNoWarns(UserWarning, self.test_no_warn)
        with self.assertRaises(Warning):
            warnings.warn("This is a warning", UserWarning)
            self.fail("应该没有发出警告")

    def test_no_warn(self):
        pass

if __name__ == '__main__':
    unittest.main()
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

tester Jeffky

慷慨解囊，感激不尽。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值