首页 > 脚本中心 > Python > 关于自动化测试框架pytest的Fixture固件

关于自动化测试框架pytest的Fixture固件

福牛 3月 30, 2023 32 0

什么是固件

Fixture 翻译成中文即是固件的意思。它其实就是一些函数，会在执行测试方法/测试函数之前（或之后）加载运行它们，常见的如接口用例在请求接口前数据库的初始连接，和请求之后关闭数据库的操作。

我们之前在APP UI自动化系列中已经介绍过 unittest 的相关测试固件，如setup、teardown等。而 pytest 中提供了功能更加丰富的Fixture，用于实现setup、teardown功能。

定义方式

使用@pytest.fixture()进行定义，简单示例如下：

  1. import pytest
  3. @pytest.fixture()
  4. def before():
  5.      print(“连接数据库”)

调用方式

调用单个fixture函数

  • 方式一，使用fixture函数名作为参数
  1. import pytest
  3. @pytest.fixture()
  4. def before():
  5.      print(“连接数据库”)
  8. # 调用before
  9. def test_01(before):
  10.      print(“执行test_01”)
  • 方式二，使用 @pytest.mark.usefixtures('fixture函数名')装饰器
  1. import pytest
  3. @pytest.fixture()
  4. def before():
  5.      print(“连接数据库”)
  7. # 调用before
  8. @pytest.mark.usefixtures(‘before’)
  9. def test_01():
  10.      print(“执行test_01”)
  • 方式三，使用autouse参数自动执行fixture函数
  1. import pytest
  3. # fixture函数定义的时候使用autouse参数，作用域范围内的测试用例会自动调用该fixture函数
  4. @pytest.fixture(autouse=True)
  5. def before():
  6.      print(“连接数据库”)
  9. # 自动调用before
  10. def test_01():
  11.      print(“执行test_01”)

三种方式调用后的结果都如下：

-1

我们可以看到，先执行了fixture函数，再执行测试函数。

调用多个fixture函数

  1. import pytest
  3. @pytest.fixture()
  4. def before():
  5.      print(“连接数据库”)
  7. @pytest.fixture()
  8. def before_s():
  9.      print(“初始化数据”)
  12. def test_01(before, before_s):
  13.      print(“执行test_01”)

调用多个 fixture 函数时，由前至后依次执行，所以test_01()调用时先执行before，再执行before_s。

对fixture函数重命名

定义fixture函数时，可以利用name参数进行重命名，方便用于调用，示例如下：

  1. import pytest
  3. @pytest.fixture(name=‘db’)
  4. def connect_order_db():
  5.      print(“连接数据库”)
  8. def test_01(db):
  9.      print(“执行test_01”)

使用fixture传递测试数据

在执行完fixture函数后，有时需要将该fixture中得到到某些数据传递给测试函数/测试方法，用于后续的执行。

fixture中提供普通传递和参数化传递两种数据传递方式。

普通传递

示例如下：

  1. import pytest
  3. @pytest.fixture()
  4. def before():
  5.      print(“连接数据库”)
  6.      return “连接成功！”
  9. def test_01(before):
  10.      print(“执行test_01”)
  11.      assert before == “连接成功！”

注意，如果自定义的fixture函数有返回值，需要使用上面说的方式一调用才能获取fixture函数的返回值并传入测试函数中，方式二就无法获取返回值。

参数化传递

对fixture函数进行参数化时，需要使用参数params，并且需要传入参数request，简单示例如下：

  1. import pytest
  3. test_params = [1, 2, 0]
  4. @pytest.fixture(params=test_params)
  5. def before(request):
  6.      result = request.param
  7.      return result
  9. def test_02(before):
  10.      print(“执行test_02”)
  11.      assert before
  14. if __name__ == ‘__main__’:
  15.      pytest.main()

执行结果：

-2

可以看到，因为所调用的fixture函数进行了参数化，虽然只有一个测试函数但执行了3次。

conftest.py

上面我们举的例子都是把fixture函数放在测试用例模块里面，但如果很多测试模块需要引用同一个fixture函数怎么办，这是时候就需要把它放在命名为conftest的模块里，这样同级或以下目录中的测试用例便能调用这些自定义的fixture函数。

例如，有如下目录：

  1. ├─testcase
  2. │ │
  3. │ ├─test_module_01
  4. │ │ test_case_1.py
  5. │ │ test_case_2.py
  6. │ │
  7. │ ├─test_module_02
  8. │ │ test_case_3.py

test_module_01 中的test_case_1.py与test_case_2.py都需要调用同一个 fixture 函数，那么我们只需要在 test_module_01 中新建conftest.py并编写这个fixture函数即可，示例如下：

  1. ├─testcase
  2. │ │
  3. │ ├─test_module_01
  4. │ │ conftest.py
  5. │ │ test_case_1.py
  6. │ │ test_case_2.py
  7. │ │
  8. │ ├─test_module_02
  9. │ │ test_case_3.py

conftest.py:

  1. import pytest
  3. @pytest.fixture(autouse=True)
  4. def before():
  5.      print(“连接数据库”)

test_case_1.py：

  1. def test_01():
  2.      print(“执行test_01”)

test_case_2.py：

  1. def test_02():
  2.      print(“执行test_02”)

这样，执行这两个模块的测试用例时会自动先去调用conftest.py中的before()函数。

假设 test_module_02 中的 test_case_3.py 也需要调用这个before()函数，那么这个时候我们就需要在上一层即 testcase 中新建conftest.py并编写这个before()函数，才能在 test_case_3.py 中调用，如下：

  1. ├─testcase
  2. │ │ conftest.py
  3. │ │
  4. │ ├─test_module_01
  5. │ │ conftest.py
  6. │ │ test_case_1.py
  7. │ │ test_case_2.py
  8. │ │
  9. │ ├─test_module_02
  10. │ │ test_case_3.py

conftest.py只作用于同级或以下目录中的测试模块，且需要注意，当以下层级中存在了另一个conftest.py，那么以下层级将由另一个conftest.py文件接管。

作用域

pytest 的 fixture 作用域分session、module、class、function四个级别。在定义 fixture 函数的时候通过scope参数指定作用范围，默认为function。

  • session，每次会话执行一次
  • module，每个测试模块执行一次
  • class，每个测试类执行一次
  • function，每个测试方法执行一次

注意，对于单独定义的测试函数，class、function 都会起作用，可以从下列示例中看出来。

测试目录结构如下：

  1. ├─apiAutoTest
  2. │ │ run.py
  3. │ │
  4. │ ├─testcase
  5. │ │ │ conftest.py
  6. │ │ │
  7. │ │ ├─test_module_02
  8. │ │ │ │ conftest.py
  9. │ │ │ │ test_case_3.py
  10. │ │ │ │ test_case_4.py

其中conftest.py代码如下：

  1. import pytest
  3. @pytest.fixture(scope=“session”, autouse=True)
  4. def session_fixture():
  5.      print(“这是一个作用于session的fixture”)
  7. @pytest.fixture(scope=“module”, autouse=True)
  8. def module_fixture():
  9.      print(“这是一个作用于module的fixture”)
  11. @pytest.fixture(scope=“class”, autouse=True)
  12. def class_fixture():
  13.      print(“这是一个作用于class的fixture”)
  15. @pytest.fixture(scope=“function”, autouse=True)
  16. def function_fixture():
  17.      print(“这是一个作用于function的fixture”)

test_case_3.py代码如下：

  1. import pytest
  3. class TestOrder:
  5.      def test_a(self):
  6.          print(“test_a”)
  8.      def test_b(self):
  9.          print(“test_b”)
  11. def test_c():
  12.      print(“test_c”)

test_case_4.py代码如下：

  1. def test_e():
  2.      print(“test_e”)

run.py代码如下：

  1. import pytest
  3. if __name__ == ‘__main__’:
  4.      pytest.main([“-s”])

运行run.py，结果如下：

  1. collected 4 items
  3. testcase\test_module_02\test_case_3.py
  4. 这是一个作用于session的fixture
  5. 这是一个作用于module的fixture
  6. 这是一个作用于class的fixture
  7. 这是一个作用于function的fixture
  8. test_a
  9. .这是一个作用于function的fixture
  10. test_b
  11. .这是一个作用于class的fixture
  12. 这是一个作用于function的fixture
  13. test_c
  14. .
  15. testcase\test_module_02\test_case_4.py
  16. 这是一个作用于module的fixture
  17. 这是一个作用于class的fixture
  18. 这是一个作用于function的fixture
  19. test_e
  20. .
  22. ============================== 4 passed in 0.04s ==============================

从结果可以看出来：

  • 作用于session的fixture函数只在所有测试用例执行之前调用了一次
  • 作用于module的fixture函数在每个测试模块执行之前调用了一次
  • 作用于class的fixture函数在每个测试类执行之前调用了一次
  • 作用于function的fixture函数在每个测试方法/测试函数执行之前调用了一次

注意，在定义的测试函数（如test_c()、test_e()）执行之前也会调用scope=class的fixture函数。

总结

与 unittest 框架比较，pytest 中的Fixture更加丰富，可扩展性更高。

Fixture还有很多更加优雅的用法用于自动化测试项目中，本文只是以最简单的示例进行说明。

到此这篇关于关于自动化测试框架pytest的Fixture固件的文章就介绍到这了,更多相关自动化测试Fixture固件内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

标签

相关推荐

发表评论