ui自动化测试——unittest框架（自动化框架）

一、自动化框架介绍

1、unittest 框架是python中自带的框架

2、作用：管理和组织测试用例

当我们写的用例越来越多，我们就要考虑用例的编写的规范和组织，以便于后期的维护

3、常见的自动化框架：po框架、pytest 框架、unittest框架（我们讲解）

4、unitest 框架自带标准的库：有如下

a、TestCase类  （测试用例）

b、TestSuite类  （测试套件）

c、TestLoader类   （测试路径）

d、TextTestRunner类  （测试运行）

e、TextTestResult类  （测试结果）

f、TestFixture类   （测试前后准备）

-知识点详解-

• TestCase：

一个Testcase的实例就是一个测试用例，测试用例就是一个完整的测试流程，包括初始化setUp、运行run、测试后的还原tearDown

• TestSuite：

对一个功能的测试往往需有多个测试用例，可以把多的测试用例集合在一起执行，这就是TestSuite的概念。常用addTest()方法将一个测试用例添加到测试套件中

• TextTestRunner：

是用来执行测试用例的，其中的run(test)用来执行TestSuite/TestCase。测试的结果会保存在TextTestResult实例中

• TestFixture：

测试准备前要做的工作和测试执行完后要做的工作.包括setUp()和tearDown()。通过覆盖TestCase的setUp和tearDown来实现。

• TestLoader：

是用来搜索所有以test开头的测试用例，然后将其加入到testsuite中去执行

5、unittest的框架的结构：

import unittest       #导入unittest框架
import time
from uizdh.HTMLTestRunnerNew import HTMLTestRunner
class Cms(unittest.TestCase):
    @classmethod
    def setUpClass(cls) -> None:
        print("类开始")
    @classmethod
    def tearDownClass(cls) -> None:
        print("类的结束")
    def setUp(self) -> None:
        print("方法开始")
    def tearDown(self) -> None:
        print("方法结束")
    def test1(self):
        print("1")
    def test2(self):
        print("2")
    def testa(self):
        print("a")
    def testA(self):
        print("A")
    def dy(self):
        print("独有")
if __name__ == '__main__':
    # unittest.main()        #执行所有的用例

类开始

方法开始

1

方法结束

方法开始

2

方法结束

方法开始

A

方法结束

方法开始

a

方法结束

类的结束

*注意点：

• 类的开始，类的结束，方法开始，方法结束都可以不写
• 用例要以test开头，如果没有以test开头就不运行
• test开头的用例运行顺序:  按ascllma标准：0-9  A-Z  a-z
• 类的开始，类的结束在整个框架中就运行一次
• 方法开始和方法结束，每一条用例都执行

6、unittest运行用例

1）执行所有用例

import unittest       #导入unittest框架
import time
from uizdh.HTMLTestRunnerNew import HTMLTestRunner
class Cms(unittest.TestCase):
    @classmethod
    def setUpClass(cls) -> None:
        print("类开始")
    @classmethod
    def tearDownClass(cls) -> None:
        print("类的结束")
    def setUp(self) -> None:
        print("方法开始")
    def tearDown(self) -> None:
        print("方法结束")
    def test1(self):
        print("1")
    def test2(self):
        print("2")
    def testa(self):
        print("a")
    def testA(self):
        print("A")
    def dy(self):
        print("独有")
if __name__ == '__main__':
    # unittest.main()        #执行所有的用例

2）运行部分用例

a、复制代码存在的路径，例如：C:\Users\Administrator.USER-20231114RR\PycharmProjects\untitled12\dd\kj1.py

b、点击编辑路径

c、再python添加解释器

d、执行点击右上角的运行

e、代码

import unittest       #导入unittest框架
import time
from uizdh.HTMLTestRunnerNew import HTMLTestRunner
class Cms(unittest.TestCase):
    @classmethod
    def setUpClass(cls) -> None:
        print("类开始")
    @classmethod
    def tearDownClass(cls) -> None:
        print("类的结束")
    def setUp(self) -> None:
        print("方法开始")
    def tearDown(self) -> None:
        print("方法结束")
    def test1(self):
        print("1")
    def test2(self):
        print("2")
    def testa(self):
        print("a")
    def testA(self):
        print("A")
    def dy(self):
        print("独有")
if __name__ == '__main__':
    # unittest.main()        #执行所有的用例

    # tj=unittest.TestSuite()       # 创建一个套件对象
    # tj.addTest(Cms("test2"))             #将单个添加用例到集合中
    # tj.addTests([Cms("test2"),Cms("testa")])     #将两个或两个以上添加用例到集合中,
    # unittest.TextTestRunner().run(tj)        #通过testrunner运行套件中的用例

3）执行一个路径下的用例

import unittest       #导入unittest框架
import time
from uizdh.HTMLTestRunnerNew import HTMLTestRunner
class Cms(unittest.TestCase):
    @classmethod
    def setUpClass(cls) -> None:
        print("类开始")
    @classmethod
    def tearDownClass(cls) -> None:
        print("类的结束")
    def setUp(self) -> None:
        print("方法开始")
    def tearDown(self) -> None:
        print("方法结束")
    def test1(self):
        print("1")
    def test2(self):
        print("2")
    def testa(self):
        print("a")
    def testA(self):
        print("A")
    def dy(self):
        print("独有")
if __name__ == '__main__':
    # 运行py文件的相对路径
    # path=r"E:\1\python\PycharmProjects\untitled\uizdh"
    # d=unittest.TestLoader().discover(start_dir=path,pattern="kj*.py")
    # unittest.TextTestRunner().run(d)

 

4）运用用例后生成报告

• 固定的报告模板
• 将报告模板放在pycharm中，可以导入使用
• 代码

import unittest       #导入unittest框架
import time
from uizdh.HTMLTestRunnerNew import HTMLTestRunner
class Cms(unittest.TestCase):
    @classmethod
    def setUpClass(cls) -> None:
        print("类开始")
    @classmethod
    def tearDownClass(cls) -> None:
        print("类的结束")
    def setUp(self) -> None:
        print("方法开始")
    def tearDown(self) -> None:
        print("方法结束")
    def test1(self):
        print("1")
    def test2(self):
        print("2")
    def testa(self):
        print("a")
    def testA(self):
        print("A")
    def dy(self):
        print("独有")
if __name__ == '__main__':
    bgpath=r"E:\1\python\PycharmProjects\untitled\uizdh"
    path=r"E:\1\python\PycharmProjects\untitled\uizdh"
    d=unittest.TestLoader().discover(start_dir=path,pattern="kj*.py")
    new=time.strftime("%y-%m-%d %H-%M-%S")
    file=bgpath+"/"+str(new)+"ui.html"
    f=open(file,"bw")
    r=HTMLTestRunner(
        stream=f,title="ui自动化测试报告",description="用例执行情况",
        tester="dcs"
    )
    r.run(d)

•  运行结果

二、框架流程

讲解1：

流程：

我们要建立这个框架，首先需要导入unittest这个模块，我们做自动化的话还需要导入selenium这个模块，以及一些相关的，比方说time模块，OS模块，HTMLTestRunner模块。把我们需要的模块都导入，在unittest里我们需要去定义一个类，定义类名，继承testcase，一个testcase的实例就是一个用例，类里需要有类的开始：setupclass，以及类的结束：teardownclass，然后我们需要去定义我们的用例，test1，test2，注意一定要以test开头，因为TestLoader只搜索所有以test开头的测试用例。写完用例以后，我们需要去调用它，我们以main作为unittest的入口，执行自动化我们主要有4种调用的方式

第一种用unittest.main()去运行所有用例

第二种是创建一个套件TestSuite()，然后用addtest去添加你要执行的用例，这种方法可以执行部分测试用例，不会全部行

第三种就是搜索绝对路径去执行自动化，调用unittest.testloader.discover方法执行用例

第四种是生成测试报告，搜索绝对路径去执行自动化，调用unittest.testloader.discover方法执行用例，然后把执行结果写入我们导入的模板文件，执行之后就能看到我们路径下所有用例的执行结果。

以上就是unittest框架的整个基本流程

 

讲解2：

建立unittest框架流程：

第一步先导入unittest模块：import unittest；然后导入selenium模块：from selenium import webdriver、时间模块：from time import*等。

第二步定义一个类，给这个类取一个类名，继承unittest.testcase，一个testcase就是一个用例，之后定义一个类方法，类方法要有类的开始（setUpClass）和类的结束（tearDownClass）。

第三步进行方法的开始（setUp），每一条用例执行，他们都去执行，之后是方法的结束（tearDown）。

第四步写用例，用例一定要用test开头=》test1、test2，没有以test开头的用例 ，不被运行。

第五步调用函数，使用main方法（if __name__=='__main__':）进行主函数调用。

第六步执行用例，

第一种可以用unittest.main()运行所有用例；

第二种可以创建一个套件TestSuite()，然后用addtest去添加你要执行的用例，这种方法可以执行部分测试用例，不会全部执行；

第三种搜索绝对路径去执行自动化，调用unittest.testloader.discover方法执行用例；

第四种生成测试报告，搜索绝对路径去执行自动化，调用unittest.testloader.discover方法执行用例，然后把执行结果写入我们导入的模板文件，执行之后就能看到我们路径下所有用例的执行结果。

讲解3：

 下面我介绍一下自动化框架的基本流程：自动化框架是用来管理和组织测试用例的，首先我们先导入unittest框架，再导入本次测试应用到的一些模块，比如time模块（进行计时）等等。接下来我们进行类的定义，创建一个类，一个testcase就是一个用例，继承unittest.testcase，定义类需要类的开始setUpClass()和类的结束tearDownClass() ，在整个框架中只运行一次。为了减少代码的冗余，我们需要进行方法的定义，调用的时候直接使用这个方法名就可以了，方法的开始和结束每一条用例都会执行。然后我们进行用例定义，用例要以test开头，如果没有以test开头就不能运行，运行顺序按ascllma标准排序：0-9  A-Z  a-z。

用例编写完成之后，我们进行用例的调用，这里我们有四种方法：

1.unittest.main() #第一种执行方法，执行所有的用例

2.创建一个套件TestSuite()，通过addtest添加用例到套件中，通过TextTestRunner去运行套件中的用例

3.根据运行文件的相对路径执行自动化测试，通过unittest.TestLoader().discover匹配测试路径和文件， unittest.TextTestRunner().run(d) 运行路径d下的用例

4.根据运行文件的相对路径执行自动化测试，通过unittest.TestLoader().discover匹配测试路径和文件，接下来把执行结果写入我们导入的模板文件，执行之后就能看到我们路径下所有用例的执行结果。