08.24python单元测试之unittest

一.单元测试,集成测试,功能测试

单元测试

        颗粒度最小,一般由开发小组采用白盒方式来测试,主要测试单元是否符合"设计":是指对软件中的最小可测试单元进行检查和验证

 集成测试

介于单元测试和系统测试之间,一般由开发小组采用白盒+黑盒的方法来测试,即验证"设计"又验证"需求",主要用来测试模板之间的接口,同时还要测试一些主要的业务功能

 功能测试

        颗粒度最大,一般由独立的测试小组采用黑盒的方式来测试,主要测试系统是否符合"需求规格说明书"        

白盒：主要应用于单元测试阶段，主要是对代码级别的测试，针对程序内部的逻辑结构。测试的手段有：语句 覆盖、判定覆盖、条件覆盖、路径覆盖和条件组合覆盖

黑盒： 不考虑程序内部结构和逻辑结构，主要是测试系统的功能是否满足 “ 需求规格说明书 ” 。一般会有一个 输入值和一个输出值，和期望值做比较。

 二.unittest重要组成

        python中有一个自带的单元测试框架是unittest模块,用它来做单元测试,它里面封装好了一些校验返回的结果方法(断言)和一些用例执行前的初始化操作

 unittest中最核心的部分是：TestFixture、TestCase、TestSuite、TestRunner

 2.1TestFixture

作用:

用于一个测试环境的准备和销毁还原。

功能:

        当测试用例每次执行之前需要准备测试环境，每次测试完成后还原测试环境，比如执行前连接数据库、打 开浏览器等，执行完成后需要还原数据库、关闭浏览器等操作。这时候就可以启用testfixture

 主要方法:

setUp(): 准备环境,执行每个测试用例的前置条件

tearDown():环境还原,执行每个测试用例的后置条件

seUpClass():必须使用@classmethod装饰器,所有case执行的前置条件,只运行一次

tearDownClass():必须使用@classmehtod装饰器,所有case运行完后只运行一次

2.2 TestCase:测试用例

定义

一个类 class 继承 unittest.TestCase ，就是一个测试用例

 什么是测试用例?

        就是一个完整的测试流程，包括测试前准备环境的搭建(setUp) ，执行测试代码 (run) ，以及测试后环 境的还原(tearDown) 。

 测试用例命名规则

        继承自unittest.TestCase 的类中，测试方法的名称要以 test 开头。且只会执行以 test 开头定义的 方法（测试方法）, 测试用例执行的顺序会按照方法名的 ASCII 值排序。

如果想跳过某个测试用例，需要添加 @unittest.skip)(‘ 描述信息 ')

 代码:

import unittest
class Calc(unittest.TestCase):
    def setUp(self) -> None:  #测试用例方法执行前的操作
        print("开始")
    def test001(self):  #测试用例
        a=4
        self.assertEqual(a,5)
def tearDown():   #测试用例方法执行后的操作
        print("结束")
if __name__ == '__main__':
    unittest.main()  #调用测试用例中以test开头的方法

​

2.3TestSuite

测试套件，可以将多个测试用例集合在一起，能一起执行选中的测试用例

 方式一:

import unittest
suite=unittest.TestSuite()   #创建测试套件
case_list=["test1","test2"]
for case in case_list:
    suite.addTest(类名(case))

方式二:

import unittest
suite=unittest.TestSuite() #创建测试套件
        suite.addTest(类名("test1"))
        suite.addTest(类名("test1"))

方式三:

import unittest
suite=unittest.TestSuite()  #创建测试套件
loader=unittest.TestLoader() #创建一个加载对象
suite.addTest(loader.loadTestsFromTestCase(类名))

2.4TextRunner

 执行测试用例

通过TextTestRunner类提供的run()方法来执行test suite / test cas

格式

runner = unittest.TextTestRunner(verbosity=2)

runner . run ( suite )

 注释

verbosity ：表示测试报告信息的详细程度，一共三个值，默认是 2

0 ( 静默模式 ) ：你只能获得总的测试用例数和总的结果，如：总共 100 个 失败 10 成功 90

1 ( 默认模式 ) ：类似静默模式，只是在每个成功的用例前面有个 . 每个失败的用例前面有个 F

2 ( 详细模式 ) ：测试结果会显示每个测试用例的所有相关的信息

 三:断言

验证预期结果和实际结果

assertEqual(a,b): 断言 a 和 b 是否相等，相等则测试用例通过。

assertNotEqual(a,b): 断言 a 和 b 是否相等，不相等则测试用例通过。

assertTrue(x) ：断言 x 是否 True ，是 True 则测试用例通过。

assertFalse(x) ：断言 x 是否 False ，是 False 则测试用例通过。

assertIs(a,b): 断言 a 是否是 b ，是则测试用例通过。

assertNotIs(a,b): 断言 a 是否是 b ，不是则测试用例通过。

assertIsNone(x) ：断言 x 是否 None ，是 None 则测试用例通过。

assertIsNotNone(x) ：断言 x 是否 None ，不是 None 则测试用例通过。

assertIn(a,b) ：断言 a 是否在 b 中，在 b 中则测试用例通过。

assertNotIn(a,b) ：断言 a 是否在 b 中，不在 b 中则测试用例通过。

assertIsInstance(a,b) ：断言 a 是是 b 的一个实例，是则测试用例通过。

assertNotIsInstance(a,b) ：断言 a 是是 b 的一个实例，不是则测试用例通过。

四:生成测试报告 

        html格式的就是 HTMLTestRunner 了， HTMLTestRunner 是 Python 标准库的 unittest 框架的 一个扩展，它可以生成一个直观清晰的 HTML 测试报告。使用的前提就是要下载 HTMLTestRunner.py

格式:

with open("./reporter.html","wb") as f:
    HTMLTestRunner(
        stream=f, 
    title="单元测试",
        description="测试一期", 
        verbosity=2
    ).run(suite)

相关参数: 

stream：指定输出的方式

description：报告中要显示的面熟信息

title：测试报告的标题

verbosity ：表示测试报告信息的详细程度，一共三个值，默认是2

 五:操作

1:导入unittest模块  >>> import unittest

2:编写一个类继承unittest.TestCase

3:调用setUp(self),tearDown(self)方法实现测试用例前后阶段的操作

4:编写测试用例方法

        (1)该方法必须以test开头,否则在unittest.main()中调用测试找不到该方法

        (2)设置断言进行判断,,输入数据和输出数据的逾期结果

5:创建套件,将多个测试用例存放在套件中,一并执行()

6.生成测试报告(python自带或者导入HYMLTESTRUNNER生成html格式的测试报告)

7.运行测试用例unittest.main()调用测试用例中以test开头的方法

六:代码展示 

开发被测代码

class Calc():
    def add(self,a,b):
        c =a+b
        return c
    def redc(self,a,b):
        c = a-b
        print(c)
if __name__ == "__main__":
        c = Calc()
        c.add(2,3)
        print(c.add(2,3))

 单元测试代码

from day.Calc import Calc
import unittest
c = Calc() #实例化开发的类
class Test(unittest.TestCase):#unittest单元测试类必须继承unittest.TestCase
    def setUp(self): #测试用例之前执行
        print("start")
    def test001(self):#测试用例必须test开头
        res = c.add(2,1) #调取相加的方法
        self.assertEqual (res,5) #断言,预期结果和实际结果的对比
    def test002(self):#测试用例必须test开头
        res = c.redc(2,3) #调取相减的方法
        self.assertEqual (res,-1) #断言,预期结果和实际结果的对比
        def tearDown(self):#测试用例结束之后执行
            print("end")
if __name__ == '__main__': 
    unittest.main()

七：读取文件

读取xml文件

from xml.dom import minidom
class Readxml():
    def read_xml(self,filename,onename,twoname):
        root =minidom.parse(filename)
        firstnode =root.getElementsByTagName(onename)[0]
        secondnode=firstnode.getElementsByTagName(twoname)[0].firstChild.data
        return secondnode

读取csv文件

import csv #导入csv模块 
class ReadCsv(): 
    def read_csv(self): 
        item =[] #定义一个空列表 
        c = csv.reader(open("../commonDemo/test1.csv","r")) #得到csv文件对象 
        for csv_i in c: 
            item.append(csv_i) #将获取的数据添加到列表中 
        return item     
r = ReadCsv() 
print(r.read_csv())

作业:

1 ：单元测试：测试开发的加减乘除函数传递两个参数

2 ：通过 csv 文件和 xml 文件读取数据进行单元测试并生成 html 格式的测试报告

csv格式

demo

class Clac():
    def chufa(self,a,b):
        return a/b
    def jiafa(self,a,b):
        return a+b
    def chengfa(self,a,b):
        return a*b
    def jianfa(self,a,b):
        return a-b
# c=Clac()
# # print(c.chufa(3,2))

data

9,3,12
8,4,4
3,3,9
8,4,2

readdata

import csv
class ReadCsv():
    def read_csv(self):
        item=[]
        file=csv.reader(open("../data/testcsv.csv","r"))
        for i in file:
            item.append(i)
        return item
if __name__ == '__main__':
    r=ReadCsv()
    print(r.read_csv())

test

c=Clac()
r=ReadCsv()
i = r.read_csv()
class TestCsv(unittest.TestCase):
    def test001(self):
        self.assertEqual(int(i[0][2]),c.jiafa(int(i[0][1]),int(i[0][0])))

    def test002(self):
        self.assertEqual(int(i[1][2]), c.jianfa(int(i[1][0]), int(i[1][1])))

    def test003(self):
        self.assertEqual(int(i[2][2]), c.chengfa(int(i[2][1]), int(i[2][0])))

    def test004(self):
        self.assertEqual(int(i[3][2]), c.chufa(int(i[3][0]), int(i[3][1])))
if __name__ == '__main__':
    unittest.main()

report

import unittest
from test.testcsv import TestCsv
from common.HTMLTestRunner import HTMLTestRunner
class TestClass():
    def export_csv_report(self):
        suite=unittest.TestSuite()  #创建测试套件
        a=["test001","test002","test003","test004"]
        for ii in a:
            suite.addTest(TestCsv(ii))
        with open("./report1.html","wb")as f:
            HTMLTestRunner(
                stream=f,
                title="作业csv方法",
                description="描述",
                verbosity=2
            ).run(suite)
t=TestClass()
t.export_csv_report()

 

xml格式

demo

class Clac():
    def chufa(self,a,b):
        return a/b
    def jiafa(self,a,b):
        return a+b
    def chengfa(self,a,b):
        return a*b
    def jianfa(self,a,b):
        return a-b
# c=Clac()
# # print(c.chufa(3,2))

data

<?xml version="1.0" encoding="UTF-8" ?>
<root>
    <add>
        <add1>1</add1>
        <add2>3</add2>
        <add3>4</add3>
    </add>
    <jian>
        <add1>9</add1>
        <add2>3</add2>
        <add3>6</add3>
    </jian>
    <cheng>
        <add1>3</add1>
        <add2>3</add2>
        <add3>9</add3>
    </cheng>
    <chu>
        <add1>8</add1>
        <add2>4</add2>
        <add3>2</add3>
    </chu>
</root>

readdata

from xml.dom import minidom
class Read():
    def Read_xml(self,file,first,second):
        file=minidom.parse(file)
        firstnode=file.getElementsByTagName(first)[0]
        secondnode=firstnode.getElementsByTagName(second)[0].firstChild.data
        return secondnode
# r=Read()
# print(r.Read_xml("../data/testxml.xml","jian","add1"))

test

import unittest
from demo.jjcc import Clac
from readdata.readxml import Read
c=Clac()
r=Read()
add1=r.Read_xml("../data/testxml.xml","add","add1")
add2=r.Read_xml("../data/testxml.xml","add","add2")
add3=r.Read_xml("../data/testxml.xml","add","add3")
jian1=r.Read_xml("../data/testxml.xml","jian","add1")
jian2=r.Read_xml("../data/testxml.xml","jian","add2")
jian3=r.Read_xml("../data/testxml.xml","jian","add3")
cheng1=r.Read_xml("../data/testxml.xml","cheng","add1")
cheng2=r.Read_xml("../data/testxml.xml","cheng","add2")
cheng3=r.Read_xml("../data/testxml.xml","cheng","add3")
chu1=r.Read_xml("../data/testxml.xml","chu","add1")
chu2=r.Read_xml("../data/testxml.xml","chu","add2")
chu3=r.Read_xml("../data/testxml.xml","chu","add3")
class TesrtClass(unittest.TestCase):
    def test_001(self):      #加法
        self.assertEqual(int(add3),c.jiafa(int(add1),int(add2)))
    def test_002(self):     #减法
        self.assertEqual(int(jian3), c.jianfa(int(jian1), int(jian2)))
    def test_003(self):     #乘法
        self.assertEqual(int(cheng3), c.chengfa(int(cheng1), int(cheng2)))
    def test_004(self):     #除法
        self.assertEqual(int(chu3), c.chufa(int(chu1), int(chu2)))
if __name__ == '__main__':
    unittest.main()

report

import unittest
from test.test001 import TesrtClass
from common.HTMLTestRunner import HTMLTestRunner
class TestJiaJianChengChuClass():
    def export_test_html_report(self):
        suite=unittest.TestSuite()#创建测试套件
        a=["test_001","test_002","test_003","test_004"]
        for i in a:
            suite.addTest(TesrtClass(i))
        with open("./report.html","wb")as f:
            HTMLTestRunner(
                stream=f,
                title="20220824作业",
                description="描述",
                verbosity=2
            ).run(suite)
t=TestJiaJianChengChuClass()
t.export_test_html_report()

 (￣▽￣)~*------ ٩(๑❛ᴗ❛๑)۶谢谢阅读！！！！！！！！！！！！！