自動化七：單元測試框架五

單元測試框架：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()

執行結果：