devbox
秋刀鱼在做梦
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Python 接口测试框架_python接口框架

作者：秋刀鱼在做梦 | 2024-07-13 18:41:12

赞

踩

python接口框架

目录结构定义

首先来看一下项目整体的结构

框架结构

 

代码结构

 

Excel 文件结构

 

代码详细解析

1.工具包 tools

封装操作 excel 方法 excel_operation.py

  1. import xlrd
  2. from config.config import PROJECT_PATH
  3.  
  4.  
  5. class OperationExcel:
  6.     def __init__(self, file_name=None, sheet_id=0):
  7.         if file_name:
  8.             self.file_name = PROJECT_PATH + '/data/' + file_name
  9.             self.sheet_id = sheet_id
  10.         else:
  11.             try:
  12.                 self.file_name = PROJECT_PATH + '/data/case.xlsx'
  13.                 self.sheet_id = 0
  14.             except FileExistsError:
  15.                 raise FileExistsError("the default testcase file not found")
  16.         self.book = self.get_book()
  17.         self.data = self.get_data()
  18.  
  19.     # 获取工作簿
  20.     def get_book(self):
  21.         book = xlrd.open_workbook(self.file_name)
  22.         return book
  23.  
  24.     # 获取 sheets 的内容
  25.     def get_data(self):
  26.         book = self.book
  27.         tables = book.sheets()[self.sheet_id]
  28.         return tables
  29.  
  30.     # 获取所有 sheet 的名字
  31.     def get_sheet_name(self):
  32.         book = self.book
  33.         return book.sheet_names()
  34.  
  35.     # 获取所有 sheets
  36.     def get_sheets(self):
  37.         book = self.book
  38.         sheets = book.sheets()
  39.         return sheets
  40.  
  41.     # 获取某个单元格的内容
  42.     def get_cell_value(self, row, col):
  43.         return self.data.cell_value(row, col)
  44.  
  45.     # 获取单元格的行数
  46.     def get_lines(self):
  47.         tables = self.data
  48.         case_rows = tables.nrows - 1
  49.         return case_rows
  50.  
  51.     # 获取某一列的内容
  52.     def get_cols_data(self, col_id=None):
  53.         if col_id is not None:
  54.             cols = self.data.col_values(col_id)
  55.         else:
  56.             cols = self.data.col_values(0)
  57.         return cols
  58.  
  59.     # 获取某一行的内容
  60.     def get_rows_data(self, row_id=None):
  61.         if row_id is not None:
  62.             rows = self.data.row_values(row_id)
  63.         else:
  64.             rows = self.data.row_values(0)
  65.         return rows
  66.  
  67.     # 获取某个 caseid 对应的行号
  68.     def get_row_num(self, case_id):
  69.         num = 0
  70.         cols_data = self.get_cols_data()
  71.         for col_data in cols_data:
  72.             if case_id in col_data:
  73.                 return num
  74.             num += 1
  75.

使用 xlrd 库来操作 excel，同时，该类只做最底层的 excel 数据提取，不做任何业务相关的判断。后面会陆续增加 json，yaml 等数据结构的操作工具。

中间数据操作层 operate_data.py

  1. from config.config import ExcelConfData
  2.  
  3.  
  4. class OperateExcelData(object):
  5.     def get_caseid(self):
  6.         return ExcelConfData.caseid
  7.  
  8.     def get_url(self):
  9.         return ExcelConfData.url
  10.  
  11.     def get_method(self):
  12.         return ExcelConfData.method
  13.  
  14.     def get_is_auto_run(self):
  15.         return ExcelConfData.automated
  16.  
  17.     def get_header(self):
  18.         return ExcelConfData.header
  19.  
  20.     def get_data(self):
  21.         return ExcelConfData.data
  22.  
  23.     def get_casename(self):
  24.         return ExcelConfData.casename
  25.  
  26.     def get_statuscode(self):
  27.         return ExcelConfData.statuscode
  28.  
  29.     def get_checkpoints(self):
  30.         return ExcelConfData.checkpoints
  31.  
  32.     def get_validate(self):
  33.         return ExcelConfData.validate
  34.  
  35.     def get_caseuniqueid(self):
  36.         return ExcelConfData.caseuniqueid
  37.  
  38.     def get_authtype(self):
  39.         return ExcelConfData.authtype
  40.

属于操作数据的中间层，从配置文件中拿到我们定义好的 excel 结构，这样，如果我们的 excel 结构有变化，只需要修改配置文件即可

配置文件中的 excel 结构如下

  1. class ExcelConfData:
  2.     caseid = '0'
  3.     casename = '1'
  4.     caselevel = '2'
  5.     preconditions = '3'
  6.     testcontent = '4'
  7.     expect = '5'
  8.     casecategory = '6'
  9.     automated = '7'  # 1 是自动运行， 2 是非自动运行
  10.     caseuniqueid = '1'  # 8
  11.     method = '9'
  12.     url = '10'
  13.     data = '11'
  14.     header = '12'
  15.     statuscode = '13'
  16.     checkpoints = '14'
  17.     validate = '15'
  18.     parameterize = '16'
  19.     result = '17'
  20.     authtype = '18'  # 0:admin, 1:common user, 2:not login
  21.

获取测试文件中数据工具 get_data.py

  1. from tools.excel_operation import OperationExcel
  2. from tools.operate_data import OperateExcelData
  3.  
  4.  
  5. class GetExcelData(object):
  6.     def __init__(self, filename=None, sheet_id=0):
  7.         self.operate_excel = OperationExcel(filename, sheet_id)
  8.         self.operate_data = OperateExcelData()
  9.  
  10.     # 获取 sheet 个数
  11.     def get_sheets(self):
  12.         sheet_num = self.operate_excel.get_sheets()
  13.         return len(sheet_num)
  14.  
  15.     # 获取 excel 行数，即用例个数
  16.     def get_case_lines(self):
  17.         return self.operate_excel.get_lines()
  18.  
  19.     # 获取是否执行
  20.     def get_is_auto_run(self, row):
  21.         auto_flag = False
  22.         col = int(self.operate_data.get_is_auto_run())
  23.         run_model = self.operate_excel.get_cell_value(row, col)
  24.         if run_model == 1:
  25.             auto_flag = True
  26.         else:
  27.             auto_flag = False
  28.         return auto_flag
  29.  
  30.     # 获取请求方式
  31.     def get_request_method(self, row):
  32.         col = int(self.operate_data.get_method())
  33.         request_method = self.operate_excel.get_cell_value(row, col)
  34.         return request_method
  35.  
  36.     # 获取 url
  37.     def get_request_url(self, row):
  38.         col = int(self.operate_data.get_url())
  39.         url = self.operate_excel.get_cell_value(row, col)
  40.         return url
  41.  
  42.     # 获取请求数据
  43.     def get_request_data(self, row):
  44.         col = int(self.operate_data.get_data())
  45.         data = self.operate_excel.get_cell_value(row, col)
  46.         return data
  47.  
  48.     # 获取 status code
  49.     def get_response_statuscode(self, row):
  50.         col = int(self.operate_data.get_statuscode())
  51.         statuscode = self.operate_excel.get_cell_value(row, col)
  52.         return statuscode
  53.  
  54.     # 获取 checkpoints
  55.     def get_checkpoints(self, row):
  56.         col = int(self.operate_data.get_checkpoints())
  57.         checkpoints = self.operate_excel.get_cell_value(row, col)
  58.         return checkpoints
  59.  
  60.     # 获取 validate
  61.     def get_validate(self, row):
  62.         col = int(self.operate_data.get_validate())
  63.         validate = self.operate_excel.get_cell_value(row, col)
  64.         return validate
  65.  
  66.     # 获取测试用例唯一 ID
  67.     def get_caseuniqueid(self, row):
  68.         col = int(self.operate_data.get_caseuniqueid())
  69.         caseuniqueid = self.operate_excel.get_cell_value(row, col)
  70.         if isinstance(caseuniqueid, float):
  71.             caseuniqueid = int(caseuniqueid)
  72.         return str(caseuniqueid)
  73.  
  74.     # 获取 header 信息
  75.     def get_header(self, row):
  76.         col = int(self.operate_data.get_header())
  77.         header = self.operate_excel.get_cell_value(row, col)
  78.         return header
  79.  
  80.     # 获取是否需要鉴权信息
  81.     def get_authtype(self, row):
  82.         col = int(self.operate_data.get_authtype())
  83.         authtype = self.operate_excel.get_cell_value(row, col)
  84.         return authtype  
  85.

获取到测试数据中业务相关的数据，例如是否自动化执行，是否使用 header，是否需要鉴权信息等。

通用工具文件 common_util.py

  1. import json
  2. import operator
  3. from config.config import UserInfo, EnvConf
  4. import requests
  5.  
  6.  
  7. class CommonUtil(object):
  8.     def is_contain(self, str1, str2):
  9.         """
  10.         :param str1: 原始字符串
  11.         :param str2: 被查找的字符串
  12.         :return: True or False
  13.         """
  14.         flag = None
  15.         if str1 in str2:
  16.             flag = True
  17.         else:
  18.             flag = False
  19.         return flag
  20.  
  21.     def is_equal_dict(self, d1, d2):
  22.         if isinstance(d1, str):
  23.             d1 = json.loads(d1)
  24.         if isinstance(d2, str):
  25.             d2 = json.loads(d2)
  26.         return operator.eq(d1, d2)
  27.  
  28.  
  29. def adminlogin():
  30.     url = f"http://{EnvConf.host}:{EnvConf.port}/api/user-management/tokens"
  31.     data = UserInfo.admininfo
  32.     resp = requests.post(url=url, json=data)
  33.  
  34.     try:
  35.         token = f"Bearer {resp.json()['data']['access_token']}"
  36.     except:
  37.         raise
  38.  
  39.     return token
  40.  
  41.  
  42. def commonlogin():
  43.     url = f"http://{EnvConf.host}:{EnvConf.port}/api/user-management/tokens"
  44.     data = UserInfo.commoninfo
  45.     resp = requests.post(url=url, json=data)
  46.  
  47.     try:
  48.         token = f"Bearer {resp.json()['data']['access_token']}"
  49.     except:
  50.         raise
  51.  
  52.     return token
  53.

主要编写一些验证器，或者通用的获取登陆 token 信息等函数。这里的验证器还很简单，后面再慢慢添加，比如正则校验，解析 json 校验等。

2. 基础包 base

封装 http 请求 runmethod.py

  1. import requests
  2. import json
  3.  
  4.  
  5. class RunMethod(object):
  6.     def __init__(self):
  7.         self.verify = False
  8.         self.headers = None
  9.  
  10.     def post_main(self, url, data=None, header=None):
  11.         res = None
  12.         if header is not None:
  13.             res = requests.post(url=url, data=data, headers=header)
  14.         else:
  15.             res = requests.post(url=url, data=data)
  16.         return res.json()
  17.  
  18.     def get_main(self, url, data=None, header=None, param=None):
  19.         res = None
  20.         if header is not None:
  21.             res = requests.get(url=url, data=data, headers=header, verify=self.verify, params=param)
  22.         else:
  23.             res = requests.get(url=url, data=data, verify=self.verify, params=param)
  24.         return res.json()
  25.  
  26.     def del_main(self, url, data=None, header=None):
  27.         res = None
  28.         if header is not None:
  29.             res = requests.delete(url=url, data=data, headers=header)
  30.         else:
  31.             res = requests.delete(url=url, data=data)
  32.         return res.json()
  33.  
  34.     def run_main(self, method, url, data=None, header=None):
  35.         res = None
  36.         if method == 'POST':
  37.             res = self.post_main(url, data, header)
  38.         elif method == 'GET':
  39.             res = self.get_main(url, data, header)
  40.         else:
  41.             res = self.del_main(url, data, header)
  42.         return json.dumps(res, ensure_ascii=False, sort_keys=True, indent=2)

当前的封装还是很简陋的，并没有过多的异常处理，参数校验等，后面会对这方面做一下增强。

runmock.py 是用来做 mock 数据的，以后再用。

提取 excel 数据文件 basetest.py

  1. from tools.get_data import GetExcelData
  2. from base.runmethod import RunMethod
  3. from tools.common_util import CommonUtil
  4. from config.config import EnvConf, Header
  5. import json
  6. from tools.excel_operation import OperationExcel
  7. from tools.common_util import adminlogin, commonlogin
  8.  
  9.  
  10. class CaseDataAllSheets:
  11.     def __init__(self, filename=None):
  12.         self.filename = filename
  13.         self.opera_excel = OperationExcel(filename)
  14.         self.sheet_nums = self.opera_excel.get_sheets()
  15.  
  16.     def get_all_sheets_data(self):
  17.         total_data = {
  18.             "sheet-data": [],
  19.             'case_data_ids': []
  20.         }
  21.         for i in range(len(self.sheet_nums)):
  22.             data = {}
  23.             sheet_name = self.opera_excel.get_sheet_name()[i]
  24.             casedata = CaseData(filename=self.filename, sheet_id=i)
  25.             test_data, case_data_ids = casedata.get_testcase_data()
  26.             data[sheet_name] = test_data
  27.             total_data['sheet-data'].append(data)
  28.             total_data['case_data_ids'].append(case_data_ids)
  29.         return total_data
  30.  
  31.  
  32. class CaseData:
  33.     def __init__(self, filename=None, sheet_id=0):
  34.         self.exceldata = GetExcelData(filename, sheet_id)
  35.         self.casenums = self.exceldata.get_case_lines()
  36.  
  37.     def get_testcase_data(self):
  38.         test_data = {
  39.             'parameterize': []
  40.         }
  41.         case_data_ids = []
  42.         for case in range(1, self.casenums + 1):
  43.             if self.exceldata.get_is_auto_run(case):
  44.                 case_data_json = {
  45.                     'request-data': {},
  46.                     'response-data': {}
  47.                 }
  48.                 case_method = self.exceldata.get_request_method(case)
  49.                 data_url = self.exceldata.get_request_url(case)
  50.                 case_url = f"http://{EnvConf.host}:{EnvConf.port}" + data_url
  51.                 case_data = self.exceldata.get_request_data(case)
  52.                 if case_data != '':
  53.                     try:
  54.                         case_data = json.loads(case_data)
  55.                     except:
  56.                         raise
  57.                 case_header = self.exceldata.get_header(case)
  58.                 if case_header == '':
  59.                     case_header = Header.headers
  60.                 else:
  61.                     try:
  62.                         case_header = json.loads(case_header)
  63.                     except:
  64.                         raise
  65.                 case_statuscode = self.exceldata.get_response_statuscode(case)
  66.                 case_checkpoint = self.exceldata.get_checkpoints(case)
  67.                 case_validate = self.exceldata.get_validate(case)
  68.                 case_uniqueid = self.exceldata.get_caseuniqueid(case)
  69.                 print(case_uniqueid)
  70.                 print(type(case_uniqueid))
  71.                 case_authtype = self.exceldata.get_authtype(case)
  72.                 if case_authtype == 0:
  73.                     token = adminlogin()
  74.                     case_header['authorization'] = token
  75.                 elif case_authtype == 1:
  76.                     token = commonlogin()
  77.                     case_header['authorization'] = token
  78.                 else:
  79.                     pass
  80.                 case_data_json['request-data']['url'] = case_url
  81.                 case_data_json['request-data']['data'] = case_data
  82.                 case_data_json['request-data']['header'] = case_header
  83.                 case_data_json['request-data']['method'] = case_method
  84.                 case_data_json['response-data']['statuscode'] = case_statuscode
  85.                 case_data_json['response-data']['checkpoint'] = case_checkpoint
  86.                 case_data_json['response-data']['validate'] = case_validate
  87.                 case_data_ids.append(case_uniqueid)
  88.                 test_data['parameterize'].append(case_data_json)
  89.         return test_data, case_data_ids
  90.

我把真正的处理 excel 测试用例数据的功能放在了这里，将我们需要的数据，如：url，请求体 data，请求方法 method 等信息组装好，放到内存中，供 pytest 参数化时使用。

3. pytest 测试用例代码

在 case 文件夹中，用来存放真正的 pytest 测试代码，我们写一个简单的测试代码 demo

  1. from base.basetest import BaseTest, CaseData
  2. import pytest
  3.  
  4.  
  5. class Test_example(BaseTest):
  6.     testcase = CaseData('test.xlsx', 1)
  7.     testdata, ids = testcase.get_testcase_data()
  8.  
  9.     @pytest.mark.parametrize('autotest', testdata['parameterize'], ids=ids)
  10.     def test_case(self, autotest, casefile):
  11.         res_json = self.runmethod.run_main(autotest['request-data']['method'], autotest['request-data']['url'],
  12.                                            data=autotest['request-data']['data'],
  13.                                            header=autotest['request-data']['header'])
  14.         print(res_json)
  15.         print("casefile", casefile)
  16.         assert self.validate.is_equal_dict(res_json, autotest['response-data']['checkpoint']) is True
  17.

这里时获取 excel 中的 sheet 序号为1的内容来作为测试数据，如果我们需要把 excel 中所有 sheet 中的数据都作为测试数据来供 pytest 参数化的话，那么就可以实例化 CaseDataAllSheets 类。

4. 测试执行

最后，我们在 main.py 中运行 pytest 主程序

  1. if __name__ == '__main__':
  2.     import pytest
  3.     pytest.main(['-s', '-q', '-vv', '--html=./report/report.html', '--self-contained-html'])
  4.

使用一个 report 插件来自动产生测试报告。

至此，我们以后只需要编写易于操作的 excel，而几乎不需要动任何 Python 代码，就能完成一次接口自动化测试了。当然，编写好的 excel 要放到 data 文件夹下哦！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/秋刀鱼在做梦/article/detail/821014?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号