pytest_框架(6) - fixture作用域（scope）详解

fixture作用域（scope）详解

阅读目录：
  1. scope 参数
  2. 默认是function
  3. 执行顺序遵循： sesstion -> package -> module -> class -> function
  4. 每一个函数前后均会执行模块中的class
  5. 模块中的fixture对函数、方法均有效
  6. 测试类中的fixture只对方法有效
  7. 在模块和类中有同名的fixture存在时：局部优先，也就是类中的fixture优先

scope参数 – 表示被`@pytest.fixture标记的函数的作用域：

function -- 默认值， 作用域每个测试用例（包含函数/方法），每个用例执行前都会运行一次
class -- 作用于整个类，每个测试类/测试函数执行前都会运行一次
module -- 作用于整个模块（多个类），每个module(每个py文件)执行前都会运行一次，可以实现多个.py跨文件共享前置，后置
package -- 每个python包执行前都会运行一次
session -- 作用于整个session， 每个测试前运行一次

**若fixture放conftest.py 中，可以理解为：

scope参数为 function -- 每一个测试文件中的所有测试用例执行前都会执行一次conftest文件中的fixture
scope参数为 class -- 每一个测试文件中的测试类执行前都会执行一次conftest文件中的fixture
scope参数为 module -- 每一个测试文件执行前都会执行一次conftest文件中的fixture
scope参数为 session -- 所有py文件执行前执行一次conftest文件中的fixture

经验总结：

1. 默认是function
2. 执行顺序遵循： session > package > module > class > function
3. 模块中的fixture对函数、方法均有效
4. 测试类中的fixture只对方法有效
5. 在模块和类中有同名的fixture存在时： 局部优先， 也就是类中fixture优先

逐一验证：

未指定scope 即设置了默认运行

#! usr/bin/env python
# _*_ coding: utf-8 _*_
# @Author: zcs
# @wx: M_Haynes
# @Blog:
# 备注： pytest_框架（6） -- fixture作用域 scope 详解

""" 默认是 function """
import pytest

@pytest.fixture(autouse=True)
def setup_teardown():
    print(" ---------------- 默认是function")

def test_example6_1():
    print(" -------------- 执行测试用例1")

def test_example6_2():
    print(" --------------- 执行测试用例2")


class TestExample(object):
    def test_example6_a(self):
        print("---------------------- 执行类 -- test_example6_a")

    def test_example6_b(self):
        print(" --------------------- 执行类 -- test_example6_b")

结果： 作用域默认是function

执行顺序尊许：sesstion->package->module->class->function

@pytest.fixture(autouse=True, scope="function")
def tear_down():
    print(" ======================== fixture -- 前置 -- function")
    yield
    print(" ========================  fixture -- 后置  --- function")

@pytest.fixture(autouse=True, scope="class")
def tear_down2():
    print(" ========================  fixture -- 前置 -- class")
    yield
    print(" ========================  fixture --- 后置 -- class")

@pytest.fixture(autouse=True, scope="module")
def tear_down3():
    print(" ======================= fixture -- 前置 -- module")
    yield
    print(" ========================  fixture -- 后置 -- module")

@pytest.fixture(autouse=True, scope="package")
def tear_down4():
    print(" ====================== fixture -- 前置 -- package")
    yield
    print(" ========================  fixture -- 后置 -- package")

@pytest.fixture(autouse=True, scope="session")
def tear_down5():
    print(" ========================  fixture --- 前置 -- session")
    yield
    print(" ======================== fixture -- 后置 -- session")


def test_example6():
    print("-------------- 测试用例 -- test_example6")

def test_example7():
    print(" ------------- 测试用例 -- test_example7")

class TestScope:
    def test_example8(self):
        print(" ------------------------ test_example8")

    def test_example9(self):
        print(" ------------------------- test_example9")

运行结果：

每一个函数前后均会执行模块中的class

运行结果：

模块中的fixture对函数、方法均有效

运行结果：

测试列中的fixture只对方法有效

import pytest

def test_example10():
    print(" -------------------------- 执行测试用例 ---- test_example10")

def test_example11():
    print("--------------------------- 执行测试用例 ---- test_example11")

class  Testclass(object):
    def test_example12(self):
        print(" -------------------- 测试类中 -- 测试函数 --- test_example12")

    def test_example13(self):
        print(" ------------------ 测试类中 -- 测试函数 --- test_example13")

    @pytest.fixture(autouse=True, scope="function")
    def class_teardown(self):
        print(" ------------------------------ class_teardown: function -- 前置")
        yield
        print(" --------------------------- class_teardown: function -- 后置")

    @pytest.fixture(autouse=True, scope="class")
    def class_teardown2(self):
        print(" ---------------------- class_teardown2: class -- 前置")
        yield
        print(" ---------------------- class_teardown2: class --- 后置")

    @pytest.fixture(autouse=True, scope="module")
    def class_teardown3(self):
        print(" ---------------------- class_teardown3: module -- 前置")
        yield
        print(" ---------------------- class_teardown3: module -- 后置")

    @pytest.fixture(autouse=True, scope="package")
    def class_teardown4(self):
        print(" ---------------------- class_teardown4: package --- 前置")
        yield
        print(" ---------------------- class_teardown4: package --- 后置")

    @pytest.fixture(autouse=True, scope="session")
    def class_teardown5(self):
        print(" ---------------------- class_teardown5: session -- 前置")
        yield
        print(" ---------------------- class_teardown5: session -- 后置")

结果： 对函数无效

在模块和类中有同名的fixture存在时：局部优先，也就是类中fixture优先

"""
在模块和类中有同名的fixture存在时： 局部优先，也就是类中fixture优先
"""
import pytest

def test_example_a():
    print("------------ 测试函数： test_example_a ------------")

def test_example_b():
    print("------------ 测试函数: test_example_b ------------")


@pytest.fixture(autouse=True, scope="function")
def teardown():
    print(" ---------------------- teardown: function -- 前置")
    yield
    print("---------------------- teardown: function -- 后置")

@pytest.fixture(autouse=True, scope="class")
def teardown1():
    print("------------------------ teardwon: class -- 前置")
    yield
    print("---------------------- teardwon: class -- 后置")

@pytest.fixture(autouse=True, scope="module")
def teardown2():
    print("---------------------- teardwon: module -- 前置")
    yield
    print("---------------------- teardwon: module -- 后置")

@pytest.fixture(autouse=True, scope="package")
def teardown3():
    print("---------------------- teardwon: package -- 前置")
    yield
    print("---------------------- teardwon: package -- 后置")

@pytest.fixture(autouse=True, scope="session")
def teardown4():
    print(" ---------------------- teardwon: session -- 前置")
    yield
    print("---------------------- teardwon: session -- 后置")

class TestScope:
    def test_class_scope(self):
        print(" ---------------------- test_class_scope")

    def test_class_scope_1(self):
        print(" ---------------------- test_class_scope_1")

    @pytest.fixture(autouse=True, scope="function")
    def teardown(self):
        print(" ---------------------- teardown: function -- 前置(类中)")
        yield
        print("---------------------- teardown: function -- 后置（类中）")

    @pytest.fixture(autouse=True, scope="class")
    def teardown1(self):
        print("------------------------ teardwon: class -- 前置（类中）")
        yield
        print("---------------------- teardwon: class -- 后置（类中）")

    @pytest.fixture(autouse=True, scope="module")
    def teardown2(self):
        print("---------------------- teardwon: module -- 前置（类中）")
        yield
        print("---------------------- teardwon: module -- 后置（类中）")

    @pytest.fixture(autouse=True, scope="package")
    def teardown3(self):
        print("---------------------- teardwon: package -- 前置（类中）")
        yield
        print("---------------------- teardwon: package -- 后置（类中）")

    @pytest.fixture(autouse=True, scope="session")
    def teardown4(self):
        print(" ---------------------- teardwon: session -- 前置（类中）")
        yield
        print("---------------------- teardwon: session -- 后置（类中）")

运行结果：

更多交流和持续更新 请扫码 + VX

本文由mdnice多平台发布