pytest使用详解

• 1.pytest简介
• 2.pytest的命名规则
• • 2.1 python的命名规则
  • 2.2 pytest的命名规则
• 3.pytest的运行方式
• • 3.1 主函数运行
  • 3.2 命令行运行
  • 3.3 pytest.ini配置文件方式运行（常用）
• 4.conftest.py
• • 4.1 什么是conftest.py
  • 4.2 实际的开发场景
  • 4.3 conftest.py的特点
  • 4.4 conftest.py的代码
• 5. Pytest Exit Code 含义清单
• 6.pytest中控制测试用例的执行
• • 6.1.在第N个用例失败后，结束测试执行
  • 6.2指定执行的测试模块
  • 6.3 指定要执行的测试目录
  • 6.4 通过关键字过滤执行
  • 6.5通过 node id 指定测试用例
  • 6.6 通过标记表达式执行
  • 6.7通过包执行
  • 6.8多进程运行cases
  • 6.8测试用例的重试
  • 6.9改变执行测试用例的顺序
• 7.Pytest的setup和teardown函数
• 8.pytest.fixture的详细使用
• • 8.1前言
  • 8.2fixture的优势
  • 8.3 fixture参数
  • 8.4测试用例如何调用fixture
  • 8.5fixture使用yield实现teardown
  • 8.6pytest.fixture中使用参数request
• 9. skip、skipif 跳过测试用例
• • 9.1 @pytest.mark.skip
  • 9.2 pytest.skip()函数基础使用
  • 9.3 pytest.skip(msg="",allow_module_level=False)
  • 9.4 @pytest.mark.skipif(condition, reason="")
  • 9.5 跳过标记
  • 9.6 pytest.importorskip( modname: str, minversion: Optional[str] = None, reason: Optional[str] = Nonse )
  • 9.6 使用自定义标记 mark
• 10.参数化 @pytest.mark.parametrize
• • 10.1 函数数据参数化
• 11 标记为失败函数和失败重试
• • 11.1 标记为预期失败的函数
  • 11.2 失败后重试
• 12.测试报告生成
• • 12.1 pytest-html生成测试报告
  • 12.2 pytest-testreporting 生成测试报告
  • 12.3 allure 生成测试报告
• 13.小结

1.pytest简介

pytest是一个python的单元测试框架，也称为用例框架。
作用：
1）发现测试用例。从多个py文件中按照一定的规则找到测试用例
2）执行测试用例
3）判断测试结果，运用python断言
4）生成测试报告，可以使用allure、pytest-html、pytest-testreport

2.pytest的命名规则

2.1 python的命名规则

1）py文件全部小写，多个英文用_隔开
2）class名首字母大写，驼峰
3）函数和方法名小写，多个英文用_隔开
4）全局变量，前面要加global
5）常量字母必须全大写，如：AGE_OF_NICK

2.2 pytest的命名规则

1）模块名（py文件）必须是以test_开头或者_test结尾
2）测试类（class）必须以Test开头，并且不能带init方法，类里的方法必须以test_开头
3）测试用例（函数）必须以test_开头

3.pytest的运行方式

3.1 主函数运行

import  pytestdef test_01():    print("this is {} testcase".format(__name__))if __name__=='__main__':    pytest.main()

main中可使用的参数有：

参数	描述	案例
-v	输出调试信息。如：打印信息	pytest.main([‘-v’,‘testcase/test_one.py’,‘testcase/test_two.py’])
-s	输出更详细的信息，如：文件名、用例名	pytest.main([‘-vs’,‘testcase/test_one.py’,‘testcase/test_two.py’])
-n	多线程或分布式运行测试用例
-x	只要有一个用例执行失败，就停止执行测试	pytest.main([‘-vsx’,‘testcase/test_one.py’])
– maxfail	出现N个测试用例失败，就停止测试	pytest.main([‘-vs’,‘-x=2’,‘testcase/test_one.py’]
–html=report.html	生成测试报告	pytest.main([‘-vs’,‘–html=./report.html’,‘testcase/test_one.py’])
-m	通过标记表达式执行
-k	根据测试用例的部分字符串指定测试用例，可以使用and，or

3.2 命令行运行

def test_a():    print("this is {} testcase".format('a'))    assert 1==1def test_b():    print("this is {} testcase".format('b'))    assert 1==1def test_c():    print("this is {} testcase".format('c'))    #终端输入：pytest ./testcase/test_one.py --html=./report/report.html

main中可使用的参数有：

参数	描述	案例
-v	输出调试信息。如：打印信息	pytest -x ./testcase/test_one.py
-q	输出简单信息。	pyets -q ./testcase/test_one.py
-s	输出更详细的信息，如：文件名、用例名	pytest -s ./testcase/test_one.py
-n	多线程或分布式运行测试用例
-x	只要有一个用例执行失败，就停止执行测试	pytest -x ./testcase/test_one.py
– maxfail	出现N个测试用例失败，就停止测试	pytest --maxfail=2 ./testcase/test_one.py
–html=report.html	生成测试报告	pytest ./testcase/test_one.py --html=./report/report.html
-m	通过标记表达式执行	pytest -m slow ./testcase/test_one.py #@pytest.mark.slow装饰的所有用例
-k	根据测试用例的部分字符串指定测试用例，可以使用and，or	pytest -k “MyClass and not method”，这条命令会匹配文件名、类名、方法名匹配表达式的用例，这里这条命令会运行 TestMyClass.test_something， 不会执行 TestMyClass.test_method_simple
注意：
如果只执行 pytest ，会查找当前目录及其子目录下以test_.py或_test.py文件，找到文件后，在文件中找到以 test 开头函数并执行

3.3 pytest.ini配置文件方式运行（常用）

不管是mian执行方式还是命令执行，最终都会去读取pytest.ini文件
在项目的根目录下创建pytest.ini文件

[pytest]addopts=-vs -m slow --html=./report/report.htmltestpaths=testcasetest_files=test_*.pytest_classes=Test*test_functions=test_*makerers=smock:冒烟测试用例

参数	作用
[pytest]	用于标志这个文件是pytest的配置文件
addopts	命令行参数，多个参数之间用空格分隔
testpaths	配置搜索参数用例的范围
python_files	改变默认的文件搜索规则
python_classes	改变默认的类搜索规则
python_functions	改变默认的测试用例的搜索规则
markers	用例标记，自定义mark，需要先注册标记，运行时才不会出现warnings

pytset.ini文件尽可能不要出现中文。

4.conftest.py

4.1 什么是conftest.py

可以理解成一个专门存放fixture的配置文件

4.2 实际的开发场景

例如：多个测试用例文件（test_*.py）的所有用例都需要用登录功能来作为前置操作，那就不能把登录功能写到某个用例文件中去了

4.3 conftest.py的特点

• pytest 会默认读取 conftest.py里面的所有 fixture
• conftest.py 文件名称是固定的，不能改动
• conftest.py 只对同一个 package 下的所有测试用例生效
• 不同目录可以有自己的 conftest.py，一个项目中可以有多个 conftest.py
• 测试用例文件中不需要手动 import conftest.py，pytest 会自动查找

4.4 conftest.py的代码

目录如下：

最顶层的 conftest，一般写全局的 fixture，比如：在Web UI 自动化中，可能会写初始化 driver 的 fixture
./conftest.py

import pytest@pytest.fixture(scope="session",autouse=True)def login():    print("====根目录的session登录功能，返回账号===")    name = "testyy"    token = "npoi213bn4"    yield name, token    print("====根目录的session退出登录！！！====")

./testcase/conftest.py

import pytest@pytest.fixture(scope="module", autouse=True)def login_test_cse():    print("====testcase/module目录的登录功能，返回账号===")    name = "testyy"    token = "npoi213bn4"    yield name, token    print("====testcase/module目录的退出登录！！！====")

./testcase/test_three.py

def test_a():    print(f"=====test_three::test_a=====")def test_b():    print(f"=====test_three::test_b=====")

./testcase/testone/conftest.py

import pytest@pytest.fixture(scope="module",autouse=True)def login_test_one():    print("====testcase/testone/moduled目录的登录功能，返回账号，token===")    name = "testyy"    token = "npoi213bn4"    yield name, token    print("====testcase/testone/moduled目录的退出登录！！！====")

./testcase/testone/test_one.py

def test_a():    print(f"=====test_one::test_a=====")def test_b():    print(f"=====test_one::test_b=====")

./testcase/testone/test_two.py

def test_a():    print(f"=====test_one::test_a=====")def test_b():    print(f"=====test_one::test_b=====")

./run_test.py

import pytestif __name__ == '__main__':    pytest.main(["-s", "./testcase/"])

执行结果：

5. Pytest Exit Code 含义清单

• Exit code 0 所有用例执行完毕，全部通过
• Exit code 1 所有用例执行完毕，存在Failed的测试用例
• Exit code 2 用户中断了测试的执行
• Exit code 3 测试执行过程发生了内部错误
• Exit code 4 pytest 命令行使用错误
• Exit code 5 未采集到可用测试用例文件

6.pytest中控制测试用例的执行

6.1.在第N个用例失败后，结束测试执行

pytest -x                    # 第01次失败，就停止测试pytest --maxfail=2     # 出现2个失败就终止测试

6.2指定执行的测试模块

pytest ./testcase/test_one.py

6.3 指定要执行的测试目录

pytest ./testcase/

6.4 通过关键字过滤执行

pytest -k "MyClass and not method"#这条命令会匹配文件名、类名、方法名匹配表达式的用例，这里这条命令会运行 TestMyClass.test_something， 不会执行 TestMyClass.test_method_simple

6.5通过 node id 指定测试用例

nodeid由模块文件名、分隔符、类名、方法名、参数构成，举例如下：

#运行指定模块的指定函数pytest ./testcase/test_one.py::test_apytest ./testcase/test_one.py::test_a ./testcase/test_one.py::test_b#运行指定模块的指定类中的方法pytest test_mod.py::TestClass::test_method

6.6 通过标记表达式执行

pytest -m smock#这条命令会执行被装饰器 @pytest.mark.smock 装饰的所有测试用例

6.7通过包执行

pytest --pyargs pkg.testing#这条命令会自动导入包 pkg.testing，并使用该包所在的目录，执行下面的用例。

6.8多进程运行cases

#需要先安装pytest-xdist#pip install -U pytest-xdistpytest test_one.py -n NUM#NUM填写并发的进程数

6.8测试用例的重试

在做接口测试时，有事会遇到503或短时的网络波动，导致case运行失败，而这并非是我们期望的结果，此时可以就可以通过重试运行cases的方式来解决。

#需要先安装pytest-rerunfailures#pip install -U pytest-rerunfailurespytest test_se.py --reruns NUM#NUM 表示失败后的重试次数

6.9改变执行测试用例的顺序

默认执行顺序从上到下，改变测试用例的执行顺序，在测试用例上加上标记，实现如下：
1）先安装pytest-ordering：pip install pytest-ordering
2）在测试用例上打标记:pytest.mark.run(order=1)

import  pytest@pytest.mark.run(order=3)def test_a():    print("this is {} testcase".format('a'))    assert 1==1@pytest.mark.run(order=1)def test_b():    print("this is {} testcase".format('b'))    assert 1==1@pytest.mark.run(order=2)def test_c():    print("this is {} testcase".format('c'))if __name__=='__main__':    pytest.main()    执行结果：test_one.py::test_b this is b testcasePASSEDtest_one.py::test_c this is c testcasePASSEDtest_one.py::test_a this is a testcasePASSED

7.Pytest的setup和teardown函数

setup和teardown主要分为：模块级别、类级别、函数级别、方法级别、方法细化级别，分别如下：

方法	描述
setup_module()	在每个模块之前执行
teardown_module()	在每个模块之后执行
setup_class()	在每个类之前执行，即:在一个测试类只运行一次setup_class和teardown_class，不关心测试类内有多少个测试函数。
teardown_class()	在每个类之后执行，即:在一个测试类只运行一次setup_class和teardown_class，不关心测试类内有多少个测试函数。
setup_function()	在每个函数之前执行。
teardown_function()	在每个函数之后执行。
setup_method()	在每个方法之前执行
teardown_method()	在每个方法之后执行
setup()	在每个方法之前执行
teardown()	在每个方法之后执行
2.扩展：在unittest中前后置只有setup和teardwon、setupClass和teardwonClass两大类。

#!/usr/bin/env python# -*- coding:utf-8 -*-"""@Time:2022-10-0712:06@Auth:ting.chun@File:test_one.py.py@IDE:PyCharm"""import pytestdef setup_module():    print("=====整个.py模块开始前只执行一次:打开浏览器=====")def teardown_module():    print("=====整个.py模块结束后只执行一次:关闭浏览器=====")def setup_function():    print("===每个函数级别用例开始前都执行setup_function===")def teardown_function():    print("===每个函数级别用例结束后都执行teardown_function====")def test_one():    print("one")def test_two():    print("two")class TestCase():    def setup_class(self):        print("====整个测试类开始前只执行一次setup_class====")    def teardown_class(self):        print("====整个测试类结束后只执行一次teardown_class====")    def setup_method(self):        print("==类里面每个用例执行前都会执行setup_method==")    def teardown_method(self):        print("==类里面每个用例结束后都会执行teardown_method==")    def setup(self):        print("=类里面每个用例执行前都会执行setup=")    def teardown(self):        print("=类里面每个用例结束后都会执行teardown=")    def test_three(self):        print("three")def test_four():    print("four")if __name__ == '__main__':    pytest.main(["-q", "-s", "-ra", "test_one.py"])# 运行测试用例，显示总的结果信息，使用命令 pytest -ra

执行结果如下：

8.pytest.fixture的详细使用

8.1前言

• 虽然setup和teardown可以执行一些前置和后置操作，但是这种是针对整个脚本全局生效的
• 如果有以下场景：1.用例一需要执行登录操作；2.用例二不需要执行登录操作；3.用例三需要执行登录操作，则setup和teardown则不满足要求。
• fixture可以让我自定义测试用例的前置条件

8.2fixture的优势

• 命名方式灵活，不限于setup和teardown两种命名
• conftest.py可以实现数据共享，不需要执行import 就能自动找到fixture
• scope=module，可以实现多个.py文件共享前置
• scope=“session” 以实现多个.py 跨文件使用一个 session 来完成多个用例

8.3 fixture参数

fixture修饰器来标记固定的工厂函数,在其他函数，模块，类或整个工程调用它时会被激活并优先执行,通常会被用于完成预置处理和重复操作。

方法：fixture(scope="function", params=None, autouse=False, ids=None, name=None)常用参数:scope：被标记方法的作用域"function" (default)：作用于每个测试方法，每个test都运行一次"class"：作用于整个类，每个class的所有test只运行一次 "module"：作用于整个模块，每个module的所有test只运行一次 "session：作用于整个session(慎用)，每个session只运行一次，即整个测试会话，即开始执行 Pytest 到结束测试 params：(list类型)提供参数数据，供调用标记方法的函数使用 autouse：是否自动运行,默认为False不运行，设置为True自动运行

8.4测试用例如何调用fixture

执行的三种方式：

• 1.将fixture名称作为测试用例的输入参数
• 2.使用装饰器pytest.mark.usefixtures(fixturename)
• 3.fixture设置autouse=True

扩展知识点：

• 在类声明上面加@pytest.mark.usefixtures()，代表这个类里面所有测试用例都会调用该 fixture
• 可以叠加多个@pytest.mark.usefixtures()，先执行的放底层，后执行的放上层
• 可以传多个 fixture 参数，先执行的放前面，后执行的放后面
• 如果 fixture 有返回值，用@pytest.mark.usefixtures()是无法获取到返回值的，必须用传参的方式（方式一）

将fixture名称作为测试用例的输入参数：

class Test_ABC:    @pytest.fixture()    def before(self):        print("------->before")    def test_a(self,before): # ️ test_a方法传入了被fixture标识的函数，以参数的形式        print("------->test_a")        assert 1if __name__ == '__main__':    pytest.main("-s  test_abc.py")执行结果：    test_abc.py         ------->before # 发现before会优先于测试函数运行        ------->test_a

使用装饰器pytest.mark.usefixtures(fixturename)

#!/usr/bin/env python# -*- coding:utf-8 -*-"""@Time:2022-10-0712:06@Auth:ting.chun@File:test_one.py.py@IDE:PyCharm"""import pytest@pytest.fixture()  # fixture标记的函数可以应用于测试类外部def before():    print("------->before")@pytest.mark.usefixtures("before")class TestOne:    def setup(self):        print("------->setup")    def test_a(self):        print("------->test_a")        assert 1    def test_b(self):        print("------->test_b")        assert 1if __name__ == '__main__':    pytest.main("-s  test_one.py")  执行结果：      test_one.py::TestOne::test_a       ------->before  # 发现before自动优先于setup运行  ------->setup  ------->test_a  PASSED  test_one.py::TestOne::test_b ------->before  ------->setup  ------->test_b  PASSED

fixture设置autouse=True

import pytest @pytest.fixture(autouse=True) # 设置为默认运行 def before():     print("------->before") class Test_ABC:     def setup(self):         print("------->setup")     def test_a(self):         print("------->test_a")         assert 1 if __name__ == '__main__':     pytest.main("-s  test_abc.py")执行结果：    test_abc.py     ------->before # 发现before自动优先于测试类运行    ------->setup    ------->test_a

fixture的作用域设置为：scope=“function”

 import pytest    @pytest.fixture(scope='function',autouse=True) # 作用域设置为function，自动运行    def before():        print("------->before")    class Test_ABC:        def setup(self):            print("------->setup")        def test_a(self):            print("------->test_a")            assert 1        def test_b(self):            print("------->test_b")            assert 1    if __name__ == '__main__':        pytest.main("-s  test_abc.py")执行结果：    test_abc.py        ------->before # 运行第一次        ------->setup        ------->test_a        .------->before # 运行第二次        ------->setup        ------->test_b

fixture的作用域设置为：scope=“class”

import pytest    @pytest.fixture(scope='class',autouse=True) # 作用域设置为class，自动运行    def before():        print("------->before")    class Test_ABC:        def setup(self):            print("------->setup")        def test_a(self):            print("------->test_a")            assert 1        def test_b(self):            print("------->test_b")            assert 1    if __name__ == '__main__':        pytest.main("-s  test_abc.py")执行结果：    test_abc.py    ------->before # 发现只运行一次    ------->setup        ------->test_a        .        ------->setup        ------->test_b        .

fixture的返回值

 import pytest    @pytest.fixture()    def need_data():        return 2 # 返回数字2     class Test_ABC:         def test_a(self,need_data):            print("------->test_a")            assert need_data != 3 # 拿到返回值做一次断言     if __name__ == '__main__':        pytest.main("-s  test_abc.py")执行结果：    test_abc.py     ------->test_a    .

import pytest@pytest.fixture(params=[1, 2, 3])def need_data(request): # 传入参数request 系统封装参数    return request.param # 取列表中单个值，默认的取值方式class Test_ABC:     def test_a(self,need_data):        print("------->test_a")        assert need_data != 3 # 断言need_data不等于3 if __name__ == '__main__':    pytest.main("-s  test_abc.py")  执行结果：      # 可以发现结果运行了三次      test_abc.py       1      ------->test_a      .      2      ------->test_a      .      3      ------->test_a      F

8.5fixture使用yield实现teardown

import pytest@pytest.fixture(scope="session")def open():    # 会话前置操作setup    print("===打开浏览器===")    test = "test"    yield test    # 会话后置操作teardown    print("==关闭浏览器==")@pytest.fixturedef login(open):    # 方法级别前置操作setup    print(f"open方法yield的返回结果：{open}")    name = "==我是账号=="    pwd = "==我是密码=="    # 返回变量    yield name, pwd    # 方法级别后置操作teardown    print("登录成功")def test_s1(login):    print("==用例1==")    # 返回的是一个元组    print(login)    # 分别赋值给不同变量    name, pwd = login    print(name, pwd)    assert "账号" in name    assert "密码" in pwddef test_s2(login):    print("==用例2==")    print(login)if __name__ == '__main__':    pytest.main("-s  test_one.py")执行结果：test_one.py::test_s1 ===打开浏览器===open方法yield的返回结果：test==用例1==('==我是账号==', '==我是密码==')==我是账号== ==我是密码==PASSED登录成功test_one.py::test_s2 open方法yield的返回结果：test==用例2==('==我是账号==', '==我是密码==')PASSED登录成功==关闭浏览器==

yield和with结合使用

# 官方例子@pytest.fixture(scope="module")def smtp_connection():    with smtplib.SMTP("smtp.gmail.com", 587, timeout=5) as smtp_connection:        yield smtp_connection  # provide the fixture value

该 smtp_connection 连接将测试完成执行后已经关闭，因为smtp_connection 对象自动关闭时， with 语句结束

8.6pytest.fixture中使用参数request

传单个参数

import pytest@pytest.fixture()def pre_data(request):    name = request.param    print(f"== 账号是：{name} ==")    return namedata = ["pyy1", "polo"]ids = [f"pre_test_name is:{name}" for name in data]#添加indirect=True参数是为了把 login 当成一个函数去执行，而不是一个参数，并且将 data 当做参数传入函数#def test_name(login) ，这里的 login 是获取 fixture 返回的值@pytest.mark.parametrize("pre_data", data, ids=ids, indirect=True)def test_name(pre_data):    print(f" 测试用例的登录账号是：{pre_data} ")

多个参数

@pytest.fixture()def pre_data(request):    param = request.param    print(f"账号是：{param['username']}，密码是：{param['pwd']}")    return paramdata = [    {"username": "name1", "pwd": "pwd1"},    {"username": "name2", "pwd": "pwd2"},]#如果需要传多个参数，需要通过字典去传@pytest.mark.parametrize("pre_data", data, indirect=True)def test_name_pwd(pre_data):    print(f"账号是：{pre_data['username']}，密码是：{pre_data['pwd']}")

多个fixture（只加一个装饰器）

# 多个fixture@pytest.fixture(scope="module")def input_user(request):    user = request.param    print("登录账户：%s" % user)    return user@pytest.fixture(scope="module")def input_psw(request):    psw = request.param    print("登录密码：%s" % psw)    return pswdata = [    ("name1", "pwd1"),    ("name2", "pwd2")]@pytest.mark.parametrize("input_user,input_psw", data, indirect=True)def test_more_fixture(input_user, input_psw):    print("fixture返回的内容:", input_user, input_psw)

多个fixture（叠加装饰器）

# 多个fixture@pytest.fixture(scope="function")def input_user(request):    user = request.param    print("登录账户：%s" % user)    return user@pytest.fixture(scope="function")def input_psw(request):    psw = request.param    print("登录密码：%s" % psw)    return pswname = ["name1", "name2"]pwd = ["pwd1", "pwd2"]@pytest.mark.parametrize("input_user", name, indirect=True)@pytest.mark.parametrize("input_psw", pwd, indirect=True)def test_more_fixture(input_user, input_psw):    print("fixture返回的内容:", input_user, input_psw)

9. skip、skipif 跳过测试用例

9.1 @pytest.mark.skip

跳过执行测试用例，有可选参数 reason：跳过的原因，会在执行结果中打印

• @pytest.mark.skip可以加在函数上，类上，类方法上
• 如果加在类上面，类里面的所有测试用例都不会执行

import pytest@pytest.fixture(autouse=True)def login():    print("====登录====")def test_case01():    print("我是测试用例11111")@pytest.mark.skip(reason="不执行该用例！！因为没写好！！")def test_case02():    print("我是测试用例22222")class Test1:    def test_1(self):        print("%% 我是类测试用例1111 %%")    @pytest.mark.skip(reason="不想执行")    def test_2(self):        print("%% 我是类测试用例2222 %%")@pytest.mark.skip(reason="类也可以跳过不执行")class TestSkip:    def test_1(self):        print("%% 不会执行 %%")

9.2 pytest.skip()函数基础使用

作用：在测试用例执行期间强制跳过不再执行剩余内容
类似：在Python的循环里面，满足某些条件则break 跳出循环

def test_function():    n = 1    while True:        print(f"这是我第{n}条用例")        n += 1        if n == 5:            pytest.skip("我跑五次了不跑了")

执行结果：

9.3 pytest.skip(msg=“”,allow_module_level=False)

当 allow_module_level=True 时，可以设置在模块级别跳过整个模块

import sysimport pytestif sys.platform.startswith("win"):    pytest.skip("skipping windows-only tests", allow_module_level=True)@pytest.fixture(autouse=True)def login():    print("====登录====")def test_case01():    print("我是测试用例11111")

9.4 @pytest.mark.skipif(condition, reason=“”)

方法：
skipif(condition, reason=None)
参数：
condition：跳过的条件，必传参数
reason：标注原因，必传参数
使用方法：
@pytest.mark.skipif(condition, reason=“xxx”)

import pytestclass Test_ABC:    def setup_class(self):        print("------->setup_class")    def teardown_class(self):        print("------->teardown_class")    def test_a(self):        print("------->test_a")        assert 1    @pytest.mark.skipif(condition=2>1,reason = "跳过该函数") # 跳过测试函数test_b    def test_b(self):        print("------->test_b")            assert 0执行结果：   test_abc.py    ------->setup_class   ------->test_a #只执行了函数test_a   .   ------->teardown_class       s # 跳过函数

9.5 跳过标记

• 可以将 pytest.mark.skip 和 pytest.mark.skipif 赋值给一个标记变量
• 在不同模块之间共享这个标记变量
• 若有多个模块的测试用例需要用到相同的 skip 或 skipif ，可以用一个单独的文件去管理这些通用标记，然后适用于整个测试用例集

# 标记skipmark = pytest.mark.skip(reason="不能在window上运行=====")skipifmark = pytest.mark.skipif(sys.platform == 'win32', reason="不能在window上运行啦啦啦=====")@skipmarkclass TestSkip_Mark(object):    @skipifmark    def test_function(self):        print("测试标记")    def test_def(self):        print("测试标记")@skipmarkdef test_skip():    print("测试标记")

9.6 pytest.importorskip( modname: str, minversion: Optional[str] = None, reason: Optional[str] = Nonse )

作用：如果缺少某些导入，则跳过模块中的所有测试
参数列表

• modname：模块名
• minversion：版本号
• reason：跳过原因，默认不给也行

pexpect = pytest.importorskip("pexpect", minversion="0.3")@pexpectdef test_import():    print("test")

9.6 使用自定义标记 mark

前言

• pytest可以支持自定义标记，自定义标记可以把一个web项目划分为多个模块，然后指定模块名称执行
• 譬如我们可以标明哪些用例在window上执行，哪些用例在mac上执行，在运行的时候指定mark就行

import pytest@pytest.mark.modeldef test_model_a():    print("执行test_model_a")@pytest.mark.regulardef test_regular_a():    print("test_regular_a")@pytest.mark.modeldef test_model_b():    print("test_model_b")@pytest.mark.regularclass TestClass:    def test_method(self):        print("test_method")def testnoMark():    print("testnoMark")

命令运行
pytest -s -m model test_one.py

如何避免warnings

• 创建一个 pytest.ini 文件
• 加上自定义mark
• pytest.ini 需要和运行的测试用例同一个目录，或在根目录下作用于全局

[pytest]
markers =
model: this is model mark

如果不想标记 model 的用例

pytest -s -m " not model" test_one.py

如果想执行多个自定义标记的用例

pytest -s -m “model or regular” 08_mark.py

10.参数化 @pytest.mark.parametrize

pytest允许在多个级别启用测试化参数：
1）pytest.fixture()允许fixture有参数化功能
2）pytest.mark.parametrize 允许在测试函数和类中定义多组参数和fixtures
3）pytest_generate_tests允许定义自定义参数化方案或扩展

def parametrize(self,argnames, argvalues, indirect=False, ids=None, scope=None):
argnames：
含义：参数值列表
格式：字符串"arg1,arg2,arg3"
例如：
@pytest.mark.parametrize(“name,pwd”, [(“yy1”, “123”), (“yy2”, “123”)])
argvalues:
含义：参数值列表
格式：必须是列表，如：[ val1,val2,val3 ]
如果只有一个参数，里面则是值的列表如：@pytest.mark.parametrize(“username”, [“yy”, “yy2”, “yy3”])
如果有多个参数例，则需要用元组来存放值，一个元组对应一组参数的值，如：@pytest.mark.parametrize(“name,pwd”, [(“yy1”, “123”), (“yy2”, “123”), (“yy3”, “123”)])
ids：
含义：用例的id
格式：传一个字符串列表
作用：可以标识每一个测试用例，自定义测试数据结果的显示，为了增加可读性
indirect：
作用：如果设置成 True，则把传进来的参数当函数执行，而不是一个参数（下一篇文章即讲解

@pytest.mark.parametrize("test_input,expected", [("3+5", 8), ("2+4", 6), ("6*9", 42)])def test_eval(test_input, expected):    print(f"测试数据{test_input},期望结果{expected}")    assert eval(test_input) == expected

10.1 函数数据参数化

方便测试函数对测试属于的获取。
方法：
parametrize(argnames, argvalues, indirect=False, ids=None, scope=None)
常用参数：
argnames：参数名
argvalues：参数对应值，类型必须为list
当参数为一个时格式：[value]
当参数个数大于一个时，格式为:[(param_value1,param_value2…),(param_value1,param_value2…)]
使用方法:
@pytest.mark.parametrize(argnames,argvalues)
️ 参数值为N个，测试方法就会运行N次

单个参数

import pytestclass Test_ABC:    def setup_class(self):        print("------->setup_class")    def teardown_class(self):        print("------->teardown_class")@pytest.mark.parametrize("a",[3,6]) # a参数被赋予两个值，函数会运行两遍def test_a(self,a): # 参数必须和parametrize里面的参数一致    print("test data:a=%d"%a)   assert a%3 == 0   执行结果:test_abc.py ------->setup_classtest data:a=3 # 运行第一次取值a=3.test data:a=6 # 运行第二次取值a=6. ------->teardown_class

多个参数

import pytestclass Test_ABC:    def setup_class(self):        print("------->setup_class")    def teardown_class(self):        print("------->teardown_class")@pytest.mark.parametrize("a,b",[(1,2),(0,3)]) # 参数a,b均被赋予两个值，函数会运行两遍def test_a(self,a,b): # 参数必须和parametrize里面的参数一致    print("test data:a=%d,b=%d"%(a,b))    assert a+b == 3  执行结果：  test_abc.py   ------->setup_class  test data:a=1,b=2 # 运行第一次取值 a=1,b=2  .  test data:a=0,b=3 # 运行第二次取值 a=0,b=3  .  ------->teardown_class

函数返回值作为参数

import pytestdef return_test_data():    return [(1,2),(0,3)]class Test_ABC:    def setup_class(self):        print("------->setup_class")    def teardown_class(self):            print("------->teardown_class")@pytest.mark.parametrize("a,b",return_test_data()) # 使用函数返回值的形式传入参数值def test_a(self,a,b):    print("test data:a=%d,b=%d"%(a,b))    assert a+b == 3      执行结果：  test_abc.py   ------->setup_class  test data:a=1,b=2 # 运行第一次取值 a=1,b=2  .  test data:a=0,b=3 # 运行第二次取值 a=0,b=3  .      ------->teardown_class

“笛卡尔积”，多个参数化装饰器

• 一个函数或一个类可以装饰多个 @pytest.mark.parametrize
• 这种方式，最终生成的用例数是 nm，比如上面的代码就是：参数a的数据有 3 个，参数b的数据有 2 个，所以最终的用例数有 32=6 条
• 当参数化装饰器有很多个的时候，用例数都等于 nnnn…

# 笛卡尔积，组合数据data_1 = [1, 2, 3]data_2 = ['a', 'b']@pytest.mark.parametrize('a', data_1)@pytest.mark.parametrize('b', data_2)def test_parametrize_1(a, b):    print(f'笛卡尔积 测试数据为 ： {a}，{b}')

参数化，标记数据

# 标记参数化@pytest.mark.parametrize("test_input,expected", [    ("3+5", 8),    ("2+4", 6),    pytest.param("6 * 9", 42, marks=pytest.mark.xfail),    pytest.param("6*6", 42, marks=pytest.mark.skip)])def test_mark(test_input, expected):    assert eval(test_input) == expected

11 标记为失败函数和失败重试

11.1 标记为预期失败的函数

标记测试函数为失败函数

 方法：     xfail(condition=None, reason=None, raises=None, run=True, strict=False) 常用参数：     condition：预期失败的条件，必传参数     reason：失败的原因，必传参数 使用方法：     @pytest.mark.xfail(condition, reason="xx")

import pytestclass Test_ABC:    def setup_class(self):        print("------->setup_class")    def teardown_class(self):        print("------->teardown_class")    def test_a(self):        print("------->test_a")        assert 1    @pytest.mark.xfail(2 > 1, reason="标注为预期失败") # 标记为预期失败函数test_b       def test_b(self):           print("------->test_b")          assert 0   执行结果：       test_abc.py        ------->setup_class       ------->test_a       .       ------->test_b       ------->teardown_class       x  # 失败标记

11.2 失败后重试

需安装第三方插件：pytest-rerun、pytest-rerunfailures

• 失败重试：【–reruns=1】,用例执行失败后，会立即开始重试一次此用例，再执行下一条用例
• 失败重运行：【–if】 ，用例集或用例执行完成之后，再次pytest.main()，会收集失败的用例，再次运行；如果没有失败的用例，会执行全部
  一个run文件，可以同时写多条pytest.main()，执行pytest的命令

if __name__=="__main__":    pytest.main(['-s','test_firstFile.py'])   # 第一次运行，如果有失败的用例/第一次没有失败的用例    pytest.main(['-s','--lf','test_firstFile.py']) # 收集到第一次失败的用例，进行执行/则运行全部

注意：如果用例数较多，第一次运行全部成功的情况，第二个pytest.main()，是会收集所有的用例再执行一遍；建议使用失败重试次数（–reruns=1），失败一次后，立刻执行一次，也可减少用例的失败率

失败重试方式:
1、可在命令行 –reruns=1 reruns_delay=2 失败后重运行1次，延时2s
2、使用装饰器进行失败重运行
@pytest.mark.flaky(reruns=1, reruns_delay=2)
使用方式：
命令行参数：–reruns n（重新运行次数），–reruns-delay m（等待运行秒数）
装饰器参数：reruns=n（重新运行次数），reruns_delay=m（等待运行秒数）

重新运行所有失败的用例：

#运行失败的 fixture 或 setup_class 也将重新执行
pytest --reruns=5

添加重新运行的延时：

#要在两次重试之间增加延迟时间，使用 --reruns-delay 命令行选项，指定下次测试重新开始之前等待的秒数
pytest.main( [‘-vs’,‘–reruns=5’,‘–reruns_delay=10’,‘./testcase/test_debug.py’,‘–report=_report.html’])

重新运行指定的测试用例:

#要指定某些测试用例时，需要添加 flaky 装饰器@pytest.mark.flaky(reruns=5) ，它会在测试失败时自动重新运行，且需要指定最大重新运行的次数import pytest@pytest.mark.flaky(reruns=5)def test_example():    import random    assert random.choice([True, False, False])    #同样的，这个也可以指定重新运行的等待时间@pytest.mark.flaky(reruns=5, reruns_delay=2)def test_example():    import random    assert random.choice([True, False, False])

注意：
1.如果指定了用例的重新运行次数，在命令行添加的 --reruns 对这些用例是不会生效的
2.不可以和 fixture 装饰器@pytest.fixture()一起使用
3.该插件与 pytest-xdist 的 --looponfail 标志不兼容
4.该插件与核心 --pdb 标志不兼容

12.测试报告生成

12.1 pytest-html生成测试报告

安装插件：

pip3 install pytest-html

执行方式：

#会在当前目录下创建一个 report.html 的测试报告
pytest --html=report.html

合并CSS:

#上面命令生成的报告，css 是独立的，分享报告的时候样式会丢失，为了更好的分享发邮件展示报告，可以把css样式合并到html里
pytest --html=report.html --self-contained-html

12.2 pytest-testreporting 生成测试报告

下载插件：pip3 install pytest-testreport

pytest -vs --reruns 5 ./testcase/test_debug.py --report=_report.html

12.3 allure 生成测试报告

13.小结

来源地址：https://blog.csdn.net/chuntingting/article/details/127192385