單元測試框架Unittest

Unittest官方 4個重要概念：

Test fixture(測試固件):初始化、清除

Test case(測試用例)，test suite(測試套件)，test runner(測試運行器)

兩種單元測試加載方法：

1.unittest.main()

2.將所有test case 添加到test suit中，然后一次性加載

知識點：

1.測試類要繼承unittest.TestCase類

2.每個用例方法 test開頭(self)

3.setUp和tearDown方法在每個用例執行前后都會執行

4.unittest.main()執行同一模塊內unittest子類所有方法

 

實例

被測試模塊 Calc.py 

后續部分用例會引用此模塊

 

# coding=utf-8
class Calc(object):
    def add(self, x, y, *d):
        # 加法計算
        result = x + y
        for i in d:
            result += i
        return result

    def sub(self, x, y, *d):
        # 減法計算
        result = x - y
        for i in d:
            result -= i
        return result

    @classmethod
    def mul(cls, x, y, *d):
        # 乘法計算
        result = x * y
        for i in d:
            result *= i
        return result

    @staticmethod
    def div(x, y, *d):
        # 除法計算
        if y != 0:
            result = x / y
        else:
            return -1
        for i in d:
            if i != 0:
                result /= i
            else:
                return -1
        return result

 

 

 

例子1 用例初始化清除setUp、tearDown

 

#encoding=utf-8
import unittest
import random
class TestSequenceFunctions(unittest.TestCase):
    def setUp(self):
        # 初始化一個遞增序列
        self.seq = range(10)
        print "setup completed!"

    def test_run(self):
        # 從序列seq中隨機選取一個元素
        element = random.choice(self.seq)
        # 驗證隨機元素確實屬於列表中
        self.assertTrue(element in self.seq)

    def test_sth(self):
        assert 1==1

    def tearDown(self):
        print "tearDown completed"

class TestDictValueFormatFunctions(unittest.TestCase):
    def setUp(self):
        self.seq = range(10)

    def test_shuffle(self):
        # 隨機打亂原seq的順序
        random.shuffle(self.seq)
        self.seq.sort()
        self.assertEqual(self.seq, range(10))
        # 驗證執行函數時拋出了TypeError異常
        self.assertRaises(TypeError, random.shuffle, (1, 2, 3))

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

 

例子2 類初始化清除setUpClass(cls)、tearDownClass(cls)

類里所有用例執行前后僅執行一次

 

#encoding=utf-8
import unittest

# 被測試類
class myclass(object):
    @classmethod
    def sum(self, a, b):
        return a + b #將兩個傳入參數進行相加操作

    @classmethod
    def sub(self, a, b):
        return a - b #將兩個傳入參數進行相減操作


class mytest(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        "初始化類固件"
        print "----setUpClass"

    @classmethod
    def tearDownClass(cls):
        "重構類固件"
        print "----tearDownClass"

    # 初始化工作
    def setUp(self):
        self.a = 3
        self.b = 1
        print "--setUp"

    # 退出清理工作
    def tearDown(self):
        print "--tearDown"

    # 具體的測試用例，一定要以test開頭
    def testsum(self):
        # 斷言兩數之和的結果是否是4
        self.assertEqual(myclass.sum(self.a, self.b), 4, 'test sum fail')

    def testsub(self):
        # 斷言兩數之差的結果是否是2
        self.assertEqual(myclass.sub(self.a, self.b), 2, 'test sub fail')


if __name__ == '__main__':
unittest.main() # 啟動單元測試

 

例子3  按特定順序執行用例

unittest框架用例執行順序是按照用例名字符的ASCII碼順序

用例數小於10：可將用例名命名為test加0-9， 按數字由小到大順序執行

用例數大於10：可將用例名字首字母開始命名 a-Z按順序執行，如第一字母相同，則第二字母再按a-Z順序排序，以此類推

suit.addTest(class(‘testcase’)) 按此方式添加的用例會按添加順序執行

 

此代碼需要文本開頭的被測試模塊Calc.py

 

#encoding=utf-8
import unittest
from Calc import Calc

class MyTest(unittest.TestCase):

    @classmethod
    def setUpClass(self):
        print u"單元測試前，創建Calc類的實例"
        self.c = Calc()

    # 具體的測試用例，一定要以test開頭，執行順序按照字母順序開頭
    def test_0add(self):
        print "run add()"
        self.assertEqual(self.c.add(1, 2, 12), 15, 'test add fail')

    def test_1sub(self):
        print "run sub()"
        self.assertEqual(self.c.sub(2, 1, 3), -2, 'test sub fail')

    def test_2mul(self):
        print "run mul()"
        self.assertEqual(Calc.mul(2, 3, 5), 30, 'test mul fail')

    def test_3div(self):
        print "run div()"
        self.assertEqual(Calc.div(8, 2, 4), 1, 'test div fail')

if __name__ == '__main__':
unittest.main()# 啟動單元測試


if __name__ == '__main__':
suite = unittest.TestSuite()
suite.addTest(MyTest(‘test_2mu’))
suite.addTest(MyTest(‘test_1sub’))
runner = unittest.TextTestRunner()
runner.run(suite)

 

例子4 忽略測試方法，不想執行的用例，可跳過

unittet可以分無條件忽略和有條件忽略,通過裝飾器實現

跳過用例時打印括號內后面參數的內容(跳過原因)

@unittest.skip(reason) 裝飾器：無條件跳過裝飾的測試，並說明跳過測試的原因。

@unittest.skipIf(a > 5, "condition is not satisfied!") 條件為真時，跳過裝飾的測試，並說明跳過測試的原因。

@unittest.skipUnless(sys.platform.startswith("linux"), "requires Linux")條件為假時，跳過裝飾的測試，並說明跳過測試的原因。

@unittest.expectedFailure(): expectedFailure()測試標記為失敗。

 

# coding=utf-8
import random
import unittest    
import sys

class TestSequenceFunctions(unittest.TestCase):
    a = 1

    def setUp(self):
        self.seq = list(range(10))

    @unittest.skip("skipping") # 無條件忽略該測試方法
    def test_shuffle(self):
        random.shuffle(self.seq)
        self.seq.sort()
        self.assertEqual(self.seq, list(range(10)))
        self.assertRaises(TypeError, random.shuffle, (1, 2, 3))

    # 如果變量a > 5，則忽略該測試方法
    @unittest.skipIf(a > 5, "condition is not satisfied!")
    def test_choice(self):
        element = random.choice(self.seq)
        self.assertTrue(element in self.seq)

    # 除非執行測試用例的平台是Linux平台，否則忽略該測試方法是windows
    @unittest.skipUnless(sys.platform.startswith("linux"), "requires Linux")
    def test_sample(self):
        with self.assertRaises(ValueError):
            random.sample(self.seq, 20)
        for element in random.sample(self.seq, 5):
            self.assertTrue(element in self.seq)


if __name__ == '__main__':
    # unittest.main()
    Case = unittest.TestLoader().loadTestsFromTestCase(TestSequenceFunctions)
    suite = unittest.TestSuite(Case)
unittest.TextTestRunner(verbosity = 2).run(suite)

 

例子5 測試集合，批量執行測試用例

根據給定的測試類，獲取其中的所有以“test”開頭的測試方法，並返回一個測試套件

suite1=unittest.TestLoader().loadTestsFromTestCase(Class)

將多個測試類加載到測試套件中

suite = unittest.TestSuite([suite2, suite1,suite3]) 

通過調整suit2和suite1的順序，可以設定執行順序

設置verbosity = 2，可以打印出更詳細的執行信息

unittest.TextTestRunner(verbosity = 2).run(suite)

 

 

方式1：模塊中直接調用unittest.main() 

此代碼需要文本開頭的被測試模塊Calc.py

此代碼模塊名：TestCalc.py（下一段代碼會用到）

 

 

#encoding=utf-8
import unittest
import random
from Calc import Calc

class TestCalcFunctions(unittest.TestCase):
    def setUp(self):
        self.c=Calc()
        print "setup completed!"

    def test_sum(self):
        self.assertTrue(self.c.add(1,2,3,4)==10)
        
    def test_sub(self):
        self.assertTrue(self.c.sub(100,20,30,40)==10)

    def test_mul(self):
        self.assertTrue(self.c.mul(1,2,3,40)==240)

    def test_div(self):
        self.assertTrue(self.c.div(100,10,2)==5)

    def tearDown(self):
        
        print "test completed!"

        
    def tearDown(self):
        print "tearDown completed"

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

 

 

方式2：測試用例類加載到一個套件中

 

 

#encoding=utf-8
import random
import unittest
from TestCalc import TestCalcFunctions
class TestSequenceFunctions(unittest.TestCase):
    def setUp(self):
        self.seq = range(10)

    def tearDown(self):
        pass

    def test_choice(self):
        # 從序列seq中隨機選取一個元素
        element = random.choice(self.seq)
        # 驗證隨機元素確實屬於列表中
        self.assertTrue(element in self.seq)

    def test_sample(self):
        # 驗證執行的語句是否拋出了異常
        with self.assertRaises(ValueError):
            random.sample(self.seq, 20)
        for element in random.sample(self.seq, 5):
            self.assertTrue(element in self.seq)


class TestDictValueFormatFunctions(unittest.TestCase):
    def setUp(self):
        self.seq = range(10)

    def tearDown(self):
        pass

    def test_shuffle(self):
        # 隨機打亂原seq的順序
        random.shuffle(self.seq)
        self.seq.sort()
        self.assertEqual(self.seq, range(10))
        # 驗證執行函數時拋出了TypeError異常
        self.assertRaises(TypeError, random.shuffle, (1, 2, 3))

if __name__ == '__main__':
    # 根據給定的測試類，獲取其中的所有以“test”開頭的測試方法，並返回一個測試套件
    suite1=unittest.TestLoader().loadTestsFromTestCase(TestSequenceFunctions)
    suite2= unittest.TestLoader().loadTestsFromTestCase(TestDictValueFormatFunctions)
    suite3 = unittest.TestLoader().loadTestsFromTestCase(TestCalcFunctions)
    # 將多個測試類加載到測試套件中
    suite = unittest.TestSuite([suite2, suite1,suite3])  #通過調整suit2和suite1的順序，可以設定執行順序
    # 設置verbosity = 2，可以打印出更詳細的執行信息
    unittest.TextTestRunner(verbosity = 2).run(suite)

 

例子6 斷言

self.assertRaises(TypeError,callable,argvs)驗證執行函數時拋出了TypeError異常

執行用例時出現異常，該用例會打印一個E；斷言失敗則會打印F，代表Fail

 

#encoding=utf-8
import unittest
import random

# 被測試類
class MyClass(object):
    @classmethod
    def sum(self, a, b):
        return a + b

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

    @classmethod
    def retrun_None(self):
        return None

# 單元測試類
class MyTest(unittest.TestCase):

    # assertEqual()方法實例
    def test_assertEqual(self):
        # 斷言兩數之和的結果
        try:
            a, b = 1, 2
            sum = 3
            self.assertEqual(a + b, sum, '斷言失敗，%s + %s != %s' %(a, b, sum))
        except AssertionError, e:
            print e

    # assertNotEqual()方法實例
    def test_assertNotEqual(self):
        # 斷言兩數之差的結果
        try:
            a, b = 5, 2
            res = 1
            self.assertNotEqual(a - b, res, '斷言失敗，%s - %s != %s' %(a, b, res))
        except AssertionError, e:
            print e

    # assertTrue()方法實例
    def test_assertTrue(self):
        # 斷言表達式的為真
        try:
            self.assertTrue(1 == 1, "表達式為假")
        except AssertionError, e:
            print e

    # assertFalse()方法實例
    def test_assertFalse(self):
        # 斷言表達式為假
        try:
            self.assertFalse(3 == 2, "表達式為真")
        except AssertionError, e:
            print e

    # assertIs()方法實例
    def test_assertIs(self):
        # 斷言兩變量類型屬於同一對象
        try:
            a = 12
            b = a
            self.assertIs(a, b, "%s與%s不屬於同一對象" %(a, b))
        except AssertionError, e:
            print e

    # test_assertIsNot()方法實例
    def test_assertIsNot(self):
        # 斷言兩變量類型不屬於同一對象
        try:
            a = 12
            b = "test"
            self.assertIsNot(a, b, "%s與%s屬於同一對象" %(a, b))
        except AssertionError, e:
            print e

    # assertIsNone()方法實例
    def test_assertIsNone(self):
        # 斷言表達式結果為None
        try:
            result = MyClass.retrun_None()
            self.assertIsNone(result, "not is None")
        except AssertionError, e:
            print e

    # assertIsNotNone()方法實例
    def test_assertIsNotNone(self):
        # 斷言表達式結果不為None
        try:
            result = MyClass.sum(2, 5)
            self.assertIsNotNone(result, "is None")
        except AssertionError, e:
            print e

    # assertIn()方法實例
    def test_assertIn(self):
        # 斷言對象A是否包含在對象B中
        try:
            strA = "this is a test"
            strB = "is"
            self.assertIn(strB, strA, "%s不包含在%s中" %(strB, strA))
        except AssertionError, e:
            print e

    # assertNotIn()方法實例
    def test_assertNotIn(self):
        # 斷言對象A不包含在對象B中
        try:
            strA = "this is a test"
            strB = "Selenium"
            self.assertNotIn(strB, strA, "%s包含在%s中" %(strB, strA))
        except AssertionError, e:
            print e

    # assertIsInstance()方法實例
    def test_assertIsInstance(self):
        # 測試對象A的類型是否值指定的類型
        try:
            x = MyClass
            y = object
            self.assertIsInstance(x, y, "%s的類型不是%s".decode("utf-8") %(x, y))
        except AssertionError, e:
            print e

    # assertNotIsInstance()方法實例
    def test_assertNotIsInstance(self):
        # 測試對象A的類型不是指定的類型
        try:
            a = 123
            b = str
            self.assertNotIsInstance(a, b, "%s的類型是%s" %(a, b))
        except AssertionError, e:
            print e

    # assertRaises()方法實例
    def test_assertRaises(self):
        # 測試拋出的指定的異常類型
        # assertRaises(exception)
        with self.assertRaises(ValueError) as cm:
            random.sample([1,2,3,4,5], "j")
        # 打印詳細的異常信息
        #print "===", cm.exception

        # assertRaises(exception, callable, *args, **kwds)
        try:
            self.assertRaises(ZeroDivisionError, MyClass.div, 3, 0)
        except ZeroDivisionError, e:
            print e

    # assertRaisesRegexp()方法實例
    def test_assertRaisesRegexp(self):
        # 測試拋出的指定異常類型，並用正則表達式具體驗證
        # assertRaisesRegexp(exception, regexp)
        with self.assertRaisesRegexp(ValueError, 'literal') as ar:
            int("xyz")
        # 打印詳細的異常信息
        #print ar.exception
        # 打印正則表達式
        #print "re:",ar.expected_regexp

        # assertRaisesRegexp(exception, regexp, callable, *args, **kwds)
        try:
            self.assertRaisesRegexp(ValueError, "invalid literal for.*XYZ'$", int, 'XYZ')
        except AssertionError, e:
            print e


if __name__ == '__main__':
    # 執行單元測試
unittest.main()

 

例子7 生成報告

 

把HTMLTestRunner.py和執行程序文件放置同一目錄

 

# coding=utf-8
import unittest
import HTMLTestRunner
import math

class Calc(object):

    def add(self, x, y, *d):
        # 加法計算
        result = x + y
        for i in d:
            result += i
        return result

    def sub(self, x, y, *d):
        # 減法計算
        result = x - y
        for i in d:
            result -= i
        return result

class SuiteTestCalc(unittest.TestCase):
    def setUp(self):
        self.c = Calc()

    @unittest.skip("skipping")
    def test_Sub(self):
        print "sub"
        self.assertEqual(self.c.sub(100, 34, 6), 61, u'求差結果錯誤！')

    def testAdd(self):
        print "add"
        self.assertEqual(self.c.add(1, 32, 56), 89, u'求和結果錯誤！')


class SuiteTestPow(unittest.TestCase):
    def setUp(self):
        self.seq = range(10)

    # @unittest.skipIf()
    def test_Pow(self):
        print "Pow"
        self.assertEqual(pow(6, 3), 2161, u'求冪結果錯誤！')

    def test_hasattr(self):
        print "hasattr"
# 檢測math模塊是否存在pow屬性
        self.assertTrue(hasattr(math, 'pow1'), u"檢測的屬性不存在！")

if __name__ == "__main__":
    suite1 = unittest.TestLoader().loadTestsFromTestCase(SuiteTestCalc)
    suite2 = unittest.TestLoader().loadTestsFromTestCase(SuiteTestPow)
    suite = unittest.TestSuite([suite1, suite2])
    #unittest.TextTestRunner(verbosity=2).run(suite)
    filename = "test.html"  # 定義個報告存放路徑，支持相對路徑。
    # 以二進制方式打開文件，准備寫
    fp = file(filename, 'wb')
    # 使用HTMLTestRunner配置參數，輸出報告路徑、報告標題、描述，均可以配
    runner = HTMLTestRunner.HTMLTestRunner(stream = fp,
        title = 'Report_title', description = 'Report_description')
    # 運行測試集合
    runner.run(suite)

 

例子8 批量執行多個模塊生成報告

1程序文件模式

即將測試發現代碼編寫在測試腳本中，然后直接執行腳本文件即可，具體由

TestLoader().discover(dir)實現，dir為被測試模塊目錄

模塊名需test開頭，測試方法也要test開頭，類名不需要test開頭

 

 

#coding=utf-8
import unittest
import HTMLTestRunner
 
if __name__ == '__main__' :
    # 加載當前目錄下所有有效的測試模塊（以test開頭的文件），“.”表示當前目錄
    testSuite = unittest.TestLoader().discover('.')
    filename = "test.html"  # 定義個報告存放路徑，支持相對路徑。
    # 以二進制方式打開文件，准備寫
    fp = file(filename, 'wb')
    # 使用HTMLTestRunner配置參數，輸出報告路徑、報告標題、描述，均可以配
    runner = HTMLTestRunner.HTMLTestRunner(stream = fp,
        title = 'Report_title', description = 'Report_description')
    # 運行測試集合
runner.run(testSuite)

 

 

2命令行模式

unittest支持簡單的test discovery. 命令行傳入discovery后,框架會自動在當前目錄搜索要測試的案例並執行.搜索目錄必須是包或者模塊.基本使用如下:

python -m unittest discover

子選項如下:
-v, –verbose

python -m unittest discover -v
輸出信息的詳細級別

-s, –start-directory directory

python -m unittest discover -s other_dir
開始搜索目錄 (默認為當前目錄)

-p, –pattern pattern

python -m unittest discover -p ‘YW*.py’
匹配的文件名 (默認為test*.py)

-t, –top-level-directory directory

python -m unittest discover -t g:\
搜索的頂層目錄 (默認為start directory)

 

 

例子9 webdriver和unittest結合

#encoding=utf-8
import unittest
from selenium import webdriver
import time

class WebTest(unittest.TestCase):
    def setUp(self):
        # 啟動Firefox瀏覽器
        self.driver=webdriver.Firefox(executable_path = "d:\\driver\geckodriver")

    def testSoGou(self):
        # 訪問搜狗首頁
        self.driver.get("http://sogou.com")
        # 清空搜索輸入框默認內容
        self.driver.find_element_by_id("query").clear()
        # 在搜索輸入框中輸入“自動化測試”
        self.driver.find_element_by_id("query").send_keys(u"自動化測試")
        # 單擊“搜索”按鈕
        self.driver.find_element_by_id("stb").click()
        # 等待3秒
        time.sleep(3)
        assert u"web自動化" in self.driver.page_source, u"頁面中不存在要尋找的關鍵字！".encode("gbk")


    def testBing(self):
        # 訪問搜狗首頁
        self.driver.get("http://cn.bing.com")
        # 清空搜索輸入框默認內容
        self.driver.find_element_by_id("sb_form_q").clear()
        # 在搜索輸入框中輸入“自動化測試”
        self.driver.find_element_by_id("sb_form_q").send_keys(u"自動化測試")
        # 單擊“搜索”按鈕
        self.driver.find_element_by_id("sb_form_go").click()
        # 等待3秒
        time.sleep(3)
        assert u"web自動化" in self.driver.page_source, u"頁面中不存在要尋找的關鍵字！".encode("gbk")


    def tearDown(self):
        # 退出瀏覽器
        self.driver.quit()

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

例子10 補充:命令行模式執行測試用例

1.     運行整個測試模塊

python -m unittest test_module1 test_module2……

2.     執行測試模塊中某個測試類

python -m unittest test_module.TestClass

3.     執行測試模塊中某個測試類下的測試方法

python -m unittest test_module.TestClass.test_method

 

練習

 

寫一個讀文件的類，里面有個方法可以讀取文件的全部內容。

 

寫個單元測試，斷言文件中包含關鍵字"well done!"

 

#被測試模塊：readcont.py

#coding=utf-8
import unittest
import os.path

class TestReadContent():
    @staticmethod
    def read_content(filepath):
        if os.path.exists(filepath):
            with open(filepath) as fp:
                return fp.read()
        else:
            return ''
if __name__=='__main__':
    fcon = TestReadContent.read_content('g:/a.txt')
    print fcon

#單元測試模塊：

#coding= utf-8
import unittest
from readcont import TestReadContent

class TestRead(unittest.TestCase):
    def test_run(self):
        content = TestReadContent.read_content('g:/a.txt')
        self.assertTrue('well done!' in content )

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