• 自动化测试 —— Pytest fixture及conftest详解！

    前言

    fixture是在测试函数运行前后，由pytest执行的外壳函数。fixture中的代码可以定制，满足多变的测试需求，包括定义传入测试中的数据集、配置测试前系统的初始状态、为批量测试提供数据源等等。fixture是pytest的精髓所在，类似unittest中setup/teardown，但是比它们要强大、灵活很多，它的优势是可以跨文件共享。

    一、Pytest fixture

    1.pytest fixture几个关键特性

    • 有独立的命名，并通过声明它们从测试函数、模块、类或整个项目中的使用来激活
    • 按模块化的方式实现，每个fixture都可以互相调用
    • fixture可以实现unittest不能实现的功能，比如unittest中的测试用例和测试用例之间是无法传递参数和数据的，但是fixture却可以解决这个问题
    • fixture的范围从简单的单元扩展到复杂的功能测试，允许根据配置和组件选项对fixture和测试用例进行参数化

    2.Pytest fixture定义

    • 定义fixture跟定义普通函数差不多，唯一区别就是在函数上加个装饰器@pytest.fixture()，fixture命名不要用test_开头，跟用例区分开。用例才是test_开头的命名；
    • fixture装饰器里的scope有四个级别的参数：function（不写默认这个）、class、module、session；
    • fixture可以有返回值，如果没有return，默认会是None；用例调用fixture的返回值，就是直接把fixture的函数名称作为参数传入；
    • fixture可以返回一个元组、列表或字典；
    • 测试用例可传单个、多个fixture参数；
    • fixture与fixture间可相互调用；
    1. 现在我也找了很多测试的朋友，做了一个分享技术的交流群，共享了很多我们收集的技术文档和视频教程。
    2. 如果你不想再体验自学时找不到资源，没人解答问题，坚持几天便放弃的感受
    3. 可以加入我们一起交流。而且还有很多在自动化，性能，安全，测试开发等等方面有一定建树的技术大牛
    4. 分享他们的经验，还会分享很多直播讲座和技术沙龙
    5. 可以免费学习！划重点！开源的！！！
    6. qq群号：110685036

    3.Pytest fixture用法

    1）用法一：作为参数使用

    fixture的名字直接作为测试用例的参数，用例调用fixture的返回值，直接将fixture的函数名称当做变量名称；如果用例需要用到多个fixture的返回数据，fixture也可以返回一个元祖，list或字典，然后从里面取出对应数据。

    ① 将fixture函数作为参数传递给测试用例

    1. @pytest.fixture()
    2. def login():
    3.     print("this is login fixture")
    4.     user = "chen"
    5.     pwd = 123456
    6.     return user, pwd
    7.  
    8. def test_login(login):
    9.     """将fixture修饰的login函数作为参数传递给本用例"""
    10.     print(login)
    11.     assert login[0] == "chen"
    12.     assert login[1] == 123456
    13.     assert "chen" in str(login)

    ② 同一个用例中传入多个fixture函数

    1. @pytest.fixture()
    2. def user():
    3.     user = "cris"
    4.     return user
    5.  
    6. @pytest.fixture()
    7. def pwd():
    8.     pwd = "123456"
    9.     return pwd
    10.  
    11. def test_trans_fixture(user, pwd):
    12.     """同一条用例中传入多个fixture函数"""
    13.     print(user, pwd)
    14.     assert "cris" in str(user)
    15.     assert pwd == "123456"

    ③ fixture函数之间的相互传递

    1. @pytest.fixture()
    2. def user2():
    3.     user = "cris"
    4.     return user
    5.  
    6. @pytest.fixture()
    7. def login_info(user2):
    8.     """fixture与fixture函数之间的相互传递"""
    9.     pwd = "e10adc3949ba59abbe56e057f20f883e"
    10.     return user2, pwd
    11.  
    12. def test_assert_login_info(login_info):
    13.     print(login_info)
    14.     print(type(login_info))
    15.     assert login_info[0] == "cris"
    16.     assert login_info[1] == "e10adc3949ba59abbe56e057f20f883e"

    2）用法二：提供灵活的类似setup和teardown功能

    Pytest的fixture另一个强大的功能就是在函数执行前后增加操作，类似setup和teardown操作，但是比setup和teardown的操作更加灵活；具体使用方式是同样定义一个函数，然后用装饰器标记为fixture，然后在此函数中使用一个yield语句，yield语句之前的就会在测试用例之前使用，yield之后的语句就会在测试用例执行完成之后再执行。

    1. @pytest.fixture()
    2. def run_function():
    3.     print("run before function...")
    4.     yield
    5.     print("run after function...")
    6.  
    7. def test_run_1(run_function):
    8.     print("case 1")
    9.  
    10. def test_run_2():
    11.     print("case 2")
    12.  
    13. def test_run_3(run_function):
    14.     print("case 3")

    运行结果如下：

    常见的应用场景：@pytest.fixture可以用在selenium中测试用例执行前后打开、关闭浏览器的操作：

    1. @pytest.fixture()
    2. def fixture_driver():
    3.     driver = webdriver.Chrome()
    4.     yield driver
    5.     driver.quit()
    6.  
    7. def test_baidu(fixture_driver):
    8.     driver = fixture_driver
    9.     driver.get("http://www.baidu.com")
    10.     driver.find_element_by_id('kw').send_keys("python fixture")
    11.     driver.find_element_by_id('su').click()

    3）用法三：利用pytest.mark.usefixtures叠加调用多个fixture

    如果一个方法或者一个class用例想要同时调用多个fixture，可以使用@pytest.mark.usefixtures()进行叠加。注意叠加顺序，① 与直接传入fixture不同的是，@pytest.mark.usefixtures无法获取到被fixture装饰的函数的返回值；

    ② @pytest.mark.usefixtures的使用场景是：被测试函数需要多个fixture做前后置工作时使用；

    1. @pytest.fixture
    2. def func_1():
    3.     print("用例前置操作---1")
    4.     yield
    5.     print("用例后置操作---1")
    6.  
    7. @pytest.fixture
    8. def func_2():
    9.     print("用例前置操作---2")
    10.     yield
    11.     print("用例后置操作---2")
    12.  
    13. @pytest.fixture
    14. def func_3():
    15.     print("用例前置操作---3")
    16.     yield
    17.     print("用例后置操作---3")
    18.  
    19. @pytest.mark.usefixtures("func_3")  # 最后执行func_3
    20. @pytest.mark.usefixtures("func_2")  # 再执行func_1
    21. @pytest.mark.usefixtures("func_1")  # 先执行func_1
    22. def test_func():
    23.     print("这是测试用例")

    执行结果：

    4）用法四：fixture自动使用autouse=True

    当用例很多的时候，每次都传这个参数，会很麻烦。fixture里面有个参数autouse，默认是False没开启的，可以设置为True开启自动使用fixture功能，这样用例就不用每次都去传参了，autouse设置为True，自动调用fixture功能。所有用例都会生效，包括类中的测试用例和类以外的测试用例。

    1. @pytest.fixture(autouse=True, scope="function")
    2. def func_auto():
    3.     """autouse为True时，会作用于每一条用例"""
    4.     print("\n---用例前置操作---")
    5.     yield
    6.     print("---用例后置操作---")
    7.  
    8. # func_auto函数的autouse=True时，无论是否使用usefixtures引用func_auto，都会执行func_auto
    9. @pytest.mark.usefixtures("func_auto")
    10. def test_01():
    11.     print("case 1")
    12.  
    13. def test_02():
    14.     print("case 2")
    15.  
    16. class Test:
    17.     def test_03(self):
    18.         print("case 3")

    执行结果：

    4.Pytest fixture四种作用域

    fixture(scope='function'，params=None，autouse=False，ids=None，name=None)

    fixture里面有个

    • function：每一个函数或方法都会调用
    • class：每一个类调用一次，一个类中可以有多个方法
    • module：每一个.py文件调用一次，该文件内又有多个function和class
    • session：多个文件调用一次，可以跨.py文件调用（通常这个级别会结合conftest.py文件使用）

    1）function级别

    function默认模式为@pytest.fixture() 函数级别，即scope="function"，scope可以不写。每一个函数或方法都会调用，每个测试用例执行前都会执行一次function级别的fixture。

    1. # @pytest.fixture(scope="function")等价于@pytest.fixture()
    2. @pytest.fixture(scope="function")
    3. def func_auto():
    4.     """用例级别fixture，作用域单个用例"""
    5.     print("\n---function级别的用例前置操作---")
    6.     yield
    7.     print("---function级别的用例后置操作---")
    8.  
    9. # test_01会引用func_auto函数，test_02没有用修饰器修饰，故不会引用
    10. def test_func_auto_fixture_1(func_auto):
    11.     print("func 1 print")
    12.  
    13. def test_func_auto_fixture_2():
    14.     print("func 2 print")

    2）class级别

    fixture的scope值还可以是class，此时则fixture定义的动作就会在测试类class的所有用例之前和之后运行，需注意：测试类中只要有一个测试用例的参数中使用了class级别的fixture，则在整个测试类的所有测试用例都会调用fixture函数

    ① 用例类中的测试用例调用fixture

    执行fixture定义的动作，以及此测试类的所有用例结束后同样要运行fixture指定的动作

    1. @pytest.fixture(scope="class")
    2. def class_auto():
    3.     """类级别fixture，作用域整个类"""
    4.     print("\n---class级别的用例前置操作---")
    5.     yield
    6.     print("---class级别的用例后置操作---")
    7.  
    8. class TestClassAutoFixture:
    9.     # class级别的fixture任意一个用例引用即可
    10.     def test_class_auto_fixture_1(self, class_auto):
    11.         print("class 1 print")
    12.  
    13.     def test_class_auto_fixture_2(self):
    14.         print("class 1 print")

    测试类中的第1条测试用例引用了fixture修饰的函数，则整个测试类的所有测试用例都会执行fixture函数的前置操作，在所有用例执行完成后，都会执行fixture函数的后置操作。

    ② 用例类外的测试用例调用fixture

    如果在类外的函数中去使用class级别的fixture，则此时在测试类外每个测试用例中，fixture跟function级别的fixture作用是一致的，即def test_class_auto_fixture(class_auto): print("class 1 print")

    如下图所示，测试类外的函数引用了class级别的fixture，则它的作用会等同于function级别的fixture，运行结果如下：

    3）module级别

    在Python中module即.py文件，当fixture定义为module时，则此fixture将在当前文件中起作用。这里需要特别说明的是，当fixture的scope定义为module时，只要当前文件中有一个测试用例使用了fixture，不管这个用例是在类外，还是在类中，都会在当前文件（模块）的所有测试用例执行之前去执行fixture定义的行为以及当前文件的所有用例结束之后同样去执行fixture定义的对应操作。

    1. @pytest.fixture(scope="module")
    2. def module_auto():
    3.     """作用于整个py文件"""
    4.     print("\n---module级别的用例前置操作---")
    5.     yield
    6.     print("---module级别的用例后置操作---")
    7.     
    8. # 测试类外和测试类内的函数方法都调用了module级别的fixture，但整个py文件只会生效一次fixture。
    9. def test_module_scope_out_class(module_auto):
    10.     print("case scope 01")
    11.     
    12. class TestScope1:
    13.     def test_scope_01(self):
    14.         print("case scope 01")
    15.  
    16.     def test_scope_02(self, module_auto):
    17.         print("case scope 02")
    18.  
    19.     def test_scope_03(self):
    20.         print("case scope 03")

    若类中的方法分别调用了class级别的fixture和module级别的fixture，则会两个fixture都生效：

    1. # 顺序在前面fixture会先执行
    2. def test_scope_01(self, module_auto, class_auto): 
    3.     print("case scope 01")

    若类中的方法同时调用了function级别、class级别、module级别的fixture，则3种fixture会同时生效：

    1. # 顺序在前面fixture会先执行
    2. def test_scope_02(self, module_auto, class_auto, func_auto):  
    3.     print("case scope 02")

    4）session级别(使用conftest.py共享fixture)

    当fixture的scope定义为session时，是指在当前目录下的所有用例之前和之后执行fixture对应的操作

    fixture为session级别是可以跨.py模块调用的，也就是当我们有多个.py文件的用例的时候，如果多个用例只需调用一次fixture，那就可以设置为scope="session"，并且写到conftest.py文件里

    使用方式：

    ① 定义测试用例文件

    ② 在指定目录下创建conftest.py（固定命名，不可修改）文件，然后在conftest.py文件中定义fixture方法，将scope指定为session，此时在当前目录下只要有一个用例使用了此fixture，则就会在当前目录下所有用例之前和之后会执行fixture定义的对应的操作。

    1. @pytest.fixture(scope="session", )
    2. def session_auto():
    3.     """session级别的fixture,针对该目录下的所有用例都生效"""
    4.     print("\n---session级别的用例前置操作---")
    5.     yield
    6.     print("---session级别的用例后置操作---")

    定义了session级别的fixture，存放于该用例文件的同一个目录下的conftest.py文件中，该目录下的任一用例文件中的任一测试用例，引用了这个session级别的fixture，则这个session级别的fixture会针对这整个用例文件会生效。若存放在根目录下，则针对整个工程的所有用例都会生效。

    1. class TestSessionAutoFixture:
    2.     # session级别的fixture任意一个用例引用即可
    3.     def test_session_auto_fixture_1(self, session_auto):
    4.         print("session 1 print")
    5.  
    6.     def test_session_auto_fixture_2(self):
    7.         print("session 1 print")
    8.  
    9.  
    10. def test_session_auto_fixture():
    11.     print("session 1 print")

    运行结果如下：

    5.Pytest fixture其他参数用法

    1）ids参数-修改用例结果名称

    @pytest.mark.parametrize() 还提供了第三个 ids 参数来自定义显示结果。

    1. stars = ["刘德华", "张学友", "黎明", "郭富城"]
    2. # 利用列表生成式生成一个用例名称的列表
    3. ids = [f"test-case-{d}" for d in range(len(stars))]
    4.  
    5. @pytest.mark.parametrize("name", stars, ids=ids)
    6. def test_multi_param(name):
    7.     print(f"my name is {name}")

    注：ids生成的用例名称数量一定要和用例数量一致，否则会报错，执行结果如下：

    2）name参数-重命名fixture函数名称

    1. @pytest.fixture(name="rename_get_user_info")
    2. def get_user_info():
    3.     user_name = "周润发"
    4.     print(user_name)
    5.  
    6. # 此处需传入重命名后的fixture函数名
    7. @pytest.mark.usefixtures("rename_get_user_info")
    8. def test_parametrize_by_use_fixtures():
    9.     """通过usefixtures装饰器传入fixture"""
    10.     print(f"test parametrize use fixtures")
    11.     
    12. def test_parametrize_by_fixture_name(rename_get_user_info):
    13.     """将fixture函数名作为形参传入"""
    14.     print(f"test parametrize use fixtures")

    3）params参数-提供返回值供测试函数调用

    示例一

    1. @pytest.fixture(params=[{"name": "周润发"}, {"age": 61}, {"height": 183}])
    2. def fix_func(request):  # request为内建fixture
    3.     # 使用request.param作为返回值供测试函数调用，params的参数列表中包含了做少元素，该fixture就会被调用几次，分别作用在每个测试函数上
    4.     return request.param  # request.param为固定写法
    5.  
    6. def test_fix_func(fix_func):
    7.     print(f"fixture函数fix_func的返回值为：{fix_func}")
    8.     
    9.     """打印结果如下：
    10.     fixture函数fix_func的返回值为：{'name': '周润发'}
    11.     fixture函数fix_func的返回值为：{'age': 61}
    12.     fixture函数fix_func的返回值为：{'height': 183}
    13.     """

    示例二

    1. params = [
    2.     {"case_id": 1, "case_title": "验证正常添加车辆", "car_name": "苏C99688", "car_type": 1, "origin": 1, "expected": "200"},
    3.     {"case_id": 2, "case_title": "验证添加重复车辆", "car_name": "苏C99688", "car_type": 1, "origin": 1, "expected": "500"},
    4.     {"case_id": 3, "case_title": "验证车牌号为空", "car_name": "", "car_type": 2, "origin": 1, "expected": "500"}]
    5.  
    6. @pytest.fixture(params=params)
    7. def add_car_params(request):
    8.     return request.param
    9.  
    10. def test_add_car(add_car_params):
    11.     print(f"{add_car_params['case_id']}-{add_car_params['case_title']}-{add_car_params['car_name']}")
    12.     
    13.     """
    14.     运行结果如下：
    15.     1-验证正常添加车辆-苏C99688
    16.     2-验证添加重复车辆-苏C99688
    17.     3-验证车牌号为空-
    18.     """

    6.内置fixture

    1）tmpdir和tmpdir_factory

    内置的tmpdir和tmpdir_factory负责在测试开始运行前创建临时文件目录，并在测试结束后删除。如果测试代码要对文件进行读/写操作，那么可以使用tmpdir或tmpdir_factory来创建文件或目录。单个测试使用tmpdir，多个测试使用tmpdir_factory。tmpdir的作用范围是函数级别，tmpdir_factory的作用范围是会话级别。

    1. def test_tmpdir(tmpdir):
    2.     # tmpdir already has a path name associated with it
    3.     # join() extends the path to include a filename
    4.     # the file is created when it's written to
    5.     a_file = tmpdir.join('something.txt')
    6.  
    7.     # you can create directories
    8.     a_sub_dir = tmpdir.mkdir('anything')
    9.  
    10.     # you can create files in directories (created when written)
    11.     another_file = a_sub_dir.join('something_else.txt')
    12.  
    13.     # this write creates 'something.txt'
    14.     a_file.write('contents may settle during shipping')
    15.  
    16.     # this write creates 'anything/something_else.txt'
    17.     another_file.write('something different')
    18.  
    19.     # you can read the files as well
    20.     assert a_file.read() == 'contents may settle during shipping'
    21.     assert another_file.read() == 'something different'
    22.  
    23.  
    24. def test_tmpdir_factory(tmpdir_factory):
    25.     # you should start with making a directory
    26.     # a_dir acts like the object returned from the tmpdir fixture
    27.     a_dir = tmpdir_factory.mktemp('mydir')
    28.  
    29.     # base_temp will be the parent dir of 'mydir'
    30.     # you don't have to use getbasetemp()
    31.     # using it here just to show that it's available
    32.     base_temp = tmpdir_factory.getbasetemp()
    33.     print('base:', base_temp)
    34.  
    35.     # the rest of this test looks the same as the 'test_tmpdir()'
    36.     # example except I'm using a_dir instead of tmpdir
    37.  
    38.     a_file = a_dir.join('something.txt')
    39.     a_sub_dir = a_dir.mkdir('anything')
    40.     another_file = a_sub_dir.join('something_else.txt')
    41.  
    42.     a_file.write('contents may settle during shipping')
    43.     another_file.write('something different')
    44.  
    45.     assert a_file.read() == 'contents may settle during shipping'
    46.     assert another_file.read() == 'something different'

    2）pytestconfig

    内置的pytestconfig可以通过命令行参数、选项、配置文件、插件、运行目录等方式来控制pytest。pytestconfig是request.config的快捷方式，它在pytest文档里有时候被称为“pytest配置对象”。

    要理解pytestconfig如何工作，可以添加一个自定义的命令行选项，然后在测试中读取该选项。

    1. def pytest_addoption(parser):
    2.     """"添加一个命令行选项"""
    3.     parser.addoption(
    4.         "--env", default="test", choices=["dev", "test", "pre"], help="enviroment parameter")

    以pytest_addoption添加的命令行选项必须通过插件来实现，或者在项目顶层目录的conftest.py文件中完成。它所在的conftest.py不能处于测试子目录下。

    上述是一个传入测试环境的命令行选项，接下来可以在测试用例中使用这些选项。

    1. def test_option(pytestconfig):
    2.     print('the current environment is:', pytestconfig.getoption('env'))
    3. # 运行测试
    4. pytest -s -q test_config.py::test_option

    由于前面的pytest_addoption中定义的env的默认参数是test，所以通过pytestconfig.getoption获取到的env的值就是test：

    3）其他内置fixture

    • cache：作用是存储一段测试会话的信息，在下一段测试会话中使用；
    • capsys：capsys 有两个功能：允许使用代码读取 stdout 和 stderr；可以临时禁制抓取日志输出；
    • monkeypatch：可以在运行期间对类或模块进行动态修改。在测试中，monkey patch 常用于替换被测试代码的部分运行环境，或者将输入依赖或输出依赖替换成更容易测试的对象或函数；
    • doctest_namespace：doctest 模块是 Python 标准库的一部分，借助它，可以在函数的文档字符串中放入示例代码，并通过测试确保有效。你可以使用 --doctest-modules 标识搜寻并运行 doctest 测试用例；
    • recwarn：可以用来检查待测代码产生的警告信息；recwarn 的值就像是一个警告信息列表，列表里的每个警告信息都有4个属性 category、message、filename、lineno。警告信息在测试开始后收集，如果你在意的警告信息出现在测试尾部，则可以在信息收集前使用 recwarn.clear() 清除不需要的内容。除了 recwarn，pytest 还可以使用 pytest.warns() 来检查警告信息。

    二、Pytest conftest全局作用文件详解

    Pytest支持在测试的目录中，创建conftest.py文件，进行全局配置。

    conftest.py文件须知：

    1. 可以跨.py文件调用，有多个.py文件调用时，可让conftest.py只调用了一次fixture，或调用多次fixture；
    2. conftest.py与运行的用例要在同一个pakage下，并且有__init__.py文件；
    3. 不需要import导入conftest.py，pytest用例会自动识别该文件，放到项目的根目录下就可以全局目录调用了，如果放到某个package下，那就在package内有效，可有多个conftest.py；
    4. conftest.py配置脚本名称是固定的，不能改名称；
    5. conftest.py文件不能被其他文件导入；
    6. 所有同目录测试文件运行前都会执行conftest.py文件；

    敲字不易，如果此文章对你有帮助的话，点个赞收个藏，给作者一个鼓励。也方便你下次能够快速查找。

  • 相关阅读:
    MongoDB聚合运算符：$setEquals
    Qt入门学习及GUI编程基础教程
    （C）一些题2
    普鸥知识产权｜西班牙商标注册流程你知道吗？
    windows下-mysql环境配置，以及使用navicat可视化数据库，便捷撰写sql语句。
    8 个最有用的 Flutter 技巧！
    Pyside6/PyQt6如何添加右键菜单，源码示例
    MySQL主键类型使用int、bigint、varchar区别
    远程控制安卓手机：便捷、高效与安全的方法
    LabVIEW与欧陆温控表通讯的实现与应用：厂商软件与自主开发的优缺点
  • 原文地址：https://blog.csdn.net/qq_43371695/article/details/133798172