pytest-fixture
资料来源：虫师2020的个人空间-虫师2020个人主页-哔哩哔哩视频
支持类似unittest风格的fixture，即setup和teardown
class类中的方法分类
类方法可以直接调用，需要添加装饰器，修改类中的变量
实例方法，需要先实例化，修改实例方法内的变量
静态方法可以直接调用
class A:
name = 'jerry'
#类方法:修改类变量
@classmethod
def motify_name(cls):
return cls.name+'class'
# 初始化方法
def __init__(self):
self.name = 'tom'
#实例方法 instance Method：修改实例变量
def hello(self):
return self.name+'new'
#静态方法
@staticmethod
def static_method(x,y):
return x+y
if __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 pytest
def multiply(a, b):
"""Return the product of two numbers."""
return a * b
# Test fixture for the multiply function
class TestMultiply:
@classmethod
def setup_class(cls):
print("setup_class(): Executed before any method in this class")
@classmethod
def 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) == 12
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'
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) == 12
def 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 True
def 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 True
def 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 pytest
class Counter:
def __init__(self):
self.value = 0
def increment(self):
self.value += 1
def get_value(self):
return self.value
if __name__ == '__main__':
c = Counter()
c.increment()
c.increment()
c.increment()
c.increment()
print(c.get_value())import pytest
class Counter:
def __init__(self):
self.value = 0
def increment(self):
self.value += 1
def get_value(self):
return self.value
@pytest.fixture
def counter():
#setup
c = Counter()
print("setup_value:",c.value)
yield c #返回实例 c
#还原数据，用例结束后实现
c.value=0
print("teardonw_value:",c.value)
def test_counter(counter):
print('test-start')
assert counter.get_value() == 0
counter.increment()
assert counter.get_value() == 1
counter.increment()
assert counter.get_value() == 2
终结器 finalizer
同上，value增加后再重置为0
import pytest
class Counter:
def __init__(self):
self.value = 0
def increment(self):
self.value += 1
def get_value(self):
return self.value
@pytest.fixture
def counter(request):#request 参数不需要传值
#setup
c = Counter()
print("setup_value:",c.value)
def reset_counter():
#还原数据
c.value = 0
print("teardown_value:",c.value)
request.addfinalizer(reset_counter)
return c
def test_counter(counter):
print('test-start')
assert counter.get_value() == 0
counter.increment()
assert counter.get_value() == 1
counter.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_input
assert eval(input_str) == expectedpytest.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"原文地址：https://blog.csdn.net/sinat_34766121/article/details/140519720
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！