接口自动化测试框架(pytest+allure+aiohttp+ 用例自动生成)

近期准备优先做接口测试的覆盖，为此需要开发一个测试框架，经过思考，这次依然想做点儿不一样的东西。

• 接口测试是比较讲究效率的，测试人员会希望很快能得到结果反馈，然而接口的数量一般都很多，而且会越来越多，所以提高执行效率很有必要
• 接口测试的用例其实也可以用来兼做简单的压力测试，而压力测试需要并发
• 接口测试的用例有很多重复的东西，测试人员应该只需要关注接口测试的设计，这些重复劳动最好自动化来做pytest和allure太好用了，新框架要集成它们
• 接口测试的用例应该尽量简洁，最好用yaml，这样数据能直接映射为请求数据，写起用例来跟做填空题一样，便于向没有自动化经验的成员推广 加上我对Python的协程很感兴趣，也学了一段时间，一直希望学以致用，所以http请求我决定用aiohttp来实现。 但是pytest是不支持事件循环的，如果想把它们结合还需要一番功夫。于是继续思考，思考的结果是其实我可以把整个事情分为两部分。 第一部分，读取yaml测试用例，http请求测试接口，收集测试数据。 第二部分，根据测试数据，动态生成pytest认可的测试用例，然后执行，生成测试报告。 这样一来，两者就能完美结合了，也完美符合我所做的设想。想法既定，接着 就是实现了。

第一部分（整个过程都要求是异步非阻塞的）

读取yaml测试用例

一份简单的用例模板我是这样设计的，这样的好处是，参数名和aiohttp.ClientSession().request(method,url,**kwargs)是直接对应上的，我可以不费力气的直接传给请求方法，避免各种转换，简洁优雅，表达力又强。

1. args:

2. - post

3. - /xxx/add

4. kwargs:

5. -

6. caseName: 新增xxx

7. data:

8. name: ${gen_uid(10)}

9. validator:

10. -

11. json:

12. successed: True

异步读取文件可以使用aiofiles这个第三方库，yaml_load是一个协程，可以保证主进程读取yaml测试用例时不被阻塞，通过await yaml_load()便能获取测试用例的数据

1. async def yaml_load(dir='', file=''):

2. """

3. 异步读取yaml文件，并转义其中的特殊值

4. :param file:

5. :return:

6. """

7. if dir:

8. file = os.path.join(dir, file)

9. async with aiofiles.open(file, 'r', encoding='utf-8', errors='ignore') as f:

10. data = await f.read()

12. data = yaml.load(data)

14. # 匹配函数调用形式的语法

15. pattern_function = re.compile(r'^\${([A-Za-z_]+\w*\(.*\))}$')

16. pattern_function2 = re.compile(r'^\${(.*)}$')

17. # 匹配取默认值的语法

18. pattern_function3 = re.compile(r'^\$\((.*)\)$')

20. def my_iter(data):

21. """

22. 递归测试用例，根据不同数据类型做相应处理，将模板语法转化为正常值

23. :param data:

24. :return:

25. """

26. if isinstance(data, (list, tuple)):

27. for index, _data in enumerate(data):

28. data[index] = my_iter(_data) or _data

29. elif isinstance(data, dict):

30. for k, v in data.items():

31. data[k] = my_iter(v) or v

32. elif isinstance(data, (str, bytes)):

33. m = pattern_function.match(data)

34. if not m:

35. m = pattern_function2.match(data)

36. if m:

37. return eval(m.group(1))

38. if not m:

39. m = pattern_function3.match(data)

40. if m:

41. K, k = m.group(1).split(':')

42. return bxmat.default_values.get(K).get(k)

44. return data

46. my_iter(data)

48. return BXMDict(data)

'

运行

运行

可以看到，测试用例还支持一定的模板语法，如${function}、$(a:b)等，这能在很大程度上拓展测试人员用例编写的能力

http请求测试接口

http请求可以直接用aiohttp.ClientSession().request(method,url,**kwargs)，http也是一个协程，可以保证网络请求时不被阻塞，通过await http()便可以拿到接口测试数据

1. async def http(domain, *args, **kwargs):

2. """

3. http请求处理器

4. :param domain: 服务地址

5. :param args:

6. :param kwargs:

7. :return:

8. """

9. method, api = args

10. arguments = kwargs.get('data') or kwargs.get('params') or kwargs.get('json') or {}

12. # kwargs中加入token

13. kwargs.setdefault('headers', {}).update({'token': bxmat.token})

14. # 拼接服务地址和api

15. url = ''.join([domain, api])

17. async with ClientSession() as session:

18. async with session.request(method, url, **kwargs) as response:

19. res = await response_handler(response)

20. return {

21. 'response': res,

22. 'url': url,

23. 'arguments': arguments

24. }

'

运行

运行

收集测试数据

协程的并发真的很快，这里为了避免服务响应不过来导致熔断，可以引入

1. async def entrace(test_cases, loop, semaphore=None):

2. """

3. http执行入口

4. :param test_cases:

5. :param semaphore:

6. :return:

7. """

8. res = BXMDict()

9. # 在CookieJar的update_cookies方法中，如果unsafe=False并且访问的是IP地址，客户端是不会更新cookie信息

10. # 这就导致session不能正确处理登录态的问题

11. # 所以这里使用的cookie_jar参数使用手动生成的CookieJar对象，并将其unsafe设置为True

12. async with ClientSession(loop=loop, cookie_jar=CookieJar(unsafe=True), headers={'token': bxmat.token}) as session:

13. await advertise_cms_login(session)

14. if semaphore:

15. async with semaphore:

16. for test_case in test_cases:

17. data = await one(session, case_name=test_case)

18. res.setdefault(data.pop('case_dir'), BXMList()).append(data)

19. else:

20. for test_case in test_cases:

21. data = await one(session, case_name=test_case)

22. res.setdefault(data.pop('case_dir'), BXMList()).append(data)

24. return res

27. async def one(session, case_dir='', case_name=''):

28. """

29. 一份测试用例执行的全过程，包括读取.yml测试用例，执行http请求，返回请求结果

30. 所有操作都是异步非阻塞的

31. :param session: session会话

32. :param case_dir: 用例目录

33. :param case_name: 用例名称

34. :return:

35. """

36. project_name = case_name.split(os.sep)[1]

37. domain = bxmat.url.get(project_name)

38. test_data = await yaml_load(dir=case_dir, file=case_name)

39. result = BXMDict({

40. 'case_dir': os.path.dirname(case_name),

41. 'api': test_data.args[1].replace('/', '_'),

42. })

43. if isinstance(test_data.kwargs, list):

44. for index, each_data in enumerate(test_data.kwargs):

45. step_name = each_data.pop('caseName')

46. r = await http(session, domain, *test_data.args, **each_data)

47. r.update({'case_name': step_name})

48. result.setdefault('responses', BXMList()).append({

49. 'response': r,

50. 'validator': test_data.validator[index]

51. })

52. else:

53. step_name = test_data.kwargs.pop('caseName')

54. r = await http(session, domain, *test_data.args, **test_data.kwargs)

55. r.update({'case_name': step_name})

56. result.setdefault('responses', BXMList()).append({

57. 'response': r,

58. 'validator': test_data.validator

59. })

61. return result

事件循环负责执行协程并返回结果，在最后的结果收集中，我用测试用例目录来对结果进行了分类，这为接下来的自动生成pytest认可的测试用例打下了良好的基础

1. def main(test_cases):

2. """

3. 事件循环主函数，负责所有接口请求的执行

4. :param test_cases:

5. :return:

6. """

7. loop = asyncio.get_event_loop()

8. semaphore = asyncio.Semaphore(bxmat.semaphore)

9. # 需要处理的任务

10. # tasks = [asyncio.ensure_future(one(case_name=test_case, semaphore=semaphore)) for test_case in test_cases]

11. task = loop.create_task(entrace(test_cases, loop, semaphore))

12. # 将协程注册到事件循环，并启动事件循环

13. try:

14. # loop.run_until_complete(asyncio.gather(*tasks))

15. loop.run_until_complete(task)

16. finally:

17. loop.close()

19. return task.result()

第二部分

动态生成pytest认可的测试用例

首先说明下pytest的运行机制，pytest首先会在当前目录下找conftest.py文件，如果找到了，则先运行它，然后根据命令行参数去指定的目录下找test开头或结尾的.py文件，如果找到了，如果找到了，再分析fixture，如果有session或module类型的，并且参数autotest=True或标记了pytest.mark.usefixtures(a...)，则先运行它们；再去依次找类、方法等，规则类似。大概就是这样一个过程。

可以看出，pytest测试运行起来的关键是，必须有至少一个被pytest发现机制认可的testxx.py文件，文件中有TestxxClass类，类中至少有一个def testxx(self)方法。

现在并没有任何pytest认可的测试文件，所以我的想法是先创建一个引导型的测试文件，它负责让pytest动起来。可以用pytest.skip()让其中的测试方法跳过。然后我们的目标是在pytest动起来之后，怎么动态生成用例，然后发现这些用例，执行这些用例，生成测试报告，一气呵成。

1. # test_bootstrap.py

2. import pytest

3. class TestStarter(object):

4. def test_start(self):

5. pytest.skip('此为测试启动方法, 不执行')

我想到的是通过fixture，因为fixture有setup的能力，这样我通过定义一个scope为session的fixture，然后在TestStarter上面标记use，就可以在导入TestStarter之前预先处理一些事情，那么我把生成用例的操作放在这个fixture里就能完成目标了。

1. # test_bootstrap.py

2. import pytest

4. @pytest.mark.usefixtures('te', 'test_cases')

5. class TestStarter(object):

7. def test_start(self):

8. pytest.skip('此为测试启动方法, 不执行')

pytest有个--rootdir参数，该fixture的核心目的就是，通过--rootdir获取到目标目录，找出里面的.yml测试文件，运行后获得测试数据，然后为每个目录创建一份testxx.py的测试文件，文件内容就是content变量的内容，然后把这些参数再传给pytest.main()方法执行测试用例的测试，也就是在pytest内部再运行了一个pytest！最后把生成的测试文件删除。注意该fixture要定义在conftest.py里面，因为pytest对于conftest中定义的内容有自发现能力，不需要额外导入。

1. # conftest.py

2. @pytest.fixture(scope='session')

3. def test_cases(request):

4. """

5. 测试用例生成处理

6. :param request:

7. :return:

8. """

9. var = request.config.getoption("--rootdir")

10. test_file = request.config.getoption("--tf")

11. env = request.config.getoption("--te")

12. cases = []

13. if test_file:

14. cases = [test_file]

15. else:

16. if os.path.isdir(var):

17. for root, dirs, files in os.walk(var):

18. if re.match(r'\w+', root):

19. if files:

20. cases.extend([os.path.join(root, file) for file in files if file.endswith('yml')])

22. data = main(cases)

24. content = """

25. import allure

26. from conftest import CaseMetaClass

27. @allure.feature('{}接口测试({}项目)')

28. class Test{}API(object, metaclass=CaseMetaClass):

29. test_cases_data = {}

30. """

31. test_cases_files = []

32. if os.path.isdir(var):

33. for root, dirs, files in os.walk(var):

34. if not ('.' in root or '__' in root):

35. if files:

36. case_name = os.path.basename(root)

37. project_name = os.path.basename(os.path.dirname(root))

38. test_case_file = os.path.join(root, 'test_{}.py'.format(case_name))

39. with open(test_case_file, 'w', encoding='utf-8') as fw:

40. fw.write(content.format(case_name, project_name, case_name.title(), data.get(root)))

41. test_cases_files.append(test_case_file)

43. if test_file:

44. temp = os.path.dirname(test_file)

45. py_file = os.path.join(temp, 'test_{}.py'.format(os.path.basename(temp)))

46. else:

47. py_file = var

49. pytest.main([

50. '-v',

51. py_file,

52. '--alluredir',

53. 'report',

54. '--te',

55. env,

56. '--capture',

57. 'no',

58. '--disable-warnings',

59. ])

61. for file in test_cases_files:

62. os.remove(file)

64. return test_cases_files

可以看到，测试文件中有一个TestxxAPI的类，它只有一个test_cases_data属性，并没有testxx方法，所以还不是被pytest认可的测试用例，根本运行不起来。那么它是怎么解决这个问题的呢？答案就是CaseMetaClass。

1. function_express = """

2. def {}(self, response, validata):

3. with allure.step(response.pop('case_name')):

4. validator(response,validata)"""

7. class CaseMetaClass(type):

8. """

9. 根据接口调用的结果自动生成测试用例

10. """

12. def __new__(cls, name, bases, attrs):

13. test_cases_data = attrs.pop('test_cases_data')

14. for each in test_cases_data:

15. api = each.pop('api')

16. function_name = 'test' + api

17. test_data = [tuple(x.values()) for x in each.get('responses')]

18. function = gen_function(function_express.format(function_name),

19. namespace={'validator': validator, 'allure': allure})

20. # 集成allure

21. story_function = allure.story('{}'.format(api.replace('_', '/')))(function)

22. attrs[function_name] = pytest.mark.parametrize('response,validata', test_data)(story_function)

24. return super().__new__(cls, name, bases, attrs)

CaseMetaClass是一个元类，它读取test_cases_data属性的内容，然后动态生成方法对象，每一个接口都是单独一个方法，在相继被allure的细粒度测试报告功能和pytest提供的参数化测试功能装饰后，把该方法对象赋值给test+api的类属性，也就是说，TestxxAPI在生成之后便有了若干testxx的方法，此时内部再运行起pytest，pytest也就能发现这些用例并执行了。

1. def gen_function(function_express, namespace={}):

2. """

3. 动态生成函数对象, 函数作用域默认设置为builtins.__dict__，并合并namespace的变量

4. :param function_express: 函数表达式，示例 'def foobar(): return "foobar"'

5. :return:

6. """

7. builtins.__dict__.update(namespace)

8. module_code = compile(function_express, '', 'exec')

9. function_code = [c for c in module_code.co_consts if isinstance(c, types.CodeType)][0]

10. return types.FunctionType(function_code, builtins.__dict__)

在生成方法对象时要注意namespace的问题，最好默认传builtins.__dict__，然后自定义的方法通过namespace参数传进去。

后续（yml测试文件自动生成）

至此，框架的核心功能已经完成了，经过几个项目的实践，效果完全超过预期，写起用例来不要太爽，运行起来不要太快，测试报告也整的明明白白漂漂亮亮的，但我发现还是有些累，为什么呢？
我目前做接口测试的流程是，如果项目集成了swagger，通过swagger去获取接口信息，根据这些接口信息来手工起项目创建用例。这个过程很重复很繁琐，因为我们的用例模板已经大致固定了，其实用例之间就是一些参数比如目录、用例名称、method等等的区别，那么这个过程我觉得完全可以自动化。

因为swagger有个网页啊，我可以去提取关键信息来自动创建.yml测试文件，就像搭起架子一样，待项目架子生成后，我再去设计用例填传参就可以了。

于是我试着去解析请求swagger首页得到的HTML，然后失望的是并没有实际数据，后来猜想应该是用了ajax，打开浏览器控制台的时，我发现了api-docs的请求，一看果然是json数据，那么问题就简单了，网页分析都不用了。

1. import re

2. import os

3. import sys

5. from requests import Session

7. template ="""

8. args:

9. - {method}

10. - {api}

11. kwargs:

12. -

13. caseName: {caseName}

14. {data_or_params}:

15. {data}

16. validator:

17. -

18. json:

19. successed: True

20. """

23. def auto_gen_cases(swagger_url, project_name):

24. """

25. 根据swagger返回的json数据自动生成yml测试用例模板

26. :param swagger_url:

27. :param project_name:

28. :return:

29. """

30. res = Session().request('get', swagger_url).json()

31. data = res.get('paths')

33. workspace = os.getcwd()

35. project_ = os.path.join(workspace, project_name)

37. if not os.path.exists(project_):

38. os.mkdir(project_)

40. for k, v in data.items():

41. pa_res = re.split(r'[/]+', k)

42. dir, *file = pa_res[1:]

44. if file:

45. file = ''.join([x.title() for x in file])

46. else:

47. file = dir

49. file += '.yml'

51. dirs = os.path.join(project_, dir)

53. if not os.path.exists(dirs):

54. os.mkdir(dirs)

56. os.chdir(dirs)

58. if len(v) > 1:

59. v = {'post': v.get('post')}

60. for _k, _v in v.items():

61. method = _k

62. api = k

63. caseName = _v.get('description')

64. data_or_params = 'params' if method == 'get' else 'data'

65. parameters = _v.get('parameters')

67. data_s = ''

68. try:

69. for each in parameters:

70. data_s += each.get('name')

71. data_s += ': \n'

72. data_s += ' ' * 8

73. except TypeError:

74. data_s += '{}'

76. file_ = os.path.join(dirs, file)

78. with open(file_, 'w', encoding='utf-8') as fw:

79. fw.write(template.format(

80. method=method,

81. api=api,

82. caseName=caseName,

83. data_or_params=data_or_params,

84. data=data_s

85. ))

87. os.chdir(project_)

现在要开始一个项目的接口测试覆盖，只要该项目集成了swagger，就能秒生成项目架子，测试人员只需要专心设计接口测试用例即可，我觉得对于测试团队的推广使用是很有意义的，也更方便了我这样的懒人。

总结：

感谢每一个认真阅读我文章的人！！！

作为一位过来人也是希望大家少走一些弯路，如果你不想再体验一次学习时找不到资料，没人解答问题，坚持几天便放弃的感受的话，在这里我给大家分享一些自动化测试的学习资源，希望能给你前进的路上带来帮助。

软件测试面试文档

我们学习必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有字节大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

 

          视频文档获取方式：
这份文档和视频资料，对于想从事【软件测试】的朋友来说应该是最全面最完整的备战仓库，这个仓库也陪伴我走过了最艰难的路程，希望也能帮助到你！以上均可以分享，点下方小卡片即可自行领取。