devbox
码创造者
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

python API自动化(Pytest+Excel+Allure完整框架集成+yaml入门+大量响应报文处理及加解密、签名处理)_python + execl+pytest+allure

作者：码创造者 | 2024-06-29 14:05:10

赞

踩

python + execl+pytest+allure

1.pytest数据参数化

        假设你需要测试一个登录功能，输入用户名和密码后验证登录结果。可以使用参数化实现多组输入数据的测试:

        测试正确的用户名和密码登录成功

        测试正确的用户名和错误的密码登录失败

        测试错误的用户名和正确的密码登录失败

        测试错误的用户名和密码登录失败

        在参数化中我们可以单参数、多参数、函数数据参数化

        不管哪一种场景，它们都是数据不一样而产生的问题。核心步骤其实都是一样的---发送请求。

        我们采取的思想就是进行数据分离--DDT数据驱动

        

  1. # 1. 第一个情况：单数据
  2. data = [值1,值2,值3...]
  3. data = (值1,值2,值3...)
  4.  
  5. 单数据，通过对应的下标去进行获取【pytest会自己进行处理】
  6.  
  7. # 2. 第一个情况：多数据，列表和元组嵌套
  8. data = [("admin","123456"),("admin","123456"),("admin","123456"),...]
  9. data = (["admin","123456"],["admin","123456"],...)
  10. 多数据，通过对应的下标去进行获取
  11.  
  12. # 3.【重要】：列表嵌套字典
  13. data = [{“name”:"admin","password":"123456"},
  14. {“name”:"admin","password":"123456"},
  15. {“name”:"admin","password":"123456"}
  16. ...]
  17. 多数据，通过对应的KEY去进行获取
  18.  
  19. 2. 引用对应的数据
  20. 在对应的方法上去加上一个装饰器即可引用：
  21. @pytest.mark.parametrize(argnames,argvalues)
  22. @pytest.mark.parametrize("变量名",引用的变量的值)  #  引用上面的数据，并且取名加：变量名

       2. Pytest+Excel接口自动化框架

        我们如何将对应的数据信息进行提取出来,我们如何使用python来读取Excel

读取excel的方法如下

        

  1.  
  2. import openpyxl
  3. from collectionsFramework.P02_pytest_excel_allure.config import *
  4.  
  5.  
  6. class FileReader:
  7.     """
  8.     专门用来读取和写入yaml、excel文件
  9.     """
  10.  
  11.     # 读取excel--openpyxl -- 文件格式：.xlsx
  12.     @staticmethod  # 直接通过类名进行调用
  13.     def read_excel(file_path=CASEDATAURL, sheet_name=SHEETNAME):
  14.         """
  15.         读取Excel文件，只支持 .xlsx文件
  16.         :param file_path: 文件路径
  17.         :return: excel文件数据,元组的格式
  18.         """
  19.         # 打开现有的Excel文件或创建新的文件
  20.         try:
  21.             #  正常情况下直接打开
  22.             workbook = openpyxl.load_workbook(file_path)
  23.         except FileNotFoundError:
  24.             workbook = openpyxl.Workbook()
  25.  
  26.         # 选择或创建指定的工作表
  27.         if sheet_name in workbook.sheetnames:
  28.             # 【正常】  判断有没有对应的shtttname ，有的话把对应的数据给我加载出来
  29.             worksheet = workbook[sheet_name]
  30.         else:
  31.             # 没有的话，给我新建一个
  32.             worksheet = workbook.create_sheet(sheet_name)
  33.  
  34.         # 获取列名 --- 把第2行的数据拿出来作为我们的key值
  35.         headers = [cell.value for cell in worksheet[2]]
  36.         # print("所有的key", headers)
  37.  
  38.         # 将数据存储为字典,并且放在我们data当中
  39.         data = []  # 所有的数据
  40.  
  41.         # 把小的数据从第三行开始
  42.         for row in worksheet.iter_rows(min_row=3, values_only=True):
  43.             data.append(dict(zip(headers, row)))
  44.  
  45.             # data.append(dict(zip(headers, row)))
  46.             # data.append()
  47.             # dict(zip(headers, row))  # key 和 value 一一对应起来 ==={}
  48.  
  49.         workbook.close()
  50.         # 所有的数据
  51.         return data
  52.  
  53.  
  54. if __name__ == '__main__':
  55.     CaseData = FileReader.read_excel()
  56.     print(CaseData)

EXCEL读取的方法封装

        

        

  1. # -*- coding: utf-8 -*-
  2. # @Time : 2023/11/8 20:55
  3. # @Author : Hami
  4. import json
  5. import pytest
  6. from collectionsFramework.P02_pytest_excel_allure.common.FileDataDriver import FileReader
  7. from collectionsFramework.P02_pytest_excel_allure.api_keyword.api_key import ApiKey
  8.  
  9.  
  10. class TestCase:
  11.     # 获取对应的数据 CaseData 需要从文档当中去进行读取
  12.     CaseData = FileReader.read_excel()
  13.     ak = ApiKey()
  14.  
  15.     @pytest.mark.parametrize("CaseData", CaseData)
  16.     def testCase(self, CaseData):
  17.         # 没一个对应的数据都来临，获取对应的接口请求的四要素
  18.         # 1. 获取数据(四要素) 2. 发送请求 3.获取响应数据 4.断言
  19.  
  20.         # 1. 字典获取的方式依次拿到
  21.         # url = CaseData["url"]+CaseData["path"]
  22.         # params = eval(CaseData["params"])
  23.         # headers = eval(CaseData["headers"])
  24.         # data = eval(CaseData["data"])
  25.  
  26.         dict_data = {
  27.             "url":CaseData["url"]+CaseData["path"],
  28.             "params": eval(CaseData["params"]),
  29.             "headers": eval(CaseData["headers"]),
  30.             "data": eval(CaseData["data"])
  31.         }
  32.  
  33.         if CaseData["type"] == "json":
  34.             dict_data["data"] = json.dumps(dict_data["data"])
  35.  
  36.         # self.ak.post(url=url,....)  # 不建议
  37.         res = self.ak.post(**dict_data) # 不定长参数传值方式
  38.         print(res)
  39.  
  40.  
  41.  
  42.  
  43.  
  44.

eval

eval() 函数是 Python 内置的一个函数，用于将字符串作为代码执行，并返回结果。
 

  1. def add(a, b):
  2. return a + b
  3. result = eval("add(2, 3)")
  4. print(result) # 输出: 5

getattr()函数的应用

        getattr() 函数是 Python 内置的一个函数，用于获取对象的属性或方法

    getattr(object, name, default)
 object : 表示要获取属性或方法的对象。

name : 表示要获取的属性或方法的名称。

default (可选): 表示当属性或方法不存在时的默认值

例子如下

        

  1. """
  2. `getattr()` 函数是 Python 内置的一个函数，用于获取对象的属性或方法。
  3. 语法结构：
  4. getattr(object, name, default)
  5. - `object`: 表示要获取属性或方法的对象。
  6. - `name`: 表示要获取的属性或方法的名称。
  7. - `default` (可选): 表示当属性或方法不存在时的默认值。
  8. """
  9. # 案例一：类当中只有属性
  10. class MyClass:
  11. name = "hami"
  12. age = 18
  13. obj = MyClass()
  14. value = getattr(obj, "name")
  15. print(value) # 输出: hami
  16. # 案例二：类当中对应的属性不存在（有参数）,如果直接参数不存在也没有给参数，报错
  17. class MyClass:
  18. name = "hami"
  19. age = 18
  20. obj = MyClass()
  21. value = getattr(obj, "sex", "女")
  22. print(value) # 输出: hami
  23. # 案例三：类当中对应的方法，一定要记得调用（无参数）
  24. class MyClass:
  25. def greet(self):
  26. print("Hello, world!")
  27. obj = MyClass()
  28. method = getattr(obj, "greet") # 返回对应的方法
  29. method() # 输出: Hello, world!
  30. # 案例四：类当中对应的方法，一定要记得调用（有参数）
  31. class MyClass:
  32. def greet(self,name,age):
  33. print("您的姓名是: {}，年龄是：{}".format(name,age))
  34. obj = MyClass()
  35. method = getattr(obj, "greet")("hami","25") # 您的姓名是hami，年龄是：25

封装主函数

        

  1.  
  2. import json
  3. import pytest
  4. from collectionsFramework.P02_pytest_excel_allure.common.FileDataDriver import FileReader
  5. from collectionsFramework.P02_pytest_excel_allure.api_keyword.api_key import ApiKey
  6. from collectionsFramework.P02_pytest_excel_allure.config import *
  7.  
  8.  
  9. class TestCase:
  10.     # 获取对应的数据 CaseData 需要从文档当中去进行读取
  11.     # 1. 获取数据(四要素) 2. 发送请求 3.获取响应数据 4.断言
  12.     CaseData = FileReader.read_excel()
  13.     ak = ApiKey()
  14.  
  15.     @pytest.mark.parametrize("CaseData", CaseData)
  16.     def testCase(self, CaseData):
  17.  
  18.         # -------------------------发送请求-------------------------------
  19.         try:
  20.             # 请求数据
  21.             dict_data = {
  22.                 "url": CaseData["url"] + CaseData["path"],
  23.                 "params": eval(CaseData["params"]),
  24.                 "headers": eval(CaseData["headers"]),
  25.                 "data": eval(CaseData["data"])
  26.             }
  27.  
  28.             if CaseData["type"] == "json":
  29.                 dict_data["data"] = json.dumps(dict_data["data"])
  30.         except Exception:
  31.             value = MSG_DATA_ERROR
  32.             # ----待定----
  33.             print("写入测试结果", value)
  34.         else:
  35.             # 得到对应的响应数据
  36.             res = getattr(self.ak, CaseData["method"])(**dict_data)
  37.  
  38.         # -------------------------进行断言处理-------------------------------
  39.         # 实际结果
  40.         try:
  41.              msg = self.ak.get_text(res.json(),CaseData["actualResult"])
  42.         except Exception:
  43.             value = MSG_EXDATA_ERROR
  44.             # ----待定----
  45.             print("写入测试结果", value)
  46.         else:
  47.             # 只会是一个分支语言，但是不会造成测试结果成功或者失败，所以必须无论如何都是需要断言
  48.             if msg == CaseData["expectResult"]:
  49.                 value = MSG_ASSERT_OK
  50.             else:
  51.                 value = MSG_ASSERT_NO
  52.                 # ----待定----
  53.             print("写入测试结果", value)
  54.         finally:
  55.             assert msg == CaseData["expectResult"],value

Allure报告日志及动态标题

        

  1.  
  2. import json
  3. import pytest
  4. from collectionsFramework.P02_pytest_excel_allure.common.FileDataDriver import FileReader
  5. from collectionsFramework.P02_pytest_excel_allure.api_keyword.api_key import ApiKey
  6. from collectionsFramework.P02_pytest_excel_allure.config import *
  7.  
  8. import allure
  9.  
  10. class TestCase:
  11.     # 获取对应的数据 CaseData 需要从文档当中去进行读取
  12.     # 1. 获取数据(四要素) 2. 发送请求 3.获取响应数据 4.断言
  13.     CaseData = FileReader.read_excel()
  14.     ak = ApiKey()
  15.  
  16.     def __dynamic_title(self, CaseData):
  17.         # # 动态生成标题
  18.         # allure.dynamic.title(data[11])
  19.  
  20.         # 如果存在自定义标题
  21.         if CaseData["caseName"] is not None:
  22.             # 动态生成标题
  23.             allure.dynamic.title(CaseData["caseName"])
  24.  
  25.         if CaseData["storyName"] is not None:
  26.             # 动态获取story模块名
  27.             allure.dynamic.story(CaseData["storyName"])
  28.  
  29.         if CaseData["featureName"] is not None:
  30.             # 动态获取feature模块名
  31.             allure.dynamic.feature(CaseData["featureName"])
  32.  
  33.         if CaseData["remark"] is not None:
  34.             # 动态获取备注信息
  35.             allure.dynamic.description(CaseData["remark"])
  36.  
  37.         if CaseData["rank"] is not None:
  38.             # 动态获取级别信息(blocker、critical、normal、minor、trivial)
  39.             allure.dynamic.severity(CaseData["rank"])
  40.  
  41.     @pytest.mark.parametrize("CaseData", CaseData)
  42.     def testCase(self, CaseData):
  43.         self.__dynamic_title(CaseData)
  44.  
  45.         # -------------------------发送请求-------------------------------
  46.         try:
  47.             # 请求数据
  48.             dict_data = {
  49.                 "url": CaseData["url"] + CaseData["path"],
  50.                 "params": eval(CaseData["params"]),
  51.                 "headers": eval(CaseData["headers"]),
  52.                 "data": eval(CaseData["data"])
  53.             }
  54.  
  55.             if CaseData["type"] == "json":
  56.                 dict_data["data"] = json.dumps(dict_data["data"])
  57.         except Exception:
  58.             value = MSG_DATA_ERROR
  59.             # ----待定----
  60.             print("写入测试结果", value)
  61.         else:
  62.             # 得到对应的响应数据
  63.             res = getattr(self.ak, CaseData["method"])(**dict_data)
  64.  
  65.         # -------------------------进行断言处理-------------------------------
  66.         # 实际结果
  67.         try:
  68.              msg = self.ak.get_text(res.json(),CaseData["actualResult"])
  69.         except Exception:
  70.             value = MSG_EXDATA_ERROR
  71.             # ----待定----
  72.             print("写入测试结果", value)
  73.         else:
  74.             # 只会是一个分支语言，但是不会造成测试结果成功或者失败，所以必须无论如何都是需要断言
  75.             if msg == CaseData["expectResult"]:
  76.                 value = MSG_ASSERT_OK
  77.             else:
  78.                 value = MSG_ASSERT_NO
  79.                 # ----待定----
  80.             print("写入测试结果", value)
  81.         finally:
  82.             assert msg == CaseData["expectResult"],value

3.Excel框架优化及Yaml入门

         1.写入excel框架

                        我们在FileDataDriver.py， 增加一个写入excel的方法
                        

  1.  @staticmethod
  2.     def writeDataToExcel(file_path=CASEDATAURL, sheet_name=SHEETNAME, row=None, column=None, value=None):
  3.         # 打开现有的Excel文件或创建新的文件
  4.         try:
  5.             workbook = openpyxl.load_workbook(file_path)
  6.         except FileNotFoundError:
  7.             workbook = openpyxl.Workbook()
  8.  
  9.         # 选择或创建指定的工作表
  10.         if sheet_name in workbook.sheetnames:
  11.             worksheet = workbook[sheet_name]
  12.         else:
  13.             worksheet = workbook.create_sheet(sheet_name)
  14.  
  15.         # 写入数据到指定行和列
  16.         worksheet.cell(row=row, column=column).value = value
  17.  
  18.         # 保存修改后的文件--- 所以执行过程当中excel是要关闭的状态
  19.         workbook.save(file_path)

        在config.py中写入对应的常量,我们就可以在对应的测试用例中修改代码如下

        

  1.  
  2. import json
  3. import pytest
  4. from YamlOptimization.P02_pytest_excel_allure.common.FileDataDriver import FileReader
  5. from YamlOptimization.P02_pytest_excel_allure.api_keyword.api_key import ApiKey
  6. from YamlOptimization.P02_pytest_excel_allure.config import *
  7. import allure
  8.  
  9.  
  10. class TestCase:
  11.     # 获取对应的数据 CaseData 需要从文档当中去进行读取
  12.     # 1. 获取数据(四要素) 2. 发送请求 3.获取响应数据 4.断言
  13.     AllCaseData = FileReader.read_excel()
  14.     ak = ApiKey()
  15.  
  16.  
  17.  
  18.     def __dynamic_title(self, CaseData):
  19.         # # 动态生成标题
  20.         # allure.dynamic.title(data[11])
  21.  
  22.         # 如果存在自定义标题
  23.         if CaseData["caseName"] is not None:
  24.             # 动态生成标题
  25.             allure.dynamic.title(CaseData["caseName"])
  26.  
  27.         if CaseData["storyName"] is not None:
  28.             # 动态获取story模块名
  29.             allure.dynamic.story(CaseData["storyName"])
  30.  
  31.         if CaseData["featureName"] is not None:
  32.             # 动态获取feature模块名
  33.             allure.dynamic.feature(CaseData["featureName"])
  34.  
  35.         if CaseData["remark"] is not None:
  36.             # 动态获取备注信息
  37.             allure.dynamic.description(CaseData["remark"])
  38.  
  39.         if CaseData["rank"] is not None:
  40.             # 动态获取级别信息(blocker、critical、normal、minor、trivial)
  41.             allure.dynamic.severity(CaseData["rank"])
  42.  
  43.     @pytest.mark.parametrize("CaseData", AllCaseData)
  44.     def testCase(self, CaseData):
  45.         self.__dynamic_title(CaseData)
  46.  
  47.         # 写Excle的行和列
  48.         row = CaseData["id"]
  49.         column = 11
  50.  
  51.         # 初始化对应的值：
  52.         res = None
  53.         msg = None
  54.         value = None
  55.  
  56.         # -------------------------发送请求-------------------------------
  57.         try:
  58.             # 请求数据
  59.             dict_data = {
  60.                 "url": CaseData["url"] + CaseData["path"],
  61.                 "params": eval(CaseData["params"]),
  62.                 "headers": eval(CaseData["headers"]),
  63.                 "data": eval(CaseData["data"])
  64.             }
  65.  
  66.             if CaseData["type"] == "json":
  67.                 dict_data["data"] = json.dumps(dict_data["data"])
  68.         except Exception:
  69.             value = MSG_DATA_ERROR
  70.             FileReader.writeDataToExcel(row=row,column=column,value=value)
  71.         else:
  72.             # 得到对应的响应数据
  73.             res = getattr(self.ak, CaseData["method"])(**dict_data)
  74.  
  75.         # -------------------------进行断言处理-------------------------------
  76.         # 实际结果
  77.         try:
  78.             msg = self.ak.get_text(res.json(), CaseData["actualResult"])
  79.         except Exception:
  80.             value = MSG_EXDATA_ERROR
  81.             FileReader.writeDataToExcel(row=row,column=column,value=value)
  82.         else:
  83.             # 只会是一个分支语言，但是不会造成测试结果成功或者失败，所以必须无论如何都是需要断言
  84.             if msg == CaseData["expectResult"]:
  85.                 value = MSG_ASSERT_OK
  86.             else:
  87.                 value = MSG_ASSERT_NO
  88.             FileReader.writeDataToExcel(row=row,column=column,value=value)
  89.         finally:
  90.             assert msg == CaseData["expectResult"], value
  91.  
  92.

        2.实现优化接口关联

        思路:

  1. excel ---字段 {"key":"value"} ----{"变量名":"jsonpath值"，"变量名":"jsonpath值"}

{"token":"$..token"，"name":"$..name"}

    2. 写一个方法：

循环遍历这个值 ：{"token":"$..token"，"name":"$..name"}

遍历的过程当中，通过"$..token"提取具体的值：56465456456313521456 ---new_value

3. 定义一个全局变量：专门用来存放提取之后的数据。

all_val={"token":"56465456456313521456"，"name":"hami"}

代码如下:

        

  1.   def __json_extraction(self, CaseData, res):
  2.         """
  3.         提取响应之后的数据
  4.         :param CaseData: 当前的Case，主要获取需要提取数据的字段：jsonExData
  5.         :param res:响应得到的对应的结果
  6.         :return:
  7.         """
  8.         try:
  9.             if CaseData["jsonExData"]:
  10.                 Exdata = eval(CaseData["jsonExData"])  # {"VAR_TOKEN":"$..token","MSG":"$.msg"}
  11.                 print("需要提取的数据：>>>", Exdata)
  12.                 for key, value in Exdata.items():
  13.                     # 通过对应的jsonpath获取具体的数据
  14.                     new_value = self.ak.get_text(res.json(), value)
  15.                     self.all_var.update(
  16.                         {key: new_value}
  17.                     )
  18.                 print("提取出来的数据：>>>", self.all_var)
  19.             else:
  20.                 print("需要提取的数据为空")
  21.         except Exception:
  22.             print("请检查你需要提取数据数据格式的正确性。")

3.进行变量渲染

        我们提取出来的casedata如下所示

        

我们可以看到此处的id和var_token没有具体的值,我们需要把具体的值渲染进去

        

  1.  all_val = {"VAR_TOKEN": "134324324324", "id": "158"}
  2.  CaseData = {"id": 3,
  3.              "url": "http://novel.hctestedu.com/book/queryBookDetail/{{id}}",
  4.              'params': '{"application": "app",\n"application_client_type": "weixin",\n"token":  "{{VAR_TOKEN}}"}'
  5.              }
  6.  
  7.  CaseData = eval(Template(str(CaseData)).render(all_val))

就用template来进行渲染

3.数据库操作(提取数据)

        我们的思路如下:

  1. 框架能够连接数据库
  2. 执行SQL
  3. 把数据返回

思路：同json提取器

从数据库提取数据：Excle进行维护 ；思路：同json提取器

   1.游标对象

        在数据库中，游标是一个十分重要的概念。游标提供了一种从表中检索出的数据进行操作的灵活手段，就本质而言，游标实际上是一种能从包括多条数据记录的结果集中每次提取一条记录的机制。游标总是与一条SQL 选择语句相关联因为游标由结果集（可以是零条，一条或由相关的选择语句检索出的多条记录）和结果集中指向特定记录的游标位置组成。当决定对结果进行处理时，必须声明一个指向该结果的游标
        

        常用的方法:

        cursor(): 创建游标对象

        close(): 关闭游标对象

        fetchone(): 得到结果集的下一行

        fetchmany([size = cursor.arraysize]):得到结果集的下几行fetchall():得到结果集中剩下的所有行

        excute(sql[,args]): 执行一个数据库查询或命令executemany(sql,args):执行多个数据库查询或命令

      例子如下:

        

  1.  
  2.  
  3. """
  4. 在测试过程中偶然需要从数据库获取数据进行测试或者通过数据库的数据进行断言，这时候既要连接到数据库。
  6. python当中利用PySQL进行连接
  7. 安装：pip install pymysql
  8. """
  9. import pymysql
  10.  
  11. # 1. 配置数据库连接信息并连接
  12. connection = pymysql.connect(
  13.     host='shop-xo.hctestedu.com',  # 数据库地址
  14.     port=3306,
  15.     user='api_test',  # 数据库用户名
  16.     password='Aa9999!',  # 数据库密码
  17.     db='shopxo_hctested',  # 数据库名称
  18. )
  19.  
  20. # 2. 创建游标对象，使用它进行操作---人
  21. cursor = connection.cursor()
  22.  
  23. # 3. SQL语句---饭
  24. sql =  "SELECT username FROM sxo_user WHERE id = 75;"
  25.  
  26. # 4. 使用游标对象去执行操作SQL
  27. cursor.execute(sql)
  28.  
  29. # 5. 得到结果集的下一行
  30. result = cursor.fetchone()
  31.  
  32. print(result)  # 元组
  33. # 6. 关闭数据库连接
  34. cursor.close()

2.我们继续优化代码 将数据库提取的操作写入api_key和测试用例当中

        api中

  1.  @allure.step(">>>>>>:开始提取数据库的数据")
  2.     def get_sqlData(self, sqlValue):
  3.         """
  5.         :param sqlValue: SQL,返回的数据是一个元组
  6.         :return:
  7.         """
  8.         import pymysql
  9.  
  10.         # 1. 配置数据库连接信息并连接
  11.         connection = pymysql.connect(
  12.             host=DB_HOST,  # 数据库地址
  13.             port=DB_PORT,
  14.             user=DB_USER,  # 数据库用户名
  15.             password=DB_PASSWORD,  # 数据库密码
  16.             db=DB_NAME,  # 数据库名称
  17.         )
  18.         # 2. 创建游标对象，使用它进行操作
  19.         cursor = connection.cursor()
  20.         # 4. 使用游标对象去执行操作SQL
  21.         cursor.execute(sqlValue)
  22.         # 5. 得到结果集的下一行
  23.         result = cursor.fetchone()
  24.         # 6. 关闭数据库连接
  25.         cursor.close()
  26.         return result[0]

测试用例中

        

  1.     def __sql_extraction(self,CaseData):
  2.         """
  3.          从数据库提取数据
  4.         :param CaseData: 当前的Case，主要获取需要提取数据的字段：sqlExData
  5.         :return:
  6.         """
  7.         try:
  8.             if CaseData["sqlExData"]:
  9.                 Exdata = eval(CaseData["sqlExData"])  # {"name":"SELECT username FROM sxo_user WHERE username='hami'","id":"SELECT id FROM sxo_user WHERE username='hami'"}
  10.                 print("SQL-需要提取的数据：>>>", Exdata)
  11.                 for key, value in Exdata.items():
  12.                     # 通过对应的sql获取具体的数据
  13.                     new_value = self.ak.get_sqlData(value)
  14.                     self.all_var.update(
  15.                         {key: new_value}
  16.                     )
  17.                 print("SQL-提取出来的数据：>>>", self.all_var)
  18.             else:
  19.                 print("SQL-需要提取的数据为空")
  20.         except Exception:
  21.             print("SQL-请检查你需要提取数据数据格式的正确性。")

4.数据库操作-数据库断言【一般是极为重要的接口我们去做】

  1. 检查数据库是否有这个用户？ --- 数据库断言
  2. 是否能够正确的登录

        

思路：excel

  1. 期望结果：{"username":"yeye"}
  2. 实际结果：{"username":"SELECT username FROM sxo_user WHERE id=75"}

        代码如下

        

  1.   def __sql_assertData(self, CaseData):
  2.         res = True
  3.         if CaseData["sqlAssertData"] and CaseData["sqlExpectRe ult"]:
  4.             # 实际结果：从数据库读取出来的数据--字典的格式 # {"name":"SELECT username FROM sxo_user WHERE username='hami'","id":"SELECT id FROM sxo_user WHERE username='hami'"}
  5.             realityData = eval(CaseData["sqlAssertData"])
  6.             # 期望结果:{"name":"hami","id":75}
  7.             expectData = json.loads(CaseData["sqlExpectResult"])
  8.  
  9.             realityDataDict = {}
  10.             for key, value in realityData.items():
  11.                 # 通过对应的sql获取具体的数据
  12.                 new_value = self.ak.get_sqlData(value)
  13.                 realityDataDict.update(
  14.                     {key: new_value}
  15.                 )
  16.  
  17.             if expectData != realityDataDict:
  18.                 res = False
  19.         return res

整个侧事故用例代码如下

        

  1. # -*- coding: utf-8 -*-
  2. # @Time : 2023/11/8 20:55
  3. # @Author : Hami
  4. import json
  5. import pytest
  6. from YamlOptimization.P02_pytest_excel_allure.common.FileDataDriver import FileReader
  7. from YamlOptimization.P02_pytest_excel_allure.api_keyword.api_key import ApiKey
  8. from YamlOptimization.P02_pytest_excel_allure.config import *
  9. import allure
  10. from jinja2 import Template  # 变量渲染
  11.  
  12.  
  13. class TestCase:
  14.     # 获取对应的数据 CaseData 需要从文档当中去进行读取
  15.     # 1. 获取数据(四要素) 2. 发送请求 3.获取响应数据 4.断言
  16.     AllCaseData = FileReader.read_excel()
  17.     ak = ApiKey()
  18.     # 定义：all_val 存放提取出的数据
  19.     all_var = {}
  20.  
  21.     def __dynamic_title(self, CaseData):
  22.         # # 动态生成标题
  23.         # allure.dynamic.title(data[11])
  24.  
  25.         # 如果存在自定义标题
  26.         if CaseData["caseName"] is not None:
  27.             # 动态生成标题
  28.             allure.dynamic.title(CaseData["caseName"])
  29.  
  30.         if CaseData["storyName"] is not None:
  31.             # 动态获取story模块名
  32.             allure.dynamic.story(CaseData["storyName"])
  33.  
  34.         if CaseData["featureName"] is not None:
  35.             # 动态获取feature模块名
  36.             allure.dynamic.feature(CaseData["featureName"])
  37.  
  38.         if CaseData["remark"] is not None:
  39.             # 动态获取备注信息
  40.             allure.dynamic.description(CaseData["remark"])
  41.  
  42.         if CaseData["rank"] is not None:
  43.             # 动态获取级别信息(blocker、critical、normal、minor、trivial)
  44.             allure.dynamic.severity(CaseData["rank"])
  45.  
  46.     def __json_extraction(self, CaseData, res):
  47.         """
  48.         提取响应之后的数据
  49.         :param CaseData: 当前的Case，主要获取需要提取数据的字段：jsonExData
  50.         :param res:响应得到的对应的结果
  51.         :return:
  52.         """
  53.         try:
  54.             if CaseData["jsonExData"]:
  55.                 Exdata = eval(CaseData["jsonExData"])  # {"VAR_TOKEN":"$..token","MSG":"$.msg"}
  56.                 print("需要提取的数据：>>>", Exdata)
  57.                 for key, value in Exdata.items():
  58.                     # 通过对应的jsonpath获取具体的数据
  59.                     new_value = self.ak.get_text(res.json(), value)
  60.                     self.all_var.update(
  61.                         {key: new_value}
  62.                     )
  63.                 print("提取出来的数据：>>>", self.all_var)
  64.             else:
  65.                 print("需要提取的数据为空")
  66.         except Exception:
  67.             print("请检查你需要提取数据数据格式的正确性。")
  68.  
  69.     def __sql_extraction(self, CaseData):
  70.         """
  71.          从数据库提取数据
  72.         :param CaseData: 当前的Case，主要获取需要提取数据的字段：sqlExData
  73.         :return:
  74.         """
  75.         try:
  76.             if CaseData["sqlExData"]:
  77.                 Exdata = eval(CaseData[
  78.                                   "sqlExData"])  # {"name":"SELECT username FROM sxo_user WHERE username='hami'","id":"SELECT id FROM sxo_user WHERE username='hami'"}
  79.                 print("SQL-需要提取的数据：>>>", Exdata)
  80.                 for key, value in Exdata.items():
  81.                     # 通过对应的sql获取具体的数据
  82.                     new_value = self.ak.get_sqlData(value)
  83.                     self.all_var.update(
  84.                         {key: new_value}
  85.                     )
  86.                 print("SQL-提取出来的数据：>>>", self.all_var)
  87.             else:
  88.                 print("SQL-需要提取的数据为空")
  89.         except Exception:
  90.             print("SQL-请检查你需要提取数据数据格式的正确性。")
  91.  
  92.     def __sql_assertData(self, CaseData):
  93.         res = True
  94.         if CaseData["sqlAssertData"] and CaseData["sqlExpectRe ult"]:
  95.             # 实际结果：从数据库读取出来的数据--字典的格式 # {"name":"SELECT username FROM sxo_user WHERE username='hami'","id":"SELECT id FROM sxo_user WHERE username='hami'"}
  96.             realityData = eval(CaseData["sqlAssertData"])
  97.             # 期望结果:{"name":"hami","id":75}
  98.             expectData = json.loads(CaseData["sqlExpectResult"])
  99.  
  100.             realityDataDict = {}
  101.             for key, value in realityData.items():
  102.                 # 通过对应的sql获取具体的数据
  103.                 new_value = self.ak.get_sqlData(value)
  104.                 realityDataDict.update(
  105.                     {key: new_value}
  106.                 )
  107.  
  108.             if expectData != realityDataDict:
  109.                 res = False
  110.         return res
  111.  
  112.     @pytest.mark.parametrize("CaseData", AllCaseData)
  113.     def testCase(self, CaseData):
  114.         self.__dynamic_title(CaseData)
  115.         CaseData = eval(Template(str(CaseData)).render(self.all_var))
  116.  
  117.         print(CaseData)
  118.  
  119.         # 写Excle的行和列
  120.         row = CaseData["id"]
  121.         column = 11
  122.  
  123.         # 初始化对应的值：
  124.         res = None
  125.         msg = None
  126.         value = None
  127.  
  128.         # -------------------------发送请求-------------------------------
  129.         try:
  130.             # 请求数据
  131.             dict_data = {
  132.                 "url": CaseData["url"] + CaseData["path"],
  133.                 "params": eval(CaseData["params"]),
  134.                 "headers": eval(CaseData["headers"]),
  135.                 "data": eval(CaseData["data"])
  136.             }
  137.  
  138.             if CaseData["type"] == "json":
  139.                 dict_data["data"] = json.dumps(dict_data["data"])
  140.         except Exception:
  141.             value = MSG_DATA_ERROR
  142.             FileReader.writeDataToExcel(row=row, column=column, value=value)
  143.         else:
  144.             # 得到对应的响应数据
  145.             res = getattr(self.ak, CaseData["method"])(**dict_data)
  146.  
  147.         # -------------------------提取数据库的操作---------------------------
  148.         self.__sql_extraction(CaseData)
  149.  
  150.         # -------------------------进行断言处理-------------------------------
  151.         # 实际结果
  152.         try:
  153.             msg = self.ak.get_text(res.json(), CaseData["actualResult"])
  154.         except Exception:
  155.             value = MSG_EXDATA_ERROR
  156.             FileReader.writeDataToExcel(row=row, column=column, value=value)
  157.         else:
  158.             # 只会是一个分支语言，但是不会造成测试结果成功或者失败，所以必须无论如何都是需要断言
  159.             if msg == CaseData["expectResult"]:
  160.                 value = MSG_ASSERT_OK
  161.                 # 成功之后进行数据提取
  162.                 self.__json_extraction(CaseData, res)
  163.  
  164.             else:
  165.                 value = MSG_ASSERT_NO
  166.             FileReader.writeDataToExcel(row=row, column=column, value=value)
  167.         finally:
  168.             assert msg == CaseData["expectResult"], value
  169.  
  170.         # -------------------------进行数据库断言处理-------------------------------
  171.         try:
  172.             res = self.__sql_assertData(CaseData)  # False True
  173.         except:
  174.             print("SQL断言出现问题")
  175.             value = "SQL断言出现问题"
  176.             assert res, value
  177.         else:
  178.             assert res
  179.         finally:
  180.             FileReader.writeDataToExcel(row=row, column=column, value=value)

5.yaml应用 

                yaml的概念:

                YAML 的语法和其他高级语言类似，并且可以简单表达清单、散列表，标量等数据形态。它使用空白符号缩进和大量依赖外观的特色，特别适合用来表达或编辑数据结构、各种配置文件、倾印调试内容、文件大纲（例如：许多电子邮件标题格式和YAML非常接近）


        YAML 的配置文件后缀为 .yml或.yaml，如：huace.yml

        基本语法:

        大小写敏感

        使用缩进表示层级关系

        缩进不允许使用tab，只允许空格

        缩进的空格数不重要，只要相同层级的元素左对齐即可

        '#' 表示注释

        Yaml当中如果是数字字符的话，一定要加双引号（不加就是一个整型）

        数据类型

纯量：字符串/数字 ，直接写就好了

列表：用符号去代替： -

字典：key : value

符号后面必须要有对应空格

                我们的yaml中可以这样写

                

  1. data:
  2. -
  3.  id: "0001"
  4.  name: "qsdd"
  5. -
  6.  id: "0002"
  7.  name: "yeyeyeye"

可以成功转换为json格式

 也可以这样写:

data: [{ "id": "0001"},{ "id": "0002"}]

        也可以转换为json格式

        excel格式的转换

        

  1. 方法一：
  2. - 
  3.  {"id":"0001","name":"hami"}
  4. -
  5.  {"id":"0002","name":"hami"}
  6. 方法二：
  7. - 
  8.  id: "0001"
  9.  name: hami1
  10. -
  11.  id: 0002
  12.  name: hami2
  13.  
  14.  效果：
  15.  [{"id":"0001","name":"hami"},{"id":"0002","name":"hami"}]

excel转换为yaml格式

                代码如下

        

  1.  
  2. """
  3. YAML 是 "YAML Ain't a Markup Language" -- 数据格式
  4. YAML 的配置文件后缀为 .yml或.yam，如：huace.yml 。
  6. 1.1 基本语法
  7. - 大小写敏感
  8. - 使用缩进表示层级关系
  9. - 缩进不允许使用tab，只允许空格
  10. - 缩进的空格数不重要，只要相同层级的元素左对齐即可
  11. - '#' 表示注释
  13. YAML 支持以下几种数据类型：
  14. - 对象：键值对的集合，又称为映射（mapping）/ 哈希（hashes） / 字典（dictionary）
  15. - 数组：一组按次序排列的值，又称为序列（sequence） / 列表（list）
  16. - 纯量（scalars）：单个的、不可再分的值 -- 任意的数据类型
  18. 对象格式： key: value
  19. 数组格式： -
  21. 可以在在线网址先确定格式的正确性：https://tool.p2hp.com/tool-format-yaml/
  23. 安装：pip install pyyaml
  24. """
  25. # 1. 读取数据
  26. import yaml
  27.  
  28. # file_path = "yamlData/test_yaml_04.yaml"
  29. file_path = "yamlData/x_testFavor.yaml"
  30. with open(file_path, 'r', encoding="utf-8") as file:
  31.     data = yaml.safe_load(file)
  32. print(data)
  33.  
  34. # # 2. 修改数据
  35. # data[1]["res"] = "执行失败"
  36. #
  37. # # 3. 写入数据
  38. # with open(file_path, 'w', encoding="utf-8") as file:
  39. #     # allow_unicode=True，避免将中文字符转换为 Unicode 转义序列
  40. #     yaml.dump(data, file, allow_unicode=True)

对yaml进行读写

我们在专门用来读写yaml和excel的py文件中新增一个方法

        

  1.   @staticmethod
  2.     def write_yaml(data, file_path=YAMLDATA):
  3.         """
  4.         写入yaml文件，写入无序没有关系，通过key获取数据
  5.         :param data: 需要写入的数据
  6.         :param file_path: 文件路径
  7.         :return:
  8.         """
  9.         with open(file_path, 'w', encoding='utf-8') as file:
  10.             # 可以结合异常处理进行封装
  11.             try:
  12.                 yaml.dump(data, file, allow_unicode=True)
  13.                 print("YAML数据写入成功。")
  14.             except yaml.YAMLError as e:
  15.                 print(f"YAML数据写入失败: {e}")

对框架进行修改

 我们改成读取yaml文件

        对应的读取读取数据源的方法需要修改成： AllCaseData = FileReader.read_yaml()

        写入到Yaml文件，所以无需行号去进行记录，可删除变量： row、cell


        因为通过Yaml读取出来的本身就是json，所以 dict_data 这个变量值，有可能

是字典，也有可能是字符串，所以为了灵活起见，统一改成如下，同时也可以直接去掉eval方法即可

        

  1. # 扩展：不做强制要求
  2. # 字符串
  3. # input_string = "{'name':'Alice', 'age':'25', 'city':'New York'}"
  4. # 字典
  5. input_string = {'name':'Alice', 'age':'25', 'city':'New York'}
  6.  
  7. print("转之前：", type(input_string))  # 字符串
  8. # 如果input_string类型是str 则 转成字典eval(input_string)； 否则的话：直接输出 （ else input_string）
  9. result = eval(input_string) if isinstance(input_string, str) else input_string
  10. print("转之后：", type(result))  # 字典
  11. print(result)

就是判断值是字典还是字符串 是字符串就转为字典

我们只需要在测试用例中修改读写的数据

        

再根据情况修改上述的转换格式的代码 即可

回写数据到yaml

        首先我们写入的时候是写入所有的数据到data 当中

如，我们所有读取出来的数据是AllCaseData，比如如下格式

        

  1. [{id":0,"caseName":"登录接口","result":nall},
  2. {id":1,"caseName":"加入购物车","result":nall}]

通过参数化方式我们每次能够拿到一条数据，比如你要修改第一个这条数据，可以
 

CaseData["result"] = value

重点：但是你修改的只是这一条数据，直接写入就会不正确（覆盖其它的数据）。
所以，正确的做法是：这里的CaseData["id"] 代表下标。
 

AllCaseData[CaseData["id"] ] = value

yaml+allure+pytest框架如下所示:

        

  1.  
  2. import json
  3. import pytest
  4. from YamlOptimization.pytest_yaml_allure.common.FileDataDriver import FileReader
  5. from YamlOptimization.pytest_yaml_allure.api_keyword.api_key import ApiKey
  6. from YamlOptimization.pytest_yaml_allure.config import *
  7. import allure
  8. from jinja2 import Template  # 变量渲染
  9.  
  10.  
  11. class TestCase:
  12.     # 获取对应的数据 CaseData 需要从文档当中去进行读取
  13.     # 1. 获取数据(四要素) 2. 发送请求 3.获取响应数据 4.断言
  14.     AllCaseData = FileReader.read_yaml()
  15.     ak = ApiKey()
  16.     # 定义：all_val 存放提取出的数据
  17.     all_var = {}
  18.  
  19.     def __dynamic_title(self, CaseData):
  20.         # # 动态生成标题
  21.         # allure.dynamic.title(data[11])
  22.  
  23.         # 如果存在自定义标题
  24.         if CaseData["caseName"] is not None:
  25.             # 动态生成标题
  26.             allure.dynamic.title(CaseData["caseName"])
  27.  
  28.         if CaseData["storyName"] is not None:
  29.             # 动态获取story模块名
  30.             allure.dynamic.story(CaseData["storyName"])
  31.  
  32.         if CaseData["featureName"] is not None:
  33.             # 动态获取feature模块名
  34.             allure.dynamic.feature(CaseData["featureName"])
  35.  
  36.         if CaseData["remark"] is not None:
  37.             # 动态获取备注信息
  38.             allure.dynamic.description(CaseData["remark"])
  39.  
  40.         if CaseData["rank"] is not None:
  41.             # 动态获取级别信息(blocker、critical、normal、minor、trivial)
  42.             allure.dynamic.severity(CaseData["rank"])
  43.  
  44.     def __json_extraction(self, CaseData, res):
  45.         """
  46.         提取响应之后的数据
  47.         :param CaseData: 当前的Case，主要获取需要提取数据的字段：jsonExData
  48.         :param res:响应得到的对应的结果
  49.         :return:
  50.         """
  51.         try:
  52.             if CaseData["jsonExData"]:
  53.                 Exdata = CaseData["jsonExData"] # {"VAR_TOKEN":"$..token","MSG":"$.msg"}
  54.                 print("需要提取的数据：>>>", Exdata)
  55.                 for key, value in Exdata.items():
  56.                     # 通过对应的jsonpath获取具体的数据
  57.                     new_value = self.ak.get_text(res.json(), value)
  58.                     self.all_var.update(
  59.                         {key: new_value}
  60.                     )
  61.                 print("提取出来的数据：>>>", self.all_var)
  62.             else:
  63.                 print("需要提取的数据为空")
  64.         except Exception:
  65.             print("请检查你需要提取数据数据格式的正确性。")
  66.  
  67.     def __sql_extraction(self, CaseData):
  68.         """
  69.          从数据库提取数据
  70.         :param CaseData: 当前的Case，主要获取需要提取数据的字段：sqlExData
  71.         :return:
  72.         """
  73.         try:
  74.             if CaseData["sqlExData"]:
  75.                 Exdata = CaseData["sqlExData"]  # {"name":"SELECT username FROM sxo_user WHERE username='hami'","id":"SELECT id FROM sxo_user WHERE username='hami'"}
  76.                 print("SQL-需要提取的数据：>>>", Exdata)
  77.                 for key, value in Exdata.items():
  78.                     # 通过对应的sql获取具体的数据
  79.                     new_value = self.ak.get_sqlData(value)
  80.                     self.all_var.update(
  81.                         {key: new_value}
  82.                     )
  83.                 print("SQL-提取出来的数据：>>>", self.all_var)
  84.             else:
  85.                 print("SQL-需要提取的数据为空")
  86.         except Exception:
  87.             print("SQL-请检查你需要提取数据数据格式的正确性。")
  88.  
  89.     def __sql_assertData(self, CaseData):
  90.  
  91.         res = True
  92.         if CaseData["sqlAssertData"] and CaseData["sqlExpectResult"]:
  93.             # 实际结果：从数据库读取出来的数据--字典的格式 # {"name":"SELECT username FROM sxo_user WHERE username='hami'","id":"SELECT id FROM sxo_user WHERE username='hami'"}
  94.             realityData = CaseData["sqlAssertData"]
  95.             # 期望结果:{"name":"hami","id":75}
  96.             expectData = CaseData["sqlExpectResult"]
  97.  
  98.             realityDataDict = {}
  99.             for key, value in realityData.items():
  100.                 # 通过对应的sql获取具体的数据
  101.                 new_value = self.ak.get_sqlData(value)
  102.                 realityDataDict.update(
  103.                     {key: new_value}
  104.                 )
  105.  
  106.             if expectData != realityDataDict:
  107.                 res = False
  108.         return res
  109.  
  110.     @pytest.mark.parametrize("CaseData", AllCaseData)
  111.     def testCase(self, CaseData):
  112.         self.__dynamic_title(CaseData)
  113.         CaseData = eval(Template(str(CaseData)).render(self.all_var))
  114.  
  115.         print(CaseData)
  116.  
  117.         # 写Yaml的下标
  118.         row = CaseData["id"]
  119.  
  120.         # 初始化对应的值：
  121.         res = None
  122.         msg = None
  123.         value = None
  124.  
  125.         # 知识：是否断言
  126.         # is_assert = True
  127.  
  128.         # -------------------------发送请求-------------------------------
  129.         try:
  130.             # 请求数据
  131.             params = eval(CaseData["params"]) if isinstance(CaseData["params"], str) else CaseData["params"]
  132.  
  133.             dict_data = {
  134.                 "url": CaseData["url"] + CaseData["path"],
  135.                 "params": params,
  136.                 "headers": CaseData["headers"],
  137.                 "data": CaseData["data"]
  138.             }
  139.  
  140.             if CaseData["type"] == "json":
  141.                 dict_data["data"] = json.dumps(dict_data["data"])
  142.  
  143.         except Exception:
  144.             value = MSG_DATA_ERROR
  145.             CaseData["result"] = value
  146.         else:
  147.             # 得到对应的响应数据
  148.             res = getattr(self.ak, CaseData["method"])(**dict_data)
  149.  
  150.         # -------------------------提取数据库的操作---------------------------
  151.         self.__sql_extraction(CaseData)
  152.  
  153.         # -------------------------进行断言处理-------------------------------
  154.         # 实际结果
  155.         try:
  156.             msg = self.ak.get_text(res.json(), CaseData["actualResult"])
  157.         except Exception:
  158.             value = MSG_EXDATA_ERROR
  159.             CaseData["result"] = value
  160.         else:
  161.             # 只会是一个分支语言，但是不会造成测试结果成功或者失败，所以必须无论如何都是需要断言
  162.             if msg == CaseData["expectResult"]:
  163.                 value = MSG_ASSERT_OK
  164.                 # 成功之后进行数据提取
  165.                 self.__json_extraction(CaseData, res)
  166.  
  167.             else:
  168.                 # is_assert = False
  169.                 value = MSG_ASSERT_NO
  170.             CaseData["result"] = value
  171.         finally:
  172.             assert msg == CaseData["expectResult"], value
  173.  
  174.         # -------------------------进行数据库断言处理-------------------------------
  175.         try:
  176.             res = self.__sql_assertData(CaseData)  # False True
  177.         except:
  178.             print("SQL断言出现问题")
  179.             value = "SQL断言出现问题"
  180.             assert res, value
  181.         else:
  182.             assert res
  183.         finally:
  184.             CaseData["result"] = value
  185.  
  186.         # -------------------------把当前的CaseData值写入：可以通过后置处理方法去处理-------------------------------
  187.         self.AllCaseData[row] = CaseData
  188.         FileReader.write_yaml(self.AllCaseData)

4.大量响应报文处理及加解密、签名处理

        1.全字段断言-DeepDiff

        deepdiff 是一个Python库，用于比较Python数据结构（例如字典、列表、JSON等）之间的差异。它不仅可以比较简单的Python数据类型，还可以比较任意深度或复杂度的数据结构。

在Python中，我们经常需要比较两个JSON对象的异同。例如测试中，我们需要比较预期输出和实际输出是否相同。而在开发中，我们也需要比较两个JSON对象的差异以便维护。使用 deepdiff 库，可以轻松处理这些场景

        DeepDiff库的主要模块如下：
        

        1. deepdiff.DeepDiff ：这是DeepDiff库的核心模块，提供了比较两个对象之间差异的功能。它可以比较字典、列表、集合等复杂对象，并返回差异的详细信息。

2. deepdiff.DeepSearch ：这是一个工具类，用于在复杂对象中搜索指定值。它可以深度遍历对象，并返回找到的匹配项的路径信息。

3. deepdiff.DeepHash ：这个模块用于生成复杂对象的哈希值。它可以递归地计算对象的哈希值，并考虑对象中的差异

  2.deepdiff常用操作

        如果实际请求结果和预期值的json数据都一致，那么会返回 {} 空字典，否则会返回对比差异的结果，接口测试中我们也可以根据这个特点进行断言

        如果对比结果不同，将会给出下面对应的返回
        1. type_changes：类型改变的key=

        2. values_changed：值发生变化的key

        3. dictionary_item_added：字典key添加

        4. dictionary_item_removed：字段key删除

        案例如下

        

  1.  
  2. from deepdiff import DeepDiff
  3. """
  4. 总结:
  5. 1. 当数据没有差异的时候: 返回是一个空字典 {}
  6. 2. 当数据有差异的情况,会根据实际情况显示:
  7.     1. type_changes：类型改变的key
  8.     2. values_changed：值发生变化的key
  9.     3. dictionary_item_added：字典key添加
  10.     4. dictionary_item_removed：字段key删除
  11. """
  12.  
  13. # 期望结果
  14. exjson = {
  15.     'code': 0,
  16.     "message": "成功",
  17.     "data": {
  18.         "total": 28,
  19.         "id": 123
  20.     }
  21. }
  22.  
  23. # 实际结果
  24. sjjson= {
  25.     'code': 0,
  26.     "message": "成功",
  27.     "data": {
  28.         "total": 28,
  29.         "id": 123
  30.     }
  31. }
  32.  
  33. # 1. 如果两个json 是一样的情况下，返回的值是一个空字典
  34. res = DeepDiff(exjson,sjjson)
  35. print(res)
  36.  
  37. 实际结果
  38. sjjson = {
  39.     'code': "0",  # 类型不一样
  40.     "message": "成功",
  41.     "data": {
  42.         "total": 28,
  43.         "id": 123
  44.     }
  45. }
  46.  
  47. # 2. 类型错误会提示：{'type_changes'：XXXXXXXXX},root代表的是根节点
  48. res = DeepDiff(exjson, sjjson)
  49. print(res)  # {'type_changes'：XXXXXXXXX}
  50. sjjson = {
  51.     'code': 100,  # 类型一样，数据不一样
  52.     "message": "成功",
  53.     "data": {
  54.         "total": 28,
  55.         "id": 123
  56.     }
  57. }
  58. 3. 当你的值有改变，会显示 ：values_changed
  59. res = DeepDiff(exjson, sjjson)
  60. print(res)  # 'values_changed': {"root['code']": {'new_value': 100, 'old_value': 0}}}
  61.  
  62.  
  63. sjjson = {
  64.     'code': 0,  # 类型一样，数据不一样
  65.     "message": "成功",
  66.     "data": {
  67.         "total": 28,
  68.         "id": 123
  69.     },
  70.     "add": "长沙"
  71. }
  72. res = DeepDiff(exjson, sjjson)
  73. print(res)  # {'dictionary_item_added': [root['add']]}
  74.  
  75.  
  76. sjjson = {
  77.     "message": "成功",
  78.     "data": {
  79.         "total": 28,
  80.         "id": 123
  81.     }
  82. }
  83. res = DeepDiff(exjson, sjjson)
  84. print(res)  # {'dictionary_item_removed': [root['code']]}



忽略排序、大小写及某个字段\

其实，在实际接口断言中，可能需要校验的字段顺序不一样，又或者有一些字段值不需要，为了解决这类问题，Deepdiff也提供了相信的参数，只需要在比较的时候加入，传入对应参数即可

例如 我们遇到一个相应数据:

期望结果：

{"code":"200","ordeid":"OR567456415645646",data:"241523415361123132132"}

实际结果：【未定】--- ID 是不确定的，是后端自动生成的，过滤字段。

{"code":"200","ordeid":"OR567456415645646",data:"241523415361123132132"}

ignore_order(忽略排序)

ignore_string_case(忽略大小写)

exclude_paths排除指定的字段

  1.  
  2.  
  3. from deepdiff import DeepDiff
  4.  
  5. """
  6. 总结:
  7. 1. 当数据没有差异的时候: 返回是一个空字典 {}
  8. 2. 当数据有差异的情况,会根据实际情况显示:
  9.     1. type_changes：类型改变的key
  10.     2. values_changed：值发生变化的key
  11.     3. dictionary_item_added：字典key添加
  12.     4. dictionary_item_removed：字段key删除
  13. """
  14. from deepdiff import DeepDiff
  15.  
  16. # 1. 字典是以key,顺序没有关系
  17. # json1 = {"name": "hami", "age": 18}
  18. # json2 = {"age": 18, "name": "hami"}
  19.  
  20. # res = DeepDiff(json1,json2)
  21. # print(res)
  22.  
  23. # 2. 定义两个列表进行比较,列表有序的,按照顺序去进行对比
  24. # list1 = [1, 2, 3]
  25. # list2 = [3, 2, 1]
  26.  
  27. # 有序列表,会返回对应的数据: {'values_changed': {'root[0]': {'new_value': 3, 'old_value': 1}, 'root[2]': {'new_value': 1, 'old_value': 3}}}
  28. # res = DeepDiff(list1, list2)
  29. # print(res)
  30. # # 过滤对应的顺序: ignore_order=True ------{}
  31. # res = DeepDiff(list1, list2, ignore_order=True)
  32. # print(res)
  33.  
  34. # 3. 过滤大小写的操作:  ignore_string_case=True
  35. # json1 = {"name": "hami", "age": 18}
  36. # json2 = {"age": 18, "name": "Hami"}
  37. #
  38. # res = DeepDiff(json1, json2)
  39. # print(res)
  40. # # 过滤字符的大小写(不区分)
  41. # res = DeepDiff(json1, json2, ignore_string_case=True)
  42. # print(res)
  43.  
  44.  
  45. # 4. 忽略某个字段  exclude_paths={"age"} --- 用的最多
  46. json1 = {"code": "200", "name": "hami", "usercode": "431123456789", "age": 18}
  47. json2 = {"code": "200", "name": "hami", "usercode": "431123456789", "age": 20}
  48. res = DeepDiff(json1, json2)
  49. print(res)
  50. res = DeepDiff(json1, json2, exclude_paths={"age"})
  51. # res = DeepDiff(json1, json2, exclude_paths={"root['age']"})
  52. print(res)

        

  其他参数:

        

  1.  
  2. from deepdiff import DeepDiff
  3.  
  4. """
  5. 总结:
  6. 1. 当数据没有差异的时候: 返回是一个空字典 {}
  7. 2. 当数据有差异的情况,会根据实际情况显示:
  8.     1. type_changes：类型改变的key
  9.     2. values_changed：值发生变化的key
  10.     3. dictionary_item_added：字典key添加
  11.     4. dictionary_item_removed：字段key删除
  12. """
  13. from deepdiff import DeepDiff
  14.  
  15.  
  16. # 忽略数字
  17. from decimal import Decimal
  18. # 高精度的十进制计算，避免了浮点数运算中的精度丢失问题。
  19. t1 = Decimal('10.01') # 数字类型
  20. t2 = 10.01
  21.  
  22. # print(DeepDiff(t1, t2))
  23. # print(DeepDiff(t1, t2, ignore_numeric_type_changes=True))
  24.  
  25. # 忽略字符串
  26. res = DeepDiff(b'hello', 'hello', ignore_string_type_changes=True)
  27. # print(res)
  28.  
  29.  
  30. # 打印出来的格式可以指定:
  31. # TREE_VIEW = 'tree'
  32. # TEXT_VIEW = 'text'  # 默认
  33. t1 = {"name": "yanan", "pro": {"sh": "shandong", "city": ["zibo", "weifang"]}}
  34. t2 = {"name": "yanan", "pro": {"sh": "shandong", "city": ["taian", "weifang"]}}
  35. # 显示格式：tree
  36. diff1 = DeepDiff(t1, t2, view='tree')
  37. print(diff1)
  38. # 默认为text # 可读性
  39. diff2 = DeepDiff(t1, t2, view='text')
  40. print(diff2)

搜索模块

 我们使用deepdiff还可以用来搜索

        

  1.  
  2. from deepdiff import DeepSearch
  3.  
  4. obj = ["long somewhere", "string", 0, "somewhere great!"]
  5. item = 'some' # 大小写敏感的
  6. ds = DeepSearch(obj, item, case_sensitive=True)
  7. print(ds)

 

返回的结果就是其下标值 

哈希模块-DeepHash

        DeepHash模块是DeepDiff库中的一个模块，用于生成复杂对象的哈希值。它可以递归地计算对象的哈希值，并考虑对象中的差异。可以方便地计算复杂对象的哈希值，并在需要时用于对象的唯一标识或数据校验等用途

        

  1.  
  2.  
  3. from deepdiff import DeepHash
  4. #  可以把对应的Value 转成对应的Hash
  5.  
  6. t1 = {"name": "yanan", "pro": {"sh": "shandong", "city": ["zibo", "weifang"]}}
  7. res = DeepHash(t1)
  8. print(res)

 如图显示,输出的结果就是一串hash值

3.全字段对比

                deepdiff的封装

                        

  1. from deepdiff import DeepDiff
  2.  
  3.  
  4. def jsonDeepDiff(json1, json2, **other):
  5.     """
  6.     对比json数据的一致性
  7.     :param json1: 期望结果
  8.     :param json2: 实际结果
  9.     :param other: 你想要写的对应的规则
  10.     :return:
  11.     """
  12.     res = DeepDiff(json1, json2, **other)
  13.     if res == {}:
  14.         return True
  15.     else:
  16.         return False

将deepdiff结果之前的框架   

       

                我们在deepdiff封装在关键字封装的类之中和对应的测试用例中

                
    

另外我们还要避免excel表中的值为空的情况,因此,我们需要再请求数据的地方进行修改

        

4.加密

核心思路：如果说对应的参数需要进行加密的话，在传参的时候在key当中通过 @ 符号进行标识
对我们的data对进行遍历,判断key的[0] == @

例如:{"@name":"tony","@password":"123456"}

我们先把加密方法进行封装

        

  1.  
  2.  
  3. """
  4. 对称加密：加密和解密使用的是同一把钥匙，即：使用相同的密匙对同一密码进行加密和解密。
  5. 常用的加密方法：DES、3DES、AES...(AES算法是目前最常用的对称加密算法)
  6. """
  7. import base64
  8. from Crypto.Cipher import AES
  9.  
  10.  
  11. class EncryptDate:
  12.     # 构造方法
  13.     def __init__(self, key):
  14.         #  类属性
  15.         self.key = key.encode("utf-8")  # 初始化密钥
  16.         self.length = AES.block_size  # 初始化数据块大小 ：16位
  17.         self.aes = AES.new(self.key, AES.MODE_ECB)  # 初始化AES,ECB模式的实例
  18.         # 截断函数，去除填充的字符
  19.         self.unpad = lambda date: date[0:-ord(date[-1])]
  20.  
  21.     # 缺几位数据就补齐多少位数据：16的倍数
  22.     def pad(self, text):  # text == tony
  23.         """
  24.         #填充函数，使被加密数据的字节码长度是block_size的整数倍
  25.         """
  26.         count = len(text.encode('utf-8'))  # count = 4
  27.         add = self.length - (count % self.length)  # 求它们相差的位数
  28.         # add = 16- （4%16）  === 16 - 4 == 12
  29.         entext = text + (chr(add) * add)
  30.         #  entext = “tony” + （chr(add) * 12  ）  === entext == tony
  31.         # print("entext的数据是:",entext)
  32.         return entext
  33.  
  34.     # 加密函数
  35.     def encrypt(self, encrData):  # 加密函数   encrData == tony （16位）
  36.         res = self.aes.encrypt(self.pad(encrData).encode("utf8"))  # self.aes.encrypt(tony)
  37.         msg = str(base64.b64encode(res), encoding="utf8")
  38.         return msg
  39.  
  40.     # 解密函数
  41.     def decrypt(self, decrData):  # 解密函数   XbXHJrNLwoTVcyfqM9eTgQ==
  42.         # 从base64编码转回来
  43.         res = base64.decodebytes(decrData.encode("utf8"))
  44.         # 将数据进行对应的解密：XbXHJrNLwoTVcyfqM9eTgQ==
  45.         msg = self.aes.decrypt(res).decode("utf8")
  46.         # print("msg的值：",msg)
  47.         # 把转回来的数据后面的字符去掉。
  48.         return self.unpad(msg)
  49.  
  50.  
  51. key = "1234567812345678"
  52. ENCRYPTAES = EncryptDate(key)

然后我们再进行加密处理

 在excel和yaml的处理py文件中 写上对应的方法:

  1.     @staticmethod
  2.     def data_EncryptDateAES(data):
  3.         newdata = {}  # 去掉前面@符号同时数据进行加密
  4.         for key in data:
  5.             if key[0] == "@":
  6.                 # 需要加密处理
  7.                 newdata[key[1:]] = ENCRYPTAES.encrypt(data[key])
  8.             else:
  9.                 # 不需要加密处理
  10.                 newdata[key] = data[key]
  11.         return newdata

5.接口签名Sign封装

        数字签名是一种用于验证数据完整性和身份认证的密码学技术。它通过使用私钥对数据进行加密来创建一个唯一的数字标识，该标识称为签名。验证者可以使用相应的公钥对签名进行解密和验证，以确认数据的完整性和真实性


token \ session \ cookie \ 签名(sign) --- 都是用来鉴权的

它们的区别是什么?

token \ session \ cookie

token 其实用来代表是系统当中的某个用户 --- 一般正常情况下是写在header

session \ cookie 是你发送请求的时候自带的.浏览器会自带这个对应的数据

session \ cookie 区别是什么?

存储位置不同: cookie -客户端 ; session--服务端(会话)

大小限制不同: cookie - 有大小限制; session 没有大小限制

安全隐患不同: cookie 存在安全隐患,可以拦截或找你本地文件得到你存储的信息

时效性不同: cookie 是时效性, session关闭浏览器时就消失

签名(sign) --- 是接口当中的一个字段. 发送消息\发送文档\保证安全性\需要在接口传一波数据.

通过算法得到一串数据(类似于token)

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

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

  

闽ICP备14008679号