Pytest框架 — 07、Pytest的Fixture（部分前后置）(二)

目录

• 4、Fixture的相互调用
  
• 5、Fixture复用
  
• 6、Fixture缓存返回结果
  
• 7、Fixture的后置处理
  
  
  
  • （一）使用yield关键字实现后置
    
  • （二）使用addfinalizer关键字实现后置
    
  • （三）yield和addfinalizer的区别
    
  
  

4、Fixture的相互调用

示例：

1. import pytest
4. # 第一层fixture
5. @pytest.fixture()
6. def fixture_1():
7.     data = "fixture_1"
8.     print("这是第一层fixture")
9.     return data
12. # 第二层fixture
13. @pytest.fixture()
14. def fixture_2(fixture_1):  # 在这里传递调用第一层fixture
15.     print("这是第二层fixture")
17. # 第三层fixture
18. @pytest.fixture()
19. @pytest.mark.usefixtures("fixture_1")  # 这种fixture相互调用方式不生效
20. def fixture_3():
21.     print("这是第三层fixture")
24. # 测试类
25. class TestClass:
26.     def test_1(self, fixture_1):
27.         print("调用第1层fixture，返回值为{}".format(fixture_1))
29.     def test_2(self, fixture_2):
30.         print("调用第2层fixture，返回值为{}".format(fixture_2))
32.     def test_3(self, fixture_3):
33.         print("调用第3层fixture")
36. """
37. 执行结果
38. fixture/use_fixture_each_other.py::TestClass::test_1 这是第一层fixture
39. 调用第1层fixture，返回值为fixture_1
40. PASSED
41. fixture/use_fixture_each_other.py::TestClass::test_2 这是第一层fixture
42. 这是第二层fixture
43. 调用第2层fixture，返回值为None
44. PASSED
45. fixture/use_fixture_each_other.py::TestClass::test_3 这是第三层fixture
46. 调用第3层fixture
47. PASSED
48. """

复制代码

示例说明：

• 在调用存在相互调用的fixture时，执行顺序由顶层fixture逐层向下执行（如示例test_2优先执行fixture_1再执行fixture_2）
  
• 当调用存在相互调用的fixture时，直接被调用的fixture不会将自己接收到的返回值返回给调用方（如示例test_2不会接收到由fixture_1返回的值）
  
• 相互调用fixture时不能使用pytest.mark.usefixture装饰器（如示例fixture_3）
  

5、Fixture复用

不同的测试函数可以请求相同的fixture，每个测试函数都会获得该fixture的各自结果。不同的测试函数不互相影响，这样可以保证每个测试函数都能得到干净一致的数据。
示例

1. import pytest
4. @pytest.fixture()
5. def fixture_1():
6.     return []
9. def test_1(fixture_1):
10.     fixture_1.append(0)
11.     print(f"结果:{fixture_1}")
14. def test_2(fixture_1):
15.     fixture_1.append(9)
16.     print(f"结果:{fixture_1}")
18. """
19. 执行结果
20. fixture/reuse_fixture.py::test_1 结果:[0]
21. PASSED
22. fixture/reuse_fixture.py::test_2 结果:[9]
23. PASSED
24. """

复制代码

示例说明
由上面例子可以看出，两个测试函数都调用了fixture_1，但每次调用返回的结果是一样的，并不会因为test_1中fixture_1先添加了0而影响test_2调用的fixture_1返回的结果
6、Fixture缓存返回结果

在同一个测试函数多次调用同一个fixture时，第一次执行该fixture函数之后，会把返回结果缓存起来，不会再次执行它们
示例：

1. import pytest
4. @pytest.fixture()
5. def fixture_1():
6.     print("执行fixture_1")
7.     return "a"
9. @pytest.fixture()
10. def fixture_2():
11.     print("执行fixture_2")
12.     return []
14. @pytest.fixture()
15. def fixture_append(fixture_1, fixture_2):
16.     print("执行fixture_append")
17.     fixture_2.append(fixture_1)
19. def test_fixture(fixture_append, fixture_2, fixture_1):
20.     print("执行测试函数")
21.     print(fixture_2)
23. """
24. 执行结果
25. fixture/fixture_cache.py::test_fixture 执行fixture_1
26. 执行fixture_2
27. 执行fixture_append
28. 执行测试函数
29. ['a']
30. PASSED
32. """

复制代码

示例说明：
由上面例子可以看出在fixture函数fixture_append中，fixture_1第一次被请求返回字母a，fixture_2被第二次被请求返回空列表，在测试函数test_fixture中fixture_2第二次被请求，但返回结果不是不是空列表，而是['a']。如果同一个fixture在同一个测试函数中每次都去请求，那么必然返回的是空列表。
7、Fixture的后置处理

前面的案例都是加了前置处理，相当于setup()，后置teardown()在fixture中是可以通过yield关键字和addfinalizer关键字来实现
（一）使用yield关键字实现后置

• 示例
  

1. import pytest
4. @pytest.fixture(autouse=True)
5. def fixture_3():
6.     print("这是一个前置处理")
7.     yield
8.     print("这是一个后置处理")
10. def testcase_1(fixture_3):
11.     print("这是测试用例1")
13. def testcase_2(fixture_3):
14.     print("这是测试用例2")
16. """
17. 执行结果
18. fixture/use_fixture_3.py::testcase_1 这是一个前置处理
19. 这是测试用例1
20. PASSED这是一个后置处理
22. fixture/use_fixture_3.py::testcase_2 这是一个前置处理
23. 这是测试用例2
24. PASSED这是一个后置处理
25. """

复制代码

• 执行顺序
  在前置处理中会根据fixture函数之间的线性关系顺序调用的，后置处理顺序会反过来
  

1. import pytest
4. @pytest.fixture()
5. def fixture_1():
6.     print("这是fixture_1")
7.     return 1
9. @pytest.fixture()
10. def fixture_2(fixture_1):
11.     print("这是fixture_2的【前置】")
12.     yield 2
13.     print("这是fixture_2的【后置】")
15. @pytest.fixture()
16. def fixture_add(fixture_1, fixture_2):
17.     print("这是fixture_add的【前置】")
18.     yield fixture_1 + fixture_2
19.     print('这是fixture_add的【后置】')
21. def test_fixture(fixture_2, fixture_add):
22.     print("这是测试函数")
23.     assert fixture_add == 3
25. """
26. 执行结果
27. fixture/yiled_order.py::test_fixture 这是fixture_1
28. 这是fixture_2的【前置】
29. 这是fixture_add的【前置】
30. 这是测试函数
31. PASSED这是fixture_add的【后置】
32. 这是fixture_2的【后置】
33. """

复制代码

（二）使用addfinalizer关键字实现后置

• request.addfinalizer把函数变成终结器实现后置处理
  

1. import pytest
3. @pytest.fixture()
4. def fixture_1(request):
5.     print("这是fixture_1的【前置】处理")
6.     def addfinalizer_demo():
7.         print("这是fixture_1的【后置】处理")
9.     # 注册后置处理
10.     request.addfinalizer(addfinalizer_demo)
13. def test_fixture(fixture_1):
14.     print("===这是测试函数===")
17. """
18. 执行结果
19. fixture/use_addfinalizer.py::test_fixture 这是fixture_1的【前置】处理
20. ===这是测试函数===
21. PASSED这是fixture_1的【后置】处理
22. """

复制代码

• request.addfinalizer注册多个终结器函数
  

1. import pytest
3. @pytest.fixture()
4. def fixture_1(request):
5.     print("这是fixture_1的【前置】处理")
7.     def addfinalizer_demo_1():
8.         print("这是fixture_1的【后置】处理1")
10.     def addfinalizer_demo_2():
11.         print("这是fixture_2的【后置】处理2")
13.     # 将多个后置处理函数注册成终结函数
14.     request.addfinalizer(addfinalizer_demo_1)
15.     request.addfinalizer(addfinalizer_demo_2)
17. def test_fixture(fixture_1):
18.     print("=====这是测试函数=====")
21. """
22. 执行结果
23. fixture/use_more_addfinalizer.py::test_fixture 这是fixture_1的【前置】处理
24. =====这是测试函数=====
25. PASSED这是fixture_2的【后置】处理2
26. 这是fixture_1的【后置】处理1
27. """

复制代码

• 执行顺序
  由上面注册多个终结器函数示例中可以看到，使用addfinalizer关键字处理后置函数的执行顺序与注册顺序是反的
  

（三）yield和addfinalizer的区别

区别在于如果fixture中前置出现异常，yield后置不会执行，而addfinalizer后置会执行。

• 使用yield
  

1. import pytest
4. @pytest.fixture()
5. def fixture_yield():
6.     print("这是fixture_yield前置")
7.     res = 21/0
8.     yield
9.     print("这是fixtue_yield后置")
13. def test_fixture(fixture_yield):
14.     print("这是测试函数")
16. """
17. 执行结果
18. yield_error.py::test_fixture ERROR                                       [100%]这是fixture_yield前置
20. test setup failed
21. @pytest.fixture()
22.     def fixture_yield():
23.         print("这是fixture_yield前置")
24. >       res = 21/0
25. E       ZeroDivisionError: division by zero
27. yield_error.py:12: ZeroDivisionError
29. """

复制代码

• 使用addfinalizer
  

1. import pytest
4. @pytest.fixture()
5. def fixture_1(request):
6.     print("这是fixture_1前置")
8.     def addfinalizer_demo():
9.         print("这是fixture_1后置")
10.     request.addfinalizer(addfinalizer_demo)
11.     res = 21/0
13. def test_fixture(fixture_1):
14.     print("这是测试函数")
17. """
18. 执行结果
19. addfinalizer_error.py::test_fixture ERROR                                [100%]这是fixture_1前置
21. test setup failed
22. request = <SubRequest 'fixture_1' for <Function test_fixture>>
24.     @pytest.fixture()
25.     def fixture_1(request):
26.         print("这是fixture_1前置")
27.    
28.         def addfinalizer_demo():
29.             print("这是fixture_1后置")
30.         request.addfinalizer(addfinalizer_demo)
31. >       res = 21/0
32. E       ZeroDivisionError: division by zero
34. addfinalizer_error.py:16: ZeroDivisionError
35. 这是fixture_1后置
36. """

复制代码

从上面yield和addfinalizer的示例中可以看出yield前置中出现异常，后置处理没有被执行，而addfinalizer的前置中出现异常，并没有影响后置的执行。
注意： 使用addfinalizer一定是后置函数注册成功后出现异常才不会受影响。

参考：https://zhuanlan.zhihu.com/p/355285675

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！