自动化七：单元测试框架五

单元测试框架：unittest

assert 系列：在单元测试框架中，都是通过断言来对case进行判断期望结果和实际结果是否相符

assert 系列包含以下方法：

　　assertEqual  判断是否相等

　　assertNotEqual  判断是否不相等

　　assertTrue  判断是否为真

　　assertFalse  判断是否为假

　　assertIs  判断地址和值是否相等（也就是判断是否是同一个对象）

　　assertIsNot  判断地址和值是否不相等

　　assertIsNone  判断是否为None

　　assertIsNotNone  判断是否不为None

　　assertIn  判断是否包含在里面

　　assertNotIn  判断是否不包含在里面

　　assertIsInstance  判断指定的参数类型是否和期望的类型一致

　　assertNotIsInstance  判断指定的参数是否和期望的类型不一致

　　assertRaises  判断函数执行的异常是否和期望的类型一致

　　assertRaisesRegex  正则异常捕获

# encoding=utf-8
import unittest
import random


# 被测试类
class MyClass(object):
    @classmethod
    def sum(cls, a, b):
        return a + b

    @classmethod
    def div(cls, a, b):
        return a / b

    @classmethod
    def retrun_None(cls):
        return None


# 单元测试类
class MyTest(unittest.TestCase):

    # assertEqual()方法实例
    def test_assertEqual(self):
        # 断言两数之和的结果
        a, b = 1, 2
        sum = 3
        self.assertEqual(a + b, sum, '断言失败，%s + %s != %s' %(a, b, sum))

    # assertNotEqual()方法实例
    def test_assertNotEqual(self):
        # 断言两数之差的结果
        a, b = 5, 2
        res = 1
        self.assertNotEqual(a - b, res, '断言失败，%s - %s != %s' %(a, b, res))

    # assertTrue()方法实例
    def test_assertTrue(self):
        # 断言表达式的为真
        self.assertTrue(1 == 1, "表达式为假")

    # assertFalse()方法实例
    def test_assertFalse(self):
        # 断言表达式为假
        self.assertFalse(3 == 2, "表达式为真")

    # assertIs()方法实例
    def test_assertIs(self):
        # 断言两变量类型属于同一对象

        a = 12
        b = a
        self.assertIs(a, b, "%s与%s不属于同一对象" %(a, b))

    # test_assertIsNot()方法实例
    def test_assertIsNot(self):
        # 断言两变量类型不属于同一对象
        a = 12
        b = "test"
        self.assertIsNot(a, b, "%s与%s属于同一对象" %(a, b))

    # assertIsNone()方法实例
    def test_assertIsNone(self):
        # 断言表达式结果为None
        result = MyClass.retrun_None()
        self.assertIsNone(result, "not is None")

    # assertIsNotNone()方法实例
    def test_assertIsNotNone(self):
        # 断言表达式结果不为None
        result = MyClass.sum(2, 5)
        self.assertIsNotNone(result, "is None")

    # assertIn()方法实例
    def test_assertIn(self):
        # 断言对象A是否包含在对象B中
        strA = "this is a test"
        strB = "is"
        self.assertIn(strB, strA, "%s不包含在%s中" %(strB, strA))

    # assertNotIn()方法实例
    def test_assertNotIn(self):
        # 断言对象A不包含在对象B中
        strA = "this is a test"
        strB = "Selenium"
        self.assertNotIn(strB, strA, "%s包含在%s中" %(strB, strA))

    # assertIsInstance()方法实例
    def test_assertIsInstance(self):
        # 测试对象A的类型是否值指定的类型

        x = MyClass
        y = object
        self.assertIsInstance(x, y, "%s的类型不是%s" %(x, y))

    # assertNotIsInstance()方法实例
    def test_assertNotIsInstance(self):
        # 测试对象A的类型不是指定的类型
        try:
            a = 123
            b = int
            self.assertNotIsInstance(a, b, "%s的类型是%s" %(a, b))
        except AssertionError as e:
            print(e)

    # assertRaises()方法实例
    def test_assertRaises(self):
        # 测试抛出的指定的异常类型
        # assertRaises(exception)
        with self.assertRaises(TypeError) as cm:
            random.sample([1, 2, 3, 4, 5], "j")
            print("===", cm.exception)  # 打印详细的异常信息
        try:
            # assertRaises(exception, callable, *args, **kwds)
            self.assertRaises(ZeroDivisionError, MyClass.div, 3, 0)
        except ZeroDivisionError as e:
            print(e)

    # assertRaisesRegexp()方法实例
    def test_assertRaisesRegexp(self):
        # 测试抛出的指定异常类型，并用正则表达式具体验证
        # assertRaisesRegexp(exception, regexp)
        with self.assertRaisesRegex(ValueError, 'literal') as ar:
            # print(ar.exception)  # 打印详细的异常信息
            int("xyz")
            print("re:", ar.expected_regexp)  # 打印正则表达式
        try:
            self.assertRaisesRegex(ValueError, "invalid literal for.*XYZ'$", int, 'XYZ')
        except AssertionError as e:
            print(e)


if __name__ == '__main__':
    # 执行单元测试
    unittest.main()

执行结果：