None: print("tearDown结束") #._conftest.py模块层继">
当前位置:   article > 正文

Pytest中fixture夹具_conftest.py模块层继承

conftest.py模块层继承

在这里插入图片描述

Unittest和Pytest前后置区别

这里抽用例前置与后置的区别来讲,先看unittest的前后置使用:

import unittest

class TestFixtures01(unittest.TestCase):
    # 所有用例执行前执行
    def setUp(self) -> None:
        print("setUp开始")
    def tearDown(self) -> None:
        print("tearDown结束")

    # 每条用例执行前执行
    @classmethod
    def setUpClass(cls) -> None:
        print("setUpClass开始")

    @classmethod
    def tearDownClass(cls) -> None:
        print("tearDownClass结束")

    # 测试用例
    def test_001(self):
        print("测试用例001")

class TestFixtures02(unittest.TestCase):
    def test_002(self):
        print("测试类2")

# 每个模块执行前执行
def setUpModule():
    """
    在所有测试类在调用之前会被执行一次,函数名是固定写法,会被unittest框架自动识别
    """
    print('集成测试 >>>>>>>>>>>>>>开始')
def tearDownModule():
    print("集成测试 >>>>>>>>>>>>>>结束")

if __name__ == '__main__':
    unittest.main()
  • 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
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37

运行结果:
在这里插入图片描述
接下来看pytest的前后置:

1、我们都知道在自动化测试中都会用到前后置,pytest 相比 unittest 无论是前后置还是插件等都灵活了许多,还能自己用 fixture 来定义。

首先了解一下,用例运行前后置级别如下:

1.模块级:全局的,整个模块开只运行一次,优先于测试用例。

2.类级别:定义在类里面,只针对此类生效。类似unittest的cls装饰器

3.函数级:只对函数生效,类下面的函数不生效。

4.方法级:定义在类里面,每个用例都执行一次

def setup_module():
    print('\n整个模块 前 只运行一次')

def teardown_module():
    print('\n整个模块 后 只运行一次')

def setup_function():
    print('\n不在类中的函数,每个用例 前 只运行一次')

def teardown_function():
    print('\n不在类中的函数,每个用例 后 只运行一次')

def test_ab():
    b = 2
    assert b < 3

def test_aba():
    b = 2
    assert b < 3

class Test_api():

    def setup_class(self):
        print('\n此类用例 前 只执行一次')
    def teardown_class(self):
        print('\n此类用例 后 只执行一次')

    def setup_method(self):
        print('\n此类每个用例 前 只执行一次')

    def teardown_method(self):
        print('\n此类每个用例 后 执行一次')

    def test_aa(self):
        a = 1
        print('\n我是用例:a')       # pytest -s 显示打印内容
        assert a > 0

    def test_b(self):
        b = 2
        assert b < 3
  • 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
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41

运行结果:
在这里插入图片描述

详解Pytest中fixture

一、conftest.py

定义公共的fixture,多个测试类中都可以调用
pytest提供了conftest.py文件,可以将fixture定义在此文件中
运行测试用例时,不需要去导入这个文件,会自动去查找conftest.py文件,然后去找到对用的fixture

二、前置和后置

fixture函数根据关键字yield作为前置和后置的分割线,并且yield也可以接收返回值,作用相当于return

unittest的前置后置写在setUp和tearDown中的,如果其他测试类有一样的前置后置我要重复运用这些前置后置unittest办不到,或者我需要用之前的部分前置 后置.pytest的共享conftest.py的函数里面的前置后置,可以做到前置后置共享。也不要引用。
在这里插入图片描述

@pytest.fixture(scope="class")
def access_web():
    driver = webdriver.Chrome()
    driver.maximize_window()
    driver.get(cd.login_url)
    yield driver
    driver.quit()


@pytest.fixture(scope="class")
def longin_web(access_web):  # 继承access_web的前置后置 access_web作为参数,也作为返回值
    # 以学生帐叼,登陆系统。这里是在网页上操作
    # driver = webdriver.Chrome()
    # driver.maximize_window()
    # driver.get(cd.login_url)
    LoginPage(access_web).login(*cd.student_user)
    # ip = IndexPage(access_web)
    yield access_web
    # driver.quit()
# 先调用access_web的前置
# 在调用自己的前置
# 在执行用例
# 在执行自己的后置
# 在执行access_web的后置
#继承顺序 函数可以继承类 类可以继承模块 模块可以继承会话 低级别可以跨越继承高级别
  • 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
import pytest

@pytest.fixture()
def init_demo():
    print("这是测试用例的前置")
    a = 1
    yield a  # 分割线(yield + 返回值)
    print("这是测试用例的后置")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

三、调用fixture

1.在测试用例中直接调用

将fixtures的函数名称作为测试用例的入参

如果fixture有返回值,那么测试用例中的fixture函数名称就接收返回值,并且可以将fixture函数名称作为返回值使用

def test_add_01(init_demo):
    b = init_demo + 2
    assert 3 == b
  • 1
  • 2
  • 3

在这里插入图片描述
2.用fixture装饰器调用fixture

在测试用例/测试类前面加上@pytest.mark.usefixtures(‘fixture函数名称’)
ps:定义conftest.py文件,在此文件中可以定义多个fixture,pytest会自动搜索此文件

import pytest

@pytest.mark.usefixtures('init_demo')
def test_add_02():
    b = 1 + 2
    assert 3 == b
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

在这里插入图片描述
3.用autos调用fixture

在定义fixture时,有一个参数autouse,默认设置的为False
当默认为False,就可以选择用上面两种方式来使用fixture
当设置为Ture时,在一个session内的所有的test都会自动调用这个fixture,建议该开关谨慎使用

conftest代码如下:

import pytest

@pytest.fixture(autouse=True)
def init_demo():
    print("这是测试用例的前置")
    yield
    print("这是测试用例的后置")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

测试代码如下:

import pytest

def test_add_02():
    b = 1 + 2
    assert 3 == b
  • 1
  • 2
  • 3
  • 4
  • 5

在这里插入图片描述

四、fixture的继承(前置的前置,后置的后置)

作用域(scope关键字):function/函数级(测试用例)、class/类级(测试类)、- module/模块级(测试模块—py文件)、session/会话级(整个测试执行会话)
形象比喻:夹心饼干
继承条件:作用域由里向外继承作用域,也可以继承同级的作用域
执行顺序:前置由外层到内层执行,后置由内层到外层执行,先执行最里层的作用域,在执行它的上一层作用域,直到再向外找不到作用域为止
继承方法:直接将继承的fixture的函数名称作为入参传入即可
返回值:继承父类的同时,也继承了父类的返回值

conftest.py代码如下:

import pytest

@pytest.fixture(scope='session')
def init_session():
    print("这是测试会话的前置")
    yield
    print("这是测试会话的后置")


@pytest.fixture(scope='module')
def init_module(init_session):
    print("这是测试模块的前置")
    yield
    print("这是测试模块的后置")


@pytest.fixture(scope='class')
def init_class(init_module):
    print("这是测试类的前置")
    yield
    print("这是测试类的后置")


@pytest.fixture  # 相当于@pytest.fixture(scope='function')
def init_function(init_class):
    print("这是测试用例的前置")
    yield
    print("这是测试用例的后置")
  • 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

在这里插入图片描述
打印结果
在这里插入图片描述

fixture不同级别的执行次数

session 会话级,在一个会话只会执行一次。不管你在py文件打多少次,只会执行一次
module 模块级。 不管你在py文件,哪里多次打多少次,一个模块只会执行一次。
会话级和module打一个对象头上,会先执行会话级的前置–module的前置–代码–module的后置–session的前置 如下图这种
在这里插入图片描述
演示代码:

mport pytest

@pytest.fixture(scope='session')
def init_session():
    print("这是测试会话的前置")
    yield
    print("这是测试会话的后置")


@pytest.fixture(scope='module')
def init_module():
    print("这是测试模块的前置")
    yield
    print("这是测试模块的后置")


@pytest.fixture(scope='class')
def init_class():
    print("这是测试类的前置")
    yield
    print("这是测试类的后置")


@pytest.fixture  # 相当于@pytest.fixture(scope='function')
def init_function():
    print("这是测试用例的前置")
    yield
    print("这是测试用例的后置")
  • 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

测试代码 全程打断点 可以看得非常清楚
在这里插入图片描述
在这里插入图片描述
会话级 class 打类上面,类里面的测试用例在执行测试用例之前只会执行一次,相当于unittest的setupClass 和tearDownClass 例子我就不举了,但是如果类级别打在外面的函数上,还是会执行的。这里要注意
函数级 函数级fixture打类上面,下面所有测试用例都会,执行函数级的前置 后置。类似unittest 的setUp tearDown.
pytest fixture的作用域,函数级和会话级 可以用unittest的 setup setUpClass来理解
在这里插入图片描述
在这里插入图片描述
fixture的参数params接收一个容器比如list 元组 嵌套的list等等。传个内置的fixturerequest通过request.para返回。这种也可以类似parametrize功能。
在这里插入图片描述

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/Cpp五条/article/detail/672706
推荐阅读
相关标签
  

闽ICP备14008679号