资料来源:虫师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"