Pytest中fixture夹具_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功能。