xx

InterfaceAutoTest/__init__.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_58
+# FileName:      __init__.py
+# Author:       xxxxxxx
+# Datetime:     2024/1/4 9:31
+# Description:
+# 
+# ---------------------------------------------------------------------------

InterfaceAutoTest/common/__init__.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_58
+# FileName:      __init__.py
+# Author:       xxxxxxx
+# Datetime:     2024/1/4 9:33
+# Description:
+# 
+# ---------------------------------------------------------------------------
+import functools
+import os
+
+from InterfaceAutoTest.common.log import log
+
+# 日志文件的路径，需要先创建好日志文件
+log_path = os.path.join(os.path.join(os.path.join(os.path.dirname(os.path.dirname(__file__)), "report"), "log"), "log_template.log")
+# 获取loger
+loger = log(log_path)
+
+
+# 装饰器
+def log_decorator(func):
+    @functools.wraps(func)  # 解决被装饰函数和方法名重名的问题，它会将被装饰的函数或方法使用原来的名称
+    def inner(*args, **kwargs):
+        # 在执行func之前需要获取func的名称和功能，并写入到日志
+        loger.info("功能的名称为："+str(func.__name__)+" 功能的描述为："+str(func.__doc__))
+        try:
+            # 执行func
+            result = func(*args, **kwargs)
+        except Exception as e:
+            # 如果有错误，需要写入到日志
+            loger.error(str(e))
+            # 将错误，原路返回
+            raise e
+        else:
+            return result
+    return inner
\ No newline at end of file

InterfaceAutoTest/common/db.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_58
+# FileName:      db.py
+# Author:       xxxxxxx
+# Datetime:     2024/1/4 9:53
+# Description:
+# 
+# ---------------------------------------------------------------------------
+import pymysql
+
+from InterfaceAutoTest.common.read_ini import ReadIni
+from InterfaceAutoTest.data_config.settings import *
+
+
+class DB:
+    def __init__(self):
+        """链接数据库，获取链接对象，并创建游标对象"""
+        # 创建ReadIni的对象，因为后面需要调用get_sql_connect_msg获取数据库的链接信息
+        read_ini = ReadIni()
+        try:
+            # 链接数据库, 获取链接对象
+            self.conn = pymysql.connect(
+                host=read_ini.get_sql_connect_msg(SQL_HOST),
+                port=int(read_ini.get_sql_connect_msg(SQL_PORT)),
+                user=read_ini.get_sql_connect_msg(SQL_USER),
+                password=read_ini.get_sql_connect_msg(SQL_PASSWORD),
+                database=read_ini.get_sql_connect_msg(SQL_DATABASE),
+                charset="utf8"
+            )
+        except:
+            raise ConnectionError("链接数据库出错，请查看配置文件是否配置正确")
+        else:
+            # 获取游标对象
+            self.cursor = self.conn.cursor()
+
+    def close(self):
+        """关闭数据的链接"""
+        self.cursor.close()
+        self.conn.close()
+
+    def delete(self, sql_sentence):
+        """执行删除的sql语句"""
+        try:
+            # 使用游标对象执行删除的sql语句
+            self.cursor.execute(sql_sentence)
+        except:
+            raise ValueError("请察看sql语句是否正确")
+        else:
+            # 使用链接对象提交
+            self.conn.commit()
+
+    def select(self, sql_sentence):
+        """执行查询的sql语句，并返回查询的结果，如果没有查询结果返回None"""
+        try:
+            # 使用游标对象执行查询的sql语句
+            self.cursor.execute(sql_sentence)
+        except:
+            raise ValueError("请察看sql语句是否正确")
+        else:
+            # 接收查询的结果
+            select_result = self.cursor.fetchall()
+            # 判断查询的结果是否为空的元组，如果是返回None，如果不是返回查询的第一个值
+            if select_result:
+                return select_result[0][0]
\ No newline at end of file

InterfaceAutoTest/common/log.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_58
+# FileName:      log.py
+# Author:       xxxxxxx
+# Datetime:     2024/1/4 11:48
+# Description:
+# 
+# ---------------------------------------------------------------------------
+import logging
+
+
+def log(filename):
+    # 创建logger对象
+    loger = logging.getLogger()
+    # 创建文件的控制器
+    handler = logging.FileHandler(filename, mode="a", encoding="utf-8")
+    # 设置日志文件中内容的格式
+    formatter = logging.Formatter('%(levelname)s--%(asctime)s--%(message)s')
+    # 格式添加到文件的控制器中
+    handler.setFormatter(formatter)
+    # logger对象添加文件控制器
+    loger.addHandler(handler)
+    # 设置日志文件的级别
+    loger.level = logging.INFO
+
+    return loger

InterfaceAutoTest/common/read_excel.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_58
+# FileName:      read_excel.py
+# Author:       xxxxxxx
+# Datetime:     2024/1/4 10:05
+# Description:
+# 
+# ---------------------------------------------------------------------------
+import os
+
+import openpyxl
+
+from InterfaceAutoTest.common.read_ini import ReadIni
+from InterfaceAutoTest.common.read_json import read_json
+from InterfaceAutoTest.data_config.settings import *
+
+
+class ReadExcel:
+    def __init__(self, excel_path, table_name, case_data_path, expect_data_path, sql_data_path):
+        """
+        根据传入的文件路径，读取文件中的内容
+        :param excel_path: excel文件的路径
+        :param table_name: 工作表名称
+        :param case_data_path: 用例json文件的路径
+        :param expect_data_path: 期望json文件的路径
+        :param sql_data_path: sql语句json文件的路径
+        """
+        # 读取json文件，使用read_json函数
+        self.case_data_dict = read_json(case_data_path)
+        self.expect_data_dict = read_json(expect_data_path)
+        self.sql_data_dict = read_json(sql_data_path)
+
+        try:
+            # 加载excel的工作簿
+            wb = openpyxl.load_workbook(excel_path)
+            # 再获取工作表
+            self.ws = wb[table_name]
+        except:
+            raise ValueError("传入的excel路径或者工作表的名称错误")
+
+    def __get_cell_value(self, column: str, row: int) -> str:
+        """根据列号和行号，获取单元格数据"""
+        try:
+            # 工作表["列号行号"].value
+            cell_value = self.ws[column+str(row)].value
+        except:
+            raise ValueError("传入的列号或行号错误")
+        else:
+            # 判断单元格数据是否为None，如果是返回None
+            if cell_value is None:
+                return None
+            # 判断单元格数据去掉前后空格，是否为空字符串，如果是返回None，如果不是返回去掉空格的字符串
+            elif cell_value.strip():
+                return cell_value.strip()
+
+    def module_name(self, row):
+        """根据行号，获取模块名称"""
+        return self.__get_cell_value(MODULE_NAME, row)
+
+    def api_name(self, row):
+        """根据行号，获取接口名称"""
+        return self.__get_cell_value(API_NAME, row)
+
+    def case_req(self, row):
+        """根据行号，获取请求方法"""
+        return self.__get_cell_value(REQUEST_METHOD, row)
+
+    def case_mime(self, row):
+        """根据行号，获取用例的媒体类型"""
+        mime_value = self.__get_cell_value(MIME, row)
+        # 判断媒体类型的值是否为None，如果为None返回None，如果不为None，返回转小写的媒体类型的值
+        if mime_value:
+            return mime_value.lower()
+
+    def case_url(self, row):
+        """根据行号，获取用例请求的url"""
+        # 获取用例请求的路径
+        path = self.__get_cell_value(PATH, row)
+        # 判断用例请求的路径的值是否为None，如果为None返回None，如果不为None，返回完整的url
+        if path:
+            return ReadIni().get_host("bpm") + path
+
+    def case_data(self, row):
+        """根据行号，获取用例数据"""
+        # 获取用例数据的key
+        case_data_key = self.__get_cell_value(CASE_DATA, row)
+        # 判断用例数据的key是否不为None，如果是就提取用例数据，如果为None，返回None
+        if case_data_key:
+            # 获取模块名称
+            module_name = self.module_name(row)
+            # 获取接口名称
+            api_name = self.api_name(row)
+            # 返回用例数据
+            return self.case_data_dict[module_name][api_name][case_data_key]
+
+    def expect_data(self, row):
+        """根据行号，获取用例数据"""
+        # 获取期望数据的key
+        expect_data_key = self.__get_cell_value(EXPECT_DATA, row)
+        # 判断期望数据的key是否不为None，如果是就提取期望数据，如果为None，返回None
+        if expect_data_key:
+            # 获取模块名称
+            module_name = self.module_name(row)
+            # 获取接口名称
+            api_name = self.api_name(row)
+            # 返回期望数据
+            return self.expect_data_dict[module_name][api_name][expect_data_key]
+
+    def sql_data(self, row):
+        """根据行号，获取用例数据"""
+        # 获取sql语句的key
+        sql_data_key = self.__get_cell_value(SQL_DATA, row)
+        # 判断sql语句的key是否不为None，如果是就提取sql语句，如果为None，返回None
+        if sql_data_key:
+            # 获取模块名称
+            module_name = self.module_name(row)
+            # 获取接口名称
+            api_name = self.api_name(row)
+            # 返回sql语句
+            return self.sql_data_dict[module_name][api_name][sql_data_key]
+
+    def sql_type(self, row):
+        """根据行号，获取sql语句的类型"""
+        # 获取sql语句的类型的值
+        sql_type_value = self.__get_cell_value(SQL_TYPE, row)
+        # 判断sql语句的类型的值不为None，如果不为None，将sql语句的类型的值转小写返回，如果为None，返回None
+        if sql_type_value:
+            return sql_type_value.lower()
+
+    def update_key(self, row):
+        """根据行号，获取更新的key"""
+        return self.__get_cell_value(UPDATE_KEY, row)
+
+    def get_data(self):
+        """将使用的数据存放到一个二维列表中"""
+        # 创建空列表
+        list_data = []
+        # 循环所有的行，并取出每行的数据，再规避空行
+        for row in range(2, self.ws.max_row+1):
+            # 请求方法
+            case_req = self.case_req(row)
+            # 请求url
+            case_url = self.case_url(row)
+            # 请求媒体类型
+            case_mime = self.case_mime(row)
+            # 请求用例数据
+            case_data = self.case_data(row)
+            # 期望数据
+            expect_data = self.expect_data(row)
+            # sql语句类型
+            sql_type = self.sql_type(row)
+            # sql语句
+            sql_data = self.sql_data(row)
+            # 更新的key
+            update_key = self.update_key(row)
+            # 将数据存放在列表中
+            row_list = [case_req, case_url, case_mime, case_data, expect_data, sql_type, sql_data, update_key]
+            # 规避空行===每行的空数据不能超过5个
+            if row_list.count(None) <= 5:
+                # 将存放每行数据的列表追加到前面创建的空列表中
+                list_data.append(row_list)
+        else:
+            return list_data
+
+
+if __name__ == '__main__':
+    dir_path = os.path.join(os.path.join(os.path.dirname(os.path.dirname(__file__)), "data_config"), "template")
+    excel_path = os.path.join(dir_path, "APIAutoTest.xlsx")
+    case_data_path = os.path.join(dir_path, "case_data.json")
+    expect_data_path = os.path.join(dir_path, "expect_data.json")
+    sql_data_path = os.path.join(dir_path, "sql_data.json")
+    table_name = "BPM"
+    excel = ReadExcel(excel_path, table_name, case_data_path, expect_data_path, sql_data_path)
+    print(excel.get_data())

InterfaceAutoTest/common/read_ini.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_58
+# FileName:      read_ini.py
+# Author:       xxxxxxx
+# Datetime:     2024/1/4 9:40
+# Description:
+# 
+# ---------------------------------------------------------------------------
+import configparser
+import os
+from InterfaceAutoTest.data_config.settings import *
+
+
+class ReadIni:
+    def __init__(self):
+        """获取ini文件的路径，并创建Configparser对象，再读取ini文件"""
+        # 获取data_config的路径
+        self.data_config_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), "data_config")
+        # 获取ini文件的路径
+        ini_path = os.path.join(self.data_config_path, "config.ini")
+        # 创建Configparser对象
+        self.conf = configparser.ConfigParser()
+        # 读取ini文件
+        self.conf.read(ini_path, encoding="utf-8")
+
+    def get_host(self, key):
+        """根据key， 获取被测系统的域名"""
+        try:
+            # Configparser对象调用get方法获取节点下key对应的值
+            host = self.conf.get(HOST, key)
+            return host
+        except:
+            raise KeyError("传入的key错误~~")
+        # else:
+        #     return host
+
+    def get_sql_connect_msg(self, key):
+        """根据key 获取数据库的链接信息"""
+        try:
+            # Configparser对象调用get方法获取节点下key对应的值
+            msg = self.conf.get(SQL, key)
+        except:
+            raise KeyError("传入的key错误~~")
+        else:
+            return msg
+
+

InterfaceAutoTest/common/read_json.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_58
+# FileName:      read_json.py
+# Author:       xxxxxxx
+# Datetime:     2024/1/4 9:48
+# Description:
+# 
+# ---------------------------------------------------------------------------
+import json
+import os
+
+
+def read_json(filename: str):
+    """根据文件的路径，读取json文件，并将json文件的数据转成python对象并返回"""
+    # 判断传入的文件路径是否合法并且是.json结尾
+    if os.path.isfile(filename) and filename.endswith(".json"):
+        # 以读的模式打开文件
+        with open(filename, mode="r", encoding="utf-8") as f:
+            try:
+                # 读取文件中的内容，并将内容转成python对象
+                res_obj = json.loads(f.read())
+            except:
+                raise FileExistsError("将文件的内容转成python对象出错~~")
+            else:
+                return res_obj
+    else:
+        raise FileNotFoundError("传入的json文件错误")

InterfaceAutoTest/data_config/config.ini

+;[file]
+;# 数据配置层中文件的名称
+;excel=APIAutoTest.xlsx
+;case=case_data.json
+;expect=expect_data.json
+;sql=sql_data.json
+;
+;[table]
+;# excel工作表的名称
+;name=BPM
+
+[host]
+# 被测系统的域名
+bpm=http://120.46.172.186:8080
+
+[sql]
+# 数据库链接信息
+host=120.46.172.186
+port=3306
+user=root
+pwd=root@2023
+database=eipsaas
\ No newline at end of file

InterfaceAutoTest/data_config/mr_wang/case_data.json

+{
+    "认证接口":{
+        "登录系统":{
+            "LoginSuccess":{"username":"admin","password":"MTIzNDU2"},
+            "LoginErrorUsernameIsNone":{"username":"","password":"MTIzNDU2"},
+            "LoginErrorUsernameIsShort":{"username":"a","password":"MTIzNDU2"},
+            "LoginErrorUsernameIsLong":{"username":"adminadminadminadminadminadminadminadminadminadmin","password":"MTIzNDU2"},
+            "LoginErrorUsernameIsSpecial":{"username":"♠♣▣▤▥▦▩◘◙◈","password":"MTIzNDU2"},
+            "LoginErrorUsernameIsError":{"username":"Admin","password":"MTIzNDU2"},
+            "LoginErrorPasswordIsNone":{"username":"admin","password":""},
+            "LoginErrorPasswordIsLong":{"username":"admin","password":"MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2"},
+            "LoginErrorPasswordIsShort":{"username":"admin","password":"m"},
+            "LoginErrorPasswordIsSpecial":{"username":"admin","password":"♠♣▣▤▥▦▩◘◙◈"}
+        }
+    },
+    "维度管理": {
+        "添加维度": {
+            "AddDemSuccess": {
+                "code": "test58_dem_abc",
+                "description": "测试维度-58",
+                "isDefault": 0,
+                "name": "测试维度-58"
+            }
+        },
+        "根据维度编码删除维度": {
+            "DeleteDemSuccess": {"ids": "需要更新"}
+        }
+    },
+    "组织管理": {
+        "添加组织": {
+            "AddOrgSuccess": {
+                "code": "test_58_org",
+                "demId": "需要更新",
+                "exceedLimitNum": 0,
+                "grade": "",
+                "limitNum": 0,
+                "name": "测试组织-58",
+                "nowNum": 0,
+                "orderNo": 0,
+                "parentId": "0"
+            }
+        },
+        "用户加入组织": {
+            "OrgAddUserSuccess": {"orgCode": "test_58_org", "accounts": "admin,guest"}
+        },
+        "保存组织参数": {
+            "OrgSaveParamSuccess": {"query": {"orgCode": "test_58_org"}, "json": [{"alias": "sz", "value": "999"}]}
+        },
+        "删除组织": {
+            "DeleteOrgSuccess": "test_58_org"
+        }
+    }
+}
+

InterfaceAutoTest/data_config/mr_wang/expect_data.json

+{
+    "认证接口":{
+        "登录系统":{
+            "LoginSuccess":{"username":"超级管理员","account":"admin","loginStatus":true},
+            "LoginErrorUsernameIsNone":{"state":false,"message":"账号或密码错误"},
+            "LoginErrorUsernameIsShort":{"state":false,"message":"账号或密码错误"},
+            "LoginErrorUsernameIsLong":{"state":false,"message":"账号或密码错误"},
+            "LoginErrorUsernameIsSpecial":{"state":false,"message":"账号或密码错误"},
+            "LoginErrorUsernameIsError":{"state":false,"message":"账号或密码错误"},
+            "LoginErrorPasswordIsNone":{"state":false,"message":"账号或密码错误"},
+            "LoginErrorPasswordIsLong":{"state":false,"message":"账号或密码错误"},
+            "LoginErrorPasswordIsShort":{"state":false,"message":"账号或密码错误"},
+            "LoginErrorPasswordIsSpecial":{"state":false,"message":"账号或密码错误"}
+        },
+        "刷新token": {
+            "RefreshTokenSuccess": {"message": "刷新成功"}
+        }
+    },
+    "维度管理": {
+        "添加维度": {
+            "AddDemSuccess": {"message": "添加维度成功！"}
+        },
+        "根据维度编码删除维度": {
+            "DeleteDemSuccess": {"message": "删除维度成功！"}
+        }
+    },
+    "组织管理": {
+        "添加组织": {
+            "AddOrgSuccess": {"message": "添加组织成功"}
+        },
+        "用户加入组织": {
+            "OrgAddUserSuccess": {"state":true,"message":"加入成功"}
+        },
+        "保存组织参数": {
+            "OrgSaveParamSuccess": {"state":true,"message":"保存组织参数成功！"}
+        },
+        "删除组织": {
+            "DeleteOrgSuccess": {"state":true,"message":"删除组织成功！"}
+        }
+    }
+}
+

InterfaceAutoTest/data_config/mr_wang/sql_data.json

+{
+    "维度管理": {
+        "添加维度": {
+            "AddDemSuccess": " delete from uc_demension WHERE `CODE_`=\"test58_dem_abc\";"
+        },
+        "根据维度编码删除维度": {
+            "DeleteDemSuccess": "select ID_ from uc_demension WHERE `CODE_`=\"test58_dem_abc\";"
+        }
+    },
+    "组织管理": {
+        "添加组织": {
+            "AddOrgSuccess": {"delete": "delete from uc_org WHERE `CODE_`=\"test_58_org\";", "select": "select ID_ from uc_demension WHERE `CODE_`=\"test58_dem_abc\";"}
+        }
+    }
+}
+

InterfaceAutoTest/data_config/mr_zhang/case_data.json

+{
+    "认证接口":{
+        "登录系统":{
+            "LoginSuccess":{"username":"admin","password":"MTIzNDU2"},
+            "LoginErrorUsernameIsNone":{"username":"","password":"MTIzNDU2"},
+            "LoginErrorUsernameIsShort":{"username":"a","password":"MTIzNDU2"},
+            "LoginErrorUsernameIsLong":{"username":"adminadminadminadminadminadminadminadminadminadmin","password":"MTIzNDU2"},
+            "LoginErrorUsernameIsSpecial":{"username":"♠♣▣▤▥▦▩◘◙◈","password":"MTIzNDU2"},
+            "LoginErrorUsernameIsError":{"username":"Admin","password":"MTIzNDU2"},
+            "LoginErrorPasswordIsNone":{"username":"admin","password":""},
+            "LoginErrorPasswordIsLong":{"username":"admin","password":"MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2"},
+            "LoginErrorPasswordIsShort":{"username":"admin","password":"m"},
+            "LoginErrorPasswordIsSpecial":{"username":"admin","password":"♠♣▣▤▥▦▩◘◙◈"}
+        }
+    },
+    "维度管理": {
+        "添加维度": {
+            "AddDemSuccess": {
+                "code": "test58_dem_abc",
+                "description": "测试维度-58",
+                "isDefault": 0,
+                "name": "测试维度-58"
+            }
+        },
+        "根据维度编码删除维度": {
+            "DeleteDemSuccess": {"ids": "需要更新"}
+        }
+    },
+    "组织管理": {
+        "添加组织": {
+            "AddOrgSuccess": {
+                "code": "test_58_org",
+                "demId": "需要更新",
+                "exceedLimitNum": 0,
+                "grade": "",
+                "limitNum": 0,
+                "name": "测试组织-58",
+                "nowNum": 0,
+                "orderNo": 0,
+                "parentId": "0"
+            }
+        },
+        "用户加入组织": {
+            "OrgAddUserSuccess": {"orgCode": "test_58_org", "accounts": "admin,guest"}
+        },
+        "保存组织参数": {
+            "OrgSaveParamSuccess": {"query": {"orgCode": "test_58_org"}, "json": [{"alias": "sz", "value": "999"}]}
+        },
+        "删除组织": {
+            "DeleteOrgSuccess": "test_58_org"
+        }
+    }
+}
+

InterfaceAutoTest/data_config/mr_zhang/expect_data.json

+{
+    "认证接口":{
+        "登录系统":{
+            "LoginSuccess":{"username":"超级管理员","account":"admin","loginStatus":true},
+            "LoginErrorUsernameIsNone":{"state":false,"message":"账号或密码错误"},
+            "LoginErrorUsernameIsShort":{"state":false,"message":"账号或密码错误"},
+            "LoginErrorUsernameIsLong":{"state":false,"message":"账号或密码错误"},
+            "LoginErrorUsernameIsSpecial":{"state":false,"message":"账号或密码错误"},
+            "LoginErrorUsernameIsError":{"state":false,"message":"账号或密码错误"},
+            "LoginErrorPasswordIsNone":{"state":false,"message":"账号或密码错误"},
+            "LoginErrorPasswordIsLong":{"state":false,"message":"账号或密码错误"},
+            "LoginErrorPasswordIsShort":{"state":false,"message":"账号或密码错误"},
+            "LoginErrorPasswordIsSpecial":{"state":false,"message":"账号或密码错误"}
+        },
+        "刷新token": {
+            "RefreshTokenSuccess": {"message": "刷新成功"}
+        }
+    },
+    "维度管理": {
+        "添加维度": {
+            "AddDemSuccess": {"message": "添加维度成功！"}
+        },
+        "根据维度编码删除维度": {
+            "DeleteDemSuccess": {"message": "删除维度成功！"}
+        }
+    },
+    "组织管理": {
+        "添加组织": {
+            "AddOrgSuccess": {"message": "添加组织成功"}
+        },
+        "用户加入组织": {
+            "OrgAddUserSuccess": {"state":true,"message":"加入成功"}
+        },
+        "保存组织参数": {
+            "OrgSaveParamSuccess": {"state":true,"message":"保存组织参数成功！"}
+        },
+        "删除组织": {
+            "DeleteOrgSuccess": {"state":true,"message":"删除组织成功！"}
+        }
+    }
+}
+

InterfaceAutoTest/data_config/mr_zhang/sql_data.json

+{
+    "维度管理": {
+        "添加维度": {
+            "AddDemSuccess": " delete from uc_demension WHERE `CODE_`=\"test58_dem_abc\";"
+        },
+        "根据维度编码删除维度": {
+            "DeleteDemSuccess": "select ID_ from uc_demension WHERE `CODE_`=\"test58_dem_abc\";"
+        }
+    },
+    "组织管理": {
+        "添加组织": {
+            "AddOrgSuccess": {"delete": "delete from uc_org WHERE `CODE_`=\"test_58_org\";", "select": "select ID_ from uc_demension WHERE `CODE_`=\"test58_dem_abc\";"}
+        }
+    }
+}
+

InterfaceAutoTest/data_config/settings.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_58
+# FileName:      settings.py
+# Author:       xxxxxxx
+# Datetime:     2024/1/3 17:06
+# Description:
+# 
+# ---------------------------------------------------------------------------
+
+# ======================================================================
+"""配置列号"""
+MODULE_NAME = "B"  # 模块名称
+API_NAME = "c"  # 接口名称
+TITLE = "d"
+LEVEL = "E"
+REQUEST_METHOD = "F"
+PATH = "G"
+MIME = "H"
+CASE_DATA = "I"
+EXPECT_DATA = "J"
+SQL_TYPE = "K"
+SQL_DATA = "L"
+UPDATE_KEY = "M"
+
+# ======================================================================
+"""ini文件中的节点"""
+FILE = "file"
+TABLE = "table"
+HOST = "host"
+SQL = "sql"
+
+
+# ======================================================================
+"""配置sql节点下的key"""
+SQL_HOST = "host"
+SQL_PORT = "port"
+SQL_USER = "user"
+SQL_PASSWORD = "pwd"
+SQL_DATABASE = "database"
\ No newline at end of file

InterfaceAutoTest/data_config/template/case_data.json

+{
+    "认证接口":{
+        "登录系统":{
+            "LoginSuccess":{"username":"admin","password":"MTIzNDU2"},
+            "LoginErrorUsernameIsNone":{"username":"","password":"MTIzNDU2"},
+            "LoginErrorUsernameIsShort":{"username":"a","password":"MTIzNDU2"},
+            "LoginErrorUsernameIsLong":{"username":"adminadminadminadminadminadminadminadminadminadmin","password":"MTIzNDU2"},
+            "LoginErrorUsernameIsSpecial":{"username":"♠♣▣▤▥▦▩◘◙◈","password":"MTIzNDU2"},
+            "LoginErrorUsernameIsError":{"username":"Admin","password":"MTIzNDU2"},
+            "LoginErrorPasswordIsNone":{"username":"admin","password":""},
+            "LoginErrorPasswordIsLong":{"username":"admin","password":"MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2MTIzNDU2"},
+            "LoginErrorPasswordIsShort":{"username":"admin","password":"m"},
+            "LoginErrorPasswordIsSpecial":{"username":"admin","password":"♠♣▣▤▥▦▩◘◙◈"}
+        }
+    },
+    "维度管理": {
+        "添加维度": {
+            "AddDemSuccess": {
+                "code": "test58_dem_abc",
+                "description": "测试维度-58",
+                "isDefault": 0,
+                "name": "测试维度-58"
+            }
+        },
+        "根据维度编码删除维度": {
+            "DeleteDemSuccess": {"ids": "需要更新"}
+        }
+    },
+    "组织管理": {
+        "添加组织": {
+            "AddOrgSuccess": {
+                "code": "test_58_org",
+                "demId": "需要更新",
+                "exceedLimitNum": 0,
+                "grade": "",
+                "limitNum": 0,
+                "name": "测试组织-58",
+                "nowNum": 0,
+                "orderNo": 0,
+                "parentId": "0"
+            }
+        },
+        "用户加入组织": {
+            "OrgAddUserSuccess": {"orgCode": "test_58_org", "accounts": "admin,guest"}
+        },
+        "保存组织参数": {
+            "OrgSaveParamSuccess": {"query": {"orgCode": "test_58_org"}, "json": [{"alias": "sz", "value": "999"}]}
+        },
+        "删除组织": {
+            "DeleteOrgSuccess": "test_58_org"
+        }
+    },
+    "用户管理": {
+        "添加用户": {
+            "AddUserSuccess": {"id":"","account":"laowang","address":"","email":"","fullname":"laowang","mobile":"","password":"123456","photo":"","sex":"","status":1}
+        }
+    }
+}
+

InterfaceAutoTest/data_config/template/expect_data.json

+{
+    "认证接口":{
+        "登录系统":{
+            "LoginSuccess":{"username":"超级管理员","account":"admin","loginStatus":true},
+            "LoginErrorUsernameIsNone":{"state":false,"message":"账号或密码错误"},
+            "LoginErrorUsernameIsShort":{"state":false,"message":"账号或密码错误"},
+            "LoginErrorUsernameIsLong":{"state":false,"message":"账号或密码错误"},
+            "LoginErrorUsernameIsSpecial":{"state":false,"message":"账号或密码错误"},
+            "LoginErrorUsernameIsError":{"state":false,"message":"账号或密码错误"},
+            "LoginErrorPasswordIsNone":{"state":false,"message":"账号或密码错误"},
+            "LoginErrorPasswordIsLong":{"state":false,"message":"账号或密码错误"},
+            "LoginErrorPasswordIsShort":{"state":false,"message":"账号或密码错误"},
+            "LoginErrorPasswordIsSpecial":{"state":false,"message":"账号或密码错误"}
+        },
+        "刷新token": {
+            "RefreshTokenSuccess": {"message": "刷新成功"}
+        }
+    },
+    "维度管理": {
+        "添加维度": {
+            "AddDemSuccess": {"message": "添加维度成功！"}
+        },
+        "根据维度编码删除维度": {
+            "DeleteDemSuccess": {"message": "删除维度成功！"}
+        }
+    },
+    "组织管理": {
+        "添加组织": {
+            "AddOrgSuccess": {"message": "添加组织成功"}
+        },
+        "用户加入组织": {
+            "OrgAddUserSuccess": {"state":true,"message":"加入成功"}
+        },
+        "保存组织参数": {
+            "OrgSaveParamSuccess": {"state":true,"message":"保存组织参数成功！"}
+        },
+        "删除组织": {
+            "DeleteOrgSuccess": {"state":true,"message":"删除组织成功！"}
+        }
+    },
+    "用户管理": {
+        "添加用户": {
+            "AddUserSuccess": {"state":true,"message":"用户添加成功！"}
+        }
+    }
+}
+

InterfaceAutoTest/data_config/template/sql_data.json

+{
+    "维度管理": {
+        "添加维度": {
+            "AddDemSuccess": " delete from uc_demension WHERE `CODE_`=\"test58_dem_abc\";"
+        },
+        "根据维度编码删除维度": {
+            "DeleteDemSuccess": "select ID_ from uc_demension WHERE `CODE_`=\"test58_dem_abc\";"
+        }
+    },
+    "组织管理": {
+        "添加组织": {
+            "AddOrgSuccess": {"delete": "delete from uc_org WHERE `CODE_`=\"test_58_org\";", "select": "select ID_ from uc_demension WHERE `CODE_`=\"test58_dem_abc\";"}
+        }
+    },
+    "用户管理": {
+        "添加用户": {
+            "AddUserSuccess": "delete from uc_user WHERE `ACCOUNT_`=\"laowang\";"
+        }
+    }
+}
+

InterfaceAutoTest/requests_method/requests_method.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_58
+# FileName:      requests_method.py
+# Author:       xxxxxxx
+# Datetime:     2024/1/4 11:01
+# Description:
+# 
+# ---------------------------------------------------------------------------
+import base64
+
+import requests
+
+from InterfaceAutoTest.common.read_ini import ReadIni
+
+
+class RequestsMethod:
+    def __init__(self):
+        """关联token"""
+        # 配置登录的数据
+        login_url = ReadIni().get_host("bpm") + "/auth"
+        login_data = {"username": "admin", "password": base64.b64encode("123456".encode()).decode()}
+        # 创建Session对象
+        self.bpm_session = requests.sessions.Session()
+        # 将token更新到Session对象的headers中
+        self.bpm_session.headers["Authorization"] = "Bearer "+self.bpm_session.post(url=login_url, json=login_data).json().get("token")
+
+    def request_all(self, req_method, req_url, req_mime, case_data):
+        """
+        封装公共的请求方法
+        :param req_method: 请求方法，字符串
+        :param req_url: 请求url，字符串
+        :param req_mime: 请求的媒体类型，字符串
+        :param case_data: 用例数据
+        :return: Response type
+        """
+        # 判断媒体类型是否为表单类型，如果是，使用data传参
+        if req_mime == "application/x-www-form-urlencoded" or req_mime == "x-www-form-urlencoded":
+            return self.bpm_session.request(method=req_method, url=req_url, data=case_data)
+
+        # 判断媒体类型是否为json传参，如果是，使用json传参
+        elif req_mime == "application/json" or req_mime == "json":
+            return self.bpm_session.request(method=req_method, url=req_url, json=case_data)
+
+        # 判断媒体类型是否为上传文件，如果是，使用files传参
+        elif req_mime == "multipart/form-data" or req_mime == "form-data":
+            return self.bpm_session.request(method=req_method, url=req_url, files=case_data)
+
+        # 判断媒体类型是否为地址栏传参，如果是，使用params传参
+        elif req_mime == "query" or req_mime == "params":
+            return self.bpm_session.request(method=req_method, url=req_url, params=case_data)
+
+        # 判断媒体类型是否为None，表示没有传参
+        elif req_mime is None:
+            return self.bpm_session.request(method=req_method, url=req_url)
+
+        # 判断媒体类型是否query|json，表示地址栏和请求体中同时传参，使用params和json同时传参
+        elif req_mime == "query|json" or req_mime == "json|query" or req_mime == "params|json":
+            return self.bpm_session.request(method=req_method, url=req_url, params=case_data["query"], json=case_data["json"])
+
+        # 判断媒体类型是否text或者为text/plain，表示请求体中传纯文本，使用data传参
+        elif req_mime == "text" or req_mime == "text/plain":
+            return self.bpm_session.request(method=req_method, url=req_url, data=case_data)
+
+        else:
+            raise NameError("传入的媒体类型，没有封装，请自行封装~")
+

InterfaceAutoTest/test_case/__init__.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_58
+# FileName:      __init__.py
+# Author:       xxxxxxx
+# Datetime:     2024/1/4 11:42
+# Description:
+# 
+# ---------------------------------------------------------------------------

InterfaceAutoTest/test_case/test_dependecy_template/__init__.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_58
+# FileName:      __init__.py
+# Author:       xxxxxxx
+# Datetime:     2024/1/4 14:12
+# Description:
+# 
+# ---------------------------------------------------------------------------

InterfaceAutoTest/test_case/test_dependecy_template/test_dependecy_template.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_58
+# FileName:      test_dependecy_template.py
+# Author:       xxxxxxx
+# Datetime:     2024/1/4 14:12
+# Description:
+# 
+# ---------------------------------------------------------------------------
+import base64
+
+import pytest
+import requests
+
+data_dict = {}   # 数据的依赖
+
+
+# 标记用例需要被依赖
+@pytest.mark.dependency()
+def test_login():
+    login_url = "http://120.46.172.186:8080/auth"
+    login_data = {"username": "admin", "password": base64.b64encode("123456".encode()).decode()}
+    res = requests.request(method="post", url=login_url, json=login_data)
+    # 断言，断言成功提取token
+    try:
+        assert "超级管理员" in res.text
+    except AssertionError:
+        raise AssertionError("断言失败")
+    else:
+        token = res.json().get("token")
+        # 把token存放到字典中
+        data_dict["token"] = token
+
+
+# 指定需要依赖的用例
+@pytest.mark.dependency(depends=["test_login"])
+def test_add_demo():
+    add_dem_url = "http://120.46.172.186:8080/api/demension/v1/dem/addDem"
+    add_dem_data = {
+            "code": "dem_code_test_528",
+            "description": "测试维度528",
+            "isDefault": 0,
+            "name": "测试维度518"
+        }
+    header = {"Authorization": "Bearer "+data_dict["token"]}
+    print(header)
+    res = requests.request(method="post", url=add_dem_url, json=add_dem_data, headers=header)
+    # 断言
+    try:
+        assert "成功" in res.text
+    except AssertionError:
+        raise AssertionError("断言失败")
+    else:
+        data_dict["dem_code"] = "dem_code_test_58"
+
+
+@pytest.mark.dependency(depends=["test_login", "test_add_demo"])
+@pytest.mark.parametrize("a, b, c", [[1, 2, 3], [4, 5, 6]])
+def test3(a, b, c):
+    print("用例函数3", a, b, c)
+    print("token:", data_dict["token"], "维度code:", data_dict["dem_code"])

InterfaceAutoTest/test_case/test_mr_wang/__init__.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_58
+# FileName:      __init__.py
+# Author:       xxxxxxx
+# Datetime:     2024/1/4 11:14
+# Description:
+# 
+# ---------------------------------------------------------------------------
+import os
+
+# ========需要测试人员设置=====================================
+# 设置数据存放的目录名称
+data_dir_name = "mr_wang"
+# 获取excel文件、用例数据文件、期望数据文件、sql语句文件的路径，还需指名工作表的名称
+excel_name = "mr_wang.xlsx"
+case_data_name = "case_data.json"
+expect_data_name = "expect_data.json"
+sql_data_name = "sql_data.json"
+table_name = "维度管理"
+
+# =========禁止更改===========================================
+# 获取数据存放的目录的路径
+data_dir_path = os.path.join(os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "data_config"), data_dir_name)
+# 获取excel文件、用例数据文件、期望数据文件、sql语句文件的路径，还需指名工作表的路径
+excel_path = os.path.join(data_dir_path, excel_name)
+case_data_path = os.path.join(data_dir_path, case_data_name)
+expect_data_path = os.path.join(data_dir_path, expect_data_name)
+sql_data_path = os.path.join(data_dir_path, sql_data_name)
+

InterfaceAutoTest/test_case/test_mr_wang/conftest.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_58
+# FileName:      conftest.py
+# Author:       xxxxxxx
+# Datetime:     2024/1/4 11:31
+# Description:
+# 主要创建自定固件
+# ---------------------------------------------------------------------------
+import pytest
+from InterfaceAutoTest.common.db import DB
+from InterfaceAutoTest.requests_method.requests_method import RequestsMethod
+
+
+# 创建DB对象的自定义固件
+@pytest.fixture(scope="session")
+def db_fix():
+    # 创建DB对象, 并返回
+    db = DB()
+    yield db
+    db.close()
+
+
+# 创建RequestsMethod类对象
+@pytest.fixture(scope="session")
+def req_fix():
+    # 创建RequestsMethod类对象
+    req = RequestsMethod()
+    yield req
\ No newline at end of file

InterfaceAutoTest/test_case/test_mr_wang/test_mr_wang.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_58
+# FileName:      test_template.py
+# Author:       xxxxxxx
+# Datetime:     2024/1/4 11:14
+# Description:
+# 
+# ---------------------------------------------------------------------------
+import logging
+import pytest
+from InterfaceAutoTest.common import log_decorator
+from InterfaceAutoTest.common.read_excel import ReadExcel
+from InterfaceAutoTest.test_case.test_template import *
+
+
+class TestTemple:
+
+    @pytest.mark.parametrize("case_req, case_url, case_mime, case_data, expect_data, sql_type, sql_data, update_key", ReadExcel(excel_path=excel_path, table_name=table_name, case_data_path=case_data_path, expect_data_path=expect_data_path, sql_data_path=sql_data_path).get_data())
+    @log_decorator
+    def test_method_template(self, db_fix, req_fix, case_req, case_url, case_mime, case_data, expect_data, sql_type, sql_data, update_key):
+        # 判断sql语句类型是否为delete
+        if sql_type == "delete":
+            # 使用DB类对象，调用delete方法执行删除的sql语句
+            db_fix.delete(sql_data)
+
+        # 判断sql语句是否为select
+        elif sql_type == "select":
+            # 使用DB类对象，调用select方法执行查询的sql语句,并接收查询的结果
+            select_result = db_fix.select(sql_data)
+            # 将查询结果更新到用例数据中
+            case_data[update_key] = select_result
+
+        # 判断sql语句类型是否为select|delete, 或者为delete|select
+        elif sql_type == "select|delete" or sql_type == "delete|select":
+            # 使用DB类对象，调用delete方法执行删除的sql语句
+            db_fix.delete(sql_data["delete"])
+            # 使用DB类对象，调用select方法执行查询的sql语句,并接收查询的结果
+            select_result = db_fix.select(sql_data["select"])
+            # 将查询结果更新到用例数据中
+            case_data[update_key] = select_result
+
+        # 发送请求--使用RequestsMethod类对象的request_all方法发送请求
+        result = req_fix.request_all(req_method=case_req, req_url=case_url, req_mime=case_mime, case_data=case_data)
+
+        # 断言
+        try:
+            for key in expect_data.keys():
+                assert expect_data[key] == result.json().get(key)
+
+        except AssertionError:
+            logging.error("断言失败：用例为："+str(case_data)+"期望数据为："+str(expect_data)+"服务器返回数据为："+result.text)
+            raise AssertionError("断言失败")
+        else:
+            print("断言成功")
+
+
+if __name__ == '__main__':
+    pytest.main()
\ No newline at end of file

InterfaceAutoTest/test_case/test_mr_zhang/__init__.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_58
+# FileName:      __init__.py
+# Author:       xxxxxxx
+# Datetime:     2024/1/4 11:14
+# Description:
+# 
+# ---------------------------------------------------------------------------
+import os
+
+# ========需要测试人员设置=====================================
+# 设置数据存放的目录名称
+data_dir_name = "mr_zhang"
+# 获取excel文件、用例数据文件、期望数据文件、sql语句文件的路径，还需指名工作表的名称
+excel_name = "mr_zhang.xlsx"
+case_data_name = "case_data.json"
+expect_data_name = "expect_data.json"
+sql_data_name = "sql_data.json"
+table_name = "用户管理"
+
+# =========禁止更改===========================================
+# 获取数据存放的目录的路径
+data_dir_path = os.path.join(os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "data_config"), data_dir_name)
+# 获取excel文件、用例数据文件、期望数据文件、sql语句文件的路径，还需指名工作表的路径
+excel_path = os.path.join(data_dir_path, excel_name)
+case_data_path = os.path.join(data_dir_path, case_data_name)
+expect_data_path = os.path.join(data_dir_path, expect_data_name)
+sql_data_path = os.path.join(data_dir_path, sql_data_name)
+

InterfaceAutoTest/test_case/test_mr_zhang/conftest.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_58
+# FileName:      conftest.py
+# Author:       xxxxxxx
+# Datetime:     2024/1/4 11:31
+# Description:
+# 主要创建自定固件
+# ---------------------------------------------------------------------------
+import pytest
+from InterfaceAutoTest.common.db import DB
+from InterfaceAutoTest.requests_method.requests_method import RequestsMethod
+
+
+# 创建DB对象的自定义固件
+@pytest.fixture(scope="session")
+def db_fix():
+    # 创建DB对象, 并返回
+    db = DB()
+    yield db
+    db.close()
+
+
+# 创建RequestsMethod类对象
+@pytest.fixture(scope="session")
+def req_fix():
+    # 创建RequestsMethod类对象
+    req = RequestsMethod()
+    yield req
\ No newline at end of file

InterfaceAutoTest/test_case/test_mr_zhang/test_mr_zhang.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_58
+# FileName:      test_template.py
+# Author:       xxxxxxx
+# Datetime:     2024/1/4 11:14
+# Description:
+# 
+# ---------------------------------------------------------------------------
+import logging
+import pytest
+from InterfaceAutoTest.common import log_decorator
+from InterfaceAutoTest.common.read_excel import ReadExcel
+from InterfaceAutoTest.test_case.test_template import *
+
+
+class TestTemple:
+
+    @pytest.mark.parametrize("case_req, case_url, case_mime, case_data, expect_data, sql_type, sql_data, update_key", ReadExcel(excel_path=excel_path, table_name=table_name, case_data_path=case_data_path, expect_data_path=expect_data_path, sql_data_path=sql_data_path).get_data())
+    @log_decorator
+    def test_method_template(self, db_fix, req_fix, case_req, case_url, case_mime, case_data, expect_data, sql_type, sql_data, update_key):
+        # 判断sql语句类型是否为delete
+        if sql_type == "delete":
+            # 使用DB类对象，调用delete方法执行删除的sql语句
+            db_fix.delete(sql_data)
+
+        # 判断sql语句是否为select
+        elif sql_type == "select":
+            # 使用DB类对象，调用select方法执行查询的sql语句,并接收查询的结果
+            select_result = db_fix.select(sql_data)
+            # 将查询结果更新到用例数据中
+            case_data[update_key] = select_result
+
+        # 判断sql语句类型是否为select|delete, 或者为delete|select
+        elif sql_type == "select|delete" or sql_type == "delete|select":
+            # 使用DB类对象，调用delete方法执行删除的sql语句
+            db_fix.delete(sql_data["delete"])
+            # 使用DB类对象，调用select方法执行查询的sql语句,并接收查询的结果
+            select_result = db_fix.select(sql_data["select"])
+            # 将查询结果更新到用例数据中
+            case_data[update_key] = select_result
+
+        # 发送请求--使用RequestsMethod类对象的request_all方法发送请求
+        result = req_fix.request_all(req_method=case_req, req_url=case_url, req_mime=case_mime, case_data=case_data)
+
+        # 断言
+        try:
+            for key in expect_data.keys():
+                assert expect_data[key] == result.json().get(key)
+
+        except AssertionError:
+            logging.error("断言失败：用例为："+str(case_data)+"期望数据为："+str(expect_data)+"服务器返回数据为："+result.text)
+            raise AssertionError("断言失败")
+        else:
+            print("断言成功")
+
+
+if __name__ == '__main__':
+    pytest.main()
\ No newline at end of file

InterfaceAutoTest/test_case/test_template/__init__.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_58
+# FileName:      __init__.py
+# Author:       xxxxxxx
+# Datetime:     2024/1/4 11:14
+# Description:
+# 
+# ---------------------------------------------------------------------------
+import os
+
+# ========需要测试人员设置=====================================
+# 设置数据存放的目录名称
+data_dir_name = "template"
+# 获取excel文件、用例数据文件、期望数据文件、sql语句文件的路径，还需指名工作表的名称
+excel_name = "APIAutoTest.xlsx"
+case_data_name = "case_data.json"
+expect_data_name = "expect_data.json"
+sql_data_name = "sql_data.json"
+table_name = "BPM"
+
+# =========禁止更改===========================================
+# 获取数据存放的目录的路径
+data_dir_path = os.path.join(os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "data_config"), data_dir_name)
+# 获取excel文件、用例数据文件、期望数据文件、sql语句文件的路径，还需指名工作表的路径
+excel_path = os.path.join(data_dir_path, excel_name)
+case_data_path = os.path.join(data_dir_path, case_data_name)
+expect_data_path = os.path.join(data_dir_path, expect_data_name)
+sql_data_path = os.path.join(data_dir_path, sql_data_name)
+

InterfaceAutoTest/test_case/test_template/conftest.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_58
+# FileName:      conftest.py
+# Author:       xxxxxxx
+# Datetime:     2024/1/4 11:31
+# Description:
+# 主要创建自定固件
+# ---------------------------------------------------------------------------
+import pytest
+from InterfaceAutoTest.common.db import DB
+from InterfaceAutoTest.requests_method.requests_method import RequestsMethod
+
+
+# 创建DB对象的自定义固件
+@pytest.fixture(scope="session")
+def db_fix():
+    # 创建DB对象, 并返回
+    db = DB()
+    yield db
+    db.close()
+
+
+# 创建RequestsMethod类对象
+@pytest.fixture(scope="session")
+def req_fix():
+    # 创建RequestsMethod类对象
+    req = RequestsMethod()
+    yield req
\ No newline at end of file

InterfaceAutoTest/test_case/test_template/test_template.py

+# -*-coding:utf-8 -*- #
+# ---------------------------------------------------------------------------
+# ProjectName:   test_58
+# FileName:      test_template.py
+# Author:       xxxxxxx
+# Datetime:     2024/1/4 11:14
+# Description:
+# 
+# ---------------------------------------------------------------------------
+import logging
+import pytest
+from InterfaceAutoTest.common import log_decorator
+from InterfaceAutoTest.common.read_excel import ReadExcel
+from InterfaceAutoTest.test_case.test_template import *
+
+
+class TestTemple:
+
+    @pytest.mark.parametrize("case_req, case_url, case_mime, case_data, expect_data, sql_type, sql_data, update_key", ReadExcel(excel_path=excel_path, table_name=table_name, case_data_path=case_data_path, expect_data_path=expect_data_path, sql_data_path=sql_data_path).get_data())
+    @log_decorator
+    def test_method_template(self, db_fix, req_fix, case_req, case_url, case_mime, case_data, expect_data, sql_type, sql_data, update_key):
+        # 判断sql语句类型是否为delete
+        if sql_type == "delete":
+            # 使用DB类对象，调用delete方法执行删除的sql语句
+            db_fix.delete(sql_data)
+
+        # 判断sql语句是否为select
+        elif sql_type == "select":
+            # 使用DB类对象，调用select方法执行查询的sql语句,并接收查询的结果
+            select_result = db_fix.select(sql_data)
+            # 将查询结果更新到用例数据中
+            case_data[update_key] = select_result
+
+        # 判断sql语句类型是否为select|delete, 或者为delete|select
+        elif sql_type == "select|delete" or sql_type == "delete|select":
+            # 使用DB类对象，调用delete方法执行删除的sql语句
+            db_fix.delete(sql_data["delete"])
+            # 使用DB类对象，调用select方法执行查询的sql语句,并接收查询的结果
+            select_result = db_fix.select(sql_data["select"])
+            # 将查询结果更新到用例数据中
+            case_data[update_key] = select_result
+
+        # 发送请求--使用RequestsMethod类对象的request_all方法发送请求
+        result = req_fix.request_all(req_method=case_req, req_url=case_url, req_mime=case_mime, case_data=case_data)
+
+        # 断言
+        try:
+            for key in expect_data.keys():
+                assert expect_data[key] == result.json().get(key)
+
+        except AssertionError:
+            logging.error("断言失败：用例为："+str(case_data)+"期望数据为："+str(expect_data)+"服务器返回数据为："+result.text)
+            raise AssertionError("断言失败")
+        else:
+            print("断言成功")
+
+
+if __name__ == '__main__':
+    pytest.main()
\ No newline at end of file