pytest-fixture

资料来源：虫师2020的个人空间-虫师2020个人主页-哔哩哔哩视频

支持类似unittest风格的fixture，即setup和teardown

class类中的方法分类

类方法可以直接调用，需要添加装饰器，修改类中的变量

实例方法，需要先实例化，修改实例方法内的变量

静态方法可以直接调用

class A:name = 'jerry'#类方法:修改类变量@classmethoddef motify_name(cls):return cls.name+'class'# 初始化方法def __init__(self):self.name = 'tom'#实例方法 instance Method：修改实例变量def hello(self):return self.name+'new'#静态方法@staticmethoddef static_method(x,y):return x+yif __name__ == '__main__':# 类方法可以直接调用motify = A.motify_name()print("classmethod:",motify)#静态方法可以直接调用result = A.static_method(3, 4)print("static_method:", result)#实例方法，需要先实例化a = A()new_name = a.hello()print("类中对象的属性",a.name)print("instance Method:",new_name)

class 级别

import pytestdef multiply(a, b):"""Return the product of two numbers."""return a * b# Test fixture for the multiply function
class TestMultiply:@classmethoddef setup_class(cls):print("setup_class(): Executed before any method in this class")@classmethoddef teardown_class(cls):print("teardown_class(): Executed after all methods in this class")def setup_method(self):print("setup_method(): Executed before each test method")def teardown_method(self):print("teardown_method(): Executed after each test method")def test_multiply_3(self):"""Test multiply with two integers."""print("Executing test3")assert multiply(3, 4) == 12def test_multiply_4(self):"""Test multiply with an integer and a string (should fail)."""print("Executing test4")# Note: This test will raise a TypeError due to incompatible types.assert multiply(3, 'a') == 'aaa'

module级别

import pytest# 功能函数
def multiply(a, b):return a * b# ====== fixture ======
def setup_module(module):print("setup_module():在整个模块之前执行",module)def teardown_module(module):print("teardown_module():在整个模块之后执行",module)def setup_function(function):print("setup_function():在每个方法之前执行",function)def teardown_function(function):print("teardown_function():在每个方法之后执行",function)def test_multiply_1():print("正在执行test1")assert multiply(3, 4) == 12def test_multiply_2():print("正在执行test2")assert multiply(3, 'a') == 'aaa'class TestMultiply:def test_multiply_4(self):"""Test multiply with an integer and a string (should fail)."""print("Executing test4")# Note: This test will raise a TypeError due to incompatible types.assert multiply(3, 'a') == 'aaa'

fixture的简单用例

单个fixture

用fixture之前的原代码

import pytest# @pytest.fixture()
def init_env():print("this is fixture")return Truedef test_case(init_env):if init_env is True:print("test case")if __name__ == '__main__':ie = init_env()test_case(init_env=ie)

 fixture装饰后

import pytest@pytest.fixture()
def init_env():print("this is fixture")return Truedef test_case(init_env):if init_env is True:print("test case")

多个fixture

import pytest@pytest.fixture()
def first():print("this is fixture")return "a"@pytest.fixture()
def second():print("this is fixture")return 2@pytest.fixture()
def oder(first,second):return first * second@pytest.fixture()
def expected():return "aa"def test_string(oder,expected):print(oder)assert oder == expected

autouse = True，被装饰的函数自动执行

import pytest@pytest.fixture()
def first():print("this is fixture")return "a"@pytest.fixture()
def second(first):print("this is 2fixture")return []@pytest.fixture(autouse=True)
def order(second,first):print("自动执行")return second.append(first)def test_string(second,first):assert second == [first]

使用范围

scope:=module,session,class,function；

function：每个test都运行，默认是function的scope ，

class：每个 class的所有test只运行一次；

module：每个module的所有test只运行一次；

session：每个session只运行一次

返回参数

在 pytest 中，一个 fixture 可以返回任意数量的数据，包括多个参数。然而，当你想要通过 request 对象在 fixture 内部访问参数化装饰器 (@pytest.mark.parametrize) 提供的参数时，你需要确保正确地设置 fixture 和参数化装饰器之间的关系。在参数化装饰器中直接定义多个参数，并在测试函数中接收它们。然后在 fixture 中，可以直接返回一个元组或者一个字典，其中包含了多个值。

下面是一个示例，展示了如何在一个 fixture 中返回两个参数：

import pytest# 这个 fixture 返回一个元组，其中包含两个值
@pytest.fixture
def two_values(request):# 获取参数化装饰器提供的参数first_value = request.param[0]second_value = request.param[1]# 返回一个包含两个值的元组return (first_value, second_value)# 使用 @pytest.mark.parametrize 装饰器提供多组参数
# 直接在测试函数中接收两个参数
@pytest.mark.parametrize("first_value, second_value", [(1, 2), (3, 4)])
def test_with_two_values(first_value, second_value):assert first_value < second_value

在这个例子中，two_values fixture 返回一个包含两个值的元组。我们使用 @pytest.mark.parametrize 装饰器来提供两组参数 (1, 2) 和 (3, 4)。然后在测试函数 test_with_two_values 中，我们接收 two_values fixture 的结果，并同时接收 first_value 和 second_value 参数，这些参数是由参数化装饰器提供的。

Teardown - yield 

迭代器

#被测试类所实现功能
import pytestclass Counter:def __init__(self):self.value = 0def increment(self):self.value += 1def get_value(self):return self.valueif __name__ == '__main__':c = Counter()c.increment()c.increment()c.increment()c.increment()print(c.get_value())

import pytestclass Counter:def __init__(self):self.value = 0def increment(self):self.value += 1def get_value(self):return self.value@pytest.fixture
def counter():#setupc = Counter()print("setup_value:",c.value)yield c  #返回实例 c#还原数据，用例结束后实现c.value=0print("teardonw_value:",c.value) def test_counter(counter):print('test-start')assert counter.get_value() == 0counter.increment()assert counter.get_value() == 1counter.increment()assert counter.get_value() == 2

终结器 finalizer

同上，value增加后再重置为0

import pytestclass Counter:def __init__(self):self.value = 0def increment(self):self.value += 1def get_value(self):return self.value@pytest.fixture
def counter(request):#request 参数不需要传值#setupc = Counter()print("setup_value:",c.value)def reset_counter():#还原数据c.value = 0print("teardown_value:",c.value)request.addfinalizer(reset_counter)return cdef test_counter(counter):print('test-start')assert counter.get_value() == 0counter.increment()assert counter.get_value() == 1counter.increment()assert counter.get_value() == 2

fixture装饰的方法的request

在PyTest中，`request`对象是一个特殊的fixture，它提供了对当前测试请求的访问。当你在自定义的fixture函数中使用`request`作为参数时，你实际上可以获得当前测试的详细信息，并且可以利用这些信息来定制fixture的行为。`request`对象提供了很多有用的方法和属性，使你能够更灵活地设置和清理测试环境。

在你提供的fixture示例中，`request`对象被用来添加一个finalizer，即一个在测试结束后自动调用的清理函数。`request.addfinalizer()`方法接受一个可调用对象作为参数，并确保在测试完成时调用它，即使测试失败或抛出了异常。这使得你可以在测试结束后执行一些必要的清理工作，比如关闭文件、重置状态、释放资源等。

以下是一些`request`对象常用的方法和属性：

- `request.param`：如果测试函数使用了参数化装饰器`@pytest.mark.parametrize`，则`request.param`将包含当前测试迭代的参数值。
- `request.function`：返回当前正在运行的测试函数。
- `request.cls`：如果测试函数属于一个测试类，则返回这个测试类。
- `request.module`：返回包含当前测试的模块。
- `request.config`：返回PyTest配置对象，可以从中获取命令行选项和其他配置信息。
- `request.getfixturevalue(name)`：获取其他fixture的返回值。
- `request.cached_setup`：用于缓存setup过程的结果，避免重复执行相同的setup步骤。

总的来说，`request`对象在自定义fixture中提供了一种强大的机制，用于根据测试的具体需求动态调整fixture的行为，从而实现更加复杂的测试场景支持和资源管理。

参数化

10_pytest之fixture装饰器使用（下）_哔哩哔哩_bilibili

直接参数化（Direct Parametrization）

直接参数化是最直观的参数化方法，它在测试函数上使用 @pytest.mark.parametrize 装饰器，直接指定测试函数的参数及其值。这种方法适用于当你的参数可以直接在测试函数中使用，不需要额外的处理或准备。

import pytest@pytest.mark.parametrize("input, expected", [("3+5", 8),("2+4", 6),("-1+1", 0),
])
def test_eval(input, expected):assert eval(input) == expected

间接参数化（Indirect Parametrization）

间接参数化则是通过 fixture 来提供参数，这样可以在参数化测试之前执行一些预处理或设置工作。当你需要在测试前做某些准备工作，比如数据库连接、文件读取、网络请求等，或者当参数的准备较为复杂时，使用间接参数化就很有必要了。

import pytest@pytest.fixture
def prepared_input(request):input_str, expected = request.param# 执行一些预处理，比如从数据库获取数据return input_str, expected@pytest.mark.parametrize("prepared_input", [("3+5", 8),("2+4", 6),("-1+1", 0),
], indirect=True)
def test_eval(prepared_input):input_str, expected = prepared_inputassert eval(input_str) == expected

pytest.mark.parametrize的使用

基本使用

@pytest.mark.parametrize("argnames", argvalues)
def test_function(argnames):# 测试逻辑

argnames 是一个字符串，包含了测试函数参数的名称，多个参数用逗号分隔。

argvalues 是一个列表，其中的每一个元素都是一组参数值，对应于 argnames 中的参数。

import pytest@pytest.mark.parametrize("x, y, expected", [(1, 2, 3),(5, 3, 8),(-1, -1, -2),
])
def test_addition(x, y, expected):assert x + y == expected

使用 ids

每组参数指定一个标识符（id），这样可以使得测试报告更加可读。ids 应该是一个与 argvalues 同长度的列表，每个元素对应一组参数的描述。

@pytest.mark.parametrize("x, y, expected", [(1, 2, 3),(5, 3, 8),(-1, -1, -2),
], ids=["positive_numbers", "larger_positive_numbers", "negative_numbers"])
def test_addition(x, y, expected):assert x + y == expected

复杂参数

如果参数值本身是复杂的结构，如列表或字典，你可以直接在 argvalues 中使用这些结构。

@pytest.mark.parametrize("data", [{"input": [1, 2, 3], "expected": 6},{"input": [4, 5, 6], "expected": 15},
])
def test_sum_list(data):assert sum(data["input"]) == data["expected"]

间接参数化

间接参数化允许你使用 fixture 作为参数源，这样可以在测试函数运行前进行一些初始化工作。要使用间接参数化，你只需在 argnames 后面添加 indirect=True。

import pytest@pytest.fixture
def prepared_data(request):if request.param == "case1":return {"input": [1, 2, 3], "expected": 6}elif request.param == "case2":return {"input": [4, 5, 6], "expected": 15}@pytest.mark.parametrize("prepared_data", ["case1", "case2"], indirect=True)
def test_sum_list(prepared_data):assert sum(prepared_data["input"]) == prepared_data["expected"]

fixture两个方法传递参数

直接在 Fixture 方法中调用另一个 Fixture：

如果一个 fixture 需要依赖另一个 fixture 的输出，你可以在一个 fixture 的实现中直接调用另一个 fixture。这是最直接的方式，但要注意保持依赖关系清晰，避免过多的耦合。

import pytest@pytest.fixture
def fixture_a():return "A"@pytest.fixture
def fixture_b(fixture_a):# 使用 fixture_a 的输出return fixture_a + "B"def test_example(fixture_b):assert fixture_b == "AB"

使用 request 对象间接获取参数

当你使用 @pytest.mark.parametrize 装饰器时，可以在 fixture 中使用 request 对象来获取参数化装饰器提供的参数。

import pytest@pytest.fixture
def fixture_a(request):# 从 request.param 获取参数return request.param@pytest.fixture
def fixture_b(fixture_a):return fixture_a + "B"@pytest.mark.parametrize("fixture_a", ["A"], indirect=True)
def test_example(fixture_b):assert fixture_b == "AB"

使用 Indirect 参数化

如果你需要将一个 fixture 的输出作为另一个 fixture 的参数，你可以使用 indirect 参数化。这允许你将一个 fixture 的返回值直接作为另一个 fixture 的参数。

import pytest@pytest.fixture
def fixture_a():return "A"@pytest.fixture
def fixture_b(fixture_a):return fixture_a + "B"@pytest.mark.parametrize("fixture_a", ["A"], indirect=True)
@pytest.mark.parametrize("fixture_b", ["AB"], indirect=True)
def test_example(fixture_a, fixture_b):assert fixture_a + "B" == fixture_b

通常你不需要为每个 fixture 单独使用 @pytest.mark.parametrize，因为这可能导致不必要的重复测试。更常见的是，一个 fixture 依赖于另一个 fixture 的输出，如第一个例子所示。

使用 Fixture 返回复杂数据结构

如果一个 fixture 需要返回复杂的数据结构，如字典或元组，你可以在测试函数中直接解构这些数据结构。

import pytest@pytest.fixture
def complex_fixture():return {"part_a": "A", "part_b": "B"}def test_example(complex_fixture):part_a, part_b = complex_fixture.values()assert part_a + part_b == "AB"

Fixture接收外部参数

让第二个 fixture 既接收第一个 fixture 的返回值，又接收一个额外的参数

import pytest# 第一个 fixture
@pytest.fixture
def first_fixture():return "Hello from first fixture"# 第二个 fixture，它接收第一个 fixture 的返回值和一个额外的参数
@pytest.fixture
def second_fixture(first_fixture, extra_param):return first_fixture + ", " + extra_param# 使用 indirect=True 指定 extra_param 应该间接地传递给 second_fixture
@pytest.mark.parametrize("extra_param", ["World"], indirect=["second_fixture"])
def test_example_with_params(second_fixture):assert second_fixture == "Hello from first fixture, World"