• python excel接口自动化测试框架

    前言

    前些天写了pytest+yaml+allure接口自动化测试框架这篇文章。

    今天采用Excel继续写一个接口自动化测试框架。

    设计流程图

    这张图是我的excel接口测试框架的一些设计思路。

    首先读取excel文件，得到测试信息，然后通过封装的requests方法，用unittest进行测试。

    其中，接口关联的参数通过正则进行查找和替换，为此我专门开辟了一个全局变量池，用于管理各种各样的变量。

    最后通过HTMLrunner生成测试报告。如果执行失败，发送测试报告结果邮件。

    Excel和结果预览

    这个时excel的测试测试用例组织结构图。

    这个是运行之后生成的HTML测试报告。

    这个时运行之后生成的excel报告。可以看到我故意在预期正则中设置了错误的值，然后用例失败的同时也把失败的预期值标记出来了。

    img
    测试失败之后收到的邮件
    在这里插入图片描述

    好了上面就是一些简单的介绍，我们开始进入正题把。

    框架结构

    首先，要开发这样一个excel接口自动化测试项目必须有一个设计清晰的思路，这样我们在开发框架的过程中才会明白自己要干什么。

    目录/文件说明是否为python包
    common公共类是
    core核心类，封装requests等是
    data测试使用的excel文件存放目录
    logs日志目录
    tests测试用例目录是
    utils工具类，如：日志是
    config.py配置文件
    run.py执行文件

    Excel相关

    用例设计

    本次依然采用的是智学网登录接口。使用了智学网中的登录接口和登录验证接口，这两个接口之间有依赖的参数。

    配置文件

    在项目的根目录创建config.py，把你能想到的配置信息，全部丢在这个文件中进行统一的管理。

    1. #!/usr/bin/env python3
    2. # coding=utf-8
    3. import os
    4.  
    5.  
    6. class CF:
    7.     """配置文件"""
    8.     # 项目目录
    9.     BASE_DIR = os.path.abspath(os.path.dirname(__file__))
    10.  
    11.     # Excel首行配置
    12.     NUMBER = 0
    13.     NAME = 1
    14.     METHOD = 2
    15.     URL = 3
    16.     ROUTE = 4
    17.     HEADERS = 5
    18.     PARAMETER = 6  # 参数
    19.     EXPECTED_CODE = 7  # 预期响应码
    20.     EXPECTED_REGULAR = 8  # 预期正则
    21.     EXPECTED_VALUE = 9  # 预期结果值
    22.     SPEND_TIME = 10  # 响应时间
    23.     TEST_RESULTS = 11  # 测试结果
    24.     EXTRACT_VARIABLE = 12  # 提取变量
    25.     RESPONSE_TEXT = 13  # 响应文本
    26.     # 字体大小
    27.     FONT_SET = "微软雅黑"
    28.     FONT_SIZE = 16
    29.     # 颜色配置
    30.     COLOR_PASSED = "90EE90"
    31.     COLOR_FAILED = "FA8072"
    32.  
    33.     # 邮箱配置
    34.     EMAIL_INFO = {
    35.         'username': '1084502012@qq.com',
    36.         'password': 2,
    37.         'smtp_host': 'smtp.qq.com',
    38.         'smtp_port': 465
    39.     }
    40.     # 收件人
    41.     ADDRESSEE = ['1084502012@qq.com']
    42.  
    43.  
    44. if __name__ == '__main__':
    45.     print(CF.EXPECTED_CODE)
    46.  
    47.
    读取/写入excel#

    ​ 在common目录中新建excelset.py文件，在这个文件中我们要实现，读取excel中的用例，写入测试结果并绘制相应的颜色，写入测试耗费时长。

    1. #!/usr/bin/env python
    2. # coding=utf-8
    3. import shutil
    4. import openpyxl
    5. from config import CF
    6. from openpyxl.styles import Font
    7. from openpyxl.styles import PatternFill
    8. from common.variables import VariablePool
    9.  
    10.  
    11. class ExcelSet:
    12.     """Excel配置"""
    13.  
    14.     def __init__(self):
    15.         shutil.copyfile(VariablePool.get('excel_input'), VariablePool.get('excel_output'))
    16.         self.path = VariablePool.get('excel_output')
    17.         self.wb = openpyxl.load_workbook(self.path)
    18.         self.table = self.wb.active
    19.  
    20.     def get_cases(self, min_row=2):
    21.         """获取用例"""
    22.         all_cases = []
    23.         for row in self.table.iter_rows(min_row=min_row):
    24.             all_cases.append((self.table.cell(min_row, CF.NAME + 1).value,
    25.                               min_row, [cell.value for cell in row]))
    26.             min_row += 1
    27.         return all_cases
    28.  
    29.     def write_color(self, row_n, col_n, color=CF.COLOR_FAILED):
    30.         """写入颜色"""
    31.         cell = self.table.cell(row_n, col_n + 1)
    32.         fill = PatternFill("solid", fgColor=color)
    33.         cell.fill = fill
    34.  
    35.     def write_results(self, row_n, col_n, value, color=True):
    36.         """写入结果"""
    37.         cell = self.table.cell(row_n, col_n + 1)
    38.         cell.value = value
    39.         font = Font(name=CF.FONT_SET, size=CF.FONT_SIZE)
    40.         cell.font = font
    41.         if color:
    42.             if value.lower() in ("fail", 'failed'):
    43.                 fill = PatternFill("solid", fgColor=CF.COLOR_FAILED)
    44.                 cell.fill = fill
    45.             elif value.lower() in ("pass", "ok"):
    46.                 fill = PatternFill("solid", fgColor=CF.COLOR_PASSED)
    47.                 cell.fill = fill
    48.         self.wb.save(self.path)
    49.  
    50.  
    51. excel_set = ExcelSet()
    52. if __name__ == '__main__':
    53.     print(excel_set.get_cases())
    54.  
    55.

    日志封装

    logger.py

    在一个项目中日志是必不可少的东西，可以第一时间反馈问题。

    1. #!/usr/bin/env python3
    2. # coding=utf-8
    3. import os
    4. import logging
    5. from config import CF
    6. from datetime import datetime
    7.  
    8.  
    9. class Logger:
    10.     def __init__(self):
    11.         self.logger = logging.getLogger()
    12.         if not self.logger.handlers:
    13.             self.logger.setLevel(logging.DEBUG)
    14.  
    15.             # 创建一个handler，用于写入日志文件
    16.             fh = logging.FileHandler(self.log_path, encoding='utf-8')
    17.             fh.setLevel(logging.DEBUG)
    18.  
    19.             # 创建一个handler，用于输出到控制台
    20.             ch = logging.StreamHandler()
    21.             ch.setLevel(logging.INFO)
    22.  
    23.             # 定义handler的输出格式
    24.             formatter = logging.Formatter(self.fmt)
    25.             fh.setFormatter(formatter)
    26.             ch.setFormatter(formatter)
    27.  
    28.             # 给logger添加handler
    29.             self.logger.addHandler(fh)
    30.             self.logger.addHandler(ch)
    31.  
    32.     @property
    33.     def log_path(self):
    34.         logs_path = os.path.join(CF.BASE_DIR, 'logs')
    35.         if not os.path.exists(logs_path):
    36.             os.makedirs(logs_path)
    37.         now_month = datetime.now().strftime("%Y%m")
    38.         return os.path.join(logs_path, '{}.log'.format(now_month))
    39.  
    40.     @property
    41.     def fmt(self):
    42.         return '%(levelname)s %(asctime)s %(filename)s:%(lineno)d %(message)s'
    43.  
    44.  
    45. log = Logger().logger
    46. if __name__ == '__main__':
    47.     log.info("你好")
    48.  
    49.

    正则操作

    regular.py

    在接口关联参数的提取和传参中的起到了决定性的作用。

    1. #!/usr/bin/env python3
    2. # -*- coding:utf-8 -*-
    3. import re
    4. from utils.logger import log
    5. from common.variables import VariablePool
    6. from core.serialize import is_json_str
    7.  
    8.  
    9. class Regular:
    10.     """正则类"""
    11.  
    12.     def __init__(self):
    13.         self.reg = re.compile
    14.  
    15.     def finds(self, string):
    16.         return self.reg(r'\{{(.*?)}\}').findall(string)
    17.  
    18.     def subs(self, keys, string):
    19.         result = None
    20.         log.info("提取变量：{}".format(keys))
    21.         for i in keys:
    22.             if VariablePool.has(i):
    23.                 log.info("替换变量：{}".format(i))
    24.                 comment = self.reg(r"\{{%s}}" % i)
    25.                 result = comment.sub(VariablePool.get(i), string)
    26.         log.info("替换结果：{}".format(result))
    27.         return result
    28.  
    29.     def find_res(self, exp, string):
    30.         """在结果中查找"""
    31.         if is_json_str(string):
    32.             return self.reg(r'\"%s":"(.*?)"' % exp).findall(string)[0]
    33.         else:
    34.             return self.reg(r'%s' % exp).findall(string)[0]
    35.  
    36.  
    37. if __name__ == '__main__':
    38.     a = "{'data': {'loginName': 18291900215, 'password': '{{dd636482aca022}}', 'code': None, 'description': 'encrypt'}}"
    39.     print(Regular().finds(a))
    40.

    核心操作

    定义变量池

    variables.py

    全局变量池来了，是不是很简单，但是作用确实很巨大的。

    1. #!/usr/bin/env python3
    2. # -*- coding:utf-8 -*-
    3.  
    4.  
    5. class VariablePool:
    6.     """全局变量池"""
    7.  
    8.     @staticmethod
    9.     def get(name):
    10.         """获取变量"""
    11.         return getattr(VariablePool, name)
    12.  
    13.     @staticmethod
    14.     def set(name, value):
    15.         """设置变量"""
    16.         setattr(VariablePool, name, value)
    17.  
    18.     @staticmethod
    19.     def has(name):
    20.         return hasattr(VariablePool, name)
    21.  
    22.  
    23. if __name__ == '__main__':
    24.     VariablePool.set('name', 'wxhou')
    25.     print(VariablePool.get('name'))
    26.
    封装requests

    request.py

    最最核心的部分，对于python requests库的二次封装。用以实现接口的请求和返回结果的获取。

    1. #!/usr/bin/env python
    2. # coding=utf-8
    3. import urllib3
    4. import requests
    5. from config import CF
    6. from utils.logger import log
    7. from common.regular import Regular
    8. from common.setResult import replace_param
    9. from core.serialize import deserialization
    10. from requests.exceptions import RequestException
    11. from common.variables import VariablePool
    12.  
    13. urllib3.disable_warnings()
    14.  
    15.  
    16. class HttpRequest:
    17.     """二次封装requests方法"""
    18.  
    19.     http_method_names = 'get', 'post', 'put', 'delete', 'patch', 'head', 'options'
    20.  
    21.     def __init__(self):
    22.         self.r = requests.session()
    23.         self.reg = Regular()
    24.  
    25.     def send_request(self, case, **kwargs):
    26.         """发送请求
    27.         :param case: 测试用例
    28.         :param kwargs: 其他参数
    29.         :return: request响应
    30.         """
    31.         if case[CF.URL]:
    32.             VariablePool.set('url', case[CF.URL])
    33.         if case[CF.HEADERS]:
    34.             VariablePool.set('headers', deserialization(case[CF.HEADERS]))
    35.  
    36.         method = case[CF.METHOD].upper()
    37.         url = VariablePool.get('url') + case[CF.ROUTE]
    38.         self.r.headers = VariablePool.get('headers')
    39.         params = replace_param(case)
    40.         if params: kwargs = params
    41.         try:
    42.             log.info("Request Url: {}".format(url))
    43.             log.info("Request Method: {}".format(method))
    44.             log.info("Request Data: {}".format(kwargs))
    45.  
    46.             def dispatch(method, *args, **kwargs):
    47.                 if method in self.http_method_names:
    48.                     handler = getattr(self.r, method)
    49.                     return handler(*args, **kwargs)
    50.                 else:
    51.                     raise AttributeError('request method is ERROR!')
    52.             response = dispatch(method.lower(), url, **kwargs)
    53.             log.info(response)
    54.             log.info("Response Data: {}".format(response.text))
    55.             return response
    56.         except RequestException as e:
    57.             log.exception(format(e))
    58.         except Exception as e:
    59.             raise e
    60.
    序列化与反序列化

    serialize.py

    1. #!/usr/bin/env python3
    2. # -*- coding:utf-8 -*-
    3. import json
    4. from json.decoder import JSONDecodeError
    5.  
    6.  
    7. def deserialization(content: json):
    8.     """
    9.     反序列化
    10.         json对象 -> python数据类型
    11.     """
    12.     return json.loads(content)
    13.  
    14.  
    15. def serialization(content, ensure_ascii=True):
    16.     """
    17.     序列化
    18.         python数据类型 -> json对象
    19.     """
    20.     return json.dumps(content, ensure_ascii=ensure_ascii)
    21.  
    22.  
    23. def is_json_str(string):
    24.     """判断是否是json格式字符串"""
    25.     if isinstance(string, str):
    26.         try:
    27.             json.loads(string)
    28.             return True
    29.         except JSONDecodeError:
    30.             return False
    31.     return False
    32.  
    33.  
    34. if __name__ == '__main__':
    35.     a = "{'data': {'loginName': 18291900215, 'password': 'dd636482aca022', 'code': None, 'description': 'encrypt'}}"
    36.     print(is_json_str(a))
    37.
    检查结果

    checkResult.py

    在这个文件中，我们将对测试返回的结果进行预期的验证。

    1. #!/usr/bin/env python3
    2. # -*- coding:utf-8 -*-
    3. import re
    4. from config import CF
    5. from utils.logger import log
    6. from requests import Response
    7. from common.excelset import excel_set
    8.  
    9.  
    10. def check_result(r: Response, number, case):
    11.     """获取结果"""
    12.     results = []
    13.     excel_set.write_results(number, CF.SPEND_TIME, r.elapsed.total_seconds(), color=False)
    14.     if case[CF.EXPECTED_CODE]:
    15.         res = int(case[CF.EXPECTED_CODE]) == r.status_code
    16.         results.append(res)
    17.         if not res: excel_set.write_color(number, CF.EXPECTED_CODE)
    18.         log.info(f"预期响应码：{case[CF.EXPECTED_CODE]},实际响应码：{r.status_code}")
    19.     if case[CF.EXPECTED_VALUE]:
    20.         res = case[CF.EXPECTED_VALUE] in r.text
    21.         results.append(res)
    22.         if not res: excel_set.write_color(number, CF.EXPECTED_VALUE)
    23.         log.info(f"预期响应值：{case[CF.EXPECTED_VALUE]},实际响应值：{r.text}")
    24.     if case[CF.EXPECTED_REGULAR]:
    25.         res = r'%s' % case[CF.EXPECTED_REGULAR]
    26.         ref = re.findall(res, r.text)
    27.         results.append(ref)
    28.         if not ref: excel_set.write_color(number, CF.EXPECTED_REGULAR)
    29.         log.info(f"预期正则：{res},响应{ref}")
    30.     if all(results):
    31.         excel_set.write_results(number, CF.TEST_RESULTS, 'Pass')
    32.         log.info(f"用例【{case[CF.NAME]}】测试成功！")
    33.     else:
    34.         excel_set.write_results(number, CF.TEST_RESULTS, 'Failed')
    35.         assert all(results), f"用例【{case[CF.NUMBER]}{case[CF.NAME]}】测试失败：{results}"
    36.  
    37.
    设置参数

    setResult.py

    在这个文件中我们实现了接口返回值的提取，实现了接口传递参数的函数。

    1. #!/usr/bin/env python3
    2. # -*- coding:utf-8 -*-
    3. from requests import Response
    4. from utils.logger import log
    5. from common.regular import Regular
    6. from common.excelset import excel_set
    7. from common.variables import VariablePool
    8. from core.serialize import is_json_str, deserialization
    9. from config import CF
    10.  
    11. reg = Regular()
    12.  
    13.  
    14. def get_var_result(r: Response, number, case):
    15.     """替换变量"""
    16.     if case[CF.EXTRACT_VARIABLE]:
    17.         for i in case[CF.EXTRACT_VARIABLE].split(','):
    18.             result = reg.find_res(i, r.text)
    19.             VariablePool.set(i, result)
    20.             log.info(f"提取变量{i}={result}")
    21.             if not VariablePool.get(i):
    22.                 excel_set.write_results(number, CF.EXTRACT_VARIABLE, f"提变量{i}失败")
    23.     excel_set.write_results(number, CF.RESPONSE_TEXT,
    24.                             f"ResponseCode：{r.status_code}\nResponseText：{r.text}")
    25.  
    26.  
    27. def replace_param(case):
    28.     """传入参数"""
    29.     if case[CF.PARAMETER]:
    30.         if is_json_str(case[CF.PARAMETER]):
    31.             is_extract = reg.finds(case[CF.PARAMETER])
    32.             if is_extract:
    33.                 return deserialization(reg.subs(is_extract, case[CF.PARAMETER]))
    34.     return deserialization(case[CF.PARAMETER])
    35.  
    36.

    测试操作

    test_api.py

    我们采用unittest进行测试，在前置条件和后置条件中我们对封装的HttpRequest方法进行了初始化和关闭会话操作。

    使用parameterized库中的expend方法对excel中的用例进行参数化读取执行。

    1. #!/usr/bin/env python
    2. # coding=utf-8
    3. import unittest
    4. from parameterized import parameterized
    5. from common.excelset import excel_set
    6. from core.request import HttpRequest
    7. from common.checkResult import check_result
    8. from common.setResult import get_var_result
    9.  
    10.  
    11. class TestApi(unittest.TestCase):
    12.     """测试接口"""
    13.  
    14.     @classmethod
    15.     def setUpClass(cls) -> None:
    16.         cls.req = HttpRequest()
    17.  
    18.     @classmethod
    19.     def tearDownClass(cls) -> None:
    20.         cls.req.r.close()
    21.  
    22.     @parameterized.expand(excel_set.get_cases())
    23.     def test_api(self, name, number, case):
    24.         """
    25.         测试excel接口用例
    26.         """
    27.         r = self.req.send_request(case)
    28.         get_var_result(r, number, case)
    29.         check_result(r, number, case)
    30.  
    31.  
    32. if __name__ == '__main__':
    33.     unittest.main(verbosity=2)
    34.

    测试报告发送邮件类

    run.py

    1. #!/usr/bin/env python3
    2. # -*- coding:utf-8 -*-
    3. import os
    4. import platform
    5. import argparse
    6. import unittest
    7. from common.variables import VariablePool
    8. from utils.send_mail import send_report_mail
    9. from utils.HTMLTestRunner import HTMLTestRunner
    10.  
    11.  
    12. def running(path):
    13.     """运行"""
    14.     test_case = unittest.defaultTestLoader.discover('tests', 'test*.py')
    15.     with open(path, 'wb') as fp:
    16.         runner = HTMLTestRunner(stream=fp,
    17.                                 title='Excel接口测试',
    18.                                 description="用例执行情况",
    19.                                 verbosity=2)
    20.         result = runner.run(test_case)
    21.     if result.failure_count:
    22.         send_report_mail(path)
    23.  
    24.  
    25. def file_path(arg):
    26.     """获取输入的文件路径"""
    27.     if 'Windows' in platform.platform():
    28.         _dir = os.popen('chdir').read().strip()
    29.     else:
    30.         _dir = os.popen('pwd').read().strip()
    31.     if _dir in arg:
    32.         return arg
    33.     return os.path.join(_dir, arg)
    34.  
    35.  
    36. def main():
    37.     """主函数"""
    38.     parser = argparse.ArgumentParser(description="运行Excel接口测试")
    39.     parser.add_argument('-i', type=str, help='原始文件')
    40.     parser.add_argument('-o', type=str, default='report.xlsx', help="输出文件")
    41.     parser.add_argument('-html', type=str, default='report.html', help="报告文件")
    42.     args = parser.parse_args()
    43.     VariablePool.set('excel_input', file_path(args.i))
    44.     VariablePool.set('excel_output', file_path(args.o))
    45.     VariablePool.set('report_path', file_path(args.html))
    46.     running(VariablePool.get('report_path'))
    47.  
    48.  
    49. if __name__ == '__main__':
    50.     main()
    51.  
    52.  
    53.

    运行

    值得注意的是，运行测试时要关闭office打开该excel文件。

    最后的文件中我是使用了argparse进行了命令行管理，意味着我们可以通过命令行进行测试而无需关心excel在那个目录下存放着。

    python run.py -i data\usercase.xlsx

    输入下面的命令执行一下。

    1. INFO 2020-07-30 22:07:52,713 request.py:40 Request Url: https://www.zhixue.com/weakPwdLogin/?from=web_login
    2. INFO 2020-07-30 22:07:52,714 request.py:41 Request Method: POST
    3. INFO 2020-07-30 22:07:52,715 request.py:42 Request Data: {'data': {'loginName': 18291900215, 'password': 'dd636482aca022', 'code': None, 'descriptio
    4. n': 'encrypt'}}
    5. INFO 2020-07-30 22:08:17,204 request.py:55 <Response [200]>
    6. INFO 2020-07-30 22:08:17,204 request.py:56 Response Data: {"data":"1500000100070008427","result":"success"}
    7. INFO 2020-07-30 22:08:17,207 setResult.py:20 提取变量data=1500000100070008427
    8. INFO 2020-07-30 22:08:17,307 checkResult.py:18 预期响应码：200,实际响应码：200
    9. INFO 2020-07-30 22:08:17,308 checkResult.py:23 预期响应值："result":"success",实际响应值：{"data":"1500000100070008427","result":"success"}
    10. INFO 2020-07-30 22:08:17,310 checkResult.py:29 预期正则：[\d]{16},响应['1500000100070008']
    11. INFO 2020-07-30 22:08:17,356 checkResult.py:32 用例【登录】测试成功！
    12. ok test_api_0__ (test_api.TestApi)
    13. INFO 2020-07-30 22:08:17,358 regular.py:20 提取变量：['data']
    14. INFO 2020-07-30 22:08:17,359 regular.py:23 替换变量：data
    15. INFO 2020-07-30 22:08:17,361 regular.py:26 替换结果：{"data": {"userId": "1500000100070008427"}}
    16. INFO 2020-07-30 22:08:17,363 request.py:40 Request Url: https://www.zhixue.com/loginSuccess/
    17. INFO 2020-07-30 22:08:17,366 request.py:41 Request Method: POST
    18. INFO 2020-07-30 22:08:17,367 request.py:42 Request Data: {'data': {'userId': '1500000100070008427'}}
    19. INFO 2020-07-30 22:08:20,850 request.py:55 <Response [200]>
    20. INFO 2020-07-30 22:08:20,851 request.py:56 Response Data: {"result":"success"}
    21. INFO 2020-07-30 22:08:20,932 checkResult.py:18 预期响应码：200,实际响应码：200
    22. INFO 2020-07-30 22:08:20,933 checkResult.py:23 预期响应值："result":"success",实际响应值：{"result":"success"}
    23. INFO 2020-07-30 22:08:20,935 checkResult.py:29 预期正则：11,响应[]
    24. F  test_api_1__ (test_api.TestApi)
    25.  
    26. Time Elapsed: 0:00:28.281434
    27. 测试结果邮件发送成功！
    28.

    执行规则

    1. (venv) C:\Users\hoou\PycharmProjects\httptest-excel>python run.py -h
    2. usage: run.py [-h] [-i I] [-o O] [-html HTML]
    3.  
    4. 运行Excel接口测试
    5.  
    6. optional arguments:
    7.   -h, --help  show this help message and exit
    8.   -i I        原始文件
    9.   -o O        输出文件
    10.   -html HTML  报告文件
    11.

    SHELL 复制 全屏

    在命令行输入python run.py excel路径 新excel路径 报告路径

    如果不输入新excel路径和报告路径，会在run.py所在目录生成两个report.xlsx，report.html。

    本篇的excel测试框架就完成了。

    Python接口自动化测试零基础入门到精通（2023最新版）

  • 相关阅读:
    Python代码写好了怎么运行
    基于window10的远程桌面报错：要求的函数不受支持 的问题解决方法
    阿里云ESS弹性伸缩的实例配置以及伸缩组规则配置
    软件性能测试包括哪些内容?国内权威软件检测机构排名
    【工具 & 技巧 & 笔试】PyCharm搜索快捷键大总结 | 【笔试题分享】2023美团算法策略方向题目 解析思路及实例代码（含时间复杂度分析）| 动态规划 求解：人在地图中行走 获得最大金币数量
    《Python+Kivy(App开发)从入门到实践》自学笔记：简单UX部件——TextInput输入框
    Go代码包与引入：如何有效组织您的项目
    剑指offer(C++)-JZ38：字符串的排列(算法-搜索算法)
    vue修改node_modules打补丁步骤和注意事项
    「Java 数据结构」：手撕单链表的增删改查及大厂面试题。
  • 原文地址：https://blog.csdn.net/dq565/article/details/134060354