pytest自动化测试框架，真正做到从0到1由浅入深详细讲解【万字级】_pytest框架详解

​

一：框架简介

pytest，rf（学关键字语法，报告漂亮），unitest
pytest是python的第三方单元测试框架，可以做系统测试，比unitest更简洁和高效，执行315种以上的插件，

同时兼容unittest框架，在unittest框架迁移到pytest框架的代码不需要重写代码
unittest框架迁移到pytest框架的时候不需要重写代码
纯python代码的自动化测试框架

1：Pytest框架简介：

接口测试方案：python

一：工具类：纯手工测试，用工具来做（postman jemeter soapui）–入门简单，不好扩展（后面很多框架定制化）
二：代码类：现成的python框架：unitest(单元测试比较多，最原始的解释器自带的，不需要安装，不支持定制化，分布式) pytest（高级，效率高，支持定制化） nose
rf（报告篇评论，需要学会–封装关键字）
pytest和nose都是unitest扩展的更高级的一个库，框架，基于unitest
三：测试平台：现成平台，公司自己定制开发的，不对外 （融合jmeter，）　　综合平台
前端
后端
执行机制----框架pytest（一般融合了禅道，框架，邮件各种功能）

pytest是python的第三方单元测试框架，可以做系统测试，比unitest更简洁和高效，支持315种以上的插件，

同时兼容unittest框架，在unittest框架迁移到pytest框架的代码不需要重写代码
unittest框架迁移到pytest框架的时候不需要重写代码
纯python代码的自动化测试框架

pytest对比unitest框架的优势：高级，效率高，支持定制化，支持分布式，支持315种以上的丰富插件，还能向下兼容unitest

pytest灵活：

1：定制化（定制化用例执行，定制化报告）

2：环境清除也灵活   　　以及各方面做的都比unittest更加灵活

pytest更加灵活，便捷，效率更高，　　还支持分布式（分布式是其他框架做不了）

分布式：1000个接口用例怎么跑，一条条跑很费劲，时间长，找几个同时分担执行测试用例（pytets独有的性质）

2：pytest框架环境搭建：

pip pytest 　　　　　　　　　　　　　　  安装pytest
pip install pytest-html 　　　　　　 　　  安装原生态报告模板–自带的（有点垃圾）
Required-by: pytest-xdist(分布式测试), pytest-metadata, pytest-html, pytest-forked, allure-pytest
100个接口用例，正常是一个个用例跑，时间很长，
分布式-多个业务用例多条线来跑，提高效率（分布式设计用例—分布式逻辑设计，不要出现耦合，关联性太强的东西，否则会等待的）

3:pytets执行测试用例

设计测试用例时候注意点（必须遵循的规则，否者不识别）：

1：.py测试文件必须以test（test_xxx）开头（或者以_test结尾）
2：测试类必须以Test开头，并且不能有init方法-----测试类Test开头
3：测试方法必须以test_开头
4：断言必须使用assert

4：一般做项目是新建package包的

项目文件
lib库文件　　　　（登录接口源代码，其他接口公共的类,封装的库，登录的，订单的）（包）
data文件　　　　（参数化数据，excel文件，yaml文件，csv文件—测试文件，用例，文档）(可以是普通文件夹)
test_case文件　　（放测试用例的 ）（包）
test_func01.py（测试用例，写的最好见名知意）
report文件　　　　（存放测试报告的普通文件夹）
config　　　　　　（配置文件）

5：pytest函数级别

函数级别的测试用例必须test_开头：如下test_tc01，test_tc02两个测试用例

import pytest
    def test_tc01():　　　　#定义函数类型测试用例　　
        assert 1+1==2  　　#断言
    def test_tc02():
        assert 1+1==3  　　#断言

    if __name__ == '__main__':
        pytest.main(["test_func01.py"])        #我主动运行我的pytest框架(自动调用所有的test测试函数，按照顺序依次运行，test开头的用例自动识别）

6：pytest类级别（工作一般以类位单元，一个模块一个类，登录类，订单类，购物类）

类级别的测试l类必须以Test开头，并且类李不能有init方法，类里面的函数都是test_开头

封装好函数和类就行，其他的交给框架，设置好，框架帮你自动组织怎么运行

封装为了分层，后面更好维护，代码结构整洁

import pytest

class Test_login():  　　　　　　　　　　　　#登录模块的测试类
　　def test_login01(self):
    print("---test_login01----")
    assert 1 + 1 == 2
　　def test_login02(self):
    print("---test_login02----")
    assert 1 + 1 == 3
if __name__ == '__main__':
　　pytest.main(["test_func01.py","-s"])  #框架自己调用函数　　需要打印对应的信息，需要在列表里面加-s

7：自动化测试里面的环境初始化与清除

环境初始化目的：

清空测试环境的垃圾数据，前置条件

需不需要分层：需要

**比如：**课程模块：课程模块的初始化需要

1：删除所有的课程

2：新增我们的一些课程（这个给修改/查询/删除接口使用）　　模块级别的（大的课程模块第一件事就是删除以前的课程）

干掉数据后假如需要删除课程，这个接口需要单独的fixture的初始化，增加课程才能删除，其他的接口不需要这个fixture初始化，）

分层：模块层次的初始化，某个接口也需要初始化----框架的分层

条件初始化要和接口挂钩，接口该怎么就要怎么设计

环境初始化和清除，

一头一尾，两个不同概念，（环境的初始化也可以是清除数据）
一个接口可以多个级别的fixture，可以

分布式：1：并行执行  2：分布式

优化运行时间：分布式，（搭建环境麻烦）

什么是环境初始化：

做这个用例之前想要做个操作，初始化动作，比如登录，首先需要连上这个项目(要先能ping通)，

环境初始化–比如课程新增需要数据全部清空，也是环境初始化

功能测试：保证测试环境数据和跑什么系统的，或者后台有什么进程执行，或者项目里面测试这功能，功能里面有没有垃圾数据要清除　　做个初始化

unittest：最基础的框架，python自带（环境初始化和数据清除用setup和teardown）

jemeter：也有环境清除和初始化

不管做什么测试比如（功能，自动化，性能）都要对当前测试环境初始化，做完后要垃圾数据进行回收（特别是自动化，不然很多用例明明是对的会失败）

每次做一个场景，模块的时候，看看模块有没有需要前置的或者环境清除的步骤（基本操作流程）

pytest是unittest的升级版，对环境清除操作非常灵活（分层分级）

pytest：fixture操作类进行环境初始化  @fixture这样的一个装饰器

pytest的fixture操作

环境初始化与清除

pytest提供的fixture实现unitest中的setup/teardown功能，可以在每次执行case之前初始化数据

不同的是，fixture可以只在执行某几个特定case前运行，只需要在运行case前调用即可，比setup/teardown使用灵活

pytest的****初始化和清除可以类里面写个setup_class方法做，以类为单元，模块，包，方法为单元都可以，也可以用fixture来做

8：pytest前置和后置条件（环境初始化与清除）

环境初始化

1：清除以前的数据

2：测试的时候不是每个接口都要执行，可以定制化执行，固定执行某些接口，先执行删除用例，

但是数据已经被清除了，无法删除，修改–需要新增一批测试数据，所以这时候需要环境初始化和清除的想法

setup_class：类里面类级别的初始化，teardown

pytest初始化和前置条件,很多接口用例本身需要初始化,初始化分为很多层，

可以在整个外面做，也可以在里面做，测试类的初始化可以在类里面定义

 import pytest
    class Test_login():  　　　　　　　　　　#登录模块的测试类
        #该测试类---有个前置的操作（初始化）
        def setup_class(self):　　　　　　#类级别的初始化--可选项
            #一个项目，先登录，再购物，登录就是购物类的前置条件，可以放在setup_class里面
            print("执行测试类之前，我需要执行操作")

        def test_login01(self):
            print("---test_login01----")
            assert 1 + 1 == 2
        def test_login02(self):
            print("---test_login02----")
            assert 1 + 1 == 3

        def teardown(self):　　　　　　　　　　　　#看业务本身需不需要初始化和清除环境，--可选项
            print("------该测试类的环境清除-----")

    if __name__ == '__main__':
        pytest.main(["test_func01.py","-s"]) 

9：pyets种有四种级别的setup和teardown

1：setup_module和teardown_module,在整个测试用例所在的文件中所在的文件中所有的方法运行前和运行后运行，只运行一次—模块的
2：setup_class和teardown_class,在整个测试文件中的一个class中所有的用例的签后运行 ----class类
3：setup_method和teardown_method,在class内的每个方法运行前后运行 ---------方法的
4：setup_function和teardown_function,在非class下属的每个测试方法的前后运行 ----函数的
分层分级（不同级别有不同方法）

10：pytest里面的数据初始化装饰器****fixture参数说明

 **fixture\_function: Optional[\_FixtureFunction] = None,
 \*,
 scope: "Union[\_Scope, Callable[[str, Config], \_Scope]]" = "function", --scope参数:级别
 params: Optional[Iterable[object]] = None,------------------------------- params:参数
 autouse: bool = False,---------------------------------------------------- autouse：是否自动化执行
 ids: Optional[
 Union[
 Iterable[Union[None, str, float, int, bool]],
 Callable[[Any], Optional[object]],
 ]
 ] = None,
 name: Optional[str] = None**

@pytest.fixture(scope=xxx,params=xxx,autouse=xxx)

fiixture装饰器可以传单三个参数

**1：**scope参数：初始化清除定义级别

**2：**params:参数

**3：**autouse：是否自动化执行

11：fixture函数级别的初始化，环境初始化

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

import pytest #函数级别的@pytest.fixture()初始化操作 @pytest``.fixture()``#标记函数是个初始化操作，标记后需要传给每个函数statr_func这个函数名才会执行初始化操作（函数级别的） def statr1_func(): #这不是测试函数，一个普通函数,pytest执行用例只能识别test开头的方法和函数，所以pytest.main不会执行(不参加pytest用例) print``(``"------初始化操作1------"``) @pytest``.fixture() def statr2_func(): print``(``"------初始化操作2------"``) #fixture:有哪些操作（可以多个初始化可以一起调，需要两个初始化，需要连接，需要登录） #这种写法很方便，函数需要statr_func1函数做一个初始化操作可以调用statr_func1这个函数，---def test_001(statr1_func): # 需要其他初始化方法可以选择性调用其他初始化函数，传递函数名就行（灵活选择）----def test_002(statr2_func): #函数初始化操作需要传递几个函数也可以多个函数名传递--def test_003(statr2_func,statr1_func): #方便灵活 def test_001(statr1_func): print``(``"-----test01------"``) def test_002(statr2_func): print``(``"-----test02 ------"``) def test_003(statr2_func,statr1_func): print``(``"-----test03 ------" if __name__``=``= '__main__'``: pytest.main([``"test_pytest.py"``,``"-s"``])

聪明的小伙伴就发现了，欸出bug了，print``(``"-----test03 ------"这里明显少了个括号嘿嘿嘿，写代码还是要细心一点。记得加上【）】

![](https://img-blog.csdnimg.cn/aebd246f411a4c30b80239d076a906c9.jpeg)

12：类级别的初始化class，可以使用setup做初始化，也可以使用fixture做初始化

  import pytest

        @pytest.fixture(scope="class")   　　　　　　　　#类级别的初始化函数  scope="class" 就是把这个初始化定义成类级别的
        def statr1_func():
            print("------初始化操作1------")

        class Test_00:　　　　　　　　　　　　　　　　　　#需要执行 Test_00测试类，需要做初始化(可以setup_class)
            # def setup_class(self):
            #     print("类内部的初始化,")  　　　　    #只对类有用,类级别的，类里只做一次(几个类的初始化操作一样这种不适合，需要重复写)
                                            　　     #fixture初始化类就是避免重复代码
            def test_001(self,statr1_func):
                print("-----test01------")

            def test_002(self,statr1_func):
                print("-----test02 ------")


        if __name__ == '__main__':
            pytest.main(["test_pytest01.py","-s"])

**类级别初始化fixture，虽然test\_001和test\_002都调用了statr1\_func这个类级别的初始化函数，但是执行类测试用例的时候只执行statr1\_func初始函数一次
　　
　　多个类都可以调用statr1\_func这个类级别的初始化方法,调用的时候最好放在类里的第一个函数，后面的函数可以不传(因为对应的是类级别的初始化)**

   import pytest
        @pytest.fixture(scope="class")   　　　　　　#类级别的初始化函数
        def statr1_func():
            print("------初始化操作1------")
                                                    #一个模块里面有函数用例也有类的用例怎么做：（class级别的初始化只对类有用，对函数没用）
        def test_003(statr1_func):                  #测试函数,
            print("-----test03------")

        class Test_00:                        #需要执行test00测试类，需要做初始化(可以setup_class)
            def test_001(self,statr1_func):
                print("-----test01------")

            def test_002(self,statr1_func):
                print("-----test02 ------")

        if __name__ == '__main__':
            pytest.main(["test_pytest01.py","-s"])

**初始化方法****statr1\_func定义成class类级别的，函数级别的测试测试用例test\_\_003调用初始化函数会执行一次，
　　class类级别的测试用例Test\_00调用初始化函数会执行一次（一共执行两次）
　　看级别的，整个模块的级别的化最好用module，否则有问题，fixture可以做return，会有返回值的，对应级别来做，**

**执行结果：**

test_pytest01.py
------初始化操作1------
-----test03------
.------初始化操作1------
-----test01------
.-----test02 ------

13：类级别初始化实际代码：初始化操作是登录操作

#课程模块的测试类
        import pytest
        from lib.api_lib.lesson import Lesson
        from lib.api_lib.lesson import Login
        from tools.execlMethod import get_excelData
        import json
        import os

        @pytest.fixture(scope="class")   　　　　　　　　#类级别的初始化函数
        def start_func():
            global sessionid
            sessionid = Login().login('{"username":"auto","password":"sdfsdfsdf"}')

        class Test_lesson:
            #1:课程新增接口,前置条件登录(封装完一个方法后想办法做数据驱动)，课程增加需要通过excel表用例来做
            @pytest.mark.parametrize("inData,repsData", get_excelData('2-课程模块', 2, 26))
            def test_lesson_add(self,start_func,inData,repsData):
                reps=Lesson(sessionid).lesson_add(inData)
                print(reps)
                assert reps["retcode"]==json.loads(repsData)["retcode"]

        if __name__ == '__main__':
            pytest.main(["test_lesson01.py", "-s", "--alluredir", "../report/tmp"])
            os.system("allure serve ../report/tmp")

14：模块级别的初始化mudule，不管是类还是方法　　　　@pytest.fixture(scope=“module”)

模块（module）级别的初始化，（整个模块所有的类所有的东西要做一步操作，可以使用module这个模式）

只在模块运行前面只做一次，后面不做了，哪怕多调用也没用，一个模块里面有test_003函数测试用例，

也有classTest_00类级别的测试用例，定义一个模块级别的初始化函数statr1_func

函数里面调用初始化方法def test_003(statr1_func):和类里面的方法调用初始化方法test_001(self,statr1_func):，test_001(self,statr1_func):

整个模块执行的时候初始化函数都只执行一次（不管你这个模块里面调用多少次）

import pytest
        @pytest.fixture(scope="module")   　　　　　　#模块级别的初始化函数
        def statr1_func():
            print("------初始化操作1------")
            
        　　　　　　　　　　　　　　　　　　　　　　　　　　#一个模块里面有函数用例也有类的用例怎么做：（class级别的初始化只对类有用，对函数没用）
        def test_003(statr1_func):  　　　　　　　　  #测试函数,
            print("-----test03------")

        class Test_00:                        　　#需要执行test00测试类，需要做初始化(可以setup_class)
            # def setup_class(self):
            #     print("类内部的初始化,")  　　　　#只对类有用,类级别的，类里只做一次(几个类的初始化操作一样这种不适合，需要重复写)
            #                               　　　　#fixture初始化类就是避免重复代码

            def test_001(self,statr1_func):
                print("-----test01------")

            def test_001(self,statr1_func):
                print("-----test02 ------")

        if __name__ == '__main__':
            pytest.main(["test_pytest01.py","-s"])

执行结果：test_pytest01.py
------初始化操作1------
-----test03------
.-----test01------
.-----test02 ------

在这个模块下面所有的都会调用（包级别的，包里面运行前做个环境清除）

需要在testcase文件夹里面创建一个conftest.py模块，这个

固定名称，pytest自动识别这个名称

testcase里面：新增课程前面需要登录，增加课程前面需要清除数据，需要2个级别的初始化，1：登录    2：整个环境的清除

test_case（测试用例文件夹）创建一个：conftest.py文件　　里面写包级别的初始化

conftest.py文件里也能写类级别和模块级别的初始化，而且不需要调用，这个****conftest.py模块是pytest自动识别导入的

 **test\_case　　　　　　　　　　　　　　　　#文件夹
 conftest.py 
 import pytest
 #包级别的初始化，在运行整个包之前做个初始化，包里面不同作用域，每个包里面都可以放一个，每个包里面的操作都可以不一样
 @pytest.fixture(scope="session",autouse=True) 　　　　　　　　#session级别的处于时候autouse=True默认自动执行
 def start\_demo(request): #包的开始
 print("我是整个包的初始化")
 def fin(): 　　　　　　　　　　　　　　　　　　　　　　　　　　 #尾部这是包级别的，整个包做完后做个环境数据的清除 包的结束
 print('---测试完成，包的数据清除---')

 request.addfinalizer(fin)　　　　　　　　　　　　　　　　　　 #回调，当我整个包运行完了后回调fin这个方法

 #fixture的参数autouse: bool = False,---自动执行参数
　　　　#session的级别，包里面有很多模块，很多模块需要对整个包进行初始化在conftest.py里面做模块的数据初始化和清除（conftest.py只对当前包有用）**

15：两种调用初始化和清除函数的方式+初始化清除函数的返回值的使用

import pytest
@pytest.fixture()
def befor_func():
    print('xxxxxxxxxxxxx测试用例的初始化xxxxxxxxxxxxxxxx')
    yield 10
    print('zzzzzzzzzzzzzzzzzz测试用例的清除zzzzzzzzzzzzzz')

def test_001(befor_func):　　　　　　　　　　　　　　　　#调用初始化和清除方式一：直接在测试用例里传递初始化清除函数的函数名来调用
    print("测试用例001")
    res=befor_func　　　　　　　　　　　　　　　　　　　　#如果初始化清除函数有返回值，可以直接这样接收参数来使用
    print(res)

@pytest.mark.usefixtures('befor_func')　　　　　　　　#调用初始化和清除方式二：使用usefixtures放在测试用例前面直接调用初始化清除函数
def test_002():
    print("测试用例002")

if __name__ == '__main__':
    pytest.main(["test1.py",'-s'])

七：pytest前置条件+后置条件的两种写法

1：使用yield关键字来是实现　　推荐使用这种，因为yield关键字能返回函数的值

import pytest
@pytest.fixture()
def befor_func():
    print('xxxxxxxxxxxxx测试用例的初始化xxxxxxxxxxxxxxxx')
    yield 10　　　　　　　　　　　　　　　　　　　　　　　　　　　　#yield后面跟的是测试用例的后置条件，支持用例执行后就执行yield里的内容
    print('zzzzzzzzzzzzzzzzzz测试用例的清除zzzzzzzzzzzzzz')

def test_001(befor_func):
    print("测试用例001")
    res=befor_func
    print(res)

if __name__ == '__main__':
    pytest.main(["test1.py",'-s'])

2：使用finc()函数来实现　　　　这种就不能返回返回值了

import pytest
@pytest.fixture()
def befor_func(request):
    print('xxxxxxxxxxxxx测试用例的初始化xxxxxxxxxxxxxxxx')
    def fin():　　　　　　　　　　　　　　　　　　　　　　　　#尾部这是后置条件，测试用例执行后就会调用这个函数　　　　　　
        print('zzzzzzzzzzzz测试用例的清除zzzzzzzzzzz')

    request.addfinalizer(fin)　　　　　　　　　　　　　　　#回调，当我整个包运行完了后回调fin这个方法　　　　　　　　　　
def test_001(befor_func):
    print("测试用例001")

if __name__ == '__main__':
    pytest.main(["test1.py",'-s'])

16：pytest数据驱动（参数化）

pytest数据驱动的意义：

参数化（登录用例4条，每一个账号密码都不同，使用框架把4个用例全部执行完，不需要for循环遍历执行，采用数据驱动方案来做）

pytest内置装饰器@pytest.mark.parametrize可以让测试数据参数化，把测试数据单独管理，类似ddt数据驱动的作用，方便代码和测试数据分离

@pytest.mark.parametrize(“a”,[1,2,3])：　　　　　　　　参数化传一组参数

@pytest.mark.parametrize(“a,b”, [(1,2),(3,4),(5,6)]) 　　   参数化传多组参数

登录账户密码（name和psw不同的用例组合，一个接口几十个用例怎么做----几十组数据----传的参数不同（什么请求方式和各种都一样）

可以把name和psw分别采取多组数据进行参数化，数据分离，一个接口跑4次，每次用不同的参数）

    import pytest
    #[(1,2),(3,4),(5,6)]   [1,2,3]
    class Test_login():  
        def setup_class(self):
            print("执行测试类之前，我需要执行操作")

        @pytest.mark.parametrize("a",[1,2,3])            #("变量名",[1,2,3]),数据需要封装成一个列表，多个数据需要封装成列表嵌套元组   ----数据驱动
        def test_login01(self,a):                  #数据驱动，一定要把变量名a引入引来，不然无法参数化

print("---test_login01----")
            assert 1 + 1 == a

        @pytest.mark.parametrize("a,b", [(1,2),(3,4),(5,6)])    #数据驱动传多组参数
        def test_login02(self,a,b):
             print("---test_login02----")
             assert a + 1 == b

        def teardown_class(self):
            print("------该测试类的环境清除-----")

    if __name__ == '__main__':
        pytest.main(["test_func01.py","-s"])  

17：pytest结合allure报告操作

一：pytest自带的报告框架  pytest-html

二：allure环境搭建（allure是报告库不是python专属的，很全面的框架）-allure报告漂亮

1：下载allure.zip（压缩包）
2：解压allure.zip到一个文件目录
3：将allure-2.13.3\bin路径添加到环境变量path
4：pip install allure-pytest -------allure报告本身不是很漂亮，通过allure-pytest这个库可以定制化报告，让报告变得很漂亮
5：验证（cmd输入allure）

三：allure和pytest联合执行生成报告：运行两条语句

1：执行pytest单元测试，生成的allure报告需要的数据存在/tmp目录

pytest -sq --alluredir=…/report/tmp　　　#pytest把allure报告的生成的中间文件放到一个临时文件里面（pytets生成报告，需要数据，所以先把数据存起来）

#所有的报告需要数据支持的，数据来源pytest框架本身，结果数据存到一个文件，存在…/report/tmp文件夹